diff --git a/.idea/dictionaries/abreslav.xml b/.idea/dictionaries/abreslav.xml
index a5f9f22a06f..9035118b0b9 100644
--- a/.idea/dictionaries/abreslav.xml
+++ b/.idea/dictionaries/abreslav.xml
@@ -2,12 +2,14 @@
   <dictionary name="abreslav">
     <words>
       <w>accessor</w>
+      <w>covariantly</w>
       <w>deserialized</w>
       <w>dominator</w>
       <w>inferrer</w>
       <w>iterable</w>
       <w>nondeterministic</w>
       <w>nullable</w>
+      <w>overridable</w>
       <w>pseudocode</w>
       <w>substitutor</w>
       <w>subtyping</w>
diff --git a/.idea/dictionaries/geevee.xml b/.idea/dictionaries/geevee.xml
index 7891ab0ccaa..c83493eb226 100644
--- a/.idea/dictionaries/geevee.xml
+++ b/.idea/dictionaries/geevee.xml
@@ -2,6 +2,7 @@
   <dictionary name="geevee">
     <words>
       <w>builtins</w>
+      <w>callables</w>
       <w>klass</w>
       <w>proto</w>
       <w>protoc</w>
diff --git a/.idea/libraries/kotlin_runtime.xml b/.idea/libraries/kotlin_runtime.xml
index 217f24d439d..cb98de382af 100644
--- a/.idea/libraries/kotlin_runtime.xml
+++ b/.idea/libraries/kotlin_runtime.xml
@@ -7,8 +7,6 @@
     <JAVADOC />
     <SOURCES>
       <root url="file://$PROJECT_DIR$/libraries/stdlib/src" />
-      <root url="file://$PROJECT_DIR$/core/builtins/src" />
-      <root url="file://$PROJECT_DIR$/core/runtime.jvm/src" />
     </SOURCES>
   </library>
 </component>
\ No newline at end of file
diff --git a/.idea/runConfigurations/IDEA.xml b/.idea/runConfigurations/IDEA.xml
index ef1e614119f..a1d214d79a0 100644
--- a/.idea/runConfigurations/IDEA.xml
+++ b/.idea/runConfigurations/IDEA.xml
@@ -2,7 +2,7 @@
   <configuration default="false" name="IDEA" type="Application" factoryName="Application">
     <extension name="coverage" enabled="false" merge="false" sample_coverage="true" runner="idea" />
     <option name="MAIN_CLASS_NAME" value="com.intellij.idea.Main" />
-    <option name="VM_PARAMETERS" value="-Xmx800m -XX:ReservedCodeCacheSize=64m -XX:MaxPermSize=450m -XX:+HeapDumpOnOutOfMemoryError -ea -Didea.is.internal=true -Didea.debug.mode=true -Didea.system.path=../system-idea -Didea.config.path=../config-idea -Dapple.laf.useScreenMenuBar=true -Dapple.awt.graphics.UseQuartz=true -Dsun.io.useCanonCaches=false -Dplugin.path=$PROJECT_DIR$/out/artifacts/Kotlin,$PROJECT_DIR$/out/artifacts/KotlinAndroidExtensions -Dkotlin.internal.mode.enabled=true" />
+    <option name="VM_PARAMETERS" value="-Xmx800m -XX:ReservedCodeCacheSize=64m -XX:MaxPermSize=450m -XX:+HeapDumpOnOutOfMemoryError -ea -Didea.is.internal=true -Didea.debug.mode=true -Didea.system.path=../system-idea -Didea.config.path=../config-idea -Dapple.laf.useScreenMenuBar=true -Dapple.awt.graphics.UseQuartz=true -Dsun.io.useCanonCaches=false -Dplugin.path=$PROJECT_DIR$/out/artifacts/Kotlin,$PROJECT_DIR$/out/artifacts/KotlinAndroidExtensions -Dkotlin.internal.mode.enabled=true -Didea.additional.classpath=../idea-kotlin-runtime/kotlin-runtime.jar" />
     <option name="PROGRAM_PARAMETERS" value="" />
     <option name="WORKING_DIRECTORY" value="file://$PROJECT_DIR$/ideaSDK/bin" />
     <option name="ALTERNATIVE_JRE_PATH_ENABLED" value="false" />
diff --git a/.idea/runConfigurations/IDEA__No_ProcessCanceledException_.xml b/.idea/runConfigurations/IDEA__No_ProcessCanceledException_.xml
index 32b93154ad2..22e87e15e2b 100644
--- a/.idea/runConfigurations/IDEA__No_ProcessCanceledException_.xml
+++ b/.idea/runConfigurations/IDEA__No_ProcessCanceledException_.xml
@@ -2,7 +2,7 @@
   <configuration default="false" name="IDEA (No ProcessCanceledException)" type="Application" factoryName="Application">
     <extension name="coverage" enabled="false" merge="false" sample_coverage="true" runner="idea" />
     <option name="MAIN_CLASS_NAME" value="com.intellij.idea.Main" />
-    <option name="VM_PARAMETERS" value="-Xmx800m -XX:ReservedCodeCacheSize=64m -XX:MaxPermSize=250m -XX:+HeapDumpOnOutOfMemoryError -ea -Didea.is.internal=true -Didea.debug.mode=true -Didea.system.path=../system-idea -Didea.config.path=../config-idea -Dapple.laf.useScreenMenuBar=true -Dapple.awt.graphics.UseQuartz=true -Dsun.io.useCanonCaches=false -Dplugin.path=$PROJECT_DIR$/out/artifacts/Kotlin,$PROJECT_DIR$/out/artifacts/KotlinAndroidExtensions -Didea.ProcessCanceledException=disabled -Dkotlin.internal.mode.enabled=true" />
+    <option name="VM_PARAMETERS" value="-Xmx800m -XX:ReservedCodeCacheSize=64m -XX:MaxPermSize=250m -XX:+HeapDumpOnOutOfMemoryError -ea -Didea.is.internal=true -Didea.debug.mode=true -Didea.system.path=../system-idea -Didea.config.path=../config-idea -Dapple.laf.useScreenMenuBar=true -Dapple.awt.graphics.UseQuartz=true -Dsun.io.useCanonCaches=false -Dplugin.path=$PROJECT_DIR$/out/artifacts/Kotlin,$PROJECT_DIR$/out/artifacts/KotlinAndroidExtensions -Didea.ProcessCanceledException=disabled -Dkotlin.internal.mode.enabled=true -Didea.additional.classpath=../idea-kotlin-runtime/kotlin-runtime.jar" />
     <option name="PROGRAM_PARAMETERS" value="" />
     <option name="WORKING_DIRECTORY" value="file://$PROJECT_DIR$/ideaSDK/bin" />
     <option name="ALTERNATIVE_JRE_PATH_ENABLED" value="false" />
diff --git a/build.xml b/build.xml
index f5d3c5442ae..ca210f27c0e 100644
--- a/build.xml
+++ b/build.xml
@@ -937,6 +937,7 @@
         <zip destfile="${output}/kotlin-test-data.zip">
             <zipfileset dir="compiler/testData" prefix="compiler"/>
             <zipfileset dir="idea/testData" prefix="ide"/>
+            <zipfileset dir="idea/idea-completion/testData" prefix="ide/completion"/>
         </zip>
     </target>
 
diff --git a/compiler/backend-common/src/org/jetbrains/kotlin/backend/common/CodegenUtil.java b/compiler/backend-common/src/org/jetbrains/kotlin/backend/common/CodegenUtil.java
index 92e576a916b..b6b55e1067d 100644
--- a/compiler/backend-common/src/org/jetbrains/kotlin/backend/common/CodegenUtil.java
+++ b/compiler/backend-common/src/org/jetbrains/kotlin/backend/common/CodegenUtil.java
@@ -17,7 +17,6 @@
 package org.jetbrains.kotlin.backend.common;
 
 import com.intellij.openapi.editor.Document;
-import com.intellij.openapi.util.TextRange;
 import com.intellij.psi.PsiElement;
 import com.intellij.psi.PsiFile;
 import org.jetbrains.annotations.NotNull;
@@ -29,7 +28,7 @@ import org.jetbrains.kotlin.name.Name;
 import org.jetbrains.kotlin.psi.*;
 import org.jetbrains.kotlin.resolve.BindingContext;
 import org.jetbrains.kotlin.resolve.DescriptorUtils;
-import org.jetbrains.kotlin.resolve.calls.CallResolverUtil;
+import org.jetbrains.kotlin.resolve.calls.callResolverUtil.CallResolverUtilPackage;
 import org.jetbrains.kotlin.resolve.calls.callUtil.CallUtilPackage;
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall;
 import org.jetbrains.kotlin.types.JetType;
@@ -62,7 +61,7 @@ public class CodegenUtil {
     ) {
         Collection<FunctionDescriptor> functions = owner.getDefaultType().getMemberScope().getFunctions(name);
         for (FunctionDescriptor function : functions) {
-            if (!CallResolverUtil.isOrOverridesSynthesized(function)
+            if (!CallResolverUtilPackage.isOrOverridesSynthesized(function)
                 && function.getTypeParameters().isEmpty()
                 && valueParameterClassesMatch(function.getValueParameters(), Arrays.asList(valueParameterClassifiers))
                 && rawTypeMatches(function.getReturnType(), returnedClassifier)) {
diff --git a/compiler/backend-common/src/org/jetbrains/kotlin/backend/common/bridges/impl.kt b/compiler/backend-common/src/org/jetbrains/kotlin/backend/common/bridges/impl.kt
index 63399e7628a..06b84441db6 100644
--- a/compiler/backend-common/src/org/jetbrains/kotlin/backend/common/bridges/impl.kt
+++ b/compiler/backend-common/src/org/jetbrains/kotlin/backend/common/bridges/impl.kt
@@ -21,7 +21,7 @@ import org.jetbrains.kotlin.descriptors.FunctionDescriptor
 import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.resolve.DescriptorUtils
 import org.jetbrains.kotlin.resolve.OverrideResolver
-import org.jetbrains.kotlin.resolve.calls.CallResolverUtil
+import org.jetbrains.kotlin.resolve.calls.callResolverUtil.isOrOverridesSynthesized
 
 public fun <Signature> generateBridgesForFunctionDescriptor(
         descriptor: FunctionDescriptor,
@@ -69,7 +69,7 @@ private data class DescriptorBasedFunctionHandle(val descriptor: FunctionDescrip
  */
 public fun findTraitImplementation(descriptor: CallableMemberDescriptor): CallableMemberDescriptor? {
     if (descriptor.getKind().isReal()) return null
-    if (CallResolverUtil.isOrOverridesSynthesized(descriptor)) return null
+    if (isOrOverridesSynthesized(descriptor)) return null
 
     val implementation = findImplementationFromInterface(descriptor) ?: return null
     val immediateConcreteSuper = firstSuperMethodFromKotlin(descriptor, implementation) ?: return null
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/AccessorForConstructorDescriptor.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/AccessorForConstructorDescriptor.kt
index dc66125a88a..f5bca65b046 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/AccessorForConstructorDescriptor.kt
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/AccessorForConstructorDescriptor.kt
@@ -23,6 +23,7 @@ import org.jetbrains.kotlin.descriptors.impl.TypeParameterDescriptorImpl
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.resolve.DescriptorUtils
 import org.jetbrains.kotlin.resolve.jvm.AsmTypes
+import org.jetbrains.kotlin.types.JetType
 import java.util.*
 
 public class AccessorForConstructorDescriptor(
@@ -38,6 +39,8 @@ public class AccessorForConstructorDescriptor(
 
     override fun isPrimary(): Boolean = false
 
+    override fun getReturnType(): JetType = super<AbstractAccessorForFunctionDescriptor>.getReturnType()!!
+
     init {
         initialize(
                 DescriptorUtils.getReceiverParameterType(getExtensionReceiverParameter()),
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/AnnotationCodegen.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/AnnotationCodegen.java
index e8a775f7884..3f25b4e3422 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/AnnotationCodegen.java
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/AnnotationCodegen.java
@@ -24,8 +24,10 @@ import org.jetbrains.kotlin.descriptors.*;
 import org.jetbrains.kotlin.descriptors.annotations.Annotated;
 import org.jetbrains.kotlin.descriptors.annotations.AnnotationArgumentVisitor;
 import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptor;
+import org.jetbrains.kotlin.descriptors.annotations.AnnotationTarget;
 import org.jetbrains.kotlin.load.java.JvmAnnotationNames;
 import org.jetbrains.kotlin.name.FqName;
+import org.jetbrains.kotlin.resolve.AnnotationTargetChecker;
 import org.jetbrains.kotlin.resolve.constants.*;
 import org.jetbrains.kotlin.resolve.constants.StringValue;
 import org.jetbrains.kotlin.types.Flexibility;
@@ -34,8 +36,10 @@ import org.jetbrains.kotlin.types.TypeUtils;
 import org.jetbrains.kotlin.types.TypesPackage;
 import org.jetbrains.org.objectweb.asm.*;
 
+import java.lang.annotation.ElementType;
 import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
 import java.util.*;
 
 import static org.jetbrains.kotlin.resolve.descriptorUtil.DescriptorUtilPackage.getClassObjectType;
@@ -119,6 +123,13 @@ public abstract class AnnotationCodegen {
                 generateNullabilityAnnotation(descriptor.getReturnType(), annotationDescriptorsAlreadyPresent);
             }
         }
+        if (annotated instanceof ClassDescriptor) {
+            ClassDescriptor classDescriptor = (ClassDescriptor) annotated;
+            if (classDescriptor.getKind() == ClassKind.ANNOTATION_CLASS) {
+                generateRetentionAnnotation(classDescriptor, annotationDescriptorsAlreadyPresent);
+                generateTargetAnnotation(classDescriptor, annotationDescriptorsAlreadyPresent);
+            }
+        }
     }
 
     private static boolean isInvisibleFromTheOutside(@Nullable DeclarationDescriptor descriptor) {
@@ -160,6 +171,56 @@ public abstract class AnnotationCodegen {
         generateAnnotationIfNotPresent(annotationDescriptorsAlreadyPresent, annotationClass);
     }
 
+    private static final Map<AnnotationTarget, ElementType> annotationTargetMap =
+            new EnumMap<AnnotationTarget, ElementType>(AnnotationTarget.class);
+
+    static {
+        annotationTargetMap.put(AnnotationTarget.PACKAGE, ElementType.PACKAGE);
+        annotationTargetMap.put(AnnotationTarget.CLASSIFIER, ElementType.TYPE);
+        annotationTargetMap.put(AnnotationTarget.ANNOTATION_CLASS, ElementType.ANNOTATION_TYPE);
+        annotationTargetMap.put(AnnotationTarget.CONSTRUCTOR, ElementType.CONSTRUCTOR);
+        annotationTargetMap.put(AnnotationTarget.LOCAL_VARIABLE, ElementType.LOCAL_VARIABLE);
+        annotationTargetMap.put(AnnotationTarget.FUNCTION, ElementType.METHOD);
+        annotationTargetMap.put(AnnotationTarget.PROPERTY_GETTER, ElementType.METHOD);
+        annotationTargetMap.put(AnnotationTarget.PROPERTY_SETTER, ElementType.METHOD);
+        annotationTargetMap.put(AnnotationTarget.FIELD, ElementType.FIELD);
+        annotationTargetMap.put(AnnotationTarget.VALUE_PARAMETER, ElementType.PARAMETER);
+    }
+
+    private void generateTargetAnnotation(@NotNull ClassDescriptor classDescriptor, @NotNull Set<String> annotationDescriptorsAlreadyPresent) {
+        String descriptor = Type.getType(Target.class).getDescriptor();
+        if (!annotationDescriptorsAlreadyPresent.add(descriptor)) return;
+        Set<AnnotationTarget> targets = AnnotationTargetChecker.INSTANCE$.possibleTargetSet(classDescriptor);
+        Set<ElementType> javaTargets;
+        if (targets == null) {
+            javaTargets = getJavaTargetList(classDescriptor);
+            if (javaTargets == null) return;
+        }
+        else {
+            javaTargets = EnumSet.noneOf(ElementType.class);
+            for (AnnotationTarget target : targets) {
+                if (annotationTargetMap.get(target) == null) continue;
+                javaTargets.add(annotationTargetMap.get(target));
+            }
+        }
+        AnnotationVisitor visitor = visitAnnotation(descriptor, true);
+        AnnotationVisitor arrayVisitor = visitor.visitArray("value");
+        for (ElementType javaTarget : javaTargets) {
+            arrayVisitor.visitEnum(null, Type.getType(ElementType.class).getDescriptor(), javaTarget.name());
+        }
+        arrayVisitor.visitEnd();
+        visitor.visitEnd();
+    }
+
+    private void generateRetentionAnnotation(@NotNull ClassDescriptor classDescriptor, @NotNull Set<String> annotationDescriptorsAlreadyPresent) {
+        RetentionPolicy policy = getRetentionPolicy(classDescriptor);
+        String descriptor = Type.getType(Retention.class).getDescriptor();
+        if (!annotationDescriptorsAlreadyPresent.add(descriptor)) return;
+        AnnotationVisitor visitor = visitAnnotation(descriptor, true);
+        visitor.visitEnum("value", Type.getType(RetentionPolicy.class).getDescriptor(), policy.name());
+        visitor.visitEnd();
+    }
+
     private void generateAnnotationIfNotPresent(Set<String> annotationDescriptorsAlreadyPresent, Class<?> annotationClass) {
         String descriptor = Type.getType(annotationClass).getDescriptor();
         if (!annotationDescriptorsAlreadyPresent.contains(descriptor)) {
@@ -172,9 +233,9 @@ public abstract class AnnotationCodegen {
         return !type.isMarkedNullable() && classifier instanceof TypeParameterDescriptor && TypeUtils.hasNullableSuperType(type);
     }
 
-    public void generateAnnotationDefaultValue(@NotNull CompileTimeConstant value, @NotNull JetType expectedType) {
+    public void generateAnnotationDefaultValue(@NotNull ConstantValue<?> value, @NotNull JetType expectedType) {
         AnnotationVisitor visitor = visitAnnotation(null, false);  // Parameters are unimportant
-        genCompileTimeValue(null, value, expectedType, visitor);
+        genCompileTimeValue(null, value, visitor);
         visitor.visitEnd();
     }
 
@@ -197,17 +258,16 @@ public abstract class AnnotationCodegen {
     }
 
     private void genAnnotationArguments(AnnotationDescriptor annotationDescriptor, AnnotationVisitor annotationVisitor) {
-        for (Map.Entry<ValueParameterDescriptor, CompileTimeConstant<?>> entry : annotationDescriptor.getAllValueArguments().entrySet()) {
+        for (Map.Entry<ValueParameterDescriptor, ConstantValue<?>> entry : annotationDescriptor.getAllValueArguments().entrySet()) {
             ValueParameterDescriptor descriptor = entry.getKey();
             String name = descriptor.getName().asString();
-            genCompileTimeValue(name, entry.getValue(), descriptor.getType(), annotationVisitor);
+            genCompileTimeValue(name, entry.getValue(), annotationVisitor);
         }
     }
 
     private void genCompileTimeValue(
             @Nullable final String name,
-            @NotNull CompileTimeConstant<?> value,
-            @NotNull final JetType expectedType,
+            @NotNull ConstantValue<?> value,
             @NotNull final AnnotationVisitor annotationVisitor
     ) {
         AnnotationArgumentVisitor argumentVisitor = new AnnotationArgumentVisitor<Void, Void>() {
@@ -259,15 +319,15 @@ public abstract class AnnotationCodegen {
             @Override
             public Void visitEnumValue(EnumValue value, Void data) {
                 String propertyName = value.getValue().getName().asString();
-                annotationVisitor.visitEnum(name, typeMapper.mapType(value.getType(KotlinBuiltIns.getInstance())).getDescriptor(), propertyName);
+                annotationVisitor.visitEnum(name, typeMapper.mapType(value.getType()).getDescriptor(), propertyName);
                 return null;
             }
 
             @Override
             public Void visitArrayValue(ArrayValue value, Void data) {
                 AnnotationVisitor visitor = annotationVisitor.visitArray(name);
-                for (CompileTimeConstant<?> argument : value.getValue()) {
-                    genCompileTimeValue(null, argument, value.getType(KotlinBuiltIns.getInstance()), visitor);
+                for (ConstantValue<?> argument : value.getValue()) {
+                    genCompileTimeValue(null, argument, visitor);
                 }
                 visitor.visitEnd();
                 return null;
@@ -288,14 +348,7 @@ public abstract class AnnotationCodegen {
                 return null;
             }
 
-            @Override
-            public Void visitNumberTypeValue(IntegerValueTypeConstant value, Void data) {
-                Object numberType = value.getValue(expectedType);
-                annotationVisitor.visit(name, numberType);
-                return null;
-            }
-
-            private Void visitSimpleValue(CompileTimeConstant value) {
+            private Void visitSimpleValue(ConstantValue<?> value) {
                 annotationVisitor.visit(name, value.getValue());
                 return null;
             }
@@ -310,7 +363,7 @@ public abstract class AnnotationCodegen {
                 return visitUnsupportedValue(value);
             }
 
-            private Void visitUnsupportedValue(CompileTimeConstant value) {
+            private Void visitUnsupportedValue(ConstantValue<?> value) {
                 throw new IllegalStateException("Don't know how to compile annotation value " + value);
             }
         };
@@ -318,13 +371,70 @@ public abstract class AnnotationCodegen {
         value.accept(argumentVisitor, null);
     }
 
+    private enum KotlinRetention {
+        SOURCE(RetentionPolicy.SOURCE),
+        BINARY(RetentionPolicy.CLASS),
+        RUNTIME(RetentionPolicy.RUNTIME);
+
+        final RetentionPolicy mapped;
+
+        KotlinRetention(RetentionPolicy mapped) {
+            this.mapped = mapped;
+        }
+    }
+
+    @Nullable
+    private Set<ElementType> getJavaTargetList(ClassDescriptor descriptor) {
+        AnnotationDescriptor targetAnnotation = descriptor.getAnnotations().findAnnotation(new FqName(Target.class.getName()));
+        if (targetAnnotation != null) {
+            Collection<ConstantValue<?>> valueArguments = targetAnnotation.getAllValueArguments().values();
+            if (!valueArguments.isEmpty()) {
+                ConstantValue<?> compileTimeConstant = valueArguments.iterator().next();
+                if (compileTimeConstant instanceof ArrayValue) {
+                    List<? extends ConstantValue<?>> values = ((ArrayValue) compileTimeConstant).getValue();
+                    Set<ElementType> result = EnumSet.noneOf(ElementType.class);
+                    for (ConstantValue<?> value : values) {
+                        if (value instanceof EnumValue) {
+                            ClassDescriptor enumEntry = ((EnumValue) value).getValue();
+                            JetType classObjectType = getClassObjectType(enumEntry);
+                            if (classObjectType != null) {
+                                if ("java/lang/annotation/ElementType".equals(typeMapper.mapType(classObjectType).getInternalName())) {
+                                    result.add(ElementType.valueOf(enumEntry.getName().asString()));
+                                }
+                            }
+                        }
+                    }
+                    return result;
+                }
+            }
+        }
+        return null;
+    }
+
     @NotNull
     private RetentionPolicy getRetentionPolicy(@NotNull Annotated descriptor) {
+        AnnotationDescriptor kotlinAnnotation = descriptor.getAnnotations().findAnnotation(KotlinBuiltIns.FQ_NAMES.annotation);
+        if (kotlinAnnotation != null) {
+            for (Map.Entry<ValueParameterDescriptor, ConstantValue<?>> argument : kotlinAnnotation.getAllValueArguments().entrySet()) {
+                if ("retention".equals(argument.getKey().getName().asString()) && argument.getValue() instanceof EnumValue) {
+                    ClassDescriptor enumEntry = ((EnumValue) argument.getValue()).getValue();
+                    JetType classObjectType = getClassObjectType(enumEntry);
+                    if (classObjectType != null) {
+                        if ("kotlin/annotation/AnnotationRetention".equals(typeMapper.mapType(classObjectType).getInternalName())) {
+                            String entryName = enumEntry.getName().asString();
+                            for (KotlinRetention retention : KotlinRetention.values()) {
+                                if (retention.name().equals(entryName)) return retention.mapped;
+                            }
+                        }
+                    }
+                }
+            }
+        }
         AnnotationDescriptor retentionAnnotation = descriptor.getAnnotations().findAnnotation(new FqName(Retention.class.getName()));
         if (retentionAnnotation != null) {
-            Collection<CompileTimeConstant<?>> valueArguments = retentionAnnotation.getAllValueArguments().values();
+            Collection<ConstantValue<?>> valueArguments = retentionAnnotation.getAllValueArguments().values();
             if (!valueArguments.isEmpty()) {
-                CompileTimeConstant<?> compileTimeConstant = valueArguments.iterator().next();
+                ConstantValue<?> compileTimeConstant = valueArguments.iterator().next();
                 if (compileTimeConstant instanceof EnumValue) {
                     ClassDescriptor enumEntry = ((EnumValue) compileTimeConstant).getValue();
                     JetType classObjectType = getClassObjectType(enumEntry);
@@ -337,7 +447,7 @@ public abstract class AnnotationCodegen {
             }
         }
 
-        return RetentionPolicy.CLASS;
+        return RetentionPolicy.RUNTIME;
     }
 
     @NotNull
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/AsmUtil.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/AsmUtil.java
index 42b4e4ff79d..537d52aca79 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/AsmUtil.java
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/AsmUtil.java
@@ -37,6 +37,7 @@ import org.jetbrains.kotlin.load.java.JavaVisibilities;
 import org.jetbrains.kotlin.load.java.JvmAbi;
 import org.jetbrains.kotlin.load.java.JvmAnnotationNames;
 import org.jetbrains.kotlin.load.java.descriptors.JavaCallableMemberDescriptor;
+import org.jetbrains.kotlin.jvm.RuntimeAssertionInfo;
 import org.jetbrains.kotlin.name.FqName;
 import org.jetbrains.kotlin.resolve.DescriptorUtils;
 import org.jetbrains.kotlin.resolve.annotations.AnnotationsPackage;
@@ -45,7 +46,6 @@ import org.jetbrains.kotlin.resolve.jvm.JvmClassName;
 import org.jetbrains.kotlin.resolve.jvm.JvmPackage;
 import org.jetbrains.kotlin.resolve.jvm.JvmPrimitiveType;
 import org.jetbrains.kotlin.resolve.jvm.diagnostics.JvmDeclarationOrigin;
-import org.jetbrains.kotlin.types.Approximation;
 import org.jetbrains.kotlin.types.JetType;
 import org.jetbrains.kotlin.types.TypesPackage;
 import org.jetbrains.org.objectweb.asm.*;
@@ -637,10 +637,10 @@ public class AsmUtil {
     public static StackValue genNotNullAssertions(
             @NotNull GenerationState state,
             @NotNull final StackValue stackValue,
-            @Nullable final Approximation.Info approximationInfo
+            @Nullable final RuntimeAssertionInfo runtimeAssertionInfo
     ) {
         if (!state.isCallAssertionsEnabled()) return stackValue;
-        if (approximationInfo == null || !TypesPackage.assertNotNull(approximationInfo)) return stackValue;
+        if (runtimeAssertionInfo == null || !runtimeAssertionInfo.getNeedNotNullAssertion()) return stackValue;
 
         return new StackValue(stackValue.type) {
 
@@ -649,7 +649,7 @@ public class AsmUtil {
                 stackValue.put(type, v);
                 if (type.getSort() == Type.OBJECT || type.getSort() == Type.ARRAY) {
                     v.dup();
-                    v.visitLdcInsn(approximationInfo.getMessage());
+                    v.visitLdcInsn(runtimeAssertionInfo.getMessage());
                     v.invokestatic("kotlin/jvm/internal/Intrinsics", "checkExpressionValueIsNotNull",
                                    "(Ljava/lang/Object;Ljava/lang/String;)V", false);
                 }
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/BranchedValue.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/BranchedValue.kt
index decb9bc8b46..8eea7c615dd 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/BranchedValue.kt
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/BranchedValue.kt
@@ -17,7 +17,6 @@
 package org.jetbrains.kotlin.codegen
 
 import com.intellij.psi.tree.IElementType
-import org.jetbrains.kotlin.codegen.pseudoInsns.PseudoInsnOpcode
 import org.jetbrains.kotlin.codegen.pseudoInsns.fakeAlwaysFalseIfeq
 import org.jetbrains.kotlin.codegen.pseudoInsns.fakeAlwaysTrueIfeq
 import org.jetbrains.kotlin.lexer.JetTokens
@@ -50,7 +49,7 @@ open class BranchedValue(
     open fun condJump(jumpLabel: Label, v: InstructionAdapter, jumpIfFalse: Boolean) {
         if (arg1 is CondJump) arg1.condJump(jumpLabel, v, jumpIfFalse) else arg1.put(operandType, v)
         arg2?.put(operandType, v)
-        v.visitJumpInsn(patchOpcode(if (jumpIfFalse) opcode else negatedOperations[opcode], v), jumpLabel);
+        v.visitJumpInsn(patchOpcode(if (jumpIfFalse) opcode else negatedOperations[opcode]!!, v), jumpLabel);
     }
 
     open fun loopJump(jumpLabel: Label, v: InstructionAdapter, jumpIfFalse: Boolean) {
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/ClassBodyCodegen.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/ClassBodyCodegen.java
index 10526eae4df..0078f6ec432 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/ClassBodyCodegen.java
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/ClassBodyCodegen.java
@@ -21,10 +21,7 @@ import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.backend.common.bridges.BridgesPackage;
 import org.jetbrains.kotlin.codegen.context.ClassContext;
 import org.jetbrains.kotlin.codegen.state.GenerationState;
-import org.jetbrains.kotlin.descriptors.ClassDescriptor;
-import org.jetbrains.kotlin.descriptors.DeclarationDescriptor;
-import org.jetbrains.kotlin.descriptors.FunctionDescriptor;
-import org.jetbrains.kotlin.descriptors.PropertyDescriptor;
+import org.jetbrains.kotlin.descriptors.*;
 import org.jetbrains.kotlin.psi.*;
 import org.jetbrains.kotlin.resolve.BindingContext;
 import org.jetbrains.kotlin.resolve.DescriptorUtils;
@@ -80,7 +77,7 @@ public abstract class ClassBodyCodegen extends MemberCodegen<JetClassOrObject> {
             }
         }
 
-        generatePrimaryConstructorProperties(propertyCodegen, myClass);
+        generatePrimaryConstructorProperties();
     }
 
     private static boolean shouldProcessFirst(JetDeclaration declaration) {
@@ -101,8 +98,8 @@ public abstract class ClassBodyCodegen extends MemberCodegen<JetClassOrObject> {
         }
     }
 
-    private void generatePrimaryConstructorProperties(PropertyCodegen propertyCodegen, JetClassOrObject origin) {
-        boolean isAnnotation = origin instanceof JetClass && ((JetClass) origin).isAnnotation();
+    private void generatePrimaryConstructorProperties() {
+        boolean isAnnotation = descriptor.getKind() == ClassKind.ANNOTATION_CLASS;
         for (JetParameter p : getPrimaryConstructorParameters()) {
             if (p.hasValOrVar()) {
                 PropertyDescriptor propertyDescriptor = bindingContext.get(BindingContext.PRIMARY_CONSTRUCTOR_PARAMETER, p);
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/ClosureCodegen.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/ClosureCodegen.java
index d8906bdf2f7..852620a056b 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/ClosureCodegen.java
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/ClosureCodegen.java
@@ -18,6 +18,7 @@ package org.jetbrains.kotlin.codegen;
 
 import com.google.common.collect.Lists;
 import com.intellij.util.ArrayUtil;
+import kotlin.KotlinPackage;
 import kotlin.Unit;
 import kotlin.jvm.functions.Function1;
 import org.jetbrains.annotations.NotNull;
@@ -31,11 +32,13 @@ import org.jetbrains.kotlin.codegen.state.JetTypeMapper;
 import org.jetbrains.kotlin.descriptors.*;
 import org.jetbrains.kotlin.descriptors.impl.SimpleFunctionDescriptorImpl;
 import org.jetbrains.kotlin.load.java.JvmAbi;
+import org.jetbrains.kotlin.load.kotlin.PackageClassUtils;
 import org.jetbrains.kotlin.psi.JetElement;
 import org.jetbrains.kotlin.resolve.BindingContext;
 import org.jetbrains.kotlin.resolve.DescriptorUtils;
 import org.jetbrains.kotlin.types.JetType;
 import org.jetbrains.kotlin.types.expressions.OperatorConventions;
+import org.jetbrains.kotlin.utils.UtilsPackage;
 import org.jetbrains.org.objectweb.asm.MethodVisitor;
 import org.jetbrains.org.objectweb.asm.Type;
 import org.jetbrains.org.objectweb.asm.commons.InstructionAdapter;
@@ -46,6 +49,7 @@ import java.util.Collections;
 import java.util.List;
 
 import static org.jetbrains.kotlin.codegen.AsmUtil.*;
+import static org.jetbrains.kotlin.codegen.ExpressionCodegen.generateClassLiteralReference;
 import static org.jetbrains.kotlin.codegen.JvmCodegenUtil.isConst;
 import static org.jetbrains.kotlin.codegen.binding.CodegenBinding.CLOSURE;
 import static org.jetbrains.kotlin.codegen.binding.CodegenBinding.asmTypeForAnonymousClass;
@@ -53,6 +57,7 @@ import static org.jetbrains.kotlin.load.java.JvmAnnotationNames.KotlinSyntheticC
 import static org.jetbrains.kotlin.resolve.descriptorUtil.DescriptorUtilPackage.getBuiltIns;
 import static org.jetbrains.kotlin.resolve.jvm.AsmTypes.*;
 import static org.jetbrains.kotlin.resolve.jvm.diagnostics.DiagnosticsPackage.OtherOrigin;
+import static org.jetbrains.kotlin.resolve.jvm.diagnostics.JvmDeclarationOrigin.NO_ORIGIN;
 import static org.jetbrains.org.objectweb.asm.Opcodes.*;
 
 public class ClosureCodegen extends MemberCodegen<JetElement> {
@@ -61,6 +66,7 @@ public class ClosureCodegen extends MemberCodegen<JetElement> {
     private final SamType samType;
     private final JetType superClassType;
     private final List<JetType> superInterfaceTypes;
+    private final FunctionDescriptor functionReferenceTarget;
     private final FunctionGenerationStrategy strategy;
     private final CalculatedClosure closure;
     private final Type asmType;
@@ -76,6 +82,7 @@ public class ClosureCodegen extends MemberCodegen<JetElement> {
             @Nullable SamType samType,
             @NotNull ClosureContext context,
             @NotNull KotlinSyntheticClass.Kind syntheticClassKind,
+            @Nullable FunctionDescriptor functionReferenceTarget,
             @NotNull FunctionGenerationStrategy strategy,
             @NotNull MemberCodegen<?> parentCodegen,
             @NotNull ClassBuilder classBuilder
@@ -86,6 +93,7 @@ public class ClosureCodegen extends MemberCodegen<JetElement> {
         this.classDescriptor = context.getContextDescriptor();
         this.samType = samType;
         this.syntheticClassKind = syntheticClassKind;
+        this.functionReferenceTarget = functionReferenceTarget;
         this.strategy = strategy;
 
         if (samType == null) {
@@ -189,10 +197,14 @@ public class ClosureCodegen extends MemberCodegen<JetElement> {
             functionCodegen.generateBridges(descriptorForBridges);
         }
 
-        this.constructor = generateConstructor(superClassAsmType);
+        if (functionReferenceTarget != null) {
+            generateFunctionReferenceMethods(functionReferenceTarget);
+        }
+
+        this.constructor = generateConstructor();
 
         if (isConst(closure)) {
-            generateConstInstance();
+            generateConstInstance(asmType, asmType, UtilsPackage.<InstructionAdapter>doNothing());
         }
 
         genClosureFields(closure, v, typeMapper);
@@ -214,77 +226,39 @@ public class ClosureCodegen extends MemberCodegen<JetElement> {
     }
 
     @NotNull
-    public StackValue putInstanceOnStack(
-            @NotNull final ExpressionCodegen codegen,
-            @Nullable final FunctionDescriptor functionReferenceTarget
-    ) {
-        return StackValue.operation(asmType, new Function1<InstructionAdapter, Unit>() {
-            @Override
-            public Unit invoke(InstructionAdapter v) {
-                if (isConst(closure)) {
-                    v.getstatic(asmType.getInternalName(), JvmAbi.INSTANCE_FIELD, asmType.getDescriptor());
+    public StackValue putInstanceOnStack(@NotNull final ExpressionCodegen codegen) {
+        return StackValue.operation(
+                functionReferenceTarget != null ? K_FUNCTION : asmType,
+                new Function1<InstructionAdapter, Unit>() {
+                    @Override
+                    public Unit invoke(InstructionAdapter v) {
+                        if (isConst(closure)) {
+                            v.getstatic(asmType.getInternalName(), JvmAbi.INSTANCE_FIELD, asmType.getDescriptor());
+                        }
+                        else {
+                            v.anew(asmType);
+                            v.dup();
+
+                            codegen.pushClosureOnStack(classDescriptor, true, codegen.defaultCallGenerator);
+                            v.invokespecial(asmType.getInternalName(), "<init>", constructor.getDescriptor(), false);
+                        }
+
+                        if (functionReferenceTarget != null) {
+                            v.invokestatic(REFLECTION, "function", Type.getMethodDescriptor(K_FUNCTION, FUNCTION_REFERENCE), false);
+                        }
+
+                        return Unit.INSTANCE$;
+                    }
                 }
-                else {
-                    v.anew(asmType);
-                    v.dup();
-
-                    codegen.pushClosureOnStack(classDescriptor, true, codegen.defaultCallGenerator);
-                    v.invokespecial(asmType.getInternalName(), "<init>", constructor.getDescriptor(), false);
-                }
-
-                if (functionReferenceTarget != null) {
-                    equipFunctionReferenceWithReflection(v, functionReferenceTarget);
-                }
-
-                return Unit.INSTANCE$;
-            }
-        });
-    }
-
-    private static void equipFunctionReferenceWithReflection(@NotNull InstructionAdapter v, @NotNull FunctionDescriptor target) {
-        DeclarationDescriptor container = target.getContainingDeclaration();
-
-        Type type;
-        if (container instanceof PackageFragmentDescriptor) {
-            type = target.getExtensionReceiverParameter() != null
-                   ? K_TOP_LEVEL_EXTENSION_FUNCTION
-                   : K_TOP_LEVEL_FUNCTION;
-        }
-        else if (container instanceof ClassDescriptor) {
-            type = K_MEMBER_FUNCTION;
-        }
-        else {
-            type = K_LOCAL_FUNCTION;
-        }
-
-        Method method = method("function", K_FUNCTION, FUNCTION_REFERENCE);
-        v.invokestatic(REFLECTION, method.getName(), method.getDescriptor(), false);
-        StackValue.coerce(K_FUNCTION, type, v);
-    }
-
-
-    private void generateConstInstance() {
-        MethodVisitor mv = v.newMethod(OtherOrigin(element, funDescriptor), ACC_STATIC | ACC_SYNTHETIC, "<clinit>", "()V", null, ArrayUtil.EMPTY_STRING_ARRAY);
-        InstructionAdapter iv = new InstructionAdapter(mv);
-
-        v.newField(OtherOrigin(element, funDescriptor), ACC_STATIC | ACC_FINAL | ACC_PUBLIC, JvmAbi.INSTANCE_FIELD, asmType.getDescriptor(), null, null);
-
-        if (state.getClassBuilderMode() == ClassBuilderMode.FULL) {
-            mv.visitCode();
-            iv.anew(asmType);
-            iv.dup();
-            iv.invokespecial(asmType.getInternalName(), "<init>", "()V", false);
-            iv.putstatic(asmType.getInternalName(), JvmAbi.INSTANCE_FIELD, asmType.getDescriptor());
-            mv.visitInsn(RETURN);
-            FunctionCodegen.endVisit(mv, "<clinit>", element);
-        }
+        );
     }
 
     private void generateBridge(@NotNull Method bridge, @NotNull Method delegate) {
         if (bridge.equals(delegate)) return;
 
         MethodVisitor mv =
-                v.newMethod(OtherOrigin(element, funDescriptor), ACC_PUBLIC | ACC_BRIDGE, bridge.getName(), bridge.getDescriptor(), null, ArrayUtil.EMPTY_STRING_ARRAY);
+                v.newMethod(OtherOrigin(element, funDescriptor), ACC_PUBLIC | ACC_BRIDGE,
+                            bridge.getName(), bridge.getDescriptor(), null, ArrayUtil.EMPTY_STRING_ARRAY);
 
         if (state.getClassBuilderMode() != ClassBuilderMode.FULL) return;
 
@@ -295,17 +269,18 @@ public class ClosureCodegen extends MemberCodegen<JetElement> {
 
         iv.load(0, asmType);
 
-        ReceiverParameterDescriptor receiver = funDescriptor.getExtensionReceiverParameter();
-        int count = 1;
-        if (receiver != null) {
-            StackValue.local(count, bridge.getArgumentTypes()[count - 1]).put(typeMapper.mapType(receiver.getType()), iv);
-            count++;
-        }
+        Type[] myParameterTypes = bridge.getArgumentTypes();
 
-        List<ValueParameterDescriptor> params = funDescriptor.getValueParameters();
-        for (ValueParameterDescriptor param : params) {
-            StackValue.local(count, bridge.getArgumentTypes()[count - 1]).put(typeMapper.mapType(param.getType()), iv);
-            count++;
+        List<ParameterDescriptor> calleeParameters = KotlinPackage.plus(
+                UtilsPackage.<ParameterDescriptor>singletonOrEmptyList(funDescriptor.getExtensionReceiverParameter()),
+                funDescriptor.getValueParameters()
+        );
+
+        int slot = 1;
+        for (int i = 0; i < calleeParameters.size(); i++) {
+            Type type = myParameterTypes[i];
+            StackValue.local(slot, type).put(typeMapper.mapType(calleeParameters.get(i)), iv);
+            slot += type.getSize();
         }
 
         iv.invokevirtual(asmType.getInternalName(), delegate.getName(), delegate.getDescriptor(), false);
@@ -316,8 +291,79 @@ public class ClosureCodegen extends MemberCodegen<JetElement> {
         FunctionCodegen.endVisit(mv, "bridge", element);
     }
 
+    // TODO: ImplementationBodyCodegen.markLineNumberForSyntheticFunction?
+    private void generateFunctionReferenceMethods(@NotNull FunctionDescriptor descriptor) {
+        int flags = ACC_PUBLIC | ACC_FINAL;
+        boolean generateBody = state.getClassBuilderMode() == ClassBuilderMode.FULL;
+
+        {
+            MethodVisitor mv =
+                    v.newMethod(NO_ORIGIN, flags, "getOwner", Type.getMethodDescriptor(K_DECLARATION_CONTAINER_TYPE), null, null);
+            if (generateBody) {
+                mv.visitCode();
+                InstructionAdapter iv = new InstructionAdapter(mv);
+                generateCallableReferenceDeclarationContainer(iv, descriptor, typeMapper);
+                iv.areturn(K_DECLARATION_CONTAINER_TYPE);
+                FunctionCodegen.endVisit(iv, "function reference getOwner", element);
+            }
+        }
+
+        {
+            MethodVisitor mv =
+                    v.newMethod(NO_ORIGIN, flags, "getName", Type.getMethodDescriptor(JAVA_STRING_TYPE), null, null);
+            if (generateBody) {
+                mv.visitCode();
+                InstructionAdapter iv = new InstructionAdapter(mv);
+                iv.aconst(descriptor.getName().asString());
+                iv.areturn(JAVA_STRING_TYPE);
+                FunctionCodegen.endVisit(iv, "function reference getName", element);
+            }
+        }
+
+        {
+            MethodVisitor mv = v.newMethod(NO_ORIGIN, flags, "getSignature", Type.getMethodDescriptor(JAVA_STRING_TYPE), null, null);
+            if (generateBody) {
+                mv.visitCode();
+                InstructionAdapter iv = new InstructionAdapter(mv);
+                Method method = typeMapper.mapSignature(descriptor).getAsmMethod();
+                iv.aconst(method.getName() + method.getDescriptor());
+                iv.areturn(JAVA_STRING_TYPE);
+                FunctionCodegen.endVisit(iv, "function reference getSignature", element);
+            }
+        }
+    }
+
+    public static void generateCallableReferenceDeclarationContainer(
+            @NotNull InstructionAdapter iv,
+            @NotNull CallableDescriptor descriptor,
+            @NotNull JetTypeMapper typeMapper
+    ) {
+        DeclarationDescriptor container = descriptor.getContainingDeclaration();
+        if (container instanceof ClassDescriptor) {
+            // TODO: getDefaultType() here is wrong and won't work for arrays
+            StackValue value = generateClassLiteralReference(typeMapper, ((ClassDescriptor) container).getDefaultType());
+            value.put(K_CLASS_TYPE, iv);
+        }
+        else if (container instanceof PackageFragmentDescriptor) {
+            String packageClassInternalName = PackageClassUtils.getPackageClassInternalName(
+                    ((PackageFragmentDescriptor) container).getFqName()
+            );
+            iv.getstatic(packageClassInternalName, JvmAbi.KOTLIN_PACKAGE_FIELD_NAME, K_PACKAGE_TYPE.getDescriptor());
+        }
+        else if (container instanceof ScriptDescriptor) {
+            // TODO: correct container for scripts (KScript?)
+            StackValue value = generateClassLiteralReference(
+                    typeMapper, ((ScriptDescriptor) container).getClassDescriptor().getDefaultType()
+            );
+            value.put(K_CLASS_TYPE, iv);
+        }
+        else {
+            iv.aconst(null);
+        }
+    }
+
     @NotNull
-    private Method generateConstructor(@NotNull Type superClassAsmType) {
+    private Method generateConstructor() {
         List<FieldInfo> args = calculateConstructorParameters(typeMapper, closure, asmType);
 
         Type[] argTypes = fieldListToTypeArray(args);
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/CollectionStubMethodGenerator.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/CollectionStubMethodGenerator.kt
index 03730eff4d2..542ea8cdd9c 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/CollectionStubMethodGenerator.kt
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/CollectionStubMethodGenerator.kt
@@ -18,23 +18,25 @@ package org.jetbrains.kotlin.codegen
 
 import org.jetbrains.kotlin.codegen.state.GenerationState
 import org.jetbrains.kotlin.descriptors.*
-import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor.Kind.*
-import org.jetbrains.kotlin.descriptors.impl.*
-import org.jetbrains.org.objectweb.asm.Opcodes.*
-import org.jetbrains.kotlin.resolve.jvm.diagnostics.JvmDeclarationOrigin
-import org.jetbrains.org.objectweb.asm.commons.InstructionAdapter
-import org.jetbrains.kotlin.builtins.KotlinBuiltIns
-import org.jetbrains.kotlin.types.*
-import org.jetbrains.kotlin.resolve.scopes.JetScope
+import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor.Kind.DECLARATION
 import org.jetbrains.kotlin.descriptors.annotations.Annotations
+import org.jetbrains.kotlin.descriptors.impl.MutableClassDescriptor
+import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.resolve.OverrideResolver
 import org.jetbrains.kotlin.resolve.OverridingUtil
-import java.util.LinkedHashSet
-import org.jetbrains.kotlin.name.Name
-import java.util.ArrayList
-import org.jetbrains.kotlin.types.checker.JetTypeChecker
-import java.util.HashSet
+import org.jetbrains.kotlin.resolve.descriptorUtil.builtIns
+import org.jetbrains.kotlin.resolve.jvm.diagnostics.JvmDeclarationOrigin
 import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodSignature
+import org.jetbrains.kotlin.resolve.scopes.JetScope
+import org.jetbrains.kotlin.types.*
+import org.jetbrains.kotlin.types.checker.JetTypeChecker
+import org.jetbrains.org.objectweb.asm.Opcodes.ACC_ABSTRACT
+import org.jetbrains.org.objectweb.asm.Opcodes.ACC_PUBLIC
+import org.jetbrains.org.objectweb.asm.Opcodes.ACC_SYNTHETIC
+import org.jetbrains.org.objectweb.asm.commons.InstructionAdapter
+import java.util.ArrayList
+import java.util.HashSet
+import java.util.LinkedHashSet
 
 /**
  * Generates exception-throwing stubs for methods from mutable collection classes not implemented in Kotlin classes which inherit only from
@@ -127,7 +129,7 @@ class CollectionStubMethodGenerator(
     private fun findRelevantSuperCollectionClasses(): Collection<CollectionClassPair> {
         fun pair(readOnlyClass: ClassDescriptor, mutableClass: ClassDescriptor) = CollectionClassPair(readOnlyClass, mutableClass)
 
-        val collectionClasses = with(KotlinBuiltIns.getInstance()) {
+        val collectionClasses = with(descriptor.builtIns) {
             listOf(
                     pair(getCollection(), getMutableCollection()),
                     pair(getSet(), getMutableSet()),
@@ -164,7 +166,7 @@ class CollectionStubMethodGenerator(
         val result = ArrayList<FunctionDescriptor>()
 
         OverrideResolver.generateOverridesInAClass(klass, listOf(), object : OverridingUtil.DescriptorSink {
-            override fun addToScope(fakeOverride: CallableMemberDescriptor) {
+            override fun addFakeOverride(fakeOverride: CallableMemberDescriptor) {
                 if (fakeOverride !is FunctionDescriptor) return
                 if (fakeOverride.findOverriddenFromDirectSuperClass(mutableCollectionClass) != null) {
                     result.add(fakeOverride)
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/DefaultParameterValueSubstitutor.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/DefaultParameterValueSubstitutor.kt
index bd036f7e545..fb19e4c7287 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/DefaultParameterValueSubstitutor.kt
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/DefaultParameterValueSubstitutor.kt
@@ -206,6 +206,7 @@ public class DefaultParameterValueSubstitutor(val state: GenerationState) {
 
     private fun isEmptyConstructorNeeded(constructorDescriptor: ConstructorDescriptor, classOrObject: JetClassOrObject): Boolean {
         val classDescriptor = constructorDescriptor.getContainingDeclaration()
+        if (classDescriptor.getKind() != ClassKind.CLASS) return false
 
         if (classOrObject.isLocal()) return false
 
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/ExpressionCodegen.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/ExpressionCodegen.java
index c7f0f2dc69e..45023e2870e 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/ExpressionCodegen.java
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/ExpressionCodegen.java
@@ -32,6 +32,7 @@ import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.backend.common.CodegenUtil;
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
 import org.jetbrains.kotlin.codegen.binding.CalculatedClosure;
+import org.jetbrains.kotlin.codegen.binding.CodegenBinding;
 import org.jetbrains.kotlin.codegen.context.*;
 import org.jetbrains.kotlin.codegen.extensions.ExpressionCodegenExtension;
 import org.jetbrains.kotlin.codegen.inline.*;
@@ -45,13 +46,15 @@ import org.jetbrains.kotlin.codegen.state.JetTypeMapper;
 import org.jetbrains.kotlin.codegen.when.SwitchCodegen;
 import org.jetbrains.kotlin.codegen.when.SwitchCodegenUtil;
 import org.jetbrains.kotlin.descriptors.*;
+import org.jetbrains.kotlin.descriptors.impl.ScriptCodeDescriptor;
 import org.jetbrains.kotlin.diagnostics.DiagnosticUtils;
 import org.jetbrains.kotlin.diagnostics.Errors;
+import org.jetbrains.kotlin.jvm.RuntimeAssertionInfo;
+import org.jetbrains.kotlin.jvm.bindingContextSlices.BindingContextSlicesPackage;
 import org.jetbrains.kotlin.lexer.JetTokens;
 import org.jetbrains.kotlin.load.java.JvmAbi;
 import org.jetbrains.kotlin.load.java.descriptors.JavaClassDescriptor;
 import org.jetbrains.kotlin.load.java.descriptors.SamConstructorDescriptor;
-import org.jetbrains.kotlin.load.kotlin.PackageClassUtils;
 import org.jetbrains.kotlin.name.Name;
 import org.jetbrains.kotlin.psi.*;
 import org.jetbrains.kotlin.renderer.DescriptorRenderer;
@@ -60,22 +63,20 @@ import org.jetbrains.kotlin.resolve.BindingContextUtils;
 import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils;
 import org.jetbrains.kotlin.resolve.DescriptorUtils;
 import org.jetbrains.kotlin.resolve.annotations.AnnotationsPackage;
-import org.jetbrains.kotlin.resolve.calls.CallResolverUtil;
+import org.jetbrains.kotlin.resolve.calls.callResolverUtil.CallResolverUtilPackage;
 import org.jetbrains.kotlin.resolve.calls.model.*;
 import org.jetbrains.kotlin.resolve.calls.util.CallMaker;
 import org.jetbrains.kotlin.resolve.calls.util.FakeCallableDescriptorForObject;
 import org.jetbrains.kotlin.resolve.constants.CompileTimeConstant;
-import org.jetbrains.kotlin.resolve.constants.IntegerValueTypeConstant;
+import org.jetbrains.kotlin.resolve.constants.ConstantValue;
 import org.jetbrains.kotlin.resolve.constants.evaluate.ConstantExpressionEvaluator;
-import org.jetbrains.kotlin.resolve.constants.evaluate.EvaluatePackage;
 import org.jetbrains.kotlin.resolve.descriptorUtil.DescriptorUtilPackage;
 import org.jetbrains.kotlin.resolve.inline.InlineUtil;
-import org.jetbrains.kotlin.resolve.jvm.diagnostics.ErrorsJvm;
 import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodParameterKind;
 import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodParameterSignature;
 import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodSignature;
 import org.jetbrains.kotlin.resolve.scopes.receivers.*;
-import org.jetbrains.kotlin.types.Approximation;
+import org.jetbrains.kotlin.synthetic.SyntheticJavaPropertyDescriptor;
 import org.jetbrains.kotlin.types.JetType;
 import org.jetbrains.kotlin.types.TypeProjection;
 import org.jetbrains.kotlin.types.TypeUtils;
@@ -85,7 +86,6 @@ import org.jetbrains.org.objectweb.asm.MethodVisitor;
 import org.jetbrains.org.objectweb.asm.Opcodes;
 import org.jetbrains.org.objectweb.asm.Type;
 import org.jetbrains.org.objectweb.asm.commons.InstructionAdapter;
-import org.jetbrains.org.objectweb.asm.commons.Method;
 
 import java.util.*;
 
@@ -104,7 +104,6 @@ import static org.jetbrains.kotlin.resolve.descriptorUtil.DescriptorUtilPackage.
 import static org.jetbrains.kotlin.resolve.jvm.AsmTypes.*;
 import static org.jetbrains.kotlin.resolve.jvm.diagnostics.DiagnosticsPackage.OtherOrigin;
 import static org.jetbrains.kotlin.resolve.jvm.diagnostics.DiagnosticsPackage.TraitImpl;
-import static org.jetbrains.kotlin.serialization.deserialization.DeserializationPackage.findClassAcrossModuleDependencies;
 import static org.jetbrains.org.objectweb.asm.Opcodes.*;
 
 public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implements LocalLookup {
@@ -282,12 +281,12 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
 
             StackValue stackValue = selector.accept(visitor, receiver);
 
-            Approximation.Info approximationInfo = null;
+            RuntimeAssertionInfo runtimeAssertionInfo = null;
             if (selector instanceof JetExpression) {
-                approximationInfo = bindingContext.get(BindingContext.EXPRESSION_RESULT_APPROXIMATION, (JetExpression) selector);
+                runtimeAssertionInfo = bindingContext.get(BindingContextSlicesPackage.getRUNTIME_ASSERTION_INFO(), (JetExpression) selector);
             }
 
-            return genNotNullAssertions(state, stackValue, approximationInfo);
+            return genNotNullAssertions(state, stackValue, runtimeAssertionInfo);
         }
         catch (ProcessCanceledException e) {
             throw e;
@@ -1293,20 +1292,19 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
 
     @Override
     public StackValue visitConstantExpression(@NotNull JetConstantExpression expression, StackValue receiver) {
-        CompileTimeConstant<?> compileTimeValue = getCompileTimeConstant(expression, bindingContext);
+        ConstantValue<?> compileTimeValue = getCompileTimeConstant(expression, bindingContext);
         assert compileTimeValue != null;
         return StackValue.constant(compileTimeValue.getValue(), expressionType(expression));
     }
 
     @Nullable
-    public static CompileTimeConstant getCompileTimeConstant(@NotNull JetExpression expression, @NotNull BindingContext bindingContext) {
+    public static ConstantValue<?> getCompileTimeConstant(@NotNull JetExpression expression, @NotNull BindingContext bindingContext) {
         CompileTimeConstant<?> compileTimeValue = ConstantExpressionEvaluator.getConstant(expression, bindingContext);
-        if (compileTimeValue instanceof IntegerValueTypeConstant) {
-            JetType expectedType = bindingContext.getType(expression);
-            assert expectedType != null : "Expression is not type checked: " + expression.getText();
-            return EvaluatePackage.createCompileTimeConstantWithType((IntegerValueTypeConstant) compileTimeValue, expectedType);
+        if (compileTimeValue == null) {
+            return null;
         }
-        return compileTimeValue;
+        JetType expectedType = bindingContext.getType(expression);
+        return compileTimeValue.toConstantValue(expectedType);
     }
 
     @Override
@@ -1429,7 +1427,8 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
         );
 
         ClosureCodegen closureCodegen = new ClosureCodegen(
-                state, declaration, samType, context.intoClosure(descriptor, this, typeMapper), kind, strategy, parentCodegen, cv
+                state, declaration, samType, context.intoClosure(descriptor, this, typeMapper), kind,
+                functionReferenceTarget, strategy, parentCodegen, cv
         );
 
         closureCodegen.generate();
@@ -1439,7 +1438,7 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
             propagateChildReifiedTypeParametersUsages(closureCodegen.getReifiedTypeParametersUsages());
         }
 
-        return closureCodegen.putInstanceOnStack(this, functionReferenceTarget);
+        return closureCodegen.putInstanceOnStack(this);
     }
 
     @Override
@@ -2038,14 +2037,18 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
             return localOrCaptured;
         }
 
-        if (descriptor instanceof ValueParameterDescriptor && descriptor.getContainingDeclaration() instanceof ScriptDescriptor) {
-            ScriptDescriptor scriptDescriptor = (ScriptDescriptor) descriptor.getContainingDeclaration();
+        DeclarationDescriptor container = descriptor.getContainingDeclaration();
+        if (descriptor instanceof ValueParameterDescriptor && container instanceof ScriptCodeDescriptor) {
+            ScriptCodeDescriptor scriptCodeDescriptor = (ScriptCodeDescriptor) container;
+            ScriptDescriptor scriptDescriptor = (ScriptDescriptor) scriptCodeDescriptor.getContainingDeclaration();
             Type scriptClassType = asmTypeForScriptDescriptor(bindingContext, scriptDescriptor);
             ValueParameterDescriptor valueParameterDescriptor = (ValueParameterDescriptor) descriptor;
             ClassDescriptor scriptClass = bindingContext.get(CLASS_FOR_SCRIPT, scriptDescriptor);
+            //noinspection ConstantConditions
             StackValue script = StackValue.thisOrOuter(this, scriptClass, false, false);
             Type fieldType = typeMapper.mapType(valueParameterDescriptor);
-            return StackValue.field(fieldType, scriptClassType, valueParameterDescriptor.getName().getIdentifier(), false, script, valueParameterDescriptor);
+            return StackValue.field(fieldType, scriptClassType, valueParameterDescriptor.getName().getIdentifier(), false, script,
+                                    valueParameterDescriptor);
         }
 
         throw new UnsupportedOperationException("don't know how to generate reference " + descriptor);
@@ -2142,6 +2145,10 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
             @NotNull MethodKind methodKind,
             StackValue receiver
     ) {
+        if (propertyDescriptor instanceof SyntheticJavaPropertyDescriptor) {
+            return intermediateValueForSyntheticExtensionProperty((SyntheticJavaPropertyDescriptor) propertyDescriptor, receiver);
+        }
+
         DeclarationDescriptor containingDeclaration = propertyDescriptor.getContainingDeclaration();
 
         boolean isBackingFieldInAnotherClass = AsmUtil.isPropertyWithBackingFieldInOuterClass(propertyDescriptor);
@@ -2164,10 +2171,12 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
         if (isBackingFieldInAnotherClass && forceField) {
             backingFieldContext = context.findParentContextWithDescriptor(containingDeclaration.getContainingDeclaration());
             int flags = AsmUtil.getVisibilityForSpecialPropertyBackingField(propertyDescriptor, isDelegatedProperty);
-            skipPropertyAccessors = (flags & ACC_PRIVATE) == 0 || methodKind == MethodKind.SYNTHETIC_ACCESSOR || methodKind == MethodKind.INITIALIZER;
+            skipPropertyAccessors =
+                    (flags & ACC_PRIVATE) == 0 || methodKind == MethodKind.SYNTHETIC_ACCESSOR || methodKind == MethodKind.INITIALIZER;
             if (!skipPropertyAccessors) {
                 propertyDescriptor = (PropertyDescriptor) backingFieldContext.getAccessor(propertyDescriptor, true, delegateType);
-                changeOwnerOnTypeMapping = changeOwnerOnTypeMapping && !(propertyDescriptor instanceof AccessorForPropertyBackingFieldInOuterClass);
+                changeOwnerOnTypeMapping =
+                        changeOwnerOnTypeMapping && !(propertyDescriptor instanceof AccessorForPropertyBackingFieldInOuterClass);
             }
         }
 
@@ -2189,7 +2198,8 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
 
                 PropertyGetterDescriptor getter = propertyDescriptor.getGetter();
                 if (getter != null) {
-                    callableGetter = typeMapper.mapToCallableMethod(getter, isSuper || MethodKind.SYNTHETIC_ACCESSOR == methodKind, context);
+                    callableGetter =
+                            typeMapper.mapToCallableMethod(getter, isSuper || MethodKind.SYNTHETIC_ACCESSOR == methodKind, context);
                 }
             }
 
@@ -2200,14 +2210,16 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
                         callableSetter = null;
                     }
                     else {
-                        callableSetter = typeMapper.mapToCallableMethod(setter, isSuper || MethodKind.SYNTHETIC_ACCESSOR == methodKind, context);
+                        callableSetter =
+                                typeMapper.mapToCallableMethod(setter, isSuper || MethodKind.SYNTHETIC_ACCESSOR == methodKind, context);
                     }
                 }
             }
         }
 
         propertyDescriptor = DescriptorUtils.unwrapFakeOverride(propertyDescriptor);
-        Type backingFieldOwner = typeMapper.mapOwner(changeOwnerOnTypeMapping ? propertyDescriptor.getContainingDeclaration() : propertyDescriptor,
+        Type backingFieldOwner =
+                typeMapper.mapOwner(changeOwnerOnTypeMapping ? propertyDescriptor.getContainingDeclaration() : propertyDescriptor,
                                     isCallInsideSameModuleAsDeclared(propertyDescriptor, context, state.getOutDirectory()));
 
         String fieldName;
@@ -2224,9 +2236,18 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
         }
 
         return StackValue.property(propertyDescriptor, backingFieldOwner,
-                            typeMapper.mapType(isDelegatedProperty && forceField ? delegateType : propertyDescriptor.getOriginal().getType()),
-                            isStaticBackingField, fieldName, callableGetter, callableSetter, state, receiver);
+                                   typeMapper.mapType(
+                                           isDelegatedProperty && forceField ? delegateType : propertyDescriptor.getOriginal().getType()),
+                                   isStaticBackingField, fieldName, callableGetter, callableSetter, state, receiver);
+    }
 
+    @NotNull
+    private StackValue.Property intermediateValueForSyntheticExtensionProperty(@NotNull SyntheticJavaPropertyDescriptor propertyDescriptor, StackValue receiver) {
+        Type type = typeMapper.mapType(propertyDescriptor.getOriginal().getType());
+        CallableMethod callableGetter = typeMapper.mapToCallableMethod(propertyDescriptor.getGetMethod(), false, context);
+        FunctionDescriptor setMethod = propertyDescriptor.getSetMethod();
+        CallableMethod callableSetter = setMethod != null ? typeMapper.mapToCallableMethod(setMethod, false, context) : null;
+        return StackValue.property(propertyDescriptor, null, type, false, null, callableGetter, callableSetter, state, receiver);
     }
 
     @Override
@@ -2329,7 +2350,7 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
     @NotNull
     public StackValue invokeFunction(@NotNull Call call, @NotNull ResolvedCall<?> resolvedCall, @NotNull StackValue receiver) {
         FunctionDescriptor fd = accessibleFunctionDescriptor(resolvedCall);
-        JetSuperExpression superCallExpression = CallResolverUtil.getSuperCallExpression(call);
+        JetSuperExpression superCallExpression = CallResolverUtilPackage.getSuperCallExpression(call);
         boolean superCall = superCallExpression != null;
 
         if (superCall && !isInterface(fd.getContainingDeclaration())) {
@@ -2732,15 +2753,13 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
 
     @Override
     public StackValue visitClassLiteralExpression(@NotNull JetClassLiteralExpression expression, StackValue data) {
-        checkReflectionIsAvailable(expression);
-
         JetType type = bindingContext.getType(expression);
         assert type != null;
 
         assert state.getReflectionTypes().getkClass().getTypeConstructor().equals(type.getConstructor())
                 : "::class expression should be type checked to a KClass: " + type;
 
-        return generateClassLiteralReference(KotlinPackage.single(type.getArguments()).getType());
+        return generateClassLiteralReference(typeMapper, KotlinPackage.single(type.getArguments()).getType());
     }
 
     @Override
@@ -2754,96 +2773,39 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
         }
 
         VariableDescriptor variableDescriptor = bindingContext.get(VARIABLE, expression);
-        if (variableDescriptor == null) {
-            throw new UnsupportedOperationException("Unsupported callable reference expression: " + expression.getText());
+        if (variableDescriptor != null) {
+            return generatePropertyReference(expression, variableDescriptor, resolvedCall);
         }
 
-        // TODO: this diagnostic should also be reported on function references once they obtain reflection
-        checkReflectionIsAvailable(expression);
-
-        VariableDescriptor descriptor = (VariableDescriptor) resolvedCall.getResultingDescriptor();
-
-        DeclarationDescriptor containingDeclaration = descriptor.getContainingDeclaration();
-        if (containingDeclaration instanceof PackageFragmentDescriptor) {
-            return generateTopLevelPropertyReference(descriptor);
-        }
-        else if (containingDeclaration instanceof ClassDescriptor) {
-            return generateMemberPropertyReference(descriptor, (ClassDescriptor) containingDeclaration);
-        }
-        else if (containingDeclaration instanceof ScriptDescriptor) {
-            return generateMemberPropertyReference(descriptor, ((ScriptDescriptor) containingDeclaration).getClassDescriptor());
-        }
-        else {
-            throw new UnsupportedOperationException("Unsupported callable reference container: " + containingDeclaration);
-        }
-    }
-
-    private void checkReflectionIsAvailable(@NotNull JetExpression expression) {
-        if (findClassAcrossModuleDependencies(state.getModule(), JvmAbi.REFLECTION_FACTORY_IMPL) == null) {
-            state.getDiagnostics().report(ErrorsJvm.NO_REFLECTION_IN_CLASS_PATH.on(expression, expression));
-        }
+        throw new UnsupportedOperationException("Unsupported callable reference expression: " + expression.getText());
     }
 
     @NotNull
-    private StackValue generateTopLevelPropertyReference(@NotNull final VariableDescriptor descriptor) {
-        PackageFragmentDescriptor containingPackage = (PackageFragmentDescriptor) descriptor.getContainingDeclaration();
-        final String packageClassInternalName = PackageClassUtils.getPackageClassInternalName(containingPackage.getFqName());
-
-        final ReceiverParameterDescriptor receiverParameter = descriptor.getExtensionReceiverParameter();
-        final Method factoryMethod;
-        if (receiverParameter != null) {
-            Type[] parameterTypes = new Type[] {JAVA_STRING_TYPE, K_PACKAGE_TYPE, getType(Class.class)};
-            factoryMethod = descriptor.isVar()
-                            ? method("mutableTopLevelExtensionProperty", K_MUTABLE_TOP_LEVEL_EXTENSION_PROPERTY_TYPE, parameterTypes)
-                            : method("topLevelExtensionProperty", K_TOP_LEVEL_EXTENSION_PROPERTY_TYPE, parameterTypes);
-        }
-        else {
-            Type[] parameterTypes = new Type[] {JAVA_STRING_TYPE, K_PACKAGE_TYPE};
-            factoryMethod = descriptor.isVar()
-                            ? method("mutableTopLevelVariable", K_MUTABLE_TOP_LEVEL_VARIABLE_TYPE, parameterTypes)
-                            : method("topLevelVariable", K_TOP_LEVEL_VARIABLE_TYPE, parameterTypes);
-        }
-
-        return StackValue.operation(factoryMethod.getReturnType(), new Function1<InstructionAdapter, Unit>() {
-            @Override
-            public Unit invoke(InstructionAdapter v) {
-                v.visitLdcInsn(descriptor.getName().asString());
-                v.getstatic(packageClassInternalName, JvmAbi.KOTLIN_PACKAGE_FIELD_NAME, K_PACKAGE_TYPE.getDescriptor());
-
-                if (receiverParameter != null) {
-                    putJavaLangClassInstance(v, typeMapper.mapType(receiverParameter));
-                }
-
-                v.invokestatic(REFLECTION, factoryMethod.getName(), factoryMethod.getDescriptor(), false);
-                return Unit.INSTANCE$;
-            }
-        });
-    }
-
-    @NotNull
-    private StackValue generateMemberPropertyReference(
-            @NotNull final VariableDescriptor descriptor,
-            @NotNull final ClassDescriptor containingClass
+    private StackValue generatePropertyReference(
+            @NotNull JetCallableReferenceExpression expression,
+            @NotNull VariableDescriptor variableDescriptor,
+            @NotNull ResolvedCall<?> resolvedCall
     ) {
-        final Method factoryMethod = descriptor.isVar()
-                                     ? method("mutableMemberProperty", K_MUTABLE_MEMBER_PROPERTY_TYPE, JAVA_STRING_TYPE, K_CLASS_TYPE)
-                                     : method("memberProperty", K_MEMBER_PROPERTY_TYPE, JAVA_STRING_TYPE, K_CLASS_TYPE);
+        ClassDescriptor classDescriptor = CodegenBinding.anonymousClassForCallable(bindingContext, variableDescriptor);
 
-        return StackValue.operation(factoryMethod.getReturnType(), new Function1<InstructionAdapter, Unit>() {
-            @Override
-            public Unit invoke(InstructionAdapter v) {
-                v.visitLdcInsn(descriptor.getName().asString());
-                StackValue receiverClass = generateClassLiteralReference(containingClass.getDefaultType());
-                receiverClass.put(receiverClass.type, v);
-                v.invokestatic(REFLECTION, factoryMethod.getName(), factoryMethod.getDescriptor(), false);
+        ClassBuilder classBuilder = state.getFactory().newVisitor(
+                OtherOrigin(expression),
+                typeMapper.mapClass(classDescriptor),
+                expression.getContainingFile()
+        );
 
-                return Unit.INSTANCE$;
-            }
-        });
+        @SuppressWarnings("unchecked")
+        PropertyReferenceCodegen codegen = new PropertyReferenceCodegen(
+                state, parentCodegen, context.intoAnonymousClass(classDescriptor, this, OwnerKind.IMPLEMENTATION),
+                expression, classBuilder, classDescriptor, (ResolvedCall<VariableDescriptor>) resolvedCall
+        );
+        codegen.generate();
+
+        return codegen.putInstanceOnStack();
     }
 
     @NotNull
-    private StackValue generateClassLiteralReference(@NotNull final JetType type) {
+    public static StackValue generateClassLiteralReference(@NotNull final JetTypeMapper typeMapper, @NotNull final JetType type) {
         return StackValue.operation(K_CLASS_TYPE, new Function1<InstructionAdapter, Unit>() {
             @Override
             public Unit invoke(InstructionAdapter v) {
@@ -2851,7 +2813,10 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
                 ClassifierDescriptor descriptor = type.getConstructor().getDeclarationDescriptor();
                 //noinspection ConstantConditions
                 ModuleDescriptor module = DescriptorUtils.getContainingModule(descriptor);
-                if (descriptor instanceof JavaClassDescriptor || module == module.getBuiltIns().getBuiltInsModule()) {
+                // Instantiate annotation classes as foreign due to bug in JDK 6 and 7:
+                // http://bugs.java.com/bugdatabase/view_bug.do?bug_id=6857918
+                if (descriptor instanceof JavaClassDescriptor || module == module.getBuiltIns().getBuiltInsModule() ||
+                        DescriptorUtils.isAnnotationClass(descriptor)) {
                     putJavaLangClassInstance(v, classAsmType);
                     wrapJavaClassIntoKClass(v);
                 }
@@ -3064,7 +3029,7 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
     }
 
     private boolean isIntZero(JetExpression expr, Type exprType) {
-        CompileTimeConstant<?> exprValue = getCompileTimeConstant(expr, bindingContext);
+        ConstantValue<?> exprValue = getCompileTimeConstant(expr, bindingContext);
         return isIntPrimitive(exprType) && exprValue != null && Integer.valueOf(0).equals(exprValue.getValue());
     }
 
@@ -3596,14 +3561,14 @@ The "returned" value of try expression with no finally is either the last expres
         return StackValue.operation(expectedAsmType, new Function1<InstructionAdapter, Unit>() {
             @Override
             public Unit invoke(InstructionAdapter v) {
-
-           JetFinallySection finallyBlock = expression.getFinallyBlock();
+                JetFinallySection finallyBlock = expression.getFinallyBlock();
                 FinallyBlockStackElement finallyBlockStackElement = null;
                 if (finallyBlock != null) {
                     finallyBlockStackElement = new FinallyBlockStackElement(expression);
                     blockStackElements.push(finallyBlockStackElement);
                 }
 
+                //PseudoInsnsPackage.saveStackBeforeTryExpr(v);
 
                 Label tryStart = new Label();
                 v.mark(tryStart);
@@ -3667,6 +3632,7 @@ The "returned" value of try expression with no finally is either the last expres
                     v.mark(defaultCatchStart);
                     int savedException = myFrameMap.enterTemp(JAVA_THROWABLE_TYPE);
                     v.store(savedException, JAVA_THROWABLE_TYPE);
+
                     Label defaultCatchEnd = new Label();
                     v.mark(defaultCatchEnd);
 
@@ -3727,63 +3693,50 @@ The "returned" value of try expression with no finally is either the last expres
 
     @Override
     public StackValue visitBinaryWithTypeRHSExpression(@NotNull JetBinaryExpressionWithTypeRHS expression, StackValue receiver) {
-        JetSimpleNameExpression operationSign = expression.getOperationReference();
-        final IElementType opToken = operationSign.getReferencedNameElementType();
+        JetExpression left = expression.getLeft();
+        final IElementType opToken = expression.getOperationReference().getReferencedNameElementType();
         if (opToken == JetTokens.COLON) {
-            return gen(expression.getLeft());
+            return gen(left);
         }
-        else {
-            JetTypeReference typeReference = expression.getRight();
-            final JetType rightType = bindingContext.get(TYPE, typeReference);
-            assert rightType != null;
 
-            Type rightTypeAsm = boxType(asmType(rightType));
-            final JetExpression left = expression.getLeft();
+        final JetType rightType = bindingContext.get(TYPE, expression.getRight());
+        assert rightType != null;
 
-            DeclarationDescriptor descriptor = rightType.getConstructor().getDeclarationDescriptor();
-            if (descriptor instanceof ClassDescriptor || descriptor instanceof TypeParameterDescriptor) {
-                final StackValue value = genQualified(receiver, left);
+        final StackValue value = genQualified(receiver, left);
 
-                return StackValue.operation(rightTypeAsm, new Function1<InstructionAdapter, Unit>() {
-                    @Override
-                    public Unit invoke(InstructionAdapter v) {
-                        value.put(boxType(value.type), v);
+        return StackValue.operation(boxType(asmType(rightType)), new Function1<InstructionAdapter, Unit>() {
+            @Override
+            public Unit invoke(InstructionAdapter v) {
+                value.put(boxType(value.type), v);
 
-                        if (value.type == Type.VOID_TYPE) {
-                            v.aconst(null);
-                        }
-                        else if (opToken != JetTokens.AS_SAFE) {
-                            if (!TypeUtils.isNullableType(rightType)) {
-                                v.dup();
-                                Label nonnull = new Label();
-                                v.ifnonnull(nonnull);
-                                JetType leftType = bindingContext.getType(left);
-                                assert leftType != null;
-                                genThrow(v, "kotlin/TypeCastException", DescriptorRenderer.FQ_NAMES_IN_TYPES.renderType(leftType) +
-                                                                        " cannot be cast to " +
-                                                                        DescriptorRenderer.FQ_NAMES_IN_TYPES.renderType(rightType));
-                                v.mark(nonnull);
-                            }
-                        }
-                        else {
-                            v.dup();
-                            generateInstanceOfInstruction(rightType);
-                            Label ok = new Label();
-                            v.ifne(ok);
-                            v.pop();
-                            v.aconst(null);
-                            v.mark(ok);
-                        }
+                if (value.type == Type.VOID_TYPE) {
+                    StackValue.putUnitInstance(v);
+                }
 
-                        generateCheckCastInstruction(rightType);
-                        return Unit.INSTANCE$;
+                if (opToken != JetTokens.AS_SAFE) {
+                    if (!TypeUtils.isNullableType(rightType)) {
+                        v.dup();
+                        Label nonnull = new Label();
+                        v.ifnonnull(nonnull);
+                        genThrow(v, "kotlin/TypeCastException", "null cannot be cast to non-null type " +
+                                                                DescriptorRenderer.FQ_NAMES_IN_TYPES.renderType(rightType));
+                        v.mark(nonnull);
                     }
-                });
+                }
+                else {
+                    v.dup();
+                    generateInstanceOfInstruction(rightType);
+                    Label ok = new Label();
+                    v.ifne(ok);
+                    v.pop();
+                    v.aconst(null);
+                    v.mark(ok);
+                }
+
+                generateCheckCastInstruction(rightType);
+                return Unit.INSTANCE$;
             }
-            else {
-                throw new UnsupportedOperationException("Don't know how to handle non-class types in as/as? : " + descriptor);
-            }
-        }
+        });
     }
 
     @Override
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/FieldInfo.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/FieldInfo.java
index c00db37fe29..99e97b4bddc 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/FieldInfo.java
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/FieldInfo.java
@@ -20,7 +20,6 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.builtins.CompanionObjectMapping;
 import org.jetbrains.kotlin.codegen.state.JetTypeMapper;
 import org.jetbrains.kotlin.descriptors.ClassDescriptor;
-import org.jetbrains.kotlin.descriptors.ClassifierDescriptor;
 import org.jetbrains.kotlin.load.java.JvmAbi;
 import org.jetbrains.kotlin.resolve.DescriptorUtils;
 import org.jetbrains.org.objectweb.asm.Type;
@@ -46,18 +45,6 @@ public class FieldInfo {
         }
     }
 
-    @SuppressWarnings("deprecation")
-    @NotNull
-    public static FieldInfo deprecatedFieldForCompanionObject(@NotNull ClassDescriptor companionObject, @NotNull JetTypeMapper typeMapper) {
-        assert DescriptorUtils.isCompanionObject(companionObject) : "Not a companion object: " + companionObject;
-        return new FieldInfo(
-                typeMapper.mapType((ClassifierDescriptor) companionObject.getContainingDeclaration()),
-                typeMapper.mapType(companionObject),
-                JvmAbi.DEPRECATED_COMPANION_OBJECT_FIELD,
-                true
-        );
-    }
-
     @NotNull
     public static FieldInfo createForHiddenField(@NotNull Type owner, @NotNull Type fieldType, @NotNull String fieldName) {
         return new FieldInfo(owner, fieldType, fieldName, false);
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/FunctionCodegen.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/FunctionCodegen.java
index c0f2e76d315..8c673bf33e4 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/FunctionCodegen.java
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/FunctionCodegen.java
@@ -35,6 +35,7 @@ import org.jetbrains.kotlin.codegen.state.GenerationState;
 import org.jetbrains.kotlin.codegen.state.JetTypeMapper;
 import org.jetbrains.kotlin.descriptors.*;
 import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptor;
+import org.jetbrains.kotlin.jvm.RuntimeAssertionInfo;
 import org.jetbrains.kotlin.load.kotlin.nativeDeclarations.NativeDeclarationsPackage;
 import org.jetbrains.kotlin.name.FqName;
 import org.jetbrains.kotlin.psi.JetNamedFunction;
@@ -42,17 +43,15 @@ import org.jetbrains.kotlin.resolve.BindingContext;
 import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils;
 import org.jetbrains.kotlin.resolve.DescriptorUtils;
 import org.jetbrains.kotlin.resolve.annotations.AnnotationsPackage;
-import org.jetbrains.kotlin.resolve.calls.CallResolverUtil;
+import org.jetbrains.kotlin.resolve.calls.callResolverUtil.CallResolverUtilPackage;
 import org.jetbrains.kotlin.resolve.constants.ArrayValue;
-import org.jetbrains.kotlin.resolve.constants.CompileTimeConstant;
+import org.jetbrains.kotlin.resolve.constants.ConstantValue;
 import org.jetbrains.kotlin.resolve.constants.KClassValue;
 import org.jetbrains.kotlin.resolve.jvm.diagnostics.DiagnosticsPackage;
 import org.jetbrains.kotlin.resolve.jvm.diagnostics.JvmDeclarationOrigin;
 import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodParameterKind;
 import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodParameterSignature;
 import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodSignature;
-import org.jetbrains.kotlin.types.Approximation;
-import org.jetbrains.kotlin.types.TypesPackage;
 import org.jetbrains.org.objectweb.asm.AnnotationVisitor;
 import org.jetbrains.org.objectweb.asm.Label;
 import org.jetbrains.org.objectweb.asm.MethodVisitor;
@@ -502,7 +501,7 @@ public class FunctionCodegen {
         if (isMethodOfAny(descriptor)) return;
 
         // If the function doesn't have a physical declaration among super-functions, it's a SAM adapter or alike and doesn't need bridges
-        if (CallResolverUtil.isOrOverridesSynthesized(descriptor)) return;
+        if (CallResolverUtilPackage.isOrOverridesSynthesized(descriptor)) return;
 
         Set<Bridge<Method>> bridgesToGenerate = BridgesPackage.generateBridgesForFunctionDescriptor(
                 descriptor,
@@ -539,7 +538,7 @@ public class FunctionCodegen {
         AnnotationDescriptor annotation = function.getAnnotations().findAnnotation(new FqName("kotlin.throws"));
         if (annotation == null) return ArrayUtil.EMPTY_STRING_ARRAY;
 
-        Collection<CompileTimeConstant<?>> values = annotation.getAllValueArguments().values();
+        Collection<ConstantValue<?>> values = annotation.getAllValueArguments().values();
         if (values.isEmpty()) return ArrayUtil.EMPTY_STRING_ARRAY;
 
         Object value = values.iterator().next();
@@ -548,9 +547,9 @@ public class FunctionCodegen {
 
         List<String> strings = ContainerUtil.mapNotNull(
                 arrayValue.getValue(),
-                new Function<CompileTimeConstant<?>, String>() {
+                new Function<ConstantValue<?>, String>() {
                     @Override
-                    public String fun(CompileTimeConstant<?> constant) {
+                    public String fun(ConstantValue<?> constant) {
                         if (constant instanceof KClassValue) {
                             KClassValue classValue = (KClassValue) constant;
                             ClassDescriptor classDescriptor = DescriptorUtils.getClassDescriptorForType(classValue.getValue());
@@ -834,10 +833,10 @@ public class FunctionCodegen {
                         StackValue stackValue = AsmUtil.genNotNullAssertions(
                                 state,
                                 StackValue.onStack(delegateToMethod.getReturnType()),
-                                TypesPackage.getApproximationTo(
-                                        delegatedTo.getReturnType(),
+                                RuntimeAssertionInfo.create(
                                         delegateFunction.getReturnType(),
-                                        new Approximation.DataFlowExtras.OnlyMessage(delegatedTo.getName() + "(...)")
+                                        delegatedTo.getReturnType(),
+                                        new RuntimeAssertionInfo.DataFlowExtras.OnlyMessage(delegatedTo.getName() + "(...)")
                                 )
                         );
 
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/FunctionReferenceGenerationStrategy.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/FunctionReferenceGenerationStrategy.java
index 92a9f33c3a6..9ea0bc24122 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/FunctionReferenceGenerationStrategy.java
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/FunctionReferenceGenerationStrategy.java
@@ -16,6 +16,7 @@
 
 package org.jetbrains.kotlin.codegen;
 
+import kotlin.KotlinPackage;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.codegen.state.GenerationState;
@@ -133,8 +134,14 @@ public class FunctionReferenceGenerationStrategy extends FunctionGenerationStrat
     }
 
     private void computeAndSaveArguments(@NotNull List<? extends ValueArgument> fakeArguments, @NotNull ExpressionCodegen codegen) {
-        for (ValueParameterDescriptor parameter : callableDescriptor.getValueParameters()) {
-            ValueArgument fakeArgument = fakeArguments.get(parameter.getIndex());
+        int receivers = (referencedFunction.getDispatchReceiverParameter() != null ? 1 : 0) +
+                        (referencedFunction.getExtensionReceiverParameter() != null ? 1 : 0);
+
+        List<ValueParameterDescriptor> parameters = KotlinPackage.drop(callableDescriptor.getValueParameters(), receivers);
+        for (int i = 0; i < parameters.size(); i++) {
+            ValueParameterDescriptor parameter = parameters.get(i);
+            ValueArgument fakeArgument = fakeArguments.get(i);
+
             Type type = state.getTypeMapper().mapType(parameter);
             int localIndex = codegen.myFrameMap.getIndex(parameter);
             codegen.tempVariables.put(fakeArgument.getArgumentExpression(), StackValue.local(localIndex, type));
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/ImplementationBodyCodegen.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/ImplementationBodyCodegen.java
index 547b58b0836..b64af0caa0b 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/ImplementationBodyCodegen.java
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/ImplementationBodyCodegen.java
@@ -43,14 +43,13 @@ import org.jetbrains.kotlin.load.java.JvmAbi;
 import org.jetbrains.kotlin.load.java.JvmAnnotationNames;
 import org.jetbrains.kotlin.load.java.JvmAnnotationNames.KotlinClass;
 import org.jetbrains.kotlin.load.java.descriptors.JavaCallableMemberDescriptor;
-import org.jetbrains.kotlin.name.FqName;
 import org.jetbrains.kotlin.name.Name;
 import org.jetbrains.kotlin.psi.*;
 import org.jetbrains.kotlin.resolve.BindingContext;
 import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils;
 import org.jetbrains.kotlin.resolve.DescriptorUtils;
 import org.jetbrains.kotlin.resolve.annotations.AnnotationsPackage;
-import org.jetbrains.kotlin.resolve.calls.CallResolverUtil;
+import org.jetbrains.kotlin.resolve.calls.callResolverUtil.CallResolverUtilPackage;
 import org.jetbrains.kotlin.resolve.calls.callUtil.CallUtilPackage;
 import org.jetbrains.kotlin.resolve.calls.model.DefaultValueArgument;
 import org.jetbrains.kotlin.resolve.calls.model.ExpressionValueArgument;
@@ -139,7 +138,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
                 isAbstract = true;
                 isInterface = true;
             }
-            else if (jetClass.isAnnotation()) {
+            else if (descriptor.getKind() == ClassKind.ANNOTATION_CLASS) {
                 isAbstract = true;
                 isInterface = true;
                 isAnnotation = true;
@@ -240,13 +239,20 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
             kind = KotlinClass.Kind.ANONYMOUS_OBJECT;
         }
         else if (isTopLevelOrInnerClass(descriptor)) {
-            kind = KotlinClass.Kind.CLASS;
+            // Default value is Kind.CLASS
+            kind = null;
         }
         else {
             // LOCAL_CLASS is also written to inner classes of local classes
             kind = KotlinClass.Kind.LOCAL_CLASS;
         }
 
+        // Temporarily write class kind anyway because old compiler may not expect its absence
+        // TODO: remove after M13
+        if (kind == null) {
+            kind = KotlinClass.Kind.CLASS;
+        }
+
         DescriptorSerializer serializer =
                 DescriptorSerializer.create(descriptor, new JvmSerializerExtension(v.getSerializationBindings(), typeMapper));
 
@@ -258,11 +264,14 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
 
         AnnotationVisitor av = v.getVisitor().visitAnnotation(asmDescByFqNameWithoutInnerClasses(JvmAnnotationNames.KOTLIN_CLASS), true);
         av.visit(JvmAnnotationNames.ABI_VERSION_FIELD_NAME, JvmAbi.VERSION);
-        av.visitEnum(
-                JvmAnnotationNames.KIND_FIELD_NAME,
-                Type.getObjectType(KotlinClass.KIND_INTERNAL_NAME).getDescriptor(),
-                kind.toString()
-        );
+        //noinspection ConstantConditions
+        if (kind != null) {
+            av.visitEnum(
+                    JvmAnnotationNames.KIND_FIELD_NAME,
+                    Type.getObjectType(KotlinClass.KIND_INTERNAL_NAME).getDescriptor(),
+                    kind.toString()
+            );
+        }
         AnnotationVisitor array = av.visitArray(JvmAnnotationNames.DATA_FIELD_NAME);
         for (String string : BitEncoding.encodeBytes(SerializationUtil.serializeClassData(data))) {
             array.visit(null, string);
@@ -394,7 +403,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
     private boolean isGenericToArrayPresent() {
         Collection<FunctionDescriptor> functions = descriptor.getDefaultType().getMemberScope().getFunctions(Name.identifier("toArray"));
         for (FunctionDescriptor function : functions) {
-            if (CallResolverUtil.isOrOverridesSynthesized(function)) {
+            if (CallResolverUtilPackage.isOrOverridesSynthesized(function)) {
                 continue;
             }
 
@@ -1008,12 +1017,6 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
         StackValue.Field field = StackValue.singleton(companionObjectDescriptor, typeMapper);
         v.newField(OtherOrigin(companionObject), ACC_PUBLIC | ACC_STATIC | ACC_FINAL, field.name, field.type.getDescriptor(), null, null);
 
-        StackValue.Field deprecatedField = StackValue.deprecatedCompanionObjectAccessor(companionObjectDescriptor, typeMapper);
-        FieldVisitor fv = v.newField(OtherOrigin(companionObject), ACC_PUBLIC | ACC_STATIC | ACC_FINAL | ACC_DEPRECATED,
-                                     deprecatedField.name, deprecatedField.type.getDescriptor(), null, null);
-
-        fv.visitAnnotation(asmDescByFqNameWithoutInnerClasses(new FqName("java.lang.Deprecated")), true).visitEnd();
-
         if (state.getClassBuilderMode() != ClassBuilderMode.FULL) return;
 
         if (!isCompanionObjectWithBackingFieldsInOuter(companionObjectDescriptor)) {
@@ -1074,7 +1077,6 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
         codegen.v.dup();
         StackValue instance = StackValue.onStack(typeMapper.mapClass(companionObject));
         StackValue.singleton(companionObject, typeMapper).store(instance, codegen.v, true);
-        StackValue.deprecatedCompanionObjectAccessor(companionObject, typeMapper).store(instance, codegen.v, true);
     }
 
     private void generatePrimaryConstructor(final DelegationFieldsInfo delegationFieldsInfo) {
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/JvmRuntimeTypes.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/JvmRuntimeTypes.java
index 5db8904a904..492048c5675 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/JvmRuntimeTypes.java
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/JvmRuntimeTypes.java
@@ -29,15 +29,15 @@ import org.jetbrains.kotlin.storage.LockBasedStorageManager;
 import org.jetbrains.kotlin.types.JetType;
 import org.jetbrains.kotlin.types.expressions.ExpressionTypingUtils;
 
-import java.util.Arrays;
-import java.util.Collection;
-import java.util.Collections;
+import java.util.*;
 
 import static org.jetbrains.kotlin.resolve.descriptorUtil.DescriptorUtilPackage.getBuiltIns;
 
 public class JvmRuntimeTypes {
     private final ClassDescriptor lambda;
     private final ClassDescriptor functionReference;
+    private final List<ClassDescriptor> propertyReferences;
+    private final List<ClassDescriptor> mutablePropertyReferences;
 
     public JvmRuntimeTypes() {
         ModuleDescriptorImpl module = new ModuleDescriptorImpl(
@@ -49,6 +49,13 @@ public class JvmRuntimeTypes {
 
         this.lambda = createClass(kotlinJvmInternal, "Lambda");
         this.functionReference = createClass(kotlinJvmInternal, "FunctionReference");
+        this.propertyReferences = new ArrayList<ClassDescriptor>(3);
+        this.mutablePropertyReferences = new ArrayList<ClassDescriptor>(3);
+
+        for (int i = 0; i <= 2; i++) {
+            propertyReferences.add(createClass(kotlinJvmInternal, "PropertyReference" + i));
+            mutablePropertyReferences.add(createClass(kotlinJvmInternal, "MutablePropertyReference" + i));
+        }
     }
 
     @NotNull
@@ -98,4 +105,11 @@ public class JvmRuntimeTypes {
 
         return Arrays.asList(functionReference.getDefaultType(), functionType);
     }
+
+    @NotNull
+    public JetType getSupertypeForPropertyReference(@NotNull PropertyDescriptor descriptor) {
+        int arity = (descriptor.getExtensionReceiverParameter() != null ? 1 : 0) +
+                    (descriptor.getDispatchReceiverParameter() != null ? 1 : 0);
+        return (descriptor.isVar() ? mutablePropertyReferences : propertyReferences).get(arity).getDefaultType();
+    }
 }
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/JvmSerializerExtension.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/JvmSerializerExtension.java
index 994399eb8ed..566e5b9426b 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/JvmSerializerExtension.java
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/JvmSerializerExtension.java
@@ -45,6 +45,7 @@ import static org.jetbrains.kotlin.codegen.JvmSerializationBindings.*;
 public class JvmSerializerExtension extends SerializerExtension {
     private final JvmSerializationBindings bindings;
     private final JetTypeMapper typeMapper;
+    private final AnnotationSerializer annotationSerializer = new AnnotationSerializer();
 
     public JvmSerializerExtension(@NotNull JvmSerializationBindings bindings, @NotNull JetTypeMapper typeMapper) {
         this.bindings = bindings;
@@ -77,7 +78,7 @@ public class JvmSerializerExtension extends SerializerExtension {
     public void serializeType(@NotNull JetType type, @NotNull ProtoBuf.Type.Builder proto, @NotNull StringTable stringTable) {
         // TODO: don't store type annotations in our binary metadata on Java 8, use *TypeAnnotations attributes instead
         for (AnnotationDescriptor annotation : type.getAnnotations()) {
-            proto.addExtension(JvmProtoBuf.typeAnnotation, AnnotationSerializer.INSTANCE$.serializeAnnotation(annotation, stringTable));
+            proto.addExtension(JvmProtoBuf.typeAnnotation, annotationSerializer.serializeAnnotation(annotation, stringTable));
         }
     }
 
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/MemberCodegen.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/MemberCodegen.java
index 6e0108e2d50..a8c687c69b1 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/MemberCodegen.java
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/MemberCodegen.java
@@ -17,7 +17,9 @@
 package org.jetbrains.kotlin.codegen;
 
 import com.intellij.openapi.progress.ProcessCanceledException;
+import kotlin.Unit;
 import kotlin.jvm.functions.Function0;
+import kotlin.jvm.functions.Function1;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.codegen.context.*;
@@ -37,8 +39,7 @@ import org.jetbrains.kotlin.resolve.BindingContextUtils;
 import org.jetbrains.kotlin.resolve.BindingTrace;
 import org.jetbrains.kotlin.resolve.TemporaryBindingTrace;
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall;
-import org.jetbrains.kotlin.resolve.constants.CompileTimeConstant;
-import org.jetbrains.kotlin.resolve.constants.IntegerValueTypeConstant;
+import org.jetbrains.kotlin.resolve.constants.ConstantValue;
 import org.jetbrains.kotlin.resolve.constants.evaluate.ConstantExpressionEvaluator;
 import org.jetbrains.kotlin.resolve.descriptorUtil.DescriptorUtilPackage;
 import org.jetbrains.kotlin.storage.LockBasedStorageManager;
@@ -377,26 +378,28 @@ public abstract class MemberCodegen<T extends JetElement/* TODO: & JetDeclaratio
 
         JetExpression initializer = property.getInitializer();
 
-        CompileTimeConstant<?> initializerValue;
-        if (property.isVar() && initializer != null) {
-            BindingTrace tempTrace = TemporaryBindingTrace.create(state.getBindingTrace(), "property initializer");
-            initializerValue = ConstantExpressionEvaluator.evaluate(initializer, tempTrace, propertyDescriptor.getType());
-        }
-        else {
-            initializerValue = propertyDescriptor.getCompileTimeInitializer();
-        }
+        ConstantValue<?> initializerValue = computeInitializerValue(property, propertyDescriptor, initializer);
         // we must write constant values for fields in light classes,
         // because Java's completion for annotation arguments uses this information
         if (initializerValue == null) return state.getClassBuilderMode() != ClassBuilderMode.LIGHT_CLASSES;
 
         //TODO: OPTIMIZATION: don't initialize static final fields
-
-        Object value = initializerValue instanceof IntegerValueTypeConstant
-            ? ((IntegerValueTypeConstant) initializerValue).getValue(propertyDescriptor.getType())
-            : initializerValue.getValue();
         JetType jetType = getPropertyOrDelegateType(property, propertyDescriptor);
         Type type = typeMapper.mapType(jetType);
-        return !skipDefaultValue(propertyDescriptor, value, type);
+        return !skipDefaultValue(propertyDescriptor, initializerValue.getValue(), type);
+    }
+
+    @Nullable
+    private ConstantValue<?> computeInitializerValue(
+            @NotNull JetProperty property,
+            @NotNull PropertyDescriptor propertyDescriptor,
+            @Nullable JetExpression initializer
+    ) {
+        if (property.isVar() && initializer != null) {
+            BindingTrace tempTrace = TemporaryBindingTrace.create(state.getBindingTrace(), "property initializer");
+            return ConstantExpressionEvaluator.evaluateToConstantValue(initializer, tempTrace, propertyDescriptor.getType());
+        }
+        return propertyDescriptor.getCompileTimeInitializer();
     }
 
     @NotNull
@@ -532,4 +535,22 @@ public abstract class MemberCodegen<T extends JetElement/* TODO: & JetDeclaratio
         }
         return sourceMapper;
     }
+
+    protected void generateConstInstance(
+            @NotNull Type thisAsmType,
+            @NotNull Type fieldAsmType,
+            @NotNull Function1<InstructionAdapter, Unit> initialization
+    ) {
+        v.newField(OtherOrigin(element), ACC_STATIC | ACC_FINAL | ACC_PUBLIC, JvmAbi.INSTANCE_FIELD, fieldAsmType.getDescriptor(),
+                   null, null);
+
+        if (state.getClassBuilderMode() == ClassBuilderMode.FULL) {
+            InstructionAdapter iv = createOrGetClInitCodegen().v;
+            iv.anew(thisAsmType);
+            iv.dup();
+            iv.invokespecial(thisAsmType.getInternalName(), "<init>", "()V", false);
+            initialization.invoke(iv);
+            iv.putstatic(thisAsmType.getInternalName(), JvmAbi.INSTANCE_FIELD, fieldAsmType.getDescriptor());
+        }
+    }
 }
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/PropertyCodegen.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/PropertyCodegen.java
index 672ffac46aa..828ce88f00b 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/PropertyCodegen.java
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/PropertyCodegen.java
@@ -17,7 +17,6 @@
 package org.jetbrains.kotlin.codegen;
 
 import com.intellij.openapi.util.Pair;
-import com.intellij.openapi.util.text.StringUtil;
 import com.intellij.psi.PsiElement;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
@@ -26,14 +25,14 @@ import org.jetbrains.kotlin.codegen.state.GenerationState;
 import org.jetbrains.kotlin.codegen.state.JetTypeMapper;
 import org.jetbrains.kotlin.descriptors.*;
 import org.jetbrains.kotlin.load.java.JvmAbi;
-import org.jetbrains.kotlin.name.Name;
 import org.jetbrains.kotlin.psi.*;
 import org.jetbrains.kotlin.psi.psiUtil.PsiUtilPackage;
 import org.jetbrains.kotlin.resolve.BindingContext;
 import org.jetbrains.kotlin.resolve.DescriptorFactory;
 import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils;
+import org.jetbrains.kotlin.resolve.annotations.AnnotationsPackage;
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall;
-import org.jetbrains.kotlin.resolve.constants.CompileTimeConstant;
+import org.jetbrains.kotlin.resolve.constants.ConstantValue;
 import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodSignature;
 import org.jetbrains.kotlin.serialization.deserialization.descriptors.DeserializedPropertyDescriptor;
 import org.jetbrains.kotlin.types.ErrorUtils;
@@ -181,7 +180,7 @@ public class PropertyCodegen {
         if (state.getClassBuilderMode() == ClassBuilderMode.FULL) {
             JetExpression defaultValue = p.getDefaultValue();
             if (defaultValue != null) {
-                CompileTimeConstant<?> constant = ExpressionCodegen.getCompileTimeConstant(defaultValue, bindingContext);
+                ConstantValue<?> constant = ExpressionCodegen.getCompileTimeConstant(defaultValue, bindingContext);
                 assert constant != null : "Default value for annotation parameter should be compile time value: " + defaultValue.getText();
                 AnnotationCodegen annotationCodegen = AnnotationCodegen.forAnnotationDefaultValue(mv, typeMapper);
                 annotationCodegen.generateAnnotationDefaultValue(constant, descriptor.getType());
@@ -256,9 +255,19 @@ public class PropertyCodegen {
 
         ClassBuilder builder = v;
 
+        boolean hasPublicFieldAnnotation = AnnotationsPackage.findPublicFieldAnnotation(propertyDescriptor) != null;
+
         FieldOwnerContext backingFieldContext = context;
         if (AsmUtil.isInstancePropertyWithStaticBackingField(propertyDescriptor) ) {
-            modifiers |= ACC_STATIC | getVisibilityForSpecialPropertyBackingField(propertyDescriptor, isDelegate);
+            modifiers |= ACC_STATIC;
+
+            if (hasPublicFieldAnnotation && !isDelegate) {
+                modifiers |= ACC_PUBLIC;
+            }
+            else {
+                modifiers |= getVisibilityForSpecialPropertyBackingField(propertyDescriptor, isDelegate);
+            }
+
             if (AsmUtil.isPropertyWithBackingFieldInOuterClass(propertyDescriptor)) {
                 ImplementationBodyCodegen codegen = (ImplementationBodyCodegen) memberCodegen.getParentCodegen();
                 builder = codegen.v;
@@ -266,6 +275,9 @@ public class PropertyCodegen {
                 v.getSerializationBindings().put(STATIC_FIELD_IN_OUTER_CLASS, propertyDescriptor);
             }
         }
+        else if (!isDelegate && hasPublicFieldAnnotation) {
+            modifiers |= ACC_PUBLIC;
+        }
         else if (kind != OwnerKind.PACKAGE || isDelegate) {
             modifiers |= ACC_PRIVATE;
         }
@@ -299,7 +311,7 @@ public class PropertyCodegen {
         Object value = null;
 
         if (shouldWriteFieldInitializer(propertyDescriptor)) {
-            CompileTimeConstant<?> initializer = propertyDescriptor.getCompileTimeInitializer();
+            ConstantValue<?> initializer = propertyDescriptor.getCompileTimeInitializer();
             if (initializer != null) {
                 value = initializer.getValue();
             }
@@ -477,16 +489,6 @@ public class PropertyCodegen {
         }
     }
 
-    @NotNull
-    public static String getterName(Name propertyName) {
-        return JvmAbi.GETTER_PREFIX + StringUtil.capitalizeWithJavaBeanConvention(propertyName.asString());
-    }
-
-    @NotNull
-    public static String setterName(Name propertyName) {
-        return JvmAbi.SETTER_PREFIX + StringUtil.capitalizeWithJavaBeanConvention(propertyName.asString());
-    }
-
     public void genDelegate(@NotNull PropertyDescriptor delegate, @NotNull PropertyDescriptor delegateTo, @NotNull StackValue field) {
         ClassDescriptor toClass = (ClassDescriptor) delegateTo.getContainingDeclaration();
 
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/PropertyReferenceCodegen.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/PropertyReferenceCodegen.kt
new file mode 100644
index 00000000000..940897fd9a5
--- /dev/null
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/PropertyReferenceCodegen.kt
@@ -0,0 +1,202 @@
+/*
+ * Copyright 2010-2015 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.kotlin.codegen
+
+import org.jetbrains.kotlin.codegen.AsmUtil.method
+import org.jetbrains.kotlin.codegen.AsmUtil.writeKotlinSyntheticClassAnnotation
+import org.jetbrains.kotlin.codegen.context.ClassContext
+import org.jetbrains.kotlin.codegen.state.GenerationState
+import org.jetbrains.kotlin.descriptors.*
+import org.jetbrains.kotlin.descriptors.annotations.Annotations
+import org.jetbrains.kotlin.descriptors.impl.SimpleFunctionDescriptorImpl
+import org.jetbrains.kotlin.load.java.JvmAbi
+import org.jetbrains.kotlin.load.java.JvmAnnotationNames.KotlinSyntheticClass
+import org.jetbrains.kotlin.name.Name
+import org.jetbrains.kotlin.psi.JetCallableReferenceExpression
+import org.jetbrains.kotlin.resolve.DescriptorFactory
+import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall
+import org.jetbrains.kotlin.resolve.descriptorUtil.builtIns
+import org.jetbrains.kotlin.resolve.descriptorUtil.getSuperClassNotAny
+import org.jetbrains.kotlin.resolve.jvm.AsmTypes.*
+import org.jetbrains.kotlin.resolve.jvm.diagnostics.JvmDeclarationOrigin
+import org.jetbrains.kotlin.resolve.scopes.receivers.ScriptReceiver
+import org.jetbrains.kotlin.utils.sure
+import org.jetbrains.org.objectweb.asm.Opcodes.ACC_FINAL
+import org.jetbrains.org.objectweb.asm.Opcodes.ACC_PUBLIC
+import org.jetbrains.org.objectweb.asm.Opcodes.ACC_SUPER
+import org.jetbrains.org.objectweb.asm.Opcodes.V1_6
+import org.jetbrains.org.objectweb.asm.Type
+import org.jetbrains.org.objectweb.asm.commons.InstructionAdapter
+import org.jetbrains.org.objectweb.asm.commons.Method
+
+public class PropertyReferenceCodegen(
+        state: GenerationState,
+        parentCodegen: MemberCodegen<*>,
+        context: ClassContext,
+        expression: JetCallableReferenceExpression,
+        classBuilder: ClassBuilder,
+        private val classDescriptor: ClassDescriptor,
+        private val resolvedCall: ResolvedCall<VariableDescriptor>
+) : MemberCodegen<JetCallableReferenceExpression>(state, parentCodegen, context, expression, classBuilder) {
+    private val target = resolvedCall.getResultingDescriptor()
+    private val asmType = typeMapper.mapClass(classDescriptor)
+
+    // e.g. MutablePropertyReference0
+    private val superAsmType = typeMapper.mapClass(classDescriptor.getSuperClassNotAny().sure { "No super class for $classDescriptor" })
+
+    // e.g. mutableProperty0(Lkotlin/jvm/internal/MutablePropertyReference0;)Lkotlin/reflect/KMutableProperty0;
+    private val wrapperMethod: Method
+
+    init {
+        val hasReceiver = target.getDispatchReceiverParameter() != null || target.getExtensionReceiverParameter() != null
+        val isMutable = target.isVar()
+
+        wrapperMethod = when {
+            hasReceiver -> when {
+                isMutable -> method("mutableProperty1", K_MUTABLE_PROPERTY1_TYPE, MUTABLE_PROPERTY_REFERENCE1)
+                else -> method("property1", K_PROPERTY1_TYPE, PROPERTY_REFERENCE1)
+            }
+            else -> when {
+                isMutable -> method("mutableProperty0", K_MUTABLE_PROPERTY0_TYPE, MUTABLE_PROPERTY_REFERENCE0)
+                else -> method("property0", K_PROPERTY0_TYPE, PROPERTY_REFERENCE0)
+            }
+        }
+    }
+
+    override fun generateDeclaration() {
+        v.defineClass(
+                element,
+                V1_6,
+                ACC_FINAL or ACC_SUPER or AsmUtil.getVisibilityAccessFlagForAnonymous(classDescriptor),
+                asmType.getInternalName(),
+                null,
+                superAsmType.getInternalName(),
+                emptyArray()
+        )
+
+        v.visitSource(element.getContainingFile().getName(), null)
+    }
+
+    // TODO: ImplementationBodyCodegen.markLineNumberForSyntheticFunction?
+    override fun generateBody() {
+        generateConstInstance(asmType, wrapperMethod.getReturnType()) { iv ->
+            iv.invokestatic(REFLECTION, wrapperMethod.getName(), wrapperMethod.getDescriptor(), false)
+        }
+
+        generateMethod("property reference init", 0, method("<init>", Type.VOID_TYPE)) {
+            load(0, OBJECT_TYPE)
+            invokespecial(superAsmType.getInternalName(), "<init>", "()V", false)
+        }
+
+        generateMethod("property reference getOwner", ACC_PUBLIC, method("getOwner", K_DECLARATION_CONTAINER_TYPE)) {
+            ClosureCodegen.generateCallableReferenceDeclarationContainer(this, target, typeMapper)
+        }
+
+        generateMethod("property reference getName", ACC_PUBLIC, method("getName", JAVA_STRING_TYPE)) {
+            aconst(target.getName().asString())
+        }
+
+        generateMethod("property reference getSignature", ACC_PUBLIC, method("getSignature", JAVA_STRING_TYPE)) {
+            target as PropertyDescriptor
+
+            val getter = target.getGetter() ?: run {
+                val defaultGetter = DescriptorFactory.createDefaultGetter(target)
+                defaultGetter.initialize(target.getType())
+                defaultGetter
+            }
+
+            val method = typeMapper.mapSignature(getter).getAsmMethod()
+            aconst(method.getName() + method.getDescriptor())
+        }
+
+        generateAccessors()
+    }
+
+    private fun generateAccessors() {
+        val dispatchReceiver = resolvedCall.getDispatchReceiver()
+        val extensionReceiver = resolvedCall.getExtensionReceiver()
+        val receiverType =
+                when {
+                    dispatchReceiver is ScriptReceiver -> {
+                        // TODO: fix receiver for scripts, see ScriptReceiver#getType
+                        dispatchReceiver.getDeclarationDescriptor().getClassDescriptor().getDefaultType()
+                    }
+                    dispatchReceiver.exists() -> dispatchReceiver.getType()
+                    extensionReceiver.exists() -> extensionReceiver.getType()
+                    else -> null
+                }
+
+        fun generateAccessor(method: Method, accessorBody: InstructionAdapter.(StackValue) -> Unit) {
+            generateMethod("property reference $method", ACC_PUBLIC, method) {
+                // Note: this descriptor is an inaccurate representation of the get/set method. In particular, it has incorrect
+                // return type and value parameter types. However, it's created only to be able to use
+                // ExpressionCodegen#intermediateValueForProperty, which is poorly coupled with everything else.
+                val fakeDescriptor = SimpleFunctionDescriptorImpl.create(
+                        classDescriptor, Annotations.EMPTY, Name.identifier(method.getName()), CallableMemberDescriptor.Kind.DECLARATION,
+                        SourceElement.NO_SOURCE
+                )
+                fakeDescriptor.initialize(null, classDescriptor.getThisAsReceiverParameter(), emptyList(), emptyList(),
+                                          classDescriptor.builtIns.getAnyType(), Modality.OPEN, Visibilities.PUBLIC)
+
+                val fakeCodegen = ExpressionCodegen(
+                        this, FrameMap(), OBJECT_TYPE, context.intoFunction(fakeDescriptor), state, this@PropertyReferenceCodegen
+                )
+
+                val receiver =
+                        if (receiverType != null) StackValue.coercion(StackValue.local(1, OBJECT_TYPE), typeMapper.mapType(receiverType))
+                        else StackValue.none()
+                val value = fakeCodegen.intermediateValueForProperty(target as PropertyDescriptor, false, null, receiver)
+
+                accessorBody(value)
+            }
+        }
+
+        val getterParameters = if (receiverType != null) arrayOf(OBJECT_TYPE) else emptyArray()
+        generateAccessor(method("get", OBJECT_TYPE, *getterParameters)) { value ->
+            value.put(OBJECT_TYPE, this)
+        }
+
+        if (!target.isVar()) return
+
+        val setterParameters = (getterParameters + arrayOf(OBJECT_TYPE))
+        generateAccessor(method("set", Type.VOID_TYPE, *setterParameters)) { value ->
+            // Hard-coded 1 or 2 is safe here because there's only java/lang/Object in the signature, no double/long parameters
+            value.store(StackValue.local(if (receiverType != null) 2 else 1, OBJECT_TYPE), this)
+        }
+    }
+
+    private fun generateMethod(debugString: String, access: Int, method: Method, generate: InstructionAdapter.() -> Unit) {
+        val mv = v.newMethod(JvmDeclarationOrigin.NO_ORIGIN, access, method.getName(), method.getDescriptor(), null, null)
+
+        if (state.getClassBuilderMode() == ClassBuilderMode.FULL) {
+            val iv = InstructionAdapter(mv)
+            iv.visitCode()
+            iv.generate()
+            iv.areturn(method.getReturnType())
+            FunctionCodegen.endVisit(mv, debugString, element)
+        }
+    }
+
+    override fun generateKotlinAnnotation() {
+        writeKotlinSyntheticClassAnnotation(v, KotlinSyntheticClass.Kind.CALLABLE_REFERENCE_WRAPPER)
+    }
+
+    public fun putInstanceOnStack(): StackValue =
+            StackValue.operation(wrapperMethod.getReturnType()) { iv ->
+                iv.getstatic(asmType.getInternalName(), JvmAbi.INSTANCE_FIELD, wrapperMethod.getReturnType().getDescriptor())
+            }
+}
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/StackValue.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/StackValue.java
index f99bc87ba1d..517fde5f1ba 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/StackValue.java
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/StackValue.java
@@ -248,7 +248,7 @@ public abstract class StackValue {
     @NotNull
     public static Property property(
             @NotNull PropertyDescriptor descriptor,
-            @NotNull Type backingFieldOwner,
+            @Nullable Type backingFieldOwner,
             @NotNull Type type,
             boolean isStaticBackingField,
             @Nullable String fieldName,
@@ -552,10 +552,6 @@ public abstract class StackValue {
         return field(FieldInfo.createForSingleton(classDescriptor, typeMapper));
     }
 
-    public static Field deprecatedCompanionObjectAccessor(ClassDescriptor classDescriptor, JetTypeMapper typeMapper) {
-        return field(FieldInfo.deprecatedFieldForCompanionObject(classDescriptor, typeMapper));
-    }
-
     public static StackValue operation(Type type, Function1<InstructionAdapter, Unit> lambda) {
         return new OperationStackValue(type, lambda);
     }
@@ -993,7 +989,7 @@ public abstract class StackValue {
         private final String fieldName;
 
         public Property(
-                @NotNull PropertyDescriptor descriptor, @NotNull Type backingFieldOwner,
+                @NotNull PropertyDescriptor descriptor, @Nullable Type backingFieldOwner,
                 @Nullable CallableMethod getter, @Nullable CallableMethod setter, boolean isStaticBackingField,
                 @Nullable String fieldName, @NotNull Type type, @NotNull GenerationState state,
                 @NotNull StackValue receiver
@@ -1011,6 +1007,7 @@ public abstract class StackValue {
         public void putSelector(@NotNull Type type, @NotNull InstructionAdapter v) {
             if (getter == null) {
                 assert fieldName != null : "Property should have either a getter or a field name: " + descriptor;
+                assert backingFieldOwner != null : "Property should have either a getter or a backingFieldOwner: " + descriptor;
                 v.visitFieldInsn(isStaticPut ? GETSTATIC : GETFIELD, backingFieldOwner.getInternalName(), fieldName, this.type.getDescriptor());
                 genNotNullAssertionForField(v, state, descriptor);
                 coerceTo(type, v);
@@ -1026,6 +1023,7 @@ public abstract class StackValue {
             coerceFrom(topOfStackType, v);
             if (setter == null) {
                 assert fieldName != null : "Property should have either a setter or a field name: " + descriptor;
+                assert backingFieldOwner != null : "Property should have either a setter or a backingFieldOwner: " + descriptor;
                 v.visitFieldInsn(isStaticStore ? PUTSTATIC : PUTFIELD, backingFieldOwner.getInternalName(), fieldName, this.type.getDescriptor());
             }
             else {
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/binding/CodegenAnnotatingVisitor.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/binding/CodegenAnnotatingVisitor.java
index c93832eaec0..1e8413c8131 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/binding/CodegenAnnotatingVisitor.java
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/binding/CodegenAnnotatingVisitor.java
@@ -45,7 +45,7 @@ import org.jetbrains.kotlin.resolve.calls.callUtil.CallUtilPackage;
 import org.jetbrains.kotlin.resolve.calls.model.ExpressionValueArgument;
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall;
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedValueArgument;
-import org.jetbrains.kotlin.resolve.constants.CompileTimeConstant;
+import org.jetbrains.kotlin.resolve.constants.ConstantValue;
 import org.jetbrains.kotlin.resolve.constants.EnumValue;
 import org.jetbrains.kotlin.resolve.constants.NullValue;
 import org.jetbrains.kotlin.resolve.scopes.JetScope;
@@ -84,15 +84,15 @@ class CodegenAnnotatingVisitor extends JetVisitorVoid {
     }
 
     @NotNull
-    private ClassDescriptor recordClassForFunction(
+    private ClassDescriptor recordClassForCallable(
             @NotNull JetElement element,
-            @NotNull FunctionDescriptor funDescriptor,
+            @NotNull CallableDescriptor callableDescriptor,
             @NotNull Collection<JetType> supertypes,
             @NotNull String name
     ) {
         String simpleName = name.substring(name.lastIndexOf('/') + 1);
         ClassDescriptorImpl classDescriptor = new ClassDescriptorImpl(
-                correctContainerForLambda(funDescriptor, element),
+                correctContainerForLambda(callableDescriptor, element),
                 Name.special("<closure-" + simpleName + ">"),
                 Modality.FINAL,
                 supertypes,
@@ -100,13 +100,13 @@ class CodegenAnnotatingVisitor extends JetVisitorVoid {
         );
         classDescriptor.initialize(JetScope.Empty.INSTANCE$, Collections.<ConstructorDescriptor>emptySet(), null);
 
-        bindingTrace.record(CLASS_FOR_FUNCTION, funDescriptor, classDescriptor);
+        bindingTrace.record(CLASS_FOR_CALLABLE, callableDescriptor, classDescriptor);
         return classDescriptor;
     }
 
     @NotNull
     @SuppressWarnings("ConstantConditions")
-    private DeclarationDescriptor correctContainerForLambda(@NotNull FunctionDescriptor descriptor, @NotNull JetElement function) {
+    private DeclarationDescriptor correctContainerForLambda(@NotNull CallableDescriptor descriptor, @NotNull JetElement function) {
         DeclarationDescriptor container = descriptor.getContainingDeclaration();
 
         // In almost all cases the function's direct container is the correct container to consider in JVM back-end
@@ -286,7 +286,7 @@ class CodegenAnnotatingVisitor extends JetVisitorVoid {
 
         String name = inventAnonymousClassName(expression);
         Collection<JetType> supertypes = runtimeTypes.getSupertypesForClosure(functionDescriptor);
-        ClassDescriptor classDescriptor = recordClassForFunction(functionLiteral, functionDescriptor, supertypes, name);
+        ClassDescriptor classDescriptor = recordClassForCallable(functionLiteral, functionDescriptor, supertypes, name);
         recordClosure(classDescriptor, name);
 
         classStack.push(classDescriptor);
@@ -298,17 +298,31 @@ class CodegenAnnotatingVisitor extends JetVisitorVoid {
 
     @Override
     public void visitCallableReferenceExpression(@NotNull JetCallableReferenceExpression expression) {
-        FunctionDescriptor functionDescriptor = bindingContext.get(FUNCTION, expression);
-        // working around a problem with shallow analysis
-        if (functionDescriptor == null) return;
-
         ResolvedCall<?> referencedFunction = CallUtilPackage.getResolvedCall(expression.getCallableReference(), bindingContext);
         if (referencedFunction == null) return;
-        Collection<JetType> supertypes =
-                runtimeTypes.getSupertypesForFunctionReference((FunctionDescriptor) referencedFunction.getResultingDescriptor());
+        CallableDescriptor target = referencedFunction.getResultingDescriptor();
+
+        CallableDescriptor callableDescriptor;
+        Collection<JetType> supertypes;
+
+        if (target instanceof FunctionDescriptor) {
+            callableDescriptor = bindingContext.get(FUNCTION, expression);
+            if (callableDescriptor == null) return;
+
+            supertypes = runtimeTypes.getSupertypesForFunctionReference((FunctionDescriptor) target);
+        }
+        else if (target instanceof PropertyDescriptor) {
+            callableDescriptor = bindingContext.get(VARIABLE, expression);
+            if (callableDescriptor == null) return;
+
+            supertypes = Collections.singleton(runtimeTypes.getSupertypeForPropertyReference((PropertyDescriptor) target));
+        }
+        else {
+            return;
+        }
 
         String name = inventAnonymousClassName(expression);
-        ClassDescriptor classDescriptor = recordClassForFunction(expression, functionDescriptor, supertypes, name);
+        ClassDescriptor classDescriptor = recordClassForCallable(expression, callableDescriptor, supertypes, name);
         recordClosure(classDescriptor, name);
 
         classStack.push(classDescriptor);
@@ -354,7 +368,7 @@ class CodegenAnnotatingVisitor extends JetVisitorVoid {
         else {
             String name = inventAnonymousClassName(function);
             Collection<JetType> supertypes = runtimeTypes.getSupertypesForClosure(functionDescriptor);
-            ClassDescriptor classDescriptor = recordClassForFunction(function, functionDescriptor, supertypes, name);
+            ClassDescriptor classDescriptor = recordClassForCallable(function, functionDescriptor, supertypes, name);
             recordClosure(classDescriptor, name);
 
             classStack.push(classDescriptor);
@@ -523,7 +537,7 @@ class CodegenAnnotatingVisitor extends JetVisitorVoid {
 
         WhenByEnumsMapping mapping = new WhenByEnumsMapping(classDescriptor, currentClassName, fieldNumber);
 
-        for (CompileTimeConstant constant : SwitchCodegenUtil.getAllConstants(expression, bindingContext)) {
+        for (ConstantValue<?> constant : SwitchCodegenUtil.getAllConstants(expression, bindingContext)) {
             if (constant instanceof NullValue) continue;
 
             assert constant instanceof EnumValue : "expression in when should be EnumValue";
@@ -540,9 +554,9 @@ class CodegenAnnotatingVisitor extends JetVisitorVoid {
                SwitchCodegenUtil.checkAllItemsAreConstantsSatisfying(
                        expression,
                        bindingContext,
-                       new Function1<CompileTimeConstant, Boolean>() {
+                       new Function1<ConstantValue<?>, Boolean>() {
                            @Override
-                           public Boolean invoke(@NotNull CompileTimeConstant constant) {
+                           public Boolean invoke(@NotNull ConstantValue<?> constant) {
                                return constant instanceof EnumValue || constant instanceof NullValue;
                            }
                        }
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/binding/CodegenBinding.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/binding/CodegenBinding.java
index e5e9355c4af..ebac3428ae2 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/binding/CodegenBinding.java
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/binding/CodegenBinding.java
@@ -19,7 +19,6 @@ package org.jetbrains.kotlin.codegen.binding;
 import com.intellij.openapi.vfs.VirtualFile;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
 import org.jetbrains.kotlin.codegen.JvmCodegenUtil;
 import org.jetbrains.kotlin.codegen.SamType;
 import org.jetbrains.kotlin.codegen.state.GenerationState;
@@ -32,6 +31,7 @@ import org.jetbrains.kotlin.psi.*;
 import org.jetbrains.kotlin.psi.psiUtil.PsiUtilPackage;
 import org.jetbrains.kotlin.resolve.BindingContext;
 import org.jetbrains.kotlin.resolve.BindingTrace;
+import org.jetbrains.kotlin.resolve.descriptorUtil.DescriptorUtilPackage;
 import org.jetbrains.kotlin.resolve.scopes.JetScope;
 import org.jetbrains.kotlin.util.slicedMap.BasicWritableSlice;
 import org.jetbrains.kotlin.util.slicedMap.Slices;
@@ -40,16 +40,14 @@ import org.jetbrains.org.objectweb.asm.Type;
 
 import java.util.*;
 
-import static org.jetbrains.kotlin.codegen.JvmCodegenUtil.isInterface;
 import static org.jetbrains.kotlin.resolve.BindingContext.*;
 import static org.jetbrains.kotlin.resolve.DescriptorToSourceUtils.descriptorToDeclaration;
-import static org.jetbrains.kotlin.resolve.calls.callUtil.CallUtilPackage.getResolvedCall;
 import static org.jetbrains.kotlin.resolve.source.SourcePackage.toSourceElement;
 
 public class CodegenBinding {
     public static final WritableSlice<ClassDescriptor, MutableClosure> CLOSURE = Slices.createSimpleSlice();
 
-    public static final WritableSlice<FunctionDescriptor, ClassDescriptor> CLASS_FOR_FUNCTION = Slices.createSimpleSlice();
+    public static final WritableSlice<CallableDescriptor, ClassDescriptor> CLASS_FOR_CALLABLE = Slices.createSimpleSlice();
 
     public static final WritableSlice<ScriptDescriptor, ClassDescriptor> CLASS_FOR_SCRIPT = Slices.createSimpleSlice();
 
@@ -110,34 +108,41 @@ public class CodegenBinding {
     }
 
     @NotNull
-    public static ClassDescriptor anonymousClassForFunction(
+    public static ClassDescriptor anonymousClassForCallable(
             @NotNull BindingContext bindingContext,
-            @NotNull FunctionDescriptor descriptor
+            @NotNull CallableDescriptor descriptor
     ) {
         //noinspection ConstantConditions
-        return bindingContext.get(CLASS_FOR_FUNCTION, descriptor);
+        return bindingContext.get(CLASS_FOR_CALLABLE, descriptor);
     }
 
     @NotNull
     public static Type asmTypeForAnonymousClass(@NotNull BindingContext bindingContext, @NotNull JetElement expression) {
         if (expression instanceof JetObjectLiteralExpression) {
-            JetObjectLiteralExpression jetObjectLiteralExpression = (JetObjectLiteralExpression) expression;
-            expression = jetObjectLiteralExpression.getObjectDeclaration();
+            expression = ((JetObjectLiteralExpression) expression).getObjectDeclaration();
         }
 
         ClassDescriptor descriptor = bindingContext.get(CLASS, expression);
-        if (descriptor == null) {
-            SimpleFunctionDescriptor functionDescriptor = bindingContext.get(FUNCTION, expression);
-            assert functionDescriptor != null : "Couldn't find function descriptor for " + PsiUtilPackage.getElementTextWithContext(expression);
+        if (descriptor != null) {
+            return getAsmType(bindingContext, descriptor);
+        }
+
+        SimpleFunctionDescriptor functionDescriptor = bindingContext.get(FUNCTION, expression);
+        if (functionDescriptor != null) {
             return asmTypeForAnonymousClass(bindingContext, functionDescriptor);
         }
 
-        return getAsmType(bindingContext, descriptor);
+        VariableDescriptor variableDescriptor = bindingContext.get(VARIABLE, expression);
+        if (variableDescriptor != null) {
+            return asmTypeForAnonymousClass(bindingContext, variableDescriptor);
+        }
+
+        throw new IllegalStateException("Couldn't compute ASM type for " + PsiUtilPackage.getElementTextWithContext(expression));
     }
 
     @NotNull
-    public static Type asmTypeForAnonymousClass(@NotNull BindingContext bindingContext, @NotNull FunctionDescriptor descriptor) {
-        return getAsmType(bindingContext, anonymousClassForFunction(bindingContext, descriptor));
+    public static Type asmTypeForAnonymousClass(@NotNull BindingContext bindingContext, @NotNull CallableDescriptor descriptor) {
+        return getAsmType(bindingContext, anonymousClassForCallable(bindingContext, descriptor));
     }
 
     public static boolean canHaveOuter(@NotNull BindingContext bindingContext, @NotNull ClassDescriptor classDescriptor) {
@@ -202,7 +207,8 @@ public class CodegenBinding {
         String simpleName = asmType.getInternalName().substring(asmType.getInternalName().lastIndexOf('/') + 1);
         ClassDescriptorImpl classDescriptor =
                 new ClassDescriptorImpl(descriptor, Name.special("<script-" + simpleName + ">"), Modality.FINAL,
-                                        Collections.singleton(KotlinBuiltIns.getInstance().getAnyType()), toSourceElement(script));
+                                        Collections.singleton(DescriptorUtilPackage.getBuiltIns(descriptor).getAnyType()),
+                                        toSourceElement(script));
         classDescriptor.initialize(JetScope.Empty.INSTANCE$, Collections.<ConstructorDescriptor>emptySet(), null);
 
         recordClosure(trace, classDescriptor, null, asmType);
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/context/ClosureContext.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/context/ClosureContext.java
index 96a2f541028..e51bc7ced13 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/context/ClosureContext.java
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/context/ClosureContext.java
@@ -22,7 +22,7 @@ import org.jetbrains.kotlin.codegen.OwnerKind;
 import org.jetbrains.kotlin.codegen.state.JetTypeMapper;
 import org.jetbrains.kotlin.descriptors.FunctionDescriptor;
 
-import static org.jetbrains.kotlin.codegen.binding.CodegenBinding.anonymousClassForFunction;
+import static org.jetbrains.kotlin.codegen.binding.CodegenBinding.anonymousClassForCallable;
 
 public class ClosureContext extends ClassContext {
     private final FunctionDescriptor functionDescriptor;
@@ -33,7 +33,7 @@ public class ClosureContext extends ClassContext {
             @Nullable CodegenContext parentContext,
             @NotNull LocalLookup localLookup
     ) {
-        super(typeMapper, anonymousClassForFunction(typeMapper.getBindingContext(), functionDescriptor),
+        super(typeMapper, anonymousClassForCallable(typeMapper.getBindingContext(), functionDescriptor),
               OwnerKind.IMPLEMENTATION, parentContext, localLookup);
 
         this.functionDescriptor = functionDescriptor;
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/context/LocalLookup.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/context/LocalLookup.java
index 401a7314ebd..8f1413c69c4 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/context/LocalLookup.java
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/context/LocalLookup.java
@@ -103,7 +103,7 @@ public interface LocalLookup {
                 BindingContext bindingContext = state.getBindingContext();
                 Type localType = asmTypeForAnonymousClass(bindingContext, vd);
 
-                MutableClosure localFunClosure = bindingContext.get(CLOSURE, bindingContext.get(CLASS_FOR_FUNCTION, vd));
+                MutableClosure localFunClosure = bindingContext.get(CLOSURE, bindingContext.get(CLASS_FOR_CALLABLE, vd));
                 if (localFunClosure != null && JvmCodegenUtil.isConst(localFunClosure)) {
                     // This is an optimization: we can obtain an instance of a const closure simply by GETSTATIC ...$instance
                     // (instead of passing this instance to the constructor and storing as a field)
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/context/ScriptContext.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/context/ScriptContext.java
index 64905a5971b..9db829601c3 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/context/ScriptContext.java
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/context/ScriptContext.java
@@ -61,4 +61,9 @@ public class ScriptContext extends FieldOwnerContext<ClassDescriptor> {
         }
         return "script$" + (index + 1);
     }
+
+    @Override
+    public String toString() {
+        return "Script: " + getContextDescriptor().getName().asString();
+    }
 }
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/InlineCodegenUtil.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/InlineCodegenUtil.java
index 8db898e6d26..d35b9448bca 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/InlineCodegenUtil.java
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/InlineCodegenUtil.java
@@ -234,7 +234,7 @@ public class InlineCodegenUtil {
             return type.getInternalName();
         } else if (currentDescriptor instanceof FunctionDescriptor) {
             ClassDescriptor descriptor =
-                    typeMapper.getBindingContext().get(CodegenBinding.CLASS_FOR_FUNCTION, (FunctionDescriptor) currentDescriptor);
+                    typeMapper.getBindingContext().get(CodegenBinding.CLASS_FOR_CALLABLE, (FunctionDescriptor) currentDescriptor);
             if (descriptor != null) {
                 Type type = typeMapper.mapType(descriptor);
                 return type.getInternalName();
@@ -471,6 +471,32 @@ public class InlineCodegenUtil {
                           "()V", false);
     }
 
+    public static boolean isInlineMarker(AbstractInsnNode insn) {
+        return isInlineMarker(insn, null);
+    }
+
+    public static boolean isInlineMarker(AbstractInsnNode insn, String name) {
+        if (insn instanceof MethodInsnNode) {
+            MethodInsnNode methodInsnNode = (MethodInsnNode) insn;
+            return insn.getOpcode() == Opcodes.INVOKESTATIC &&
+                   methodInsnNode.owner.equals(INLINE_MARKER_CLASS_NAME) &&
+                   (name != null ? methodInsnNode.name.equals(name)
+                                 : methodInsnNode.name.equals(INLINE_MARKER_BEFORE_METHOD_NAME) ||
+                                   methodInsnNode.name.equals(INLINE_MARKER_AFTER_METHOD_NAME));
+        }
+        else {
+            return false;
+        }
+    }
+
+    public static boolean isBeforeInlineMarker(AbstractInsnNode insn) {
+        return isInlineMarker(insn, INLINE_MARKER_BEFORE_METHOD_NAME);
+    }
+
+    public static boolean isAfterInlineMarker(AbstractInsnNode insn) {
+        return isInlineMarker(insn, INLINE_MARKER_AFTER_METHOD_NAME);
+    }
+
     public static int getLoadStoreArgSize(int opcode) {
         return opcode == Opcodes.DSTORE || opcode == Opcodes.LSTORE || opcode == Opcodes.DLOAD || opcode == Opcodes.LLOAD ? 2 : 1;
     }
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/LambdaInfo.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/LambdaInfo.java
index e8e6656557c..c3782e78277 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/LambdaInfo.java
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/LambdaInfo.java
@@ -70,7 +70,7 @@ public class LambdaInfo implements CapturedParamOwner, LabelOwner {
         functionDescriptor = bindingContext.get(BindingContext.FUNCTION, expression);
         assert functionDescriptor != null : "Function is not resolved to descriptor: " + expression.getText();
 
-        classDescriptor = anonymousClassForFunction(bindingContext, functionDescriptor);
+        classDescriptor = anonymousClassForCallable(bindingContext, functionDescriptor);
         closureClassType = asmTypeForAnonymousClass(bindingContext, functionDescriptor);
 
         closure = bindingContext.get(CLOSURE, classDescriptor);
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/MethodInliner.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/MethodInliner.java
index 684f3808526..b687a7ccca3 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/MethodInliner.java
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/MethodInliner.java
@@ -23,6 +23,7 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.codegen.ClosureCodegen;
 import org.jetbrains.kotlin.codegen.StackValue;
 import org.jetbrains.kotlin.codegen.intrinsics.IntrinsicMethods;
+import org.jetbrains.kotlin.codegen.optimization.MandatoryMethodTransformer;
 import org.jetbrains.kotlin.codegen.state.JetTypeMapper;
 import org.jetbrains.kotlin.load.java.JvmAnnotationNames.KotlinSyntheticClass;
 import org.jetbrains.kotlin.load.kotlin.KotlinBinaryClassCache;
@@ -373,6 +374,8 @@ public class MethodInliner {
     protected MethodNode markPlacesForInlineAndRemoveInlinable(@NotNull MethodNode node, int finallyDeepShift) {
         node = prepareNode(node, finallyDeepShift);
 
+        MandatoryMethodTransformer.INSTANCE$.transform("fake", node);
+
         Analyzer<SourceValue> analyzer = new Analyzer<SourceValue>(new SourceInterpreter()) {
             @NotNull
             @Override
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/SMAP.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/SMAP.kt
index ff0cc3ddc08..d5bad814797 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/SMAP.kt
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/SMAP.kt
@@ -284,7 +284,7 @@ class RawFileMapping(val name: String, val path: String) {
             if (rangeMappings.isNotEmpty() && isLastMapped && couldFoldInRange(lastMappedWithNewIndex, source)) {
                 rangeMapping = rangeMappings.last()
                 rangeMapping.range += source - lastMappedWithNewIndex
-                dest = lineMappings[lastMappedWithNewIndex] + source - lastMappedWithNewIndex
+                dest = lineMappings[lastMappedWithNewIndex]!! + source - lastMappedWithNewIndex
             }
             else {
                 dest = currentIndex + 1
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/intrinsics/BinaryOp.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/intrinsics/BinaryOp.kt
index f52c4cba9a4..8a3a576387e 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/intrinsics/BinaryOp.kt
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/intrinsics/BinaryOp.kt
@@ -19,6 +19,7 @@ package org.jetbrains.kotlin.codegen.intrinsics
 import org.jetbrains.kotlin.codegen.AsmUtil.numberFunctionOperandType
 import org.jetbrains.kotlin.codegen.Callable
 import org.jetbrains.kotlin.codegen.CallableMethod
+import org.jetbrains.kotlin.codegen.StackValue
 import org.jetbrains.org.objectweb.asm.Opcodes.ISHL
 import org.jetbrains.org.objectweb.asm.Opcodes.ISHR
 import org.jetbrains.org.objectweb.asm.Opcodes.IUSHR
@@ -34,8 +35,11 @@ public class BinaryOp(private val opcode: Int) : IntrinsicMethod() {
         val operandType = numberFunctionOperandType(returnType)
         val paramType = if (shift()) Type.INT_TYPE else operandType
 
-        return createBinaryIntrinsicCallable(operandType, paramType, operandType) {
-            v -> v.visitInsn(returnType.getOpcode(opcode))
+        return createBinaryIntrinsicCallable(returnType, paramType, operandType) {
+            v ->
+                v.visitInsn(returnType.getOpcode(opcode));
+                if (operandType != returnType)
+                    StackValue.coerce(operandType, returnType, v)
         }
     }
 }
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/FixStackBeforeJumpTransformer.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/FixStackBeforeJumpTransformer.kt
deleted file mode 100644
index 1e39ae7eef0..00000000000
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/FixStackBeforeJumpTransformer.kt
+++ /dev/null
@@ -1,156 +0,0 @@
-/*
- * Copyright 2010-2015 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.kotlin.codegen.optimization
-
-import org.jetbrains.kotlin.codegen.optimization.common.MethodAnalyzer
-import org.jetbrains.kotlin.codegen.optimization.common.OptimizationBasicInterpreter
-import org.jetbrains.kotlin.codegen.optimization.transformer.MethodTransformer
-import org.jetbrains.kotlin.codegen.pseudoInsns.PseudoInsnOpcode
-import org.jetbrains.kotlin.codegen.pseudoInsns.parseOrNull
-import org.jetbrains.org.objectweb.asm.Opcodes
-import org.jetbrains.org.objectweb.asm.tree.*
-import org.jetbrains.org.objectweb.asm.tree.analysis.*
-import java.util.*
-import kotlin.properties.Delegates
-import kotlin.test.assertEquals
-
-class FixStackBeforeJumpTransformer : MethodTransformer() {
-    public override fun transform(internalClassName: String, methodNode: MethodNode) {
-        val jumpsToFix = linkedSetOf<JumpInsnNode>()
-        val fakesToGotos = arrayListOf<AbstractInsnNode>()
-        val fakesToRemove = arrayListOf<AbstractInsnNode>()
-
-        methodNode.instructions.forEach { insnNode ->
-            when {
-                PseudoInsnOpcode.FIX_STACK_BEFORE_JUMP.isa(insnNode) -> {
-                    val next = insnNode.getNext()
-                    assert(next.getOpcode() == Opcodes.GOTO,
-                           "Instruction after ${PseudoInsnOpcode.FIX_STACK_BEFORE_JUMP} should be GOTO")
-                    jumpsToFix.add(next as JumpInsnNode)
-                }
-                PseudoInsnOpcode.FAKE_ALWAYS_TRUE_IFEQ.isa(insnNode) -> {
-                    assert(insnNode.getNext().getOpcode() == Opcodes.IFEQ,
-                           "Instruction after ${PseudoInsnOpcode.FAKE_ALWAYS_TRUE_IFEQ} should be IFEQ")
-                    fakesToGotos.add(insnNode)
-                }
-                PseudoInsnOpcode.FAKE_ALWAYS_FALSE_IFEQ.isa(insnNode) -> {
-                    assert(insnNode.getNext().getOpcode() == Opcodes.IFEQ,
-                           "Instruction after ${PseudoInsnOpcode.FAKE_ALWAYS_FALSE_IFEQ} should be IFEQ")
-                    fakesToRemove.add(insnNode)
-                }
-            }
-        }
-
-        if (jumpsToFix.isEmpty() && fakesToGotos.isEmpty() && fakesToRemove.isEmpty()) {
-            return
-        }
-
-        if (jumpsToFix.isNotEmpty()) {
-            val analyzer = StackDepthAnalyzer(internalClassName, methodNode, jumpsToFix)
-            val frames = analyzer.analyze()
-
-            val actions = arrayListOf<() -> Unit>()
-
-            for (jumpNode in jumpsToFix) {
-                val jumpIndex = methodNode.instructions.indexOf(jumpNode)
-                val labelIndex = methodNode.instructions.indexOf(jumpNode.label)
-
-                val DEAD_CODE = -1 // Stack size is always non-negative for live code
-                val actualStackSize = frames[jumpIndex]?.getStackSize() ?: DEAD_CODE
-                val expectedStackSize = frames[labelIndex]?.getStackSize() ?: DEAD_CODE
-
-                if (actualStackSize != DEAD_CODE && expectedStackSize != DEAD_CODE) {
-                    assert(expectedStackSize <= actualStackSize,
-                           "Label at $labelIndex, jump at $jumpIndex: stack underflow: $expectedStackSize > $actualStackSize")
-                    val frame = frames[jumpIndex]!!
-                    actions.add({ replaceMarkerWithPops(methodNode, jumpNode.getPrevious(), expectedStackSize, frame) })
-                }
-                else if (actualStackSize != DEAD_CODE && expectedStackSize == DEAD_CODE) {
-                    throw AssertionError("Live jump $jumpIndex to dead label $labelIndex")
-                }
-                else {
-                    val marker = jumpNode.getPrevious()
-                    actions.add({ methodNode.instructions.remove(marker) })
-                }
-            }
-
-            actions.forEach { it() }
-        }
-
-        for (marker in fakesToGotos) {
-            replaceAlwaysTrueIfeqWithGoto(methodNode, marker)
-        }
-
-        for (marker in fakesToRemove) {
-            removeAlwaysFalseIfeq(methodNode, marker)
-        }
-    }
-
-    private fun removeAlwaysFalseIfeq(methodNode: MethodNode, nodeToReplace: AbstractInsnNode) {
-        with (methodNode.instructions) {
-            remove(nodeToReplace.getNext())
-            remove(nodeToReplace)
-        }
-    }
-
-    private fun replaceAlwaysTrueIfeqWithGoto(methodNode: MethodNode, nodeToReplace: AbstractInsnNode) {
-        with (methodNode.instructions) {
-            val next = nodeToReplace.getNext() as JumpInsnNode
-            insertBefore(nodeToReplace, JumpInsnNode(Opcodes.GOTO, next.label))
-            remove(nodeToReplace)
-            remove(next)
-        }
-    }
-
-    private fun replaceMarkerWithPops(methodNode: MethodNode, nodeToReplace: AbstractInsnNode, expectedStackSize: Int, frame: Frame<BasicValue>) {
-        with (methodNode.instructions) {
-            while (frame.getStackSize() > expectedStackSize) {
-                val top = frame.pop()
-                insertBefore(nodeToReplace, getPopInstruction(top))
-            }
-            remove(nodeToReplace)
-        }
-    }
-
-    private fun getPopInstruction(top: BasicValue) =
-            InsnNode(when (top.getSize()) {
-                         1 -> Opcodes.POP
-                         2 -> Opcodes.POP2
-                         else -> throw AssertionError("Unexpected value type size")
-                     })
-
-    private class StackDepthAnalyzer(
-            owner: String,
-            methodNode: MethodNode,
-            val markedJumps: Set<JumpInsnNode>
-    ) : MethodAnalyzer<BasicValue>(owner, methodNode, OptimizationBasicInterpreter()) {
-        protected override fun visitControlFlowEdge(insn: Int, successor: Int): Boolean {
-            val insnNode = instructions[insn]
-            return !(insnNode is JumpInsnNode && markedJumps.contains(insnNode))
-        }
-    }
-
-}
-
-private inline fun InsnList.forEach(block: (AbstractInsnNode) -> Unit) {
-    val iter = this.iterator()
-    while (iter.hasNext()) {
-        val insn = iter.next()
-        block(insn)
-    }
-}
-
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/LabelNormalizationMethodTransformer.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/LabelNormalizationMethodTransformer.kt
new file mode 100644
index 00000000000..7528cef9e4d
--- /dev/null
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/LabelNormalizationMethodTransformer.kt
@@ -0,0 +1,155 @@
+/*
+ * Copyright 2010-2015 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.kotlin.codegen.optimization
+
+import org.jetbrains.kotlin.codegen.optimization.transformer.MethodTransformer
+import org.jetbrains.org.objectweb.asm.Label
+import org.jetbrains.org.objectweb.asm.tree.*
+
+public object LabelNormalizationMethodTransformer : MethodTransformer() {
+    val newLabelNodes = hashMapOf<LabelNode, LabelNode>()
+    val removedLabelNodes = hashSetOf<LabelNode>()
+
+    public override fun transform(internalClassName: String, methodNode: MethodNode) {
+        newLabelNodes.clear()
+        removedLabelNodes.clear()
+
+        with(methodNode.instructions) {
+            insertBefore(getFirst(), LabelNode(Label()))
+            insert(getLast(), LabelNode(Label()))
+        }
+
+        rewriteLabelInsns(methodNode)
+        if (removedLabelNodes.isEmpty()) return
+
+        rewriteInsns(methodNode)
+        rewriteTryCatchBlocks(methodNode)
+        rewriteLocalVars(methodNode)
+    }
+
+    private fun rewriteLabelInsns(methodNode: MethodNode) {
+        var prevLabelNode: LabelNode? = null
+        var thisNode = methodNode.instructions.getFirst()
+        while (thisNode != null) {
+            if (thisNode is LabelNode) {
+                if (prevLabelNode != null) {
+                    newLabelNodes[thisNode] = prevLabelNode
+                    removedLabelNodes.add(thisNode)
+                    thisNode = methodNode.instructions.removeNodeGetNext(thisNode)
+                }
+                else {
+                    prevLabelNode = thisNode
+                    newLabelNodes[thisNode] = thisNode
+                    thisNode = thisNode.getNext()
+                }
+            }
+            else {
+                prevLabelNode = null
+                thisNode = thisNode.getNext()
+            }
+        }
+    }
+
+    private fun rewriteInsns(methodNode: MethodNode) {
+        var thisNode = methodNode.instructions.getFirst()
+        while (thisNode != null) {
+            thisNode = when (thisNode) {
+                is JumpInsnNode ->
+                    rewriteJumpInsn(methodNode, thisNode)
+                is LineNumberNode ->
+                    rewriteLineNumberNode(methodNode, thisNode)
+                is LookupSwitchInsnNode ->
+                    rewriteLookupSwitchInsn(methodNode, thisNode)
+                is TableSwitchInsnNode ->
+                    rewriteTableSwitchInsn(methodNode, thisNode)
+                is FrameNode ->
+                    rewriteFrameNode(methodNode, thisNode)
+                else ->
+                    thisNode.getNext()
+            }
+        }
+    }
+
+    private fun rewriteLineNumberNode(methodNode: MethodNode, oldLineNode: LineNumberNode): AbstractInsnNode? {
+        if (isRemoved(oldLineNode.start)) {
+            val newLineNode = oldLineNode.clone(newLabelNodes)
+            return methodNode.instructions.replaceNodeGetNext(oldLineNode, newLineNode)
+        }
+        else {
+            return oldLineNode.getNext()
+        }
+    }
+
+    private fun rewriteJumpInsn(methodNode: MethodNode, oldJumpNode: JumpInsnNode): AbstractInsnNode? {
+        if (isRemoved(oldJumpNode.label)) {
+            val newJumpNode = oldJumpNode.clone(newLabelNodes)
+            return methodNode.instructions.replaceNodeGetNext(oldJumpNode, newJumpNode)
+        }
+        else {
+            return oldJumpNode.getNext()
+        }
+    }
+
+    private fun rewriteLookupSwitchInsn(methodNode: MethodNode, oldSwitchNode: LookupSwitchInsnNode): AbstractInsnNode? =
+            methodNode.instructions.replaceNodeGetNext(oldSwitchNode, oldSwitchNode.clone(newLabelNodes))
+
+    private fun rewriteTableSwitchInsn(methodNode: MethodNode, oldSwitchNode: TableSwitchInsnNode): AbstractInsnNode? =
+            methodNode.instructions.replaceNodeGetNext(oldSwitchNode, oldSwitchNode.clone(newLabelNodes))
+
+    private fun rewriteFrameNode(methodNode: MethodNode, oldFrameNode: FrameNode): AbstractInsnNode? =
+            methodNode.instructions.replaceNodeGetNext(oldFrameNode, oldFrameNode.clone(newLabelNodes))
+
+    private fun rewriteTryCatchBlocks(methodNode: MethodNode) {
+        methodNode.tryCatchBlocks = methodNode.tryCatchBlocks.map { oldTcb ->
+            if (isRemoved(oldTcb.start) || isRemoved(oldTcb.end) || isRemoved(oldTcb.handler)) {
+                val newTcb = TryCatchBlockNode(getNew(oldTcb.start), getNew(oldTcb.end), getNew(oldTcb.handler), oldTcb.type)
+                newTcb.visibleTypeAnnotations = oldTcb.visibleTypeAnnotations
+                newTcb.invisibleTypeAnnotations = oldTcb.invisibleTypeAnnotations
+                newTcb
+            }
+            else {
+                oldTcb
+            }
+        }
+    }
+
+    private fun rewriteLocalVars(methodNode: MethodNode) {
+        methodNode.localVariables = methodNode.localVariables.map { oldVar ->
+            if (isRemoved(oldVar.start) || isRemoved(oldVar.end)) {
+                LocalVariableNode(oldVar.name, oldVar.desc, oldVar.signature, getNew(oldVar.start), getNew(oldVar.end), oldVar.index)
+            }
+            else {
+                oldVar
+            }
+        }
+    }
+
+    private fun isRemoved(labelNode: LabelNode): Boolean = removedLabelNodes.contains(labelNode)
+    private fun getNew(oldLabelNode: LabelNode): LabelNode = newLabelNodes[oldLabelNode]!!
+}
+
+private fun InsnList.replaceNodeGetNext(oldNode: AbstractInsnNode, newNode: AbstractInsnNode): AbstractInsnNode? {
+    insertBefore(oldNode, newNode)
+    remove(oldNode)
+    return newNode.getNext()
+}
+
+private fun InsnList.removeNodeGetNext(oldNode: AbstractInsnNode): AbstractInsnNode? {
+    val next = oldNode.getNext()
+    remove(oldNode)
+    return next
+}
diff --git a/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/KClassValue.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/MandatoryMethodTransforker.kt
similarity index 50%
rename from core/descriptors/src/org/jetbrains/kotlin/resolve/constants/KClassValue.kt
rename to compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/MandatoryMethodTransforker.kt
index 563f1b680bb..2772abf06c2 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/KClassValue.kt
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/MandatoryMethodTransforker.kt
@@ -14,16 +14,15 @@
  * limitations under the License.
  */
 
-package org.jetbrains.kotlin.resolve.constants
+package org.jetbrains.kotlin.codegen.optimization
 
-import org.jetbrains.kotlin.builtins.KotlinBuiltIns
-import org.jetbrains.kotlin.descriptors.annotations.AnnotationArgumentVisitor
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.codegen.optimization.fixStack.FixStackMethodTransformer
+import org.jetbrains.kotlin.codegen.optimization.transformer.MethodTransformer
+import org.jetbrains.org.objectweb.asm.tree.MethodNode
 
-
-public class KClassValue(type: JetType) : CompileTimeConstant<JetType>(type, true, false, false) {
-    override fun getType(kotlinBuiltIns: KotlinBuiltIns) = value
-    override fun getValue(): JetType = value.getArguments().single().getType()
-
-    override fun <R, D> accept(visitor: AnnotationArgumentVisitor<R, D>, data: D) = visitor.visitKClassValue(this, data)
-}
+public object MandatoryMethodTransformer : MethodTransformer() {
+    public override fun transform(internalClassName: String, methodNode: MethodNode) {
+        LabelNormalizationMethodTransformer.transform(internalClassName, methodNode)
+        FixStackMethodTransformer.transform(internalClassName, methodNode)
+    }
+}
\ No newline at end of file
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/OptimizationMethodVisitor.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/OptimizationMethodVisitor.java
index 6cf98fb407c..8027d2e79e3 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/OptimizationMethodVisitor.java
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/OptimizationMethodVisitor.java
@@ -22,6 +22,7 @@ import org.jetbrains.kotlin.codegen.inline.InlineCodegenUtil;
 import org.jetbrains.kotlin.codegen.optimization.boxing.RedundantBoxingMethodTransformer;
 import org.jetbrains.kotlin.codegen.optimization.boxing.RedundantNullCheckMethodTransformer;
 import org.jetbrains.kotlin.codegen.optimization.common.CommonPackage;
+import org.jetbrains.kotlin.codegen.optimization.fixStack.FixStackMethodTransformer;
 import org.jetbrains.kotlin.codegen.optimization.transformer.MethodTransformer;
 import org.jetbrains.org.objectweb.asm.MethodVisitor;
 import org.jetbrains.org.objectweb.asm.Opcodes;
@@ -36,16 +37,11 @@ import java.util.List;
 public class OptimizationMethodVisitor extends MethodVisitor {
     private static final int MEMORY_LIMIT_BY_METHOD_MB = 50;
 
-    private static final MethodTransformer[] MANDATORY_TRANSFORMERS = new MethodTransformer[] {
-            new FixStackBeforeJumpTransformer()
-    };
-
     private static final MethodTransformer[] OPTIMIZATION_TRANSFORMERS = new MethodTransformer[] {
             new RedundantNullCheckMethodTransformer(),
             new RedundantBoxingMethodTransformer(),
             new DeadCodeEliminationMethodTransformer(),
-            new RedundantGotoMethodTransformer(),
-            new StoreStackBeforeInlineMethodTransformer()
+            new RedundantGotoMethodTransformer()
     };
 
     private final MethodNode methodNode;
@@ -79,9 +75,7 @@ public class OptimizationMethodVisitor extends MethodVisitor {
         super.visitEnd();
 
         if (shouldBeTransformed(methodNode)) {
-            for (MethodTransformer transformer : MANDATORY_TRANSFORMERS) {
-                transformer.transform("fake", methodNode);
-            }
+            MandatoryMethodTransformer.INSTANCE$.transform("fake", methodNode);
             if (canBeOptimized(methodNode) && !disableOptimization) {
                 for (MethodTransformer transformer : OPTIMIZATION_TRANSFORMERS) {
                     transformer.transform("fake", methodNode);
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/StoreStackBeforeInlineMethodTransformer.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/StoreStackBeforeInlineMethodTransformer.kt
deleted file mode 100644
index e3bae6ebae2..00000000000
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/StoreStackBeforeInlineMethodTransformer.kt
+++ /dev/null
@@ -1,220 +0,0 @@
-/*
- * Copyright 2010-2015 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.kotlin.codegen.optimization
-
-import org.jetbrains.kotlin.codegen.optimization.transformer.MethodTransformer
-import org.jetbrains.kotlin.codegen.optimization.common.OptimizationBasicInterpreter
-import org.jetbrains.kotlin.codegen.inline.InlineCodegenUtil
-import org.jetbrains.org.objectweb.asm.tree.MethodNode
-import org.jetbrains.org.objectweb.asm.tree.AbstractInsnNode
-import org.jetbrains.org.objectweb.asm.Opcodes
-import org.jetbrains.org.objectweb.asm.tree.MethodInsnNode
-import org.jetbrains.org.objectweb.asm.tree.analysis.Frame
-import org.jetbrains.org.objectweb.asm.tree.analysis.BasicValue
-import org.jetbrains.org.objectweb.asm.tree.VarInsnNode
-import org.jetbrains.org.objectweb.asm.Type
-import com.intellij.util.containers.Stack
-
-class StoreStackBeforeInlineMethodTransformer : MethodTransformer() {
-    override fun transform(internalClassName: String, methodNode: MethodNode) {
-        val frames = MethodTransformer.analyze(internalClassName, methodNode, OptimizationBasicInterpreter())
-        if (needToProcess(methodNode, frames)) {
-            process(methodNode, frames)
-        }
-        else {
-            removeInlineMarkers(methodNode)
-        }
-    }
-}
-
-private fun needToProcess(node: MethodNode, frames: Array<Frame<BasicValue>?>): Boolean {
-    val insns = node.instructions.toArray()
-    var balance = 0
-    var isThereAnyInlineMarker = false
-
-    for ((insn, frame) in insns.zip(frames)) {
-        if (isInlineMarker(insn)) {
-            isThereAnyInlineMarker = true
-
-            // inline marker is not available
-            if (frame == null) return false
-        }
-
-        if (isBeforeInlineMarker(insn)) {
-            balance++
-        }
-        else if(isAfterInlineMarker(insn)) {
-            balance--
-        }
-
-        if (balance < 0) return false
-    }
-
-    return balance == 0 && isThereAnyInlineMarker
-}
-
-private fun isBeforeInlineMarker(insn: AbstractInsnNode) = isInlineMarker(insn, InlineCodegenUtil.INLINE_MARKER_BEFORE_METHOD_NAME)
-
-private fun isAfterInlineMarker(insn: AbstractInsnNode) = isInlineMarker(insn, InlineCodegenUtil.INLINE_MARKER_AFTER_METHOD_NAME)
-
-private fun isInlineMarker(insn: AbstractInsnNode, markerName: String? = null): Boolean {
-    return insn.getOpcode() == Opcodes.INVOKESTATIC &&
-           insn is MethodInsnNode &&
-           insn.owner == InlineCodegenUtil.INLINE_MARKER_CLASS_NAME &&
-           if (markerName != null) markerName == insn.name else (
-               insn.name == InlineCodegenUtil.INLINE_MARKER_BEFORE_METHOD_NAME ||
-               insn.name == InlineCodegenUtil.INLINE_MARKER_AFTER_METHOD_NAME
-           )
-}
-
-private fun process(methodNode: MethodNode, frames: Array<Frame<BasicValue>?>) {
-    val insns = methodNode.instructions.toArray()
-
-    val storedValuesDescriptorsStack = Stack<StoredStackValuesDescriptor>()
-    var firstAvailableVarIndex = methodNode.maxLocals
-    var currentStoredValuesCount = 0
-
-    for ((insn, frame) in insns.zip(frames)) {
-        if (isBeforeInlineMarker(insn)) {
-            frame ?: throw AssertionError("process method shouldn't be called if frame is null before inline marker")
-
-            val desc = storeStackValues(methodNode, frame, insn, firstAvailableVarIndex, currentStoredValuesCount)
-
-            firstAvailableVarIndex += desc.storedStackSize
-            currentStoredValuesCount += desc.storedValuesCount
-            storedValuesDescriptorsStack.push(desc)
-        }
-        else if (isAfterInlineMarker(insn)) {
-            frame ?: throw AssertionError("process method shouldn't be called if frame is null before inline marker")
-
-            val desc = storedValuesDescriptorsStack.pop() ?:
-                       throw AssertionError("should be non null becase markers are balanced")
-
-            loadStackValues(methodNode, frame, insn, desc)
-            firstAvailableVarIndex -= desc.storedStackSize
-            currentStoredValuesCount -= desc.storedValuesCount
-        }
-
-        if (isInlineMarker(insn)) {
-            methodNode.instructions.remove(insn)
-        }
-    }
-}
-
-private class StoredStackValuesDescriptor(
-        val values: List<BasicValue>,
-        val firstVariableIndex: Int,
-        val storedStackSize: Int,
-        alreadyStoredValuesCount: Int
-) {
-    val nextFreeVarIndex : Int get() = firstVariableIndex + storedStackSize
-    val storedValuesCount: Int get() = values.size()
-    val isStored: Boolean get() = storedValuesCount > 0
-    val totalValuesCountOnStackBeforeInline = alreadyStoredValuesCount + storedValuesCount
-}
-
-private fun removeInlineMarkers(node: MethodNode) {
-    for (insn in node.instructions.toArray()) {
-        if (isInlineMarker(insn)) {
-            node.instructions.remove(insn)
-        }
-    }
-}
-
-private fun storeStackValues(
-        node: MethodNode,
-        frame: Frame<BasicValue>,
-        beforeInlineMarker: AbstractInsnNode,
-        firstAvailableVarIndex: Int,
-        alreadyStoredValuesCount: Int
-) : StoredStackValuesDescriptor {
-    var stackSize = 0
-
-    val values = frame.getStackValuesStartingFrom(alreadyStoredValuesCount)
-
-    for (value in values.reverse()) {
-        node.instructions.insertBefore(
-                beforeInlineMarker,
-                VarInsnNode(
-                        value.getType()!!.getOpcode(Opcodes.ISTORE),
-                        firstAvailableVarIndex + stackSize
-                )
-        )
-        stackSize += value.getSize()
-    }
-
-    node.updateMaxLocals(firstAvailableVarIndex + stackSize)
-
-    return StoredStackValuesDescriptor(values, firstAvailableVarIndex, stackSize, alreadyStoredValuesCount)
-}
-
-private fun loadStackValues(
-        node: MethodNode,
-        frame: Frame<BasicValue>,
-        afterInlineMarker: AbstractInsnNode,
-        desc: StoredStackValuesDescriptor
-) {
-    if (!desc.isStored) return
-
-    val insns = node.instructions
-    var returnValueVarIndex = -1
-    var returnType : Type? = null
-
-    if (frame.getStackSize() != desc.totalValuesCountOnStackBeforeInline) {
-        // only returned value
-        assert(
-                (frame.getStackSize() - desc.totalValuesCountOnStackBeforeInline) == 1,
-                "Stack sizes should not differ by more than 1 (returned value)"
-        )
-
-        returnValueVarIndex = desc.nextFreeVarIndex
-        returnType = frame.getStack(frame.getStackSize() - 1)!!.getType()
-        node.updateMaxLocals(returnValueVarIndex + returnType!!.getSize())
-
-        insns.insertBefore(
-                afterInlineMarker,
-                VarInsnNode(returnType!!.getOpcode(Opcodes.ISTORE), returnValueVarIndex)
-        )
-    }
-
-    var currentVarIndex = desc.firstVariableIndex + desc.storedStackSize
-
-    for (value in desc.values) {
-        currentVarIndex -= value.getSize()
-        insns.insertBefore(
-                afterInlineMarker,
-                VarInsnNode(
-                        value.getType()!!.getOpcode(Opcodes.ILOAD),
-                        currentVarIndex
-                )
-        )
-    }
-
-    if (returnValueVarIndex != -1) {
-        insns.insertBefore(
-                afterInlineMarker,
-                VarInsnNode(returnType!!.getOpcode(Opcodes.ILOAD), returnValueVarIndex)
-        )
-    }
-}
-
-private fun <V : BasicValue> Frame<V>.getStackValuesStartingFrom(from: Int): List<V> =
-        IntRange(from, getStackSize() - 1).map { getStack(it) }.requireNoNulls()
-
-private fun MethodNode.updateMaxLocals(newMaxLocals: Int) {
-    maxLocals = Math.max(maxLocals, newMaxLocals)
-}
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/common/MethodAnalyzer.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/common/MethodAnalyzer.kt
index 2e78f8a251a..6d9a214ece3 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/common/MethodAnalyzer.kt
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/common/MethodAnalyzer.kt
@@ -44,7 +44,11 @@ public open class MethodAnalyzer<V : Value>(
 
     protected open fun newFrame(nLocals: Int, nStack: Int): Frame<V> = Frame(nLocals, nStack)
 
-    protected open fun newFrame(src: Frame<out V>): Frame<V> = Frame(src)
+    protected open fun newFrame(src: Frame<out V>): Frame<V> {
+        val frame = newFrame(src.getLocals(), src.getMaxStackSize())
+        frame.init(src)
+        return frame
+    }
 
     protected open fun visitControlFlowEdge(insn: Int, successor: Int): Boolean = true
 
@@ -94,12 +98,12 @@ public open class MethodAnalyzer<V : Value>(
                 }
 
                 handlers[insn]?.forEach { tcb ->
-                    val type = Type.getObjectType(tcb.type?:"java/lang/Throwable")
+                    val exnType = Type.getObjectType(tcb.type?:"java/lang/Throwable")
                     val jump = instructions.indexOf(tcb.handler)
                     if (visitControlFlowExceptionEdge(insn, tcb)) {
                         handler.init(f)
                         handler.clearStack()
-                        handler.push(interpreter.newValue(type))
+                        handler.push(interpreter.newValue(exnType))
                         mergeControlFlowEdge(jump, handler)
                     }
                 }
@@ -117,6 +121,9 @@ public open class MethodAnalyzer<V : Value>(
         return frames
     }
 
+    public fun getFrame(insn: AbstractInsnNode): Frame<V>? =
+            frames[instructions.indexOf(insn)]
+
     private fun checkAssertions() {
         if (instructions.toArray() any { it.getOpcode() == Opcodes.JSR || it.getOpcode() == Opcodes.RET })
             throw AssertionError("Subroutines are deprecated since Java 6")
@@ -170,9 +177,9 @@ public open class MethodAnalyzer<V : Value>(
             val ctype = Type.getObjectType(owner)
             current.setLocal(local++, interpreter.newValue(ctype))
         }
-        for (i in args.indices) {
-            current.setLocal(local++, interpreter.newValue(args[i]))
-            if (args[i].getSize() == 2) {
+        for (arg in args) {
+            current.setLocal(local++, interpreter.newValue(arg))
+            if (arg.getSize() == 2) {
                 current.setLocal(local++, interpreter.newValue(null))
             }
         }
@@ -185,8 +192,7 @@ public open class MethodAnalyzer<V : Value>(
     }
 
     private fun computeExceptionHandlersForEachInsn(m: MethodNode) {
-        for (i in m.tryCatchBlocks.indices) {
-            val tcb = m.tryCatchBlocks.get(i)
+        for (tcb in m.tryCatchBlocks) {
             val begin = instructions.indexOf(tcb.start)
             val end = instructions.indexOf(tcb.end)
             for (j in begin..end - 1) {
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/common/Util.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/common/Util.kt
index 565cbdc2d2d..b291df1fc78 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/common/Util.kt
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/common/Util.kt
@@ -18,6 +18,8 @@ package org.jetbrains.kotlin.codegen.optimization.common
 
 import org.jetbrains.org.objectweb.asm.tree.AbstractInsnNode
 import org.jetbrains.org.objectweb.asm.Opcodes
+import org.jetbrains.org.objectweb.asm.tree.InsnList
+import org.jetbrains.org.objectweb.asm.tree.LabelNode
 import org.jetbrains.org.objectweb.asm.tree.analysis.Frame
 import org.jetbrains.org.objectweb.asm.tree.analysis.BasicValue
 import org.jetbrains.org.objectweb.asm.tree.MethodNode
@@ -28,7 +30,9 @@ val AbstractInsnNode.isMeaningful : Boolean get() =
         else -> true
     }
 
-class InsnSequence(val from: AbstractInsnNode, val to: AbstractInsnNode?) : Sequence<AbstractInsnNode> {
+public class InsnSequence(val from: AbstractInsnNode, val to: AbstractInsnNode?) : Sequence<AbstractInsnNode> {
+    public constructor(insnList: InsnList) : this(insnList.getFirst(), null)
+
     override fun iterator(): Iterator<AbstractInsnNode> {
         return object : Iterator<AbstractInsnNode> {
             var current: AbstractInsnNode? = from
@@ -77,3 +81,22 @@ abstract class BasicValueWrapper(val wrappedValue: BasicValue?) : BasicValue(wra
         return super.equals(other) && this.javaClass == other?.javaClass
     }
 }
+
+inline fun AbstractInsnNode.findNextOrNull(predicate: (AbstractInsnNode) -> Boolean): AbstractInsnNode? {
+    var finger = this.getNext()
+    while (finger != null && !predicate(finger)) {
+        finger = finger.getNext()
+    }
+    return finger
+}
+
+inline fun AbstractInsnNode.findPreviousOrNull(predicate: (AbstractInsnNode) -> Boolean): AbstractInsnNode? {
+    var finger = this.getPrevious()
+    while (finger != null && !predicate(finger)) {
+        finger = finger.getPrevious()
+    }
+    return finger
+}
+
+fun AbstractInsnNode.hasOpcode(): Boolean =
+        getOpcode() >= 0
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/fixStack/AnalyzeTryCatchBlocks.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/fixStack/AnalyzeTryCatchBlocks.kt
new file mode 100644
index 00000000000..ac330676925
--- /dev/null
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/fixStack/AnalyzeTryCatchBlocks.kt
@@ -0,0 +1,97 @@
+/*
+ * Copyright 2010-2015 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.kotlin.codegen.optimization.fixStack
+
+import com.sun.xml.internal.ws.org.objectweb.asm.Opcodes
+import org.jetbrains.kotlin.codegen.optimization.common.findNextOrNull
+import org.jetbrains.kotlin.codegen.optimization.common.hasOpcode
+import org.jetbrains.kotlin.codegen.optimization.transformer.MethodTransformer
+import org.jetbrains.kotlin.codegen.pseudoInsns.PseudoInsn
+import org.jetbrains.org.objectweb.asm.tree.*
+import org.jetbrains.org.objectweb.asm.util.Printer
+
+private class DecompiledTryDescriptor(val tryStartLabel: LabelNode) {
+    var defaultHandlerTcb : TryCatchBlockNode? = null
+    val handlerStartLabels = hashSetOf<LabelNode>()
+}
+
+private fun TryCatchBlockNode.isDefaultHandlerNode(): Boolean =
+        start == handler
+
+private fun MethodNode.debugString(tcb: TryCatchBlockNode): String =
+        "TCB<${instructions.indexOf(tcb.start)}, ${instructions.indexOf(tcb.end)}, ${instructions.indexOf(tcb.handler)}>"
+
+internal fun insertTryCatchBlocksMarkers(methodNode: MethodNode) {
+    if (methodNode.tryCatchBlocks.isEmpty()) return
+
+    val decompiledTryDescriptorForStart = linkedMapOf<LabelNode, DecompiledTryDescriptor>()
+    val decompiledTryDescriptorForHandler = hashMapOf<LabelNode, DecompiledTryDescriptor>()
+
+    for (tcb in methodNode.tryCatchBlocks) {
+        if (tcb.isDefaultHandlerNode()) {
+            assert(decompiledTryDescriptorForHandler.containsKey(tcb.start),
+                   "${methodNode.debugString(tcb)}: default handler should occur after some regular handler")
+        }
+
+        val decompiledTryDescriptor = decompiledTryDescriptorForHandler.getOrPut(tcb.handler) {
+            decompiledTryDescriptorForStart.getOrPut(tcb.start) {
+                DecompiledTryDescriptor(tcb.start)
+            }
+        }
+        with(decompiledTryDescriptor) {
+            handlerStartLabels.add(tcb.handler)
+
+            if (tcb.isDefaultHandlerNode()) {
+                assert(defaultHandlerTcb == null) {
+                    "${methodNode.debugString(tcb)}: default handler is already found: ${methodNode.debugString(defaultHandlerTcb!!)}"
+                }
+
+                defaultHandlerTcb = tcb
+            }
+        }
+    }
+
+    val doneTryStartLabels = hashSetOf<LabelNode>()
+    val doneHandlerLabels = hashSetOf<LabelNode>()
+
+    for (decompiledTryDescriptor in decompiledTryDescriptorForStart.values()) {
+        with(decompiledTryDescriptor) {
+            if (!doneTryStartLabels.contains(tryStartLabel)) {
+                doneTryStartLabels.add(tryStartLabel)
+
+                val nopNode = tryStartLabel.findNextOrNull { it.hasOpcode() }!!
+                assert(nopNode.getOpcode() == Opcodes.NOP,
+                       "${methodNode.instructions.indexOf(nopNode)}: try block should start with NOP")
+
+                methodNode.instructions.insertBefore(tryStartLabel, PseudoInsn.SAVE_STACK_BEFORE_TRY.createInsnNode())
+                methodNode.instructions.insert(nopNode, PseudoInsn.RESTORE_STACK_IN_TRY_CATCH.createInsnNode())
+            }
+
+            for (handlerStartLabel in handlerStartLabels) {
+                if (!doneHandlerLabels.contains(handlerStartLabel)) {
+                    doneHandlerLabels.add(handlerStartLabel)
+
+                    val storeNode = handlerStartLabel.findNextOrNull { it.hasOpcode() }!!
+                    assert(storeNode.getOpcode() == Opcodes.ASTORE,
+                           "${methodNode.instructions.indexOf(storeNode)}: handler should start with ASTORE")
+
+                    methodNode.instructions.insert(storeNode, PseudoInsn.RESTORE_STACK_IN_TRY_CATCH.createInsnNode())
+                }
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/fixStack/FixStackAnalyzer.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/fixStack/FixStackAnalyzer.kt
new file mode 100644
index 00000000000..6f8daf431eb
--- /dev/null
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/fixStack/FixStackAnalyzer.kt
@@ -0,0 +1,157 @@
+/*
+ * Copyright 2010-2015 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.kotlin.codegen.optimization.fixStack
+
+import com.intellij.util.SmartList
+import com.intellij.util.containers.Stack
+import org.jetbrains.kotlin.codegen.inline.InlineCodegenUtil
+import org.jetbrains.kotlin.codegen.optimization.common.MethodAnalyzer
+import org.jetbrains.kotlin.codegen.optimization.common.OptimizationBasicInterpreter
+import org.jetbrains.kotlin.codegen.pseudoInsns.PseudoInsn
+import org.jetbrains.org.objectweb.asm.tree.AbstractInsnNode
+import org.jetbrains.org.objectweb.asm.tree.JumpInsnNode
+import org.jetbrains.org.objectweb.asm.tree.MethodNode
+import org.jetbrains.org.objectweb.asm.tree.TryCatchBlockNode
+import org.jetbrains.org.objectweb.asm.tree.analysis.BasicValue
+import org.jetbrains.org.objectweb.asm.tree.analysis.Frame
+import org.jetbrains.org.objectweb.asm.tree.analysis.Interpreter
+import java.util.*
+
+public class FixStackAnalyzer(
+        owner: String,
+        methodNode: MethodNode,
+        val context: FixStackContext
+) : MethodAnalyzer<BasicValue>(owner, methodNode, OptimizationBasicInterpreter()) {
+    val savedStacks = hashMapOf<AbstractInsnNode, List<BasicValue>>()
+    var maxExtraStackSize = 0; private set
+
+    protected override fun visitControlFlowEdge(insn: Int, successor: Int): Boolean {
+        val insnNode = instructions[insn]
+        return !(insnNode is JumpInsnNode && context.breakContinueGotoNodes.contains(insnNode))
+    }
+
+    protected override fun newFrame(nLocals: Int, nStack: Int): Frame<BasicValue> =
+            FixStackFrame(nLocals, nStack)
+
+    private fun indexOf(node: AbstractInsnNode) = method.instructions.indexOf(node)
+
+    public inner class FixStackFrame(nLocals: Int, nStack: Int) : Frame<BasicValue>(nLocals, nStack) {
+        val extraStack = Stack<BasicValue>()
+
+        public override fun init(src: Frame<out BasicValue>): Frame<BasicValue> {
+            extraStack.clear()
+            extraStack.addAll((src as FixStackFrame).extraStack)
+            return super.init(src)
+        }
+
+        public override fun clearStack() {
+            extraStack.clear()
+            super.clearStack()
+        }
+
+        public override fun execute(insn: AbstractInsnNode, interpreter: Interpreter<BasicValue>) {
+            when {
+                PseudoInsn.SAVE_STACK_BEFORE_TRY.isa(insn) ->
+                    executeSaveStackBeforeTry(insn)
+                PseudoInsn.RESTORE_STACK_IN_TRY_CATCH.isa(insn) ->
+                    executeRestoreStackInTryCatch(insn)
+                InlineCodegenUtil.isBeforeInlineMarker(insn) ->
+                    executeBeforeInlineCallMarker(insn)
+                InlineCodegenUtil.isAfterInlineMarker(insn) ->
+                    executeAfterInlineCallMarker(insn)
+            }
+
+            super.execute(insn, interpreter)
+        }
+
+        public fun getStackContent(): List<BasicValue> {
+            val savedStack = arrayListOf<BasicValue>()
+            IntRange(0, super.getStackSize() - 1).mapTo(savedStack) { super.getStack(it) }
+            savedStack.addAll(extraStack)
+            return savedStack
+        }
+
+        public override fun push(value: BasicValue) {
+            if (super.getStackSize() < getMaxStackSize()) {
+                super.push(value)
+            }
+            else {
+                extraStack.add(value)
+                maxExtraStackSize = Math.max(maxExtraStackSize, extraStack.size())
+            }
+        }
+
+        public fun pushAll(values: Collection<BasicValue>) {
+            values.forEach { push(it) }
+        }
+
+        public override fun pop(): BasicValue {
+            if (extraStack.isNotEmpty()) {
+                return extraStack.pop()
+            }
+            else {
+                return super.pop()
+            }
+        }
+
+        public override fun getStack(i: Int): BasicValue {
+            if (i < super.getMaxStackSize()) {
+                return super.getStack(i)
+            }
+            else {
+                return extraStack[i - getMaxStackSize()]
+            }
+        }
+    }
+
+    private fun FixStackFrame.executeBeforeInlineCallMarker(insn: AbstractInsnNode) {
+        saveStackAndClear(insn)
+    }
+
+    private fun FixStackFrame.saveStackAndClear(insn: AbstractInsnNode) {
+        val savedValues = getStackContent()
+        savedStacks[insn] = savedValues
+        clearStack()
+    }
+
+    private fun FixStackFrame.executeAfterInlineCallMarker(insn: AbstractInsnNode) {
+        val beforeInlineMarker = context.openingInlineMethodMarker[insn]
+        if (getStackSize() > 0) {
+            val returnValue = pop()
+            clearStack()
+            val savedValues = savedStacks[beforeInlineMarker]
+            pushAll(savedValues!!)
+            push(returnValue)
+        }
+        else {
+            val savedValues = savedStacks[beforeInlineMarker]
+            pushAll(savedValues!!)
+        }
+    }
+
+    private fun FixStackFrame.executeRestoreStackInTryCatch(insn: AbstractInsnNode) {
+        val saveNode = context.saveStackMarkerForRestoreMarker[insn]
+        val savedValues = savedStacks.getOrElse(saveNode!!) {
+            throw AssertionError("${indexOf(insn)}: Restore stack is unavailable for ${indexOf(saveNode)}")
+        }
+        pushAll(savedValues)
+    }
+
+    private fun FixStackFrame.executeSaveStackBeforeTry(insn: AbstractInsnNode) {
+        saveStackAndClear(insn)
+    }
+}
\ No newline at end of file
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/fixStack/FixStackContext.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/fixStack/FixStackContext.kt
new file mode 100644
index 00000000000..418d801aada
--- /dev/null
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/fixStack/FixStackContext.kt
@@ -0,0 +1,142 @@
+/*
+ * Copyright 2010-2015 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.kotlin.codegen.optimization.fixStack
+
+import com.intellij.util.SmartList
+import com.intellij.util.containers.SmartHashSet
+import com.intellij.util.containers.Stack
+import org.jetbrains.kotlin.codegen.inline.InlineCodegenUtil
+import org.jetbrains.kotlin.codegen.optimization.common.InsnSequence
+import org.jetbrains.kotlin.codegen.optimization.common.findPreviousOrNull
+import org.jetbrains.kotlin.codegen.optimization.common.hasOpcode
+import org.jetbrains.kotlin.codegen.optimization.fixStack.forEachPseudoInsn
+import org.jetbrains.kotlin.codegen.pseudoInsns.PseudoInsn
+import org.jetbrains.kotlin.codegen.pseudoInsns.parsePseudoInsnOrNull
+import org.jetbrains.org.objectweb.asm.Opcodes
+import org.jetbrains.org.objectweb.asm.tree.*
+import java.util.*
+import kotlin.properties.Delegates
+
+internal class FixStackContext(val methodNode: MethodNode) {
+    val breakContinueGotoNodes = linkedSetOf<JumpInsnNode>()
+    val fakeAlwaysTrueIfeqMarkers = arrayListOf<AbstractInsnNode>()
+    val fakeAlwaysFalseIfeqMarkers = arrayListOf<AbstractInsnNode>()
+
+    val saveStackNodesForTryStartLabel = hashMapOf<LabelNode, AbstractInsnNode>()
+    val saveStackMarkerForRestoreMarker = hashMapOf<AbstractInsnNode, AbstractInsnNode>()
+    val restoreStackMarkersForSaveMarker = hashMapOf<AbstractInsnNode, MutableList<AbstractInsnNode>>()
+
+    val openingInlineMethodMarker = hashMapOf<AbstractInsnNode, AbstractInsnNode>()
+    var consistentInlineMarkers: Boolean = true; private set
+
+    init {
+        insertTryCatchBlocksMarkers(methodNode)
+
+        val inlineMarkersStack = Stack<AbstractInsnNode>()
+
+        InsnSequence(methodNode.instructions).forEach { insnNode ->
+            val pseudoInsn = parsePseudoInsnOrNull(insnNode)
+            when {
+                pseudoInsn == PseudoInsn.FIX_STACK_BEFORE_JUMP ->
+                    visitFixStackBeforeJump(insnNode)
+                pseudoInsn == PseudoInsn.FAKE_ALWAYS_TRUE_IFEQ ->
+                    visitFakeAlwaysTrueIfeq(insnNode)
+                pseudoInsn == PseudoInsn.FAKE_ALWAYS_FALSE_IFEQ ->
+                    visitFakeAlwaysFalseIfeq(insnNode)
+                pseudoInsn == PseudoInsn.SAVE_STACK_BEFORE_TRY ->
+                    visitSaveStackBeforeTry(insnNode)
+                pseudoInsn == PseudoInsn.RESTORE_STACK_IN_TRY_CATCH ->
+                    visitRestoreStackInTryCatch(insnNode)
+                InlineCodegenUtil.isBeforeInlineMarker(insnNode) -> {
+                    inlineMarkersStack.push(insnNode)
+                }
+                InlineCodegenUtil.isAfterInlineMarker(insnNode) -> {
+                    assert(inlineMarkersStack.isNotEmpty(), "Mismatching after inline method marker at ${indexOf(insnNode)}")
+                    openingInlineMethodMarker[insnNode] = inlineMarkersStack.pop()
+                }
+            }
+        }
+
+        if (inlineMarkersStack.isNotEmpty()) {
+            consistentInlineMarkers = false
+        }
+    }
+
+    private fun visitFixStackBeforeJump(insnNode: AbstractInsnNode) {
+        val next = insnNode.getNext()
+        assert(next.getOpcode() == Opcodes.GOTO, "${indexOf(insnNode)}: should be followed by GOTO")
+        breakContinueGotoNodes.add(next as JumpInsnNode)
+    }
+
+    private fun visitFakeAlwaysTrueIfeq(insnNode: AbstractInsnNode) {
+        assert(insnNode.getNext().getOpcode() == Opcodes.IFEQ, "${indexOf(insnNode)}: should be followed by IFEQ")
+        fakeAlwaysTrueIfeqMarkers.add(insnNode)
+    }
+
+    private fun visitFakeAlwaysFalseIfeq(insnNode: AbstractInsnNode) {
+        assert(insnNode.getNext().getOpcode() == Opcodes.IFEQ, "${indexOf(insnNode)}: should be followed by IFEQ")
+        fakeAlwaysFalseIfeqMarkers.add(insnNode)
+    }
+
+    private fun visitSaveStackBeforeTry(insnNode: AbstractInsnNode) {
+        val tryStartLabel = insnNode.getNext()
+        assert(tryStartLabel is LabelNode, "${indexOf(insnNode)}: save should be followed by a label")
+        saveStackNodesForTryStartLabel[tryStartLabel as LabelNode] = insnNode
+    }
+
+    private fun visitRestoreStackInTryCatch(insnNode: AbstractInsnNode) {
+        val restoreLabel = insnNode.findPreviousOrNull { it.hasOpcode() }!!.findPreviousOrNull { it is LabelNode || it.hasOpcode() }!!
+        if (restoreLabel !is LabelNode) {
+            throw AssertionError("${indexOf(insnNode)}: restore should be preceded by a catch block label")
+        }
+        val saveNodes = findMatchingSaveNodes(insnNode, restoreLabel)
+        if (saveNodes.isEmpty()) {
+            throw AssertionError("${indexOf(insnNode)}: in handler ${indexOf(restoreLabel)} restore is not matched with save")
+        }
+        else if (saveNodes.size() > 1) {
+            throw AssertionError("${indexOf(insnNode)}: in handler ${indexOf(restoreLabel)} restore is matched with several saves")
+        }
+        val saveNode = saveNodes.first()
+        saveStackMarkerForRestoreMarker[insnNode] = saveNode
+        restoreStackMarkersForSaveMarker.getOrPut(saveNode, { SmartList<AbstractInsnNode>() }).add(insnNode)
+    }
+
+    private fun findMatchingSaveNodes(insnNode: AbstractInsnNode, restoreLabel: LabelNode): List<AbstractInsnNode> {
+        val saveNodes = SmartHashSet<AbstractInsnNode>()
+        methodNode.tryCatchBlocks.forEach { tcb ->
+            if (restoreLabel == tcb.start || restoreLabel == tcb.handler) {
+                saveStackNodesForTryStartLabel[tcb.start]?.let { saveNodes.add(it) }
+            }
+        }
+        return SmartList<AbstractInsnNode>(saveNodes)
+    }
+
+    private fun indexOf(node: AbstractInsnNode) = methodNode.instructions.indexOf(node)
+
+    fun hasAnyMarkers(): Boolean =
+            breakContinueGotoNodes.isNotEmpty() ||
+            fakeAlwaysTrueIfeqMarkers.isNotEmpty() ||
+            fakeAlwaysFalseIfeqMarkers.isNotEmpty() ||
+            saveStackNodesForTryStartLabel.isNotEmpty() ||
+            openingInlineMethodMarker.isNotEmpty()
+
+    fun isAnalysisRequired(): Boolean =
+            breakContinueGotoNodes.isNotEmpty() ||
+            saveStackNodesForTryStartLabel.isNotEmpty() ||
+            openingInlineMethodMarker.isNotEmpty()
+
+}
\ No newline at end of file
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/fixStack/FixStackMethodTransformer.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/fixStack/FixStackMethodTransformer.kt
new file mode 100644
index 00000000000..c01bc2985f6
--- /dev/null
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/fixStack/FixStackMethodTransformer.kt
@@ -0,0 +1,213 @@
+/*
+ * Copyright 2010-2015 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.kotlin.codegen.optimization.fixStack
+
+import com.intellij.util.containers.Stack
+import org.jetbrains.kotlin.codegen.inline.InlineCodegenUtil
+import org.jetbrains.kotlin.codegen.optimization.common.InsnSequence
+import org.jetbrains.kotlin.codegen.optimization.common.MethodAnalyzer
+import org.jetbrains.kotlin.codegen.optimization.common.OptimizationBasicInterpreter
+import org.jetbrains.kotlin.codegen.optimization.fixStack.forEachPseudoInsn
+import org.jetbrains.kotlin.codegen.optimization.transformer.MethodTransformer
+import org.jetbrains.kotlin.codegen.pseudoInsns.PseudoInsn
+import org.jetbrains.kotlin.codegen.pseudoInsns.parsePseudoInsnOrNull
+import org.jetbrains.org.objectweb.asm.Opcodes
+import org.jetbrains.org.objectweb.asm.tree.*
+import org.jetbrains.org.objectweb.asm.tree.analysis.BasicValue
+import org.jetbrains.org.objectweb.asm.tree.analysis.Frame
+import org.jetbrains.org.objectweb.asm.tree.analysis.Interpreter
+import java.util.*
+import kotlin.properties.Delegates
+
+public object FixStackMethodTransformer : MethodTransformer() {
+    public override fun transform(internalClassName: String, methodNode: MethodNode) {
+        val context = FixStackContext(methodNode)
+
+        if (!context.hasAnyMarkers()) return
+
+        // If inline method markers are inconsistent, remove them now
+        if (!context.consistentInlineMarkers) {
+            InsnSequence(methodNode.instructions).forEach { insnNode ->
+                if (InlineCodegenUtil.isInlineMarker(insnNode))
+                    methodNode.instructions.remove(insnNode)
+            }
+        }
+
+        if (context.isAnalysisRequired()) {
+            val analyzer = FixStackAnalyzer(internalClassName, methodNode, context)
+            analyzer.analyze()
+
+            methodNode.maxStack = methodNode.maxStack + analyzer.maxExtraStackSize
+
+            val actions = arrayListOf<() -> Unit>()
+
+            transformBreakContinueGotos(methodNode, context, actions, analyzer)
+
+            transformSaveRestoreStackMarkers(methodNode, context, actions, analyzer)
+
+            actions.forEach { it() }
+        }
+
+        context.fakeAlwaysTrueIfeqMarkers.forEach { marker ->
+            replaceAlwaysTrueIfeqWithGoto(methodNode, marker)
+        }
+
+        context.fakeAlwaysFalseIfeqMarkers.forEach { marker ->
+            removeAlwaysFalseIfeq(methodNode, marker)
+        }
+    }
+
+    private fun transformBreakContinueGotos(
+            methodNode: MethodNode,
+            fixStackContext: FixStackContext,
+            actions: MutableList<() -> Unit>,
+            analyzer: FixStackAnalyzer
+    ) {
+        fixStackContext.breakContinueGotoNodes.forEach { gotoNode ->
+            val gotoIndex = methodNode.instructions.indexOf(gotoNode)
+            val labelIndex = methodNode.instructions.indexOf(gotoNode.label)
+
+            val DEAD_CODE = -1 // Stack size is always non-negative
+            val actualStackSize = analyzer.frames[gotoIndex]?.getStackSize() ?: DEAD_CODE
+            val expectedStackSize = analyzer.frames[labelIndex]?.getStackSize() ?: DEAD_CODE
+
+            if (actualStackSize != DEAD_CODE && expectedStackSize != DEAD_CODE) {
+                assert(expectedStackSize <= actualStackSize,
+                       "Label at $labelIndex, jump at $gotoIndex: stack underflow: $expectedStackSize > $actualStackSize")
+                val frame = analyzer.frames[gotoIndex]!!
+                actions.add({ replaceMarkerWithPops(methodNode, gotoNode.getPrevious(), expectedStackSize, frame) })
+            }
+            else if (actualStackSize != DEAD_CODE && expectedStackSize == DEAD_CODE) {
+                throw AssertionError("Live jump $gotoIndex to dead label $labelIndex")
+            }
+            else {
+                val marker = gotoNode.getPrevious()
+                actions.add({ methodNode.instructions.remove(marker) })
+            }
+        }
+    }
+
+    private fun transformSaveRestoreStackMarkers(
+            methodNode: MethodNode,
+            context: FixStackContext,
+            actions: MutableList<() -> Unit>,
+            analyzer: FixStackAnalyzer
+    ) {
+        val localVariablesManager = LocalVariablesManager(context, methodNode)
+        InsnSequence(methodNode.instructions).forEach { marker ->
+            val pseudoInsn = parsePseudoInsnOrNull(marker)
+            when {
+                pseudoInsn == PseudoInsn.SAVE_STACK_BEFORE_TRY ->
+                    transformSaveStackMarker(methodNode, actions, analyzer, marker, localVariablesManager)
+                pseudoInsn == PseudoInsn.RESTORE_STACK_IN_TRY_CATCH ->
+                    transformRestoreStackMarker(methodNode, actions, marker, localVariablesManager)
+                InlineCodegenUtil.isBeforeInlineMarker(marker) ->
+                    transformBeforeInlineCallMarker(methodNode, actions, analyzer, marker, localVariablesManager)
+                InlineCodegenUtil.isAfterInlineMarker(marker) ->
+                    transformAfterInlineCallMarker(methodNode, actions, analyzer, marker, localVariablesManager)
+            }
+        }
+    }
+
+    private fun transformSaveStackMarker(
+            methodNode: MethodNode,
+            actions: MutableList<() -> Unit>,
+            analyzer: FixStackAnalyzer,
+            marker: AbstractInsnNode,
+            localVariablesManager: LocalVariablesManager
+    ) {
+        val savedStackValues = analyzer.savedStacks[marker]
+        if (savedStackValues != null) {
+            val savedStackDescriptor = localVariablesManager.allocateVariablesForSaveStackMarker(marker, savedStackValues)
+            actions.add({ saveStack(methodNode, marker, savedStackDescriptor, false) })
+        }
+        else {
+            // marker is dead code
+            localVariablesManager.allocateVariablesForSaveStackMarker(marker, emptyList())
+            actions.add({ methodNode.instructions.remove(marker) })
+        }
+    }
+
+    private fun transformRestoreStackMarker(
+            methodNode: MethodNode,
+            actions: MutableList<() -> Unit>,
+            marker: AbstractInsnNode,
+            localVariablesManager: LocalVariablesManager
+    ) {
+        val savedStackDescriptor = localVariablesManager.getSavedStackDescriptorOrNull(marker)
+        if (savedStackDescriptor != null) {
+            actions.add({ restoreStack(methodNode, marker, savedStackDescriptor) })
+        }
+        else {
+            // marker is dead code
+            actions.add({ methodNode.instructions.remove(marker) })
+        }
+        localVariablesManager.markRestoreStackMarkerEmitted(marker)
+    }
+
+    private fun transformAfterInlineCallMarker(
+            methodNode: MethodNode,
+            actions: MutableList<() -> Unit>,
+            analyzer: FixStackAnalyzer,
+            inlineMarker: AbstractInsnNode,
+            localVariablesManager: LocalVariablesManager
+    ) {
+        val savedStackDescriptor = localVariablesManager.getBeforeInlineDescriptor(inlineMarker)
+        val afterInlineFrame = analyzer.getFrame(inlineMarker) as FixStackAnalyzer.FixStackFrame?
+        if (afterInlineFrame != null && savedStackDescriptor.isNotEmpty()) {
+            assert(afterInlineFrame.getStackSize() <= 1, "Inline method should not leave more than 1 value on stack")
+            if (afterInlineFrame.getStackSize() == 1) {
+                val afterInlineStackValues = afterInlineFrame.getStackContent()
+                val returnValue = afterInlineStackValues.last()
+                val returnValueLocalVarIndex = localVariablesManager.createReturnValueVariable(returnValue)
+                actions.add({
+                                restoreStackWithReturnValue(methodNode, inlineMarker, savedStackDescriptor,
+                                                            returnValue, returnValueLocalVarIndex)
+                            })
+            }
+            else {
+                actions.add({ restoreStack(methodNode, inlineMarker, savedStackDescriptor) })
+            }
+        }
+        else {
+            // after inline marker is dead code
+            actions.add({ methodNode.instructions.remove(inlineMarker) })
+        }
+        localVariablesManager.markAfterInlineMarkerEmitted(inlineMarker)
+    }
+
+    private fun transformBeforeInlineCallMarker(
+            methodNode: MethodNode,
+            actions: MutableList<() -> Unit>,
+            analyzer: FixStackAnalyzer,
+            inlineMarker: AbstractInsnNode,
+            localVariablesManager: LocalVariablesManager
+    ) {
+        val savedStackValues = analyzer.savedStacks[inlineMarker]
+        if (savedStackValues != null) {
+            val savedStackDescriptor = localVariablesManager.allocateVariablesForBeforeInlineMarker(inlineMarker, savedStackValues)
+            actions.add({ saveStack(methodNode, inlineMarker, savedStackDescriptor, false) })
+        }
+        else {
+            // before inline marker is dead code
+            localVariablesManager.allocateVariablesForBeforeInlineMarker(inlineMarker, emptyList())
+            actions.add({ methodNode.instructions.remove(inlineMarker) })
+        }
+    }
+
+
+}
\ No newline at end of file
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/fixStack/LocalVariablesManager.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/fixStack/LocalVariablesManager.kt
new file mode 100644
index 00000000000..c4831c322e4
--- /dev/null
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/fixStack/LocalVariablesManager.kt
@@ -0,0 +1,97 @@
+/*
+ * Copyright 2010-2015 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.kotlin.codegen.optimization.fixStack
+
+import org.jetbrains.org.objectweb.asm.tree.AbstractInsnNode
+import org.jetbrains.org.objectweb.asm.tree.MethodNode
+import org.jetbrains.org.objectweb.asm.tree.analysis.BasicValue
+
+internal class LocalVariablesManager(val context: FixStackContext, val methodNode: MethodNode) {
+    private class AllocatedHandle(val savedStackDescriptor: SavedStackDescriptor, var numRestoreMarkers: Int) {
+        fun isFullyEmitted(): Boolean =
+                numRestoreMarkers == 0
+
+        fun markRestoreNodeEmitted() {
+            assert(numRestoreMarkers > 0, "Emitted more restore markers than expected for $savedStackDescriptor")
+            numRestoreMarkers--
+        }
+    }
+
+    private val initialMaxLocals = methodNode.maxLocals
+    private val allocatedHandles = hashMapOf<AbstractInsnNode, AllocatedHandle>()
+
+    private fun updateMaxLocals(newValue: Int) {
+        methodNode.maxLocals = Math.max(methodNode.maxLocals, newValue)
+    }
+
+    fun allocateVariablesForSaveStackMarker(saveStackMarker: AbstractInsnNode, savedStackValues: List<BasicValue>): SavedStackDescriptor {
+        val numRestoreStackMarkers = context.restoreStackMarkersForSaveMarker[saveStackMarker]!!.size()
+        return allocateNewHandle(numRestoreStackMarkers, saveStackMarker, savedStackValues)
+    }
+
+    private fun allocateNewHandle(numRestoreStackMarkers: Int, saveStackMarker: AbstractInsnNode, savedStackValues: List<BasicValue>): SavedStackDescriptor {
+        val firstUnusedLocalVarIndex = getFirstUnusedLocalVariableIndex()
+        val savedStackDescriptor = SavedStackDescriptor(savedStackValues, firstUnusedLocalVarIndex)
+        updateMaxLocals(savedStackDescriptor.firstUnusedLocalVarIndex)
+        val allocatedHandle = AllocatedHandle(savedStackDescriptor, numRestoreStackMarkers)
+        allocatedHandles[saveStackMarker] = allocatedHandle
+        return savedStackDescriptor
+    }
+
+    fun getSavedStackDescriptorOrNull(restoreStackMarker: AbstractInsnNode): SavedStackDescriptor {
+        val saveStackMarker = context.saveStackMarkerForRestoreMarker[restoreStackMarker]
+        return allocatedHandles[saveStackMarker]!!.savedStackDescriptor
+    }
+
+    private fun getFirstUnusedLocalVariableIndex(): Int =
+            allocatedHandles.values().fold(initialMaxLocals) {
+                index, handle -> Math.max(index, handle.savedStackDescriptor.firstUnusedLocalVarIndex)
+            }
+
+    fun markRestoreStackMarkerEmitted(restoreStackMarker: AbstractInsnNode) {
+        val saveStackMarker = context.saveStackMarkerForRestoreMarker[restoreStackMarker]
+        markEmitted(saveStackMarker!!)
+    }
+
+    fun allocateVariablesForBeforeInlineMarker(beforeInlineMarker: AbstractInsnNode, savedStackValues: List<BasicValue>): SavedStackDescriptor {
+        return allocateNewHandle(1, beforeInlineMarker, savedStackValues)
+    }
+
+    fun getBeforeInlineDescriptor(afterInlineMarker: AbstractInsnNode): SavedStackDescriptor {
+        val beforeInlineMarker = context.openingInlineMethodMarker[afterInlineMarker]
+        return allocatedHandles[beforeInlineMarker]!!.savedStackDescriptor
+    }
+
+    fun markAfterInlineMarkerEmitted(afterInlineMarker: AbstractInsnNode) {
+        val beforeInlineMarker = context.openingInlineMethodMarker[afterInlineMarker]
+        markEmitted(beforeInlineMarker!!)
+    }
+
+    private fun markEmitted(saveStackMarker: AbstractInsnNode) {
+        val allocatedHandle = allocatedHandles[saveStackMarker]!!
+        allocatedHandle.markRestoreNodeEmitted()
+        if (allocatedHandle.isFullyEmitted()) {
+            allocatedHandles.remove(saveStackMarker)
+        }
+    }
+
+    fun createReturnValueVariable(returnValue: BasicValue): Int {
+        val returnValueIndex = getFirstUnusedLocalVariableIndex()
+        updateMaxLocals(returnValueIndex + returnValue.getSize())
+        return returnValueIndex
+    }
+}
\ No newline at end of file
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/fixStack/StackTransformationUtils.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/fixStack/StackTransformationUtils.kt
new file mode 100644
index 00000000000..01541346128
--- /dev/null
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/fixStack/StackTransformationUtils.kt
@@ -0,0 +1,153 @@
+/*
+ * Copyright 2010-2015 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.kotlin.codegen.optimization.fixStack
+
+import org.jetbrains.kotlin.codegen.inline.InlineCodegenUtil
+import org.jetbrains.kotlin.codegen.optimization.common.InsnSequence
+import org.jetbrains.kotlin.codegen.pseudoInsns.PseudoInsn
+import org.jetbrains.kotlin.codegen.pseudoInsns.parsePseudoInsnOrNull
+import org.jetbrains.org.objectweb.asm.Opcodes
+import org.jetbrains.org.objectweb.asm.tree.*
+import org.jetbrains.org.objectweb.asm.tree.analysis.BasicValue
+import org.jetbrains.org.objectweb.asm.tree.analysis.Frame
+import org.jetbrains.org.objectweb.asm.tree.analysis.Value
+
+public inline fun InsnList.forEachPseudoInsn(block: (PseudoInsn, AbstractInsnNode) -> Unit) {
+    InsnSequence(this).forEach { insn ->
+        parsePseudoInsnOrNull(insn)?.let { block(it, insn) }
+    }
+}
+
+public inline fun InsnList.forEachInlineMarker(block: (String, MethodInsnNode) -> Unit) {
+    InsnSequence(this).forEach { insn ->
+        if (InlineCodegenUtil.isInlineMarker(insn)) {
+            val methodInsnNode = insn as MethodInsnNode
+            block(methodInsnNode.name, methodInsnNode)
+        }
+    }
+}
+
+public fun <V : Value> Frame<V>.top(): V? {
+    val stackSize = getStackSize()
+    if (stackSize == 0)
+        return null
+    else
+        return getStack(stackSize - 1)
+}
+
+public fun MethodNode.updateMaxLocals(newMaxLocals: Int) {
+    maxLocals = Math.max(maxLocals, newMaxLocals)
+}
+
+class SavedStackDescriptor(
+        val savedValues: List<BasicValue>,
+        val firstLocalVarIndex: Int
+) {
+    val savedValuesSize = savedValues.fold(0, { size, value -> size + value.getSize() })
+    val firstUnusedLocalVarIndex = firstLocalVarIndex + savedValuesSize
+
+    public override fun toString(): String =
+            "@$firstLocalVarIndex: [$savedValues]"
+
+    fun isNotEmpty(): Boolean = savedValues.isNotEmpty()
+}
+
+
+fun saveStack(methodNode: MethodNode, nodeToReplace: AbstractInsnNode, savedStackDescriptor: SavedStackDescriptor,
+              restoreImmediately: Boolean) {
+    with(methodNode.instructions) {
+        generateStoreInstructions(methodNode, nodeToReplace, savedStackDescriptor)
+        if (restoreImmediately) {
+            generateLoadInstructions(methodNode, nodeToReplace, savedStackDescriptor)
+        }
+        remove(nodeToReplace)
+    }
+}
+
+fun restoreStack(methodNode: MethodNode, location: AbstractInsnNode, savedStackDescriptor: SavedStackDescriptor) {
+    with(methodNode.instructions) {
+        generateLoadInstructions(methodNode, location, savedStackDescriptor)
+        remove(location)
+    }
+}
+
+fun restoreStackWithReturnValue(
+        methodNode: MethodNode,
+        nodeToReplace: AbstractInsnNode,
+        savedStackDescriptor: SavedStackDescriptor,
+        returnValue: BasicValue,
+        returnValueLocalVarIndex: Int
+) {
+    with(methodNode.instructions) {
+        insertBefore(nodeToReplace, VarInsnNode(returnValue.getType().getOpcode(Opcodes.ISTORE), returnValueLocalVarIndex))
+        generateLoadInstructions(methodNode, nodeToReplace, savedStackDescriptor)
+        insertBefore(nodeToReplace, VarInsnNode(returnValue.getType().getOpcode(Opcodes.ILOAD), returnValueLocalVarIndex))
+        remove(nodeToReplace)
+    }
+}
+
+fun generateLoadInstructions(methodNode: MethodNode, location: AbstractInsnNode, savedStackDescriptor: SavedStackDescriptor) {
+    var localVarIndex = savedStackDescriptor.firstLocalVarIndex
+    for (value in savedStackDescriptor.savedValues) {
+        methodNode.instructions.insertBefore(location,
+                                             VarInsnNode(value.getType().getOpcode(Opcodes.ILOAD), localVarIndex))
+        localVarIndex += value.getSize()
+    }
+}
+
+fun generateStoreInstructions(methodNode: MethodNode, location: AbstractInsnNode, savedStackDescriptor: SavedStackDescriptor) {
+    var localVarIndex = savedStackDescriptor.firstUnusedLocalVarIndex
+    for (value in savedStackDescriptor.savedValues.reverse()) {
+        localVarIndex -= value.getSize()
+        methodNode.instructions.insertBefore(location,
+                                             VarInsnNode(value.getType().getOpcode(Opcodes.ISTORE), localVarIndex))
+    }
+}
+
+fun getPopInstruction(top: BasicValue) =
+        InsnNode(when (top.getSize()) {
+                     1 -> Opcodes.POP
+                     2 -> Opcodes.POP2
+                     else -> throw AssertionError("Unexpected value type size")
+                 })
+
+fun removeAlwaysFalseIfeq(methodNode: MethodNode, node: AbstractInsnNode) {
+    with (methodNode.instructions) {
+        remove(node.getNext())
+        remove(node)
+    }
+}
+
+fun replaceAlwaysTrueIfeqWithGoto(methodNode: MethodNode, node: AbstractInsnNode) {
+    with (methodNode.instructions) {
+        val next = node.getNext() as JumpInsnNode
+        insertBefore(node, JumpInsnNode(Opcodes.GOTO, next.label))
+        remove(node)
+        remove(next)
+    }
+}
+
+fun replaceMarkerWithPops(methodNode: MethodNode, node: AbstractInsnNode, expectedStackSize: Int, frame: Frame<BasicValue>) {
+    with (methodNode.instructions) {
+        while (frame.getStackSize() > expectedStackSize) {
+            val top = frame.pop()
+            insertBefore(node, getPopInstruction(top))
+        }
+        remove(node)
+    }
+}
+
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/pseudoInsns/PseudoInsns.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/pseudoInsns/PseudoInsns.kt
index d1608dfe2a8..112c259daf4 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/pseudoInsns/PseudoInsns.kt
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/pseudoInsns/PseudoInsns.kt
@@ -24,78 +24,46 @@ import org.jetbrains.org.objectweb.asm.tree.InsnList
 import org.jetbrains.org.objectweb.asm.tree.MethodInsnNode
 import kotlin.platform.platformStatic
 
-public val PSEUDO_INSN_CALL_OWNER: String = "kotlin.jvm.\$PseudoInsn"
-public val PSEUDO_INSN_PARTS_SEPARATOR: String = ":"
+public val PSEUDO_INSN_CALL_OWNER: String = "kotlin/jvm/internal/\$PseudoInsn"
 
-public enum class PseudoInsnOpcode(val signature: String = "()V") {
+public enum class PseudoInsn(val signature: String = "()V") {
     FIX_STACK_BEFORE_JUMP(),
     FAKE_ALWAYS_TRUE_IFEQ("()I"),
-    FAKE_ALWAYS_FALSE_IFEQ("()I")
+    FAKE_ALWAYS_FALSE_IFEQ("()I"),
+    SAVE_STACK_BEFORE_TRY(),
+    RESTORE_STACK_IN_TRY_CATCH()
     ;
 
-    public fun insnOf(): PseudoInsn = PseudoInsn(this, emptyList())
-    public fun insnOf(args: List<String>): PseudoInsn = PseudoInsn(this, args)
-
-    public fun parseOrNull(insn: AbstractInsnNode): PseudoInsn? {
-        val pseudo = parseOrNull(insn)
-        return if (pseudo?.opcode == this) pseudo else null
-    }
-
-    public fun isa(insn: AbstractInsnNode): Boolean =
-            if (isPseudoInsn(insn)) {
-                val methodName = (insn as MethodInsnNode).name
-                methodName == this.toString() || methodName.startsWith(this.toString() + PSEUDO_INSN_PARTS_SEPARATOR)
-            }
-            else false
-
     public fun emit(iv: InstructionAdapter) {
-        insnOf().emit(iv)
+        iv.invokestatic(PSEUDO_INSN_CALL_OWNER, toString(), signature, false)
     }
+
+    public fun createInsnNode(): MethodInsnNode =
+            MethodInsnNode(Opcodes.INVOKESTATIC, PSEUDO_INSN_CALL_OWNER, toString(), signature, false)
+
+    public fun isa(node: AbstractInsnNode): Boolean =
+            this == parsePseudoInsnOrNull(node)
 }
 
-public class PseudoInsn(public val opcode: PseudoInsnOpcode, public val args: List<String>) {
-    public val encodedMethodName: String =
-            if (args.isEmpty())
-                opcode.toString()
-            else
-                opcode.toString() + PSEUDO_INSN_PARTS_SEPARATOR + args.join(PSEUDO_INSN_PARTS_SEPARATOR)
+public fun isPseudoInsn(insn: AbstractInsnNode): Boolean =
+        insn is MethodInsnNode && insn.getOpcode() == Opcodes.INVOKESTATIC && insn.owner == PSEUDO_INSN_CALL_OWNER
 
-    public fun emit(iv: InstructionAdapter) {
-        iv.invokestatic(PSEUDO_INSN_CALL_OWNER, encodedMethodName, opcode.signature, false)
-    }
-}
+public fun parsePseudoInsnOrNull(insn: AbstractInsnNode): PseudoInsn? =
+        if (isPseudoInsn(insn))
+            PseudoInsn.valueOf((insn as MethodInsnNode).name)
+        else null
 
 public fun InstructionAdapter.fixStackAndJump(label: Label) {
-    PseudoInsnOpcode.FIX_STACK_BEFORE_JUMP.emit(this)
+    PseudoInsn.FIX_STACK_BEFORE_JUMP.emit(this)
     this.goTo(label)
 }
 
 public fun InstructionAdapter.fakeAlwaysTrueIfeq(label: Label) {
-    PseudoInsnOpcode.FAKE_ALWAYS_TRUE_IFEQ.emit(this)
+    PseudoInsn.FAKE_ALWAYS_TRUE_IFEQ.emit(this)
     this.ifeq(label)
 }
 
 public fun InstructionAdapter.fakeAlwaysFalseIfeq(label: Label) {
-    PseudoInsnOpcode.FAKE_ALWAYS_FALSE_IFEQ.emit(this)
+    PseudoInsn.FAKE_ALWAYS_FALSE_IFEQ.emit(this)
     this.ifeq(label)
 }
-
-public fun parseOrNull(insn: AbstractInsnNode): PseudoInsn? =
-        if (isPseudoInsn(insn))
-            parseParts(getPseudoInsnParts(insn as MethodInsnNode))
-        else null
-
-private fun isPseudoInsn(insn: AbstractInsnNode) =
-        insn is MethodInsnNode && insn.getOpcode() == Opcodes.INVOKESTATIC && insn.owner == PSEUDO_INSN_CALL_OWNER
-
-private fun getPseudoInsnParts(insn: MethodInsnNode): List<String> =
-        insn.name.splitBy(PSEUDO_INSN_PARTS_SEPARATOR)
-
-private fun parseParts(parts: List<String>): PseudoInsn? {
-    try {
-        return PseudoInsnOpcode.valueOf(parts[0]).insnOf(parts.subList(1, parts.size()))
-    }
-    catch (e: IllegalArgumentException) {
-        return null
-    }
-}
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/state/JetTypeMapper.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/state/JetTypeMapper.java
index 832e249f77c..9c947619152 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/state/JetTypeMapper.java
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/state/JetTypeMapper.java
@@ -38,7 +38,10 @@ import org.jetbrains.kotlin.load.java.descriptors.JavaClassDescriptor;
 import org.jetbrains.kotlin.load.kotlin.PackageClassUtils;
 import org.jetbrains.kotlin.load.kotlin.PackagePartClassUtils;
 import org.jetbrains.kotlin.load.kotlin.nativeDeclarations.NativeDeclarationsPackage;
-import org.jetbrains.kotlin.name.*;
+import org.jetbrains.kotlin.name.ClassId;
+import org.jetbrains.kotlin.name.FqName;
+import org.jetbrains.kotlin.name.FqNameUnsafe;
+import org.jetbrains.kotlin.name.SpecialNames;
 import org.jetbrains.kotlin.platform.JavaToKotlinClassMap;
 import org.jetbrains.kotlin.psi.JetExpression;
 import org.jetbrains.kotlin.psi.JetFile;
@@ -51,7 +54,7 @@ import org.jetbrains.kotlin.resolve.annotations.AnnotationsPackage;
 import org.jetbrains.kotlin.resolve.calls.model.DefaultValueArgument;
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall;
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedValueArgument;
-import org.jetbrains.kotlin.resolve.constants.CompileTimeConstant;
+import org.jetbrains.kotlin.resolve.constants.ConstantValue;
 import org.jetbrains.kotlin.resolve.constants.StringValue;
 import org.jetbrains.kotlin.resolve.jvm.AsmTypes;
 import org.jetbrains.kotlin.resolve.jvm.JvmClassName;
@@ -681,13 +684,13 @@ public class JetTypeMapper {
             }
 
             boolean isAccessor = property instanceof AccessorForPropertyDescriptor;
-            Name propertyName = isAccessor
-                                ? Name.identifier(((AccessorForPropertyDescriptor) property).getIndexedAccessorSuffix())
-                                : property.getName();
+            String propertyName = isAccessor
+                                  ? ((AccessorForPropertyDescriptor) property).getIndexedAccessorSuffix()
+                                  : property.getName().asString();
 
             String accessorName = descriptor instanceof PropertyGetterDescriptor
-                                  ? PropertyCodegen.getterName(propertyName)
-                                  : PropertyCodegen.setterName(propertyName);
+                                  ? JvmAbi.getterName(propertyName)
+                                  : JvmAbi.setterName(propertyName);
 
             return isAccessor ? "access$" + accessorName : accessorName;
         }
@@ -718,10 +721,10 @@ public class JetTypeMapper {
         AnnotationDescriptor platformNameAnnotation = descriptor.getAnnotations().findAnnotation(new FqName("kotlin.platform.platformName"));
         if (platformNameAnnotation == null) return null;
 
-        Map<ValueParameterDescriptor, CompileTimeConstant<?>> arguments = platformNameAnnotation.getAllValueArguments();
+        Map<ValueParameterDescriptor, ConstantValue<?>> arguments = platformNameAnnotation.getAllValueArguments();
         if (arguments.isEmpty()) return null;
 
-        CompileTimeConstant<?> name = arguments.values().iterator().next();
+        ConstantValue<?> name = arguments.values().iterator().next();
         if (!(name instanceof StringValue)) return null;
 
         return ((StringValue) name).getValue();
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/when/EnumSwitchCodegen.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/when/EnumSwitchCodegen.java
index 3b092f7e141..7eab364b1f8 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/when/EnumSwitchCodegen.java
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/when/EnumSwitchCodegen.java
@@ -19,7 +19,7 @@ package org.jetbrains.kotlin.codegen.when;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.codegen.ExpressionCodegen;
 import org.jetbrains.kotlin.psi.JetWhenExpression;
-import org.jetbrains.kotlin.resolve.constants.CompileTimeConstant;
+import org.jetbrains.kotlin.resolve.constants.ConstantValue;
 import org.jetbrains.kotlin.resolve.constants.EnumValue;
 import org.jetbrains.org.objectweb.asm.Label;
 import org.jetbrains.org.objectweb.asm.Type;
@@ -58,7 +58,7 @@ public class EnumSwitchCodegen extends SwitchCodegen {
     }
 
     @Override
-    protected void processConstant(@NotNull CompileTimeConstant constant, @NotNull Label entryLabel) {
+    protected void processConstant(@NotNull ConstantValue<?> constant, @NotNull Label entryLabel) {
         assert constant instanceof EnumValue : "guaranteed by usage contract";
         putTransitionOnce(mapping.getIndexByEntry((EnumValue) constant), entryLabel);
     }
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/when/IntegralConstantsSwitchCodegen.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/when/IntegralConstantsSwitchCodegen.java
index 3463d689343..8915ac68485 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/when/IntegralConstantsSwitchCodegen.java
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/when/IntegralConstantsSwitchCodegen.java
@@ -19,7 +19,7 @@ package org.jetbrains.kotlin.codegen.when;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.codegen.ExpressionCodegen;
 import org.jetbrains.kotlin.psi.JetWhenExpression;
-import org.jetbrains.kotlin.resolve.constants.CompileTimeConstant;
+import org.jetbrains.kotlin.resolve.constants.ConstantValue;
 import org.jetbrains.org.objectweb.asm.Label;
 
 public class IntegralConstantsSwitchCodegen extends SwitchCodegen {
@@ -32,7 +32,7 @@ public class IntegralConstantsSwitchCodegen extends SwitchCodegen {
     }
 
     @Override
-    protected void processConstant(@NotNull CompileTimeConstant constant, @NotNull Label entryLabel) {
+    protected void processConstant(@NotNull ConstantValue<?> constant, @NotNull Label entryLabel) {
         assert constant.getValue() != null : "constant value should not be null";
         int value = (constant.getValue() instanceof Number)
                     ? ((Number) constant.getValue()).intValue()
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/when/StringSwitchCodegen.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/when/StringSwitchCodegen.java
index f3a1058bab3..e689eefdaa7 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/when/StringSwitchCodegen.java
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/when/StringSwitchCodegen.java
@@ -21,7 +21,7 @@ import com.intellij.openapi.util.Pair;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.codegen.ExpressionCodegen;
 import org.jetbrains.kotlin.psi.JetWhenExpression;
-import org.jetbrains.kotlin.resolve.constants.CompileTimeConstant;
+import org.jetbrains.kotlin.resolve.constants.ConstantValue;
 import org.jetbrains.kotlin.resolve.constants.StringValue;
 import org.jetbrains.org.objectweb.asm.Label;
 import org.jetbrains.org.objectweb.asm.Type;
@@ -47,7 +47,7 @@ public class StringSwitchCodegen extends SwitchCodegen {
 
     @Override
     protected void processConstant(
-            @NotNull CompileTimeConstant constant, @NotNull Label entryLabel
+            @NotNull ConstantValue<?> constant, @NotNull Label entryLabel
     ) {
         assert constant instanceof StringValue : "guaranteed by usage contract";
         int hashCode = constant.hashCode();
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/when/SwitchCodegen.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/when/SwitchCodegen.java
index c65505ce41e..026107f6297 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/when/SwitchCodegen.java
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/when/SwitchCodegen.java
@@ -22,7 +22,7 @@ import org.jetbrains.kotlin.codegen.FrameMap;
 import org.jetbrains.kotlin.psi.JetWhenEntry;
 import org.jetbrains.kotlin.psi.JetWhenExpression;
 import org.jetbrains.kotlin.resolve.BindingContext;
-import org.jetbrains.kotlin.resolve.constants.CompileTimeConstant;
+import org.jetbrains.kotlin.resolve.constants.ConstantValue;
 import org.jetbrains.kotlin.resolve.constants.NullValue;
 import org.jetbrains.kotlin.types.JetType;
 import org.jetbrains.kotlin.types.TypeUtils;
@@ -96,7 +96,7 @@ abstract public class SwitchCodegen {
         for (JetWhenEntry entry : expression.getEntries()) {
             Label entryLabel = new Label();
 
-            for (CompileTimeConstant constant : SwitchCodegenUtil.getConstantsFromEntry(entry, bindingContext)) {
+            for (ConstantValue<?> constant : SwitchCodegenUtil.getConstantsFromEntry(entry, bindingContext)) {
                 if (constant instanceof NullValue) continue;
                 processConstant(constant, entryLabel);
             }
@@ -110,7 +110,7 @@ abstract public class SwitchCodegen {
     }
 
     abstract protected void processConstant(
-            @NotNull CompileTimeConstant constant,
+            @NotNull ConstantValue<?> constant,
             @NotNull Label entryLabel
     );
 
@@ -154,7 +154,7 @@ abstract public class SwitchCodegen {
     private int findNullEntryIndex(@NotNull JetWhenExpression expression) {
         int entryIndex = 0;
         for (JetWhenEntry entry : expression.getEntries()) {
-            for (CompileTimeConstant constant : SwitchCodegenUtil.getConstantsFromEntry(entry, bindingContext)) {
+            for (ConstantValue<?> constant : SwitchCodegenUtil.getConstantsFromEntry(entry, bindingContext)) {
                 if (constant instanceof NullValue) {
                     return entryIndex;
                 }
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/when/SwitchCodegenUtil.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/when/SwitchCodegenUtil.java
index de79f42bd81..9e2a7db30d8 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/when/SwitchCodegenUtil.java
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/when/SwitchCodegenUtil.java
@@ -23,7 +23,7 @@ import org.jetbrains.kotlin.codegen.ExpressionCodegen;
 import org.jetbrains.kotlin.codegen.binding.CodegenBinding;
 import org.jetbrains.kotlin.psi.*;
 import org.jetbrains.kotlin.resolve.BindingContext;
-import org.jetbrains.kotlin.resolve.constants.CompileTimeConstant;
+import org.jetbrains.kotlin.resolve.constants.ConstantValue;
 import org.jetbrains.kotlin.resolve.constants.IntegerValueConstant;
 import org.jetbrains.kotlin.resolve.constants.NullValue;
 import org.jetbrains.kotlin.resolve.constants.StringValue;
@@ -36,7 +36,7 @@ public class SwitchCodegenUtil {
     public static boolean checkAllItemsAreConstantsSatisfying(
             @NotNull JetWhenExpression expression,
             @NotNull BindingContext bindingContext,
-            Function1<CompileTimeConstant, Boolean> predicate
+            Function1<ConstantValue<?>, Boolean> predicate
     ) {
         for (JetWhenEntry entry : expression.getEntries()) {
             for (JetWhenCondition condition : entry.getConditions()) {
@@ -49,7 +49,7 @@ public class SwitchCodegenUtil {
 
                 if (patternExpression == null) return false;
 
-                CompileTimeConstant constant = ExpressionCodegen.getCompileTimeConstant(patternExpression, bindingContext);
+                ConstantValue<?> constant = ExpressionCodegen.getCompileTimeConstant(patternExpression, bindingContext);
                 if (constant == null || !predicate.invoke(constant)) {
                     return false;
                 }
@@ -60,11 +60,11 @@ public class SwitchCodegenUtil {
     }
 
     @NotNull
-    public static Iterable<CompileTimeConstant> getAllConstants(
+    public static Iterable<ConstantValue<?>> getAllConstants(
             @NotNull JetWhenExpression expression,
             @NotNull BindingContext bindingContext
     ) {
-        List<CompileTimeConstant> result = new ArrayList<CompileTimeConstant>();
+        List<ConstantValue<?>> result = new ArrayList<ConstantValue<?>>();
 
         for (JetWhenEntry entry : expression.getEntries()) {
             addConstantsFromEntry(result, entry, bindingContext);
@@ -74,7 +74,7 @@ public class SwitchCodegenUtil {
     }
 
     private static void addConstantsFromEntry(
-            @NotNull List<CompileTimeConstant> result,
+            @NotNull List<ConstantValue<?>> result,
             @NotNull JetWhenEntry entry,
             @NotNull BindingContext bindingContext
     ) {
@@ -89,11 +89,11 @@ public class SwitchCodegenUtil {
     }
 
     @NotNull
-    public static Iterable<CompileTimeConstant> getConstantsFromEntry(
+    public static Iterable<ConstantValue<?>> getConstantsFromEntry(
             @NotNull JetWhenEntry entry,
             @NotNull BindingContext bindingContext
     ) {
-        List<CompileTimeConstant> result = new ArrayList<CompileTimeConstant>();
+        List<ConstantValue<?>> result = new ArrayList<ConstantValue<?>>();
         addConstantsFromEntry(result, entry, bindingContext);
         return result;
     }
@@ -132,7 +132,7 @@ public class SwitchCodegenUtil {
             @NotNull JetWhenExpression expression,
             @NotNull BindingContext bindingContext
     ) {
-        for (CompileTimeConstant constant : getAllConstants(expression, bindingContext)) {
+        for (ConstantValue<?> constant : getAllConstants(expression, bindingContext)) {
             if (constant != null && !(constant instanceof NullValue)) return true;
         }
 
@@ -150,10 +150,10 @@ public class SwitchCodegenUtil {
             return false;
         }
 
-        return checkAllItemsAreConstantsSatisfying(expression, bindingContext, new Function1<CompileTimeConstant, Boolean>() {
+        return checkAllItemsAreConstantsSatisfying(expression, bindingContext, new Function1<ConstantValue<?>, Boolean>() {
             @Override
             public Boolean invoke(
-                    @NotNull CompileTimeConstant constant
+                    @NotNull ConstantValue<?> constant
             ) {
                 return constant instanceof IntegerValueConstant;
             }
@@ -170,10 +170,10 @@ public class SwitchCodegenUtil {
             return false;
         }
 
-        return checkAllItemsAreConstantsSatisfying(expression, bindingContext, new Function1<CompileTimeConstant, Boolean>() {
+        return checkAllItemsAreConstantsSatisfying(expression, bindingContext, new Function1<ConstantValue<?>, Boolean>() {
             @Override
             public Boolean invoke(
-                    @NotNull CompileTimeConstant constant
+                    @NotNull ConstantValue<?> constant
             ) {
                 return constant instanceof StringValue || constant instanceof NullValue;
             }
diff --git a/compiler/builtins-serializer/src/org/jetbrains/kotlin/serialization/builtins/BuiltInsSerializer.kt b/compiler/builtins-serializer/src/org/jetbrains/kotlin/serialization/builtins/BuiltInsSerializer.kt
index c5d7686567b..cbb9c3cbcf7 100644
--- a/compiler/builtins-serializer/src/org/jetbrains/kotlin/serialization/builtins/BuiltInsSerializer.kt
+++ b/compiler/builtins-serializer/src/org/jetbrains/kotlin/serialization/builtins/BuiltInsSerializer.kt
@@ -113,7 +113,7 @@ public class BuiltInsSerializer(private val dependOnOldBuiltIns: Boolean) {
         // TODO: perform some kind of validation? At the moment not possible because DescriptorValidator is in compiler-tests
         // DescriptorValidator.validate(packageView)
 
-        val serializer = DescriptorSerializer.createTopLevel(BuiltInsSerializerExtension)
+        val serializer = DescriptorSerializer.createTopLevel(BuiltInsSerializerExtension())
 
         val classifierDescriptors = DescriptorSerializer.sort(packageView.memberScope.getDescriptors(DescriptorKindFilter.CLASSIFIERS))
 
diff --git a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/K2JVMCompiler.kt b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/K2JVMCompiler.kt
index 5c6fde64d83..52164b8c799 100644
--- a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/K2JVMCompiler.kt
+++ b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/K2JVMCompiler.kt
@@ -61,6 +61,7 @@ public open class K2JVMCompiler : CLICompiler<K2JVMCompilerArguments>() {
             PathUtil.getKotlinPathsForCompiler()
 
         messageSeverityCollector.report(CompilerMessageSeverity.LOGGING, "Using Kotlin home directory " + paths.getHomePath(), CompilerMessageLocation.NO_LOCATION)
+        PerformanceCounter.setTimeCounterEnabled(arguments.reportPerf);
 
         val configuration = CompilerConfiguration()
         configuration.put(CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY, messageSeverityCollector)
@@ -93,7 +94,7 @@ public open class K2JVMCompiler : CLICompiler<K2JVMCompilerArguments>() {
             return INTERNAL_ERROR
         }
         catch (e: CliOptionProcessingException) {
-            messageSeverityCollector.report(CompilerMessageSeverity.ERROR, e.getMessage(), CompilerMessageLocation.NO_LOCATION)
+            messageSeverityCollector.report(CompilerMessageSeverity.ERROR, e.getMessage()!!, CompilerMessageLocation.NO_LOCATION)
             return INTERNAL_ERROR
         }
         catch (t: Throwable) {
diff --git a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/KotlinCliJavaFileManagerImpl.kt b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/KotlinCliJavaFileManagerImpl.kt
index b5b21ba5f29..300839c8138 100644
--- a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/KotlinCliJavaFileManagerImpl.kt
+++ b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/KotlinCliJavaFileManagerImpl.kt
@@ -36,7 +36,7 @@ import kotlin.properties.Delegates
 public class KotlinCliJavaFileManagerImpl(private val myPsiManager: PsiManager)
 : CoreJavaFileManager(myPsiManager), KotlinCliJavaFileManager {
 
-    private val perfCounter = PerformanceCounter("Find Java class")
+    private val perfCounter = PerformanceCounter.create("Find Java class")
     private var index: JvmDependenciesIndex by Delegates.notNull()
 
     public fun initIndex(packagesCache: JvmDependenciesIndex) {
diff --git a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/KotlinToJVMBytecodeCompiler.java b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/KotlinToJVMBytecodeCompiler.java
index e0908706940..b75a88baaaf 100644
--- a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/KotlinToJVMBytecodeCompiler.java
+++ b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/KotlinToJVMBytecodeCompiler.java
@@ -314,7 +314,7 @@ public class KotlinToJVMBytecodeCompiler {
         MessageCollector collector = environment.getConfiguration().get(CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY);
         assert collector != null;
 
-        long analysisStart = PerformanceCounter.Companion.currentThreadCpuTime();
+        long analysisStart = PerformanceCounter.Companion.currentTime();
         AnalyzerWithCompilerReport analyzerWithCompilerReport = new AnalyzerWithCompilerReport(collector);
         analyzerWithCompilerReport.analyzeAndReport(
                 environment.getSourceFiles(), new Function0<AnalysisResult>() {
@@ -334,7 +334,7 @@ public class KotlinToJVMBytecodeCompiler {
                     }
                 }
         );
-        long analysisNanos = PerformanceCounter.Companion.currentThreadCpuTime() - analysisStart;
+        long analysisNanos = PerformanceCounter.Companion.currentTime() - analysisStart;
         String message = "ANALYZE: " + environment.getSourceFiles().size() + " files (" +
                          environment.getSourceLinesOfCode() + " lines) " +
                          (targetDescription != null ? targetDescription : "") +
@@ -395,11 +395,11 @@ public class KotlinToJVMBytecodeCompiler {
         );
         ProgressIndicatorAndCompilationCanceledStatus.checkCanceled();
 
-        long generationStart = PerformanceCounter.Companion.currentThreadCpuTime();
+        long generationStart = PerformanceCounter.Companion.currentTime();
 
         KotlinCodegenFacade.compileCorrectFiles(generationState, CompilationErrorHandler.THROW_EXCEPTION);
 
-        long generationNanos = PerformanceCounter.Companion.currentThreadCpuTime() - generationStart;
+        long generationNanos = PerformanceCounter.Companion.currentTime() - generationStart;
         String desc = moduleId != null ? "module " + moduleId + " " : "";
         String message = "GENERATE: " + sourceFiles.size() + " files (" +
                          environment.countLinesOfCode(sourceFiles) + " lines) " + desc + "in " + TimeUnit.NANOSECONDS.toMillis(generationNanos) + " ms";
diff --git a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/repl/DelegatePackageMemberDeclarationProvider.kt b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/repl/DelegatePackageMemberDeclarationProvider.kt
index 0253d888110..18eff93dde9 100644
--- a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/repl/DelegatePackageMemberDeclarationProvider.kt
+++ b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/repl/DelegatePackageMemberDeclarationProvider.kt
@@ -23,7 +23,7 @@ import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter
 open class DelegatePackageMemberDeclarationProvider(var delegate: PackageMemberDeclarationProvider) : PackageMemberDeclarationProvider {
     // Can't use Kotlin delegate feature because of inability to change delegate object in runtime (KT-5870)
 
-    override fun getAllDeclaredSubPackages() = delegate.getAllDeclaredSubPackages()
+    override fun getAllDeclaredSubPackages(nameFilter: (Name) -> Boolean) = delegate.getAllDeclaredSubPackages(nameFilter)
 
     override fun getPackageFiles() = delegate.getPackageFiles()
 
diff --git a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/repl/di/injection.kt b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/repl/di/injection.kt
index fab6bb69af9..b8cb74cb7bf 100644
--- a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/repl/di/injection.kt
+++ b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/repl/di/injection.kt
@@ -38,7 +38,7 @@ public fun createContainerForReplWithJava(
         moduleContext: ModuleContext, bindingTrace: BindingTrace, declarationProviderFactory: DeclarationProviderFactory,
         moduleContentScope: GlobalSearchScope, additionalFileScopeProvider: FileScopeProvider.AdditionalScopes
 ): ContainerForReplWithJava = createContainer("ReplWithJava") {
-    configureModule(moduleContext, KotlinJvmCheckerProvider, bindingTrace)
+    configureModule(moduleContext, KotlinJvmCheckerProvider(moduleContext.module), bindingTrace)
     configureJavaTopDownAnalysis(moduleContentScope, moduleContext.project)
 
     useInstance(additionalFileScopeProvider)
diff --git a/compiler/compiler.pro b/compiler/compiler.pro
index fa96e072b9c..bb7697b895f 100644
--- a/compiler/compiler.pro
+++ b/compiler/compiler.pro
@@ -30,7 +30,6 @@ messages/**)
 -dontwarn org.xerial.snappy.SnappyBundleActivator
 -dontwarn com.intellij.util.CompressionUtil
 -dontwarn com.intellij.util.SnappyInitializer
--dontwarn org.iq80.snappy.Snappy
 -dontwarn net.sf.cglib.**
 -dontwarn org.objectweb.asm.** # this is ASM3, the old version that we do not use
 
diff --git a/compiler/container/src/org/jetbrains/kotlin/container/Cache.kt b/compiler/container/src/org/jetbrains/kotlin/container/Cache.kt
index 73e78d10f93..bd8d2422fd4 100644
--- a/compiler/container/src/org/jetbrains/kotlin/container/Cache.kt
+++ b/compiler/container/src/org/jetbrains/kotlin/container/Cache.kt
@@ -17,9 +17,7 @@
 package org.jetbrains.kotlin.container
 
 import com.intellij.util.containers.ContainerUtil
-import java.lang.reflect.Constructor
-import java.lang.reflect.Method
-import java.lang.reflect.Modifier
+import java.lang.reflect.*
 import java.util.ArrayList
 import java.util.LinkedHashSet
 
@@ -44,17 +42,17 @@ fun Class<*>.getInfo(): ClassInfo {
 data class ClassInfo(
         val constructorInfo: ConstructorInfo?,
         val setterInfos: List<SetterInfo>,
-        val registrations: List<Class<*>>
+        val registrations: List<Type>
 )
 
 data class ConstructorInfo(
         val constructor: Constructor<*>,
-        val parameters: List<Class<*>>
+        val parameters: List<Type>
 )
 
 data class SetterInfo(
         val method: Method,
-        val parameters: List<Class<*>>
+        val parameters: List<Type>
 )
 
 private fun traverseClass(c: Class<*>): ClassInfo {
@@ -66,7 +64,7 @@ private fun getSetterInfos(c: Class<*>): List<SetterInfo> {
     for (method in c.getMethods()) {
         for (annotation in method.getDeclaredAnnotations()) {
             if (annotation.annotationType().getName().endsWith(".Inject")) {
-                setterInfos.add(SetterInfo(method, method.getParameterTypes().toList()))
+                setterInfos.add(SetterInfo(method, method.getGenericParameterTypes().toList()))
             }
         }
     }
@@ -83,25 +81,37 @@ private fun getConstructorInfo(c: Class<*>): ConstructorInfo? {
         return null
 
     val constructor = constructors.single()
-    return ConstructorInfo(constructor, constructor.getParameterTypes().toList())
+    return ConstructorInfo(constructor, constructor.getGenericParameterTypes().toList())
 }
 
 
-private fun collectInterfacesRecursive(cl: Class<*>, result: MutableSet<Class<*>>) {
-    cl.getInterfaces().forEach {
+private fun collectInterfacesRecursive(type: Type, result: MutableSet<Type>) {
+    // TODO: should apply generic substitution through hierarchy
+    val klass : Class<*>? = when(type) {
+        is Class<*> -> type
+        is ParameterizedType -> type.getRawType() as? Class<*>
+        else -> null
+    }
+    klass?.getGenericInterfaces()?.forEach {
         if (result.add(it)) {
             collectInterfacesRecursive(it, result)
         }
     }
 }
 
-private fun getRegistrations(klass: Class<*>): List<Class<*>> {
-    val registrations = ArrayList<Class<*>>()
+private fun getRegistrations(klass: Class<*>): List<Type> {
+    val registrations = ArrayList<Type>()
 
-    val superClasses = sequence(klass) { (it as Class<Any>).getSuperclass() }
+    val superClasses = sequence<Type>(klass) {
+        when (it) {
+            is Class<*> -> it.getGenericSuperclass()
+            is ParameterizedType -> (it.getRawType() as? Class<*>)?.getGenericSuperclass()
+            else -> null
+        }
+    }
     registrations.addAll(superClasses)
 
-    val interfaces = LinkedHashSet<Class<*>>()
+    val interfaces = LinkedHashSet<Type>()
     superClasses.forEach { collectInterfacesRecursive(it, interfaces) }
     registrations.addAll(interfaces)
     registrations.remove(javaClass<Any>())
diff --git a/compiler/container/src/org/jetbrains/kotlin/container/Components.kt b/compiler/container/src/org/jetbrains/kotlin/container/Components.kt
index 13cb5037d1f..ed46308acdd 100644
--- a/compiler/container/src/org/jetbrains/kotlin/container/Components.kt
+++ b/compiler/container/src/org/jetbrains/kotlin/container/Components.kt
@@ -16,13 +16,17 @@
 
 package org.jetbrains.kotlin.container
 
-import java.lang.reflect.Method
+import java.lang.reflect.*
 
 public class InstanceComponentDescriptor(val instance: Any) : ComponentDescriptor {
 
     override fun getValue(): Any = instance
-    override fun getRegistrations(): Iterable<Class<*>> = instance.javaClass.getInfo().registrations
+    override fun getRegistrations(): Iterable<Type> = instance.javaClass.getInfo().registrations
 
     override fun getDependencies(context: ValueResolveContext): Collection<Class<*>> = emptyList()
+
+    override fun toString(): String {
+        return "Instance: ${instance.javaClass.getSimpleName()}"
+    }
 }
 
diff --git a/compiler/container/src/org/jetbrains/kotlin/container/Container.kt b/compiler/container/src/org/jetbrains/kotlin/container/Container.kt
index 80dc41f2060..d7e265ef3b4 100644
--- a/compiler/container/src/org/jetbrains/kotlin/container/Container.kt
+++ b/compiler/container/src/org/jetbrains/kotlin/container/Container.kt
@@ -17,7 +17,11 @@
 package org.jetbrains.kotlin.container
 
 import java.io.Closeable
-import java.lang.reflect.Modifier
+import java.io.PrintStream
+import java.io.Writer
+import java.lang.reflect.ParameterizedType
+import java.lang.reflect.Type
+import java.lang.reflect.WildcardType
 import kotlin.properties.Delegates
 
 class ContainerConsistencyException(message: String) : Exception(message)
@@ -26,10 +30,9 @@ public interface ComponentContainer {
     fun createResolveContext(requestingDescriptor: ValueDescriptor): ValueResolveContext
 }
 
-object DynamicComponentDescriptor : ComponentDescriptor {
-    override fun getDependencies(context: ValueResolveContext): Collection<Class<*>> = throw UnsupportedOperationException()
-    override fun getRegistrations(): Iterable<Class<*>> = throw UnsupportedOperationException()
+object DynamicComponentDescriptor : ValueDescriptor {
     override fun getValue(): Any = throw UnsupportedOperationException()
+    override fun toString(): String = "Dynamic"
 }
 
 public class StorageComponentContainer(id: String) : ComponentContainer, Closeable {
@@ -47,22 +50,28 @@ public class StorageComponentContainer(id: String) : ComponentContainer, Closeab
         return this
     }
 
+    fun dump(printer: PrintStream) {
+        componentStorage.dump(printer)
+    }
+
     override fun close() = componentStorage.dispose()
 
-    jvmOverloads public fun resolve(request: Class<*>, context: ValueResolveContext = unknownContext): ValueDescriptor? {
-        val storageResolve = componentStorage.resolve(request, context)
-        if (storageResolve != null)
-            return storageResolve
+    jvmOverloads public fun resolve(request: Type, context: ValueResolveContext = unknownContext): ValueDescriptor? {
+        return componentStorage.resolve(request, context) ?: resolveIterable(request, context)
+    }
 
-        val hasSinglePublicConstructor = request.getConstructors().singleOrNull()?.let { Modifier.isPublic(it.getModifiers()) } ?: false
-        if (!hasSinglePublicConstructor)
-            return null
-
-        val modifiers = request.getModifiers()
-        if (Modifier.isInterface(modifiers) || Modifier.isAbstract(modifiers) || request.isPrimitive())
-            return null
-
-        return SingletonTypeComponentDescriptor(this, request)
+    private fun resolveIterable(request: Type, context: ValueResolveContext): ValueDescriptor? {
+        if (request !is ParameterizedType) return null
+        val rawType = request.getRawType()
+        if (rawType != javaClass<Iterable<*>>()) return null
+        val typeArguments = request.getActualTypeArguments()
+        if (typeArguments.size() != 1) return null
+        val iterableTypeArgument = typeArguments[0]
+        if (!(iterableTypeArgument is WildcardType)) return null
+        val upperBounds = iterableTypeArgument.getUpperBounds()
+        if (upperBounds.size() != 1) return null
+        val iterableType = upperBounds[0]
+        return IterableDescriptor(componentStorage.resolveMultiple(iterableType, context))
     }
 
     public fun resolveMultiple(request: Class<*>, context: ValueResolveContext = unknownContext): Iterable<ValueDescriptor> {
diff --git a/compiler/container/src/org/jetbrains/kotlin/container/DataStructures.kt b/compiler/container/src/org/jetbrains/kotlin/container/DataStructures.kt
index 34c51f56042..83d71231c72 100644
--- a/compiler/container/src/org/jetbrains/kotlin/container/DataStructures.kt
+++ b/compiler/container/src/org/jetbrains/kotlin/container/DataStructures.kt
@@ -29,7 +29,7 @@ public fun topologicalSort<T>(items: Iterable<T>, dependencies: (T) -> Iterable<
             return
 
         if (item in itemsInProgress)
-            throw CycleInTopoSortException()
+            return //throw CycleInTopoSortException()
 
         itemsInProgress.add(item)
 
diff --git a/compiler/container/src/org/jetbrains/kotlin/container/Descriptors.kt b/compiler/container/src/org/jetbrains/kotlin/container/Descriptors.kt
index def0d70e14a..41fb2eef21d 100644
--- a/compiler/container/src/org/jetbrains/kotlin/container/Descriptors.kt
+++ b/compiler/container/src/org/jetbrains/kotlin/container/Descriptors.kt
@@ -16,14 +16,23 @@
 
 package org.jetbrains.kotlin.container
 
+import java.lang.reflect.*
 
 public interface ValueDescriptor {
     public fun getValue(): Any
 }
 
 internal interface ComponentDescriptor : ValueDescriptor {
-    fun getRegistrations(): Iterable<Class<*>>
-    fun getDependencies(context: ValueResolveContext): Collection<Class<*>>
+    fun getRegistrations(): Iterable<Type>
+    fun getDependencies(context: ValueResolveContext): Collection<Type>
     val shouldInjectProperties: Boolean
         get() = false
+}
+
+public class IterableDescriptor(val descriptors: Iterable<ValueDescriptor>) : ValueDescriptor {
+    override fun getValue(): Any {
+        return descriptors.map { it.getValue() }
+    }
+
+    override fun toString(): String = "Iterable: $descriptors"
 }
\ No newline at end of file
diff --git a/compiler/container/src/org/jetbrains/kotlin/container/Registry.kt b/compiler/container/src/org/jetbrains/kotlin/container/Registry.kt
index 576285c0aeb..bb94c2517ae 100644
--- a/compiler/container/src/org/jetbrains/kotlin/container/Registry.kt
+++ b/compiler/container/src/org/jetbrains/kotlin/container/Registry.kt
@@ -18,10 +18,11 @@ package org.jetbrains.kotlin.container
 
 import com.intellij.util.containers.MultiMap
 import java.util.ArrayList
+import java.lang.reflect.*
 
 internal class ComponentRegistry {
-    fun buildRegistrationMap(descriptors: Collection<ComponentDescriptor>): MultiMap<Class<*>, ComponentDescriptor> {
-        val registrationMap = MultiMap<Class<*>, ComponentDescriptor>()
+    fun buildRegistrationMap(descriptors: Collection<ComponentDescriptor>): MultiMap<Type, ComponentDescriptor> {
+        val registrationMap = MultiMap<Type, ComponentDescriptor>()
         for (descriptor in descriptors) {
             for (registration in descriptor.getRegistrations()) {
                 registrationMap.putValue(registration, descriptor)
@@ -30,13 +31,13 @@ internal class ComponentRegistry {
         return registrationMap
     }
 
-    private var registrationMap = MultiMap.createLinkedSet<Class<*>, ComponentDescriptor>()
+    private var registrationMap = MultiMap.createLinkedSet<Type, ComponentDescriptor>()
 
     public fun addAll(descriptors: Collection<ComponentDescriptor>) {
         registrationMap.putAllValues(buildRegistrationMap(descriptors))
     }
 
-    public fun tryGetEntry(request: Class<*>): Collection<ComponentDescriptor> {
+    public fun tryGetEntry(request: Type): Collection<ComponentDescriptor> {
         return registrationMap.get(request)
     }
 }
\ No newline at end of file
diff --git a/compiler/container/src/org/jetbrains/kotlin/container/Resolve.kt b/compiler/container/src/org/jetbrains/kotlin/container/Resolve.kt
index 96ffd0ea785..62dfe8bd926 100644
--- a/compiler/container/src/org/jetbrains/kotlin/container/Resolve.kt
+++ b/compiler/container/src/org/jetbrains/kotlin/container/Resolve.kt
@@ -23,15 +23,15 @@ import java.lang.reflect.Type
 import java.util.ArrayList
 
 public interface ValueResolver {
-    fun resolve(request: Class<*>, context: ValueResolveContext): ValueDescriptor?
+    fun resolve(request: Type, context: ValueResolveContext): ValueDescriptor?
 }
 
 public interface ValueResolveContext {
-    fun resolve(registration: Class<*>): ValueDescriptor?
+    fun resolve(registration: Type): ValueDescriptor?
 }
 
 internal class ComponentResolveContext(val container: StorageComponentContainer, val requestingDescriptor: ValueDescriptor) : ValueResolveContext {
-    override fun resolve(registration: Class<*>): ValueDescriptor? = container.resolve(registration, this)
+    override fun resolve(registration: Type): ValueDescriptor? = container.resolve(registration, this)
 
     override fun toString(): String = "for $requestingDescriptor in $container"
 }
@@ -54,10 +54,10 @@ fun Class<*>.bindToConstructor(context: ValueResolveContext): ConstructorBinding
 }
 
 fun Method.bindToMethod(context: ValueResolveContext): MethodBinding {
-    return MethodBinding(this, bindArguments(getParameterTypes().toList(), context))
+    return MethodBinding(this, bindArguments(getGenericParameterTypes().toList(), context))
 }
 
-private fun Member.bindArguments(parameters: List<Class<*>>, context: ValueResolveContext): List<ValueDescriptor> {
+private fun Member.bindArguments(parameters: List<Type>, context: ValueResolveContext): List<ValueDescriptor> {
     val bound = ArrayList<ValueDescriptor>(parameters.size())
     var unsatisfied: MutableList<Type>? = null
 
diff --git a/compiler/container/src/org/jetbrains/kotlin/container/Singletons.kt b/compiler/container/src/org/jetbrains/kotlin/container/Singletons.kt
index 724f1aa8b85..4e25fe61d1c 100644
--- a/compiler/container/src/org/jetbrains/kotlin/container/Singletons.kt
+++ b/compiler/container/src/org/jetbrains/kotlin/container/Singletons.kt
@@ -19,6 +19,7 @@ package org.jetbrains.kotlin.container
 import java.io.Closeable
 import java.util.ArrayList
 import kotlin.properties.Delegates
+import java.lang.reflect.*
 
 enum class ComponentState {
     Null,
@@ -116,7 +117,9 @@ public abstract class SingletonDescriptor(val container: ComponentContainer) : C
 }
 
 public abstract class SingletonComponentDescriptor(container: ComponentContainer, val klass: Class<*>) : SingletonDescriptor(container) {
-    public override fun getRegistrations(): Iterable<Class<*>> = klass.getInfo().registrations
+    override fun toString(): String = "Singleton: ${klass.getSimpleName()}"
+
+    public override fun getRegistrations(): Iterable<Type> = klass.getInfo().registrations
 }
 
 public class SingletonTypeComponentDescriptor(container: ComponentContainer, klass: Class<*>) : SingletonComponentDescriptor(container, klass) {
@@ -139,7 +142,7 @@ public class SingletonTypeComponentDescriptor(container: ComponentContainer, kla
         return instance
     }
 
-    override fun getDependencies(context: ValueResolveContext): Collection<Class<*>> {
+    override fun getDependencies(context: ValueResolveContext): Collection<Type> {
         val classInfo = klass.getInfo()
         return classInfo.constructorInfo?.parameters.orEmpty() + classInfo.setterInfos.flatMap { it.parameters }
     }
diff --git a/compiler/container/src/org/jetbrains/kotlin/container/Storage.kt b/compiler/container/src/org/jetbrains/kotlin/container/Storage.kt
index 94cdc266321..cfba964bf03 100644
--- a/compiler/container/src/org/jetbrains/kotlin/container/Storage.kt
+++ b/compiler/container/src/org/jetbrains/kotlin/container/Storage.kt
@@ -18,7 +18,10 @@ package org.jetbrains.kotlin.container
 
 import com.intellij.util.containers.MultiMap
 import java.io.Closeable
+import java.io.PrintStream
 import java.lang.reflect.Modifier
+import java.lang.reflect.ParameterizedType
+import java.lang.reflect.Type
 import java.util.ArrayList
 import java.util.HashSet
 import java.util.LinkedHashSet
@@ -30,13 +33,15 @@ public enum class ComponentStorageState {
     Disposed
 }
 
+class InvalidCardinalityException(message: String, val descriptors: Collection<ComponentDescriptor>) : Exception(message)
+
 public class ComponentStorage(val myId: String) : ValueResolver {
     var state = ComponentStorageState.Initial
     val registry = ComponentRegistry()
     val descriptors = LinkedHashSet<ComponentDescriptor>()
-    val dependencies = MultiMap.createLinkedSet<ComponentDescriptor, Class<*>>()
+    val dependencies = MultiMap.createLinkedSet<ComponentDescriptor, Type>()
 
-    override fun resolve(request: Class<*>, context: ValueResolveContext): ValueDescriptor? {
+    override fun resolve(request: Type, context: ValueResolveContext): ValueDescriptor? {
         if (state == ComponentStorageState.Initial)
             throw ContainerConsistencyException("Container was not composed before resolving")
 
@@ -44,12 +49,14 @@ public class ComponentStorage(val myId: String) : ValueResolver {
         if (entry.isNotEmpty()) {
             registerDependency(request, context)
 
+            if (entry.size() > 1)
+                throw InvalidCardinalityException("Request $request cannot be satisfied because there is more than one type registered", entry)
             return entry.singleOrNull()
         }
         return null
     }
 
-    private fun registerDependency(request: Class<*>, context: ValueResolveContext) {
+    private fun registerDependency(request: Type, context: ValueResolveContext) {
         if (context is ComponentResolveContext) {
             val descriptor = context.requestingDescriptor
             if (descriptor is ComponentDescriptor) {
@@ -58,7 +65,30 @@ public class ComponentStorage(val myId: String) : ValueResolver {
         }
     }
 
-    public fun resolveMultiple(request: Class<*>, context: ValueResolveContext): Iterable<ValueDescriptor> {
+    public fun dump(printer: PrintStream): Unit = with (printer) {
+        val heading = "Container: $myId"
+        println(heading)
+        println("=".repeat(heading.length()))
+        println()
+        getDescriptorsInDisposeOrder().forEach { descriptor ->
+            println(descriptor)
+            dependencies[descriptor].forEach {
+                print("   -> ")
+                val typeName = it.toString()
+                print(typeName.substringBefore(" ")) // interface, class
+                print(" ")
+                print(typeName.substringAfterLast(".")) // name
+                val resolve = registry.tryGetEntry(it)
+                print(" as ")
+                print(resolve)
+                println()
+            }
+            println()
+        }
+    }
+
+
+    public fun resolveMultiple(request: Type, context: ValueResolveContext): Iterable<ValueDescriptor> {
         registerDependency(request, context)
         return registry.tryGetEntry(request)
     }
@@ -89,7 +119,7 @@ public class ComponentStorage(val myId: String) : ValueResolver {
 
         registry.addAll(descriptors)
 
-        val implicits = inspectDependenciesAndRegisterImplicits(context, descriptors)
+        val implicits = inspectDependenciesAndRegisterAdhoc(context, descriptors)
 
         injectProperties(context, descriptors + implicits)
     }
@@ -97,35 +127,43 @@ public class ComponentStorage(val myId: String) : ValueResolver {
     private fun injectProperties(context: ComponentResolveContext, components: Collection<ComponentDescriptor>) {
         for (component in components) {
             if (component.shouldInjectProperties) {
-                injectProperties(component.getValue(), context)
+                injectProperties(component.getValue(), context.container.createResolveContext(component))
             }
         }
     }
 
-    private fun inspectDependenciesAndRegisterImplicits(context: ComponentResolveContext, descriptors: Collection<ComponentDescriptor>): LinkedHashSet<ComponentDescriptor> {
-        val implicits = LinkedHashSet<ComponentDescriptor>()
-        val visitedTypes = HashSet<Class<*>>()
+    private fun inspectDependenciesAndRegisterAdhoc(context: ComponentResolveContext, descriptors: Collection<ComponentDescriptor>): LinkedHashSet<ComponentDescriptor> {
+        val adhoc = LinkedHashSet<ComponentDescriptor>()
+        val visitedTypes = HashSet<Type>()
         for (descriptor in descriptors) {
-            registerImplicits(context, descriptor, visitedTypes, implicits)
+            collectAdhocComponents(context, descriptor, visitedTypes, adhoc)
         }
-        registry.addAll(implicits)
-        return implicits
+        registry.addAll(adhoc)
+        return adhoc
     }
 
-    private fun registerImplicits(
-            context: ComponentResolveContext, descriptor: ComponentDescriptor,
-            visitedTypes: HashSet<Class<*>>, implicitDescriptors: LinkedHashSet<ComponentDescriptor>
+    private fun collectAdhocComponents(context: ComponentResolveContext, descriptor: ComponentDescriptor,
+                                       visitedTypes: HashSet<Type>, adhocDescriptors: LinkedHashSet<ComponentDescriptor>
     ) {
         val dependencies = descriptor.getDependencies(context)
         for (type in dependencies) {
-            if (!visitedTypes.add(type)) continue
+            if (!visitedTypes.add(type))
+                continue
 
             val entry = registry.tryGetEntry(type)
             if (entry.isEmpty()) {
-                if (!Modifier.isAbstract(type.getModifiers()) && !type.isPrimitive()) {
-                    val implicitDescriptor = SingletonTypeComponentDescriptor(context.container, type)
-                    implicitDescriptors.add(implicitDescriptor)
-                    registerImplicits(context, implicitDescriptor, visitedTypes, implicitDescriptors)
+                val rawType: Class<*>? = when (type) {
+                    is Class<*> -> type
+                    is ParameterizedType -> type.getRawType() as? Class<*>
+                    else -> null
+                }
+                if (rawType == null)
+                    continue
+
+                if (!Modifier.isAbstract(rawType.getModifiers()) && !rawType.isPrimitive()) {
+                    val implicitDescriptor = SingletonTypeComponentDescriptor(context.container, rawType)
+                    adhocDescriptors.add(implicitDescriptor)
+                    collectAdhocComponents(context, implicitDescriptor, visitedTypes, adhocDescriptors)
                 }
             }
         }
diff --git a/compiler/container/tests/org/jetbrains/kotlin/container/tests/ComponentContainerTest.kt b/compiler/container/tests/org/jetbrains/kotlin/container/tests/ComponentContainerTest.kt
index 2aead72b9f5..cb617b7da4f 100644
--- a/compiler/container/tests/org/jetbrains/kotlin/container/tests/ComponentContainerTest.kt
+++ b/compiler/container/tests/org/jetbrains/kotlin/container/tests/ComponentContainerTest.kt
@@ -17,53 +17,11 @@
 package org.jetbrains.kotlin.container.tests
 
 import org.jetbrains.kotlin.container.*
+import org.junit.Ignore
 import org.junit.Test
-import java.io.Closeable
 import javax.inject.Inject
 import kotlin.test.*
 
-interface TestComponentInterface {
-    public val disposed: Boolean
-    fun foo()
-}
-
-interface TestClientComponentInterface
-
-class TestComponent : TestComponentInterface, Closeable {
-    public override var disposed: Boolean = false
-    override fun close() {
-        disposed = true
-    }
-
-    override fun foo() {
-        throw UnsupportedOperationException()
-    }
-}
-
-class ManualTestComponent(val name: String) : TestComponentInterface, Closeable {
-    public override var disposed: Boolean = false
-    override fun close() {
-        disposed = true
-    }
-
-    override fun foo() {
-        throw UnsupportedOperationException()
-    }
-}
-
-class TestClientComponent(val dep: TestComponentInterface) : TestClientComponentInterface, Closeable {
-    override fun close() {
-        if (dep.disposed)
-            throw Exception("Dependency shouldn't be disposed before dependee")
-        disposed = true
-    }
-
-    var disposed: Boolean = false
-}
-
-class TestClientComponent2() : TestClientComponentInterface {
-}
-
 class ComponentContainerTest {
     Test fun should_throw_when_not_composed() {
         val container = StorageComponentContainer("test")
@@ -155,6 +113,76 @@ class ComponentContainerTest {
         }
     }
 
+    Test fun should_resolve_adhoc_types_to_same_instances() {
+        createContainer("test") {
+            useImpl<TestAdhocComponent1>()
+            useImpl<TestAdhocComponent2>()
+        }.use {
+            val descriptor1 = it.resolve<TestAdhocComponent1>()
+            assertNotNull(descriptor1)
+            val descriptor2 = it.resolve<TestAdhocComponent2>()
+            assertNotNull(descriptor2)
+            val component1 = descriptor1!!.getValue() as TestAdhocComponent1
+            val component2 = descriptor2!!.getValue() as TestAdhocComponent2
+            assertTrue(component1.service === component2.service)
+        }
+    }
+
+    Test fun should_resolve_iterable() {
+        createContainer("test") {
+            useImpl<TestComponent>()
+            useImpl<TestClientComponent>()
+            useImpl<TestClientComponent2>()
+            useImpl<TestIterableComponent>()
+        }.use {
+            val descriptor = it.resolve<TestIterableComponent>()
+            assertNotNull(descriptor)
+            val iterableComponent = descriptor!!.getValue() as TestIterableComponent
+            assertEquals(2, iterableComponent.components.count())
+            assertTrue(iterableComponent.components.any { it is TestClientComponent })
+            assertTrue(iterableComponent.components.any { it is TestClientComponent2 })
+        }
+    }
+
+    Test fun should_distinguish_generic() {
+        createContainer("test") {
+            useImpl<TestGenericClient>()
+            useImpl<TestStringComponent>()
+            useImpl<TestIntComponent>()
+        }.use {
+            val descriptor = it.resolve<TestGenericClient>()
+            assertNotNull(descriptor)
+            val genericClient = descriptor!!.getValue() as TestGenericClient
+            assertTrue(genericClient.component1 is TestStringComponent)
+            assertTrue(genericClient.component2 is TestIntComponent)
+        }
+    }
+
+    Ignore("Need generic type substitution")
+    Test fun should_resolve_generic_adhoc() {
+        createContainer("test") {
+            useImpl<TestImplicitGenericClient>()
+        }.use {
+            val descriptor = it.resolve<TestImplicitGenericClient>()
+            assertNotNull(descriptor)
+            val genericClient = descriptor!!.getValue() as TestImplicitGenericClient
+            assertTrue(genericClient.component is TestImplicitGeneric)
+        }
+    }
+
+    Test fun should_fail_with_invalid_cardinality() {
+        createContainer("test") {
+            useImpl<TestComponent>()
+            useInstance(TestComponent())
+        }.use {
+            assertTrue {
+                fails {
+                    it.resolve<TestComponent>()
+                } is InvalidCardinalityException
+            }
+        }
+    }
+
     class WithSetters {
         var isSetterCalled = false
 
diff --git a/compiler/container/tests/org/jetbrains/kotlin/container/tests/TestComponents.kt b/compiler/container/tests/org/jetbrains/kotlin/container/tests/TestComponents.kt
new file mode 100644
index 00000000000..bbeb3b452f8
--- /dev/null
+++ b/compiler/container/tests/org/jetbrains/kotlin/container/tests/TestComponents.kt
@@ -0,0 +1,82 @@
+/*
+ * Copyright 2010-2015 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.kotlin.container.tests
+
+import java.io.*
+
+interface TestComponentInterface {
+    public val disposed: Boolean
+    fun foo()
+}
+
+interface TestClientComponentInterface {
+}
+
+class TestComponent : TestComponentInterface, Closeable {
+    public override var disposed: Boolean = false
+    override fun close() {
+        disposed = true
+    }
+
+    override fun foo() {
+        throw UnsupportedOperationException()
+    }
+}
+
+class ManualTestComponent(val name: String) : TestComponentInterface, Closeable {
+    public override var disposed: Boolean = false
+    override fun close() {
+        disposed = true
+    }
+
+    override fun foo() {
+        throw UnsupportedOperationException()
+    }
+}
+
+class TestClientComponent(val dep: TestComponentInterface) : TestClientComponentInterface, Closeable {
+    override fun close() {
+        if (dep.disposed)
+            throw Exception("Dependency shouldn't be disposed before dependee")
+        disposed = true
+    }
+
+    var disposed: Boolean = false
+}
+
+class TestClientComponent2() : TestClientComponentInterface {
+}
+
+class TestAdhocComponentService
+class TestAdhocComponent1(val service: TestAdhocComponentService) {
+
+}
+
+class TestAdhocComponent2(val service: TestAdhocComponentService) {
+
+}
+
+class TestIterableComponent(val components: Iterable<TestClientComponentInterface>)
+
+interface TestGenericComponent<T>
+
+class TestGenericClient(val component1 : TestGenericComponent<String>, val component2: TestGenericComponent<Int>)
+class TestStringComponent : TestGenericComponent<String>
+class TestIntComponent : TestGenericComponent<Int>
+
+class TestImplicitGeneric<T>()
+class TestImplicitGenericClient(val component: TestImplicitGeneric<String>)
diff --git a/compiler/frontend.java/frontend.java.iml b/compiler/frontend.java/frontend.java.iml
index 6f37b7eda52..57f41bf2a78 100644
--- a/compiler/frontend.java/frontend.java.iml
+++ b/compiler/frontend.java/frontend.java.iml
@@ -13,5 +13,6 @@
     <orderEntry type="module" module-name="deserialization" />
     <orderEntry type="module" module-name="descriptor.loader.java" exported="" />
     <orderEntry type="module" module-name="util" />
+    <orderEntry type="module" module-name="util.runtime" />
   </component>
 </module>
\ No newline at end of file
diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/frontend/java/di/injection.kt b/compiler/frontend.java/src/org/jetbrains/kotlin/frontend/java/di/injection.kt
index 83aa1d5826a..a3d0cd297a6 100644
--- a/compiler/frontend.java/src/org/jetbrains/kotlin/frontend/java/di/injection.kt
+++ b/compiler/frontend.java/src/org/jetbrains/kotlin/frontend/java/di/injection.kt
@@ -42,6 +42,7 @@ import org.jetbrains.kotlin.resolve.jvm.JavaLazyAnalyzerPostConstruct
 import org.jetbrains.kotlin.resolve.lazy.FileScopeProviderImpl
 import org.jetbrains.kotlin.resolve.lazy.ResolveSession
 import org.jetbrains.kotlin.resolve.lazy.declarations.DeclarationProviderFactory
+import org.jetbrains.kotlin.synthetic.AdditionalScopesWithJavaSyntheticExtensions
 
 public fun StorageComponentContainer.configureJavaTopDownAnalysis(moduleContentScope: GlobalSearchScope, project: Project) {
     useInstance(moduleContentScope)
@@ -65,13 +66,14 @@ public fun StorageComponentContainer.configureJavaTopDownAnalysis(moduleContentS
     useImpl<JavaSourceElementFactoryImpl>()
     useImpl<JavaLazyAnalyzerPostConstruct>()
     useImpl<JavaFlexibleTypeCapabilitiesProvider>()
+    useImpl<AdditionalScopesWithJavaSyntheticExtensions>()
 }
 
 public fun createContainerForLazyResolveWithJava(
         moduleContext: ModuleContext, bindingTrace: BindingTrace, declarationProviderFactory: DeclarationProviderFactory,
         moduleContentScope: GlobalSearchScope, moduleClassResolver: ModuleClassResolver
 ): Pair<ResolveSession, JavaDescriptorResolver> = createContainer("LazyResolveWithJava") {
-    configureModule(moduleContext, KotlinJvmCheckerProvider, bindingTrace)
+    configureModule(moduleContext, KotlinJvmCheckerProvider(moduleContext.module), bindingTrace)
     configureJavaTopDownAnalysis(moduleContentScope, moduleContext.project)
 
     useInstance(moduleClassResolver)
@@ -92,8 +94,9 @@ public fun createContainerForTopDownAnalyzerForJvm(
         declarationProviderFactory: DeclarationProviderFactory,
         moduleContentScope: GlobalSearchScope
 ): ContainerForTopDownAnalyzerForJvm = createContainer("TopDownAnalyzerForJvm") {
-    configureModule(moduleContext, KotlinJvmCheckerProvider, bindingTrace)
+    configureModule(moduleContext, KotlinJvmCheckerProvider(moduleContext.module), bindingTrace)
     configureJavaTopDownAnalysis(moduleContentScope, moduleContext.project)
+
     useInstance(declarationProviderFactory)
     useInstance(BodyResolveCache.ThrowException)
 
diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/jvm/RuntimeAssertions.kt b/compiler/frontend.java/src/org/jetbrains/kotlin/jvm/RuntimeAssertions.kt
new file mode 100644
index 00000000000..c42d9a6bf48
--- /dev/null
+++ b/compiler/frontend.java/src/org/jetbrains/kotlin/jvm/RuntimeAssertions.kt
@@ -0,0 +1,116 @@
+/*
+ * Copyright 2010-2015 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.kotlin.jvm
+
+import com.intellij.openapi.util.text.StringUtil
+import org.jetbrains.kotlin.descriptors.ReceiverParameterDescriptor
+import org.jetbrains.kotlin.load.java.JvmAnnotationNames
+import org.jetbrains.kotlin.jvm.bindingContextSlices.RUNTIME_ASSERTION_INFO
+import org.jetbrains.kotlin.psi.JetExpression
+import org.jetbrains.kotlin.resolve.BindingContext
+import org.jetbrains.kotlin.resolve.calls.checkers.AdditionalTypeChecker
+import org.jetbrains.kotlin.resolve.calls.context.CallResolutionContext
+import org.jetbrains.kotlin.resolve.calls.context.ResolutionContext
+import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowValueFactory
+import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue
+import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.TypeUtils
+import org.jetbrains.kotlin.types.checker.JetTypeChecker
+import org.jetbrains.kotlin.types.upperIfFlexible
+import kotlin.platform.platformStatic
+
+public class RuntimeAssertionInfo(public val needNotNullAssertion: Boolean, public val message: String) {
+    public interface DataFlowExtras {
+        class OnlyMessage(message: String) : DataFlowExtras {
+            override val canBeNull: Boolean get() = true
+            override val possibleTypes: Set<JetType> get() = setOf()
+            override val presentableText: String = message
+        }
+
+        val canBeNull: Boolean
+        val possibleTypes: Set<JetType>
+        val presentableText: String
+    }
+
+    companion object {
+        platformStatic public fun create(
+                expectedType: JetType,
+                expressionType: JetType,
+                dataFlowExtras: DataFlowExtras
+        ): RuntimeAssertionInfo? {
+            fun assertNotNull(): Boolean {
+                if (expectedType.isError() || expressionType.isError()) return false
+
+                // T : Any, T! = T..T?
+                // Let T$ will be copy of T! with enhanced nullability.
+                // Cases when nullability assertion needed: T! -> T, T$ -> T
+
+                // Expected type either T?, T! or T$
+                if (TypeUtils.isNullableType(expectedType) || expectedType.hasEnhancedNullability()) return false
+
+                // Expression type is not nullable and not enhanced (neither T?, T! or T$)
+                val isExpressionTypeNullable = TypeUtils.isNullableType(expressionType)
+                if (!isExpressionTypeNullable && !expressionType.hasEnhancedNullability()) return false
+
+                // Smart-cast T! or T?
+                if (!dataFlowExtras.canBeNull && isExpressionTypeNullable) return false
+
+                return true
+            }
+
+            return if (assertNotNull())
+                RuntimeAssertionInfo(needNotNullAssertion = true, message = dataFlowExtras.presentableText)
+            else
+                null
+        }
+
+        private fun JetType.hasEnhancedNullability()
+                = getAnnotations().findAnnotation(JvmAnnotationNames.ENHANCED_NULLABILITY_ANNOTATION) != null
+    }
+}
+
+public object RuntimeAssertionsTypeChecker : AdditionalTypeChecker {
+    override fun checkType(expression: JetExpression, expressionType: JetType, c: ResolutionContext<*>) {
+        if (TypeUtils.noExpectedType(c.expectedType)) return
+
+        val assertionInfo = RuntimeAssertionInfo.create(
+                c.expectedType,
+                expressionType,
+                object : RuntimeAssertionInfo.DataFlowExtras {
+                    override val canBeNull: Boolean
+                        get() = c.dataFlowInfo.getNullability(dataFlowValue).canBeNull()
+                    override val possibleTypes: Set<JetType>
+                        get() = c.dataFlowInfo.getPossibleTypes(dataFlowValue)
+                    override val presentableText: String
+                        get() = StringUtil.trimMiddle(expression.getText(), 50)
+
+                    private val dataFlowValue = DataFlowValueFactory.createDataFlowValue(expression, expressionType, c)
+                }
+        )
+
+        if (assertionInfo != null) {
+            c.trace.record(RUNTIME_ASSERTION_INFO, expression, assertionInfo)
+        }
+    }
+
+    override fun checkReceiver(
+            receiverParameter: ReceiverParameterDescriptor,
+            receiverArgument: ReceiverValue,
+            safeAccess: Boolean,
+            c: CallResolutionContext<*>
+    ) { }
+}
diff --git a/core/builtins/src/kotlin/reflect/KTopLevelVariable.kt b/compiler/frontend.java/src/org/jetbrains/kotlin/jvm/bindingContextSlices.kt
similarity index 54%
rename from core/builtins/src/kotlin/reflect/KTopLevelVariable.kt
rename to compiler/frontend.java/src/org/jetbrains/kotlin/jvm/bindingContextSlices.kt
index 39b8856ac66..00d32c8a0fa 100644
--- a/core/builtins/src/kotlin/reflect/KTopLevelVariable.kt
+++ b/compiler/frontend.java/src/org/jetbrains/kotlin/jvm/bindingContextSlices.kt
@@ -14,14 +14,13 @@
  * limitations under the License.
  */
 
-package kotlin.reflect
+package org.jetbrains.kotlin.jvm.bindingContextSlices
 
-/**
- * Represents a variable declared in a package.
- */
-public interface KTopLevelVariable<out R> : KVariable<R>, KTopLevelProperty<R>
+import org.jetbrains.kotlin.jvm.RuntimeAssertionInfo
+import org.jetbrains.kotlin.psi.JetExpression
+import org.jetbrains.kotlin.util.slicedMap.BasicWritableSlice
+import org.jetbrains.kotlin.util.slicedMap.RewritePolicy
+import org.jetbrains.kotlin.util.slicedMap.WritableSlice
+import org.jetbrains.kotlin.utils.DO_NOTHING
 
-/**
- * Represents a package variable declared as a `var`.
- */
-public interface KMutableTopLevelVariable<R> : KTopLevelVariable<R>, KMutableVariable<R>, KMutableTopLevelProperty<R>
+public val RUNTIME_ASSERTION_INFO: WritableSlice<JetExpression, RuntimeAssertionInfo> = BasicWritableSlice(RewritePolicy.DO_NOTHING)
diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/components/LazyResolveBasedCache.kt b/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/components/LazyResolveBasedCache.kt
index 4fa140afd49..2ca858a52a8 100644
--- a/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/components/LazyResolveBasedCache.kt
+++ b/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/components/LazyResolveBasedCache.kt
@@ -22,23 +22,16 @@ import org.jetbrains.kotlin.load.java.structure.impl.*
 import org.jetbrains.kotlin.resolve.lazy.ResolveSession
 import org.jetbrains.kotlin.resolve.lazy.ResolveSessionUtils
 import org.jetbrains.kotlin.name.FqName
-import javax.inject.Inject
 import kotlin.properties.Delegates
 import org.jetbrains.kotlin.name.tail
 import org.jetbrains.kotlin.resolve.BindingContext.*
 import org.jetbrains.kotlin.resolve.BindingTrace
 import org.jetbrains.kotlin.resolve.BindingContextUtils
 
-public class LazyResolveBasedCache : JavaResolverCache {
-    private var resolveSession by Delegates.notNull<ResolveSession>()
+public class LazyResolveBasedCache(private val resolveSession: ResolveSession) : JavaResolverCache {
 
     private val trace: BindingTrace get() = resolveSession.getTrace()
 
-    Inject
-    public fun setSession(resolveSession: ResolveSession) {
-        this.resolveSession = resolveSession
-    }
-
     override fun getClassResolvedFromSource(fqName: FqName): ClassDescriptor? {
         return trace.get(FQNAME_TO_CLASS_DESCRIPTOR, fqName.toUnsafe()) ?: findInPackageFragments(fqName)
     }
diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/components/PsiBasedExternalAnnotationResolver.java b/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/components/PsiBasedExternalAnnotationResolver.java
index 4bd2daea519..0b8ff30a6a0 100644
--- a/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/components/PsiBasedExternalAnnotationResolver.java
+++ b/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/components/PsiBasedExternalAnnotationResolver.java
@@ -24,8 +24,8 @@ import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.load.java.structure.JavaAnnotation;
 import org.jetbrains.kotlin.load.java.structure.JavaAnnotationOwner;
 import org.jetbrains.kotlin.load.java.structure.impl.JavaAnnotationImpl;
-import org.jetbrains.kotlin.load.java.structure.impl.JavaAnnotationOwnerImpl;
 import org.jetbrains.kotlin.load.java.structure.impl.JavaElementCollectionFromPsiArrayUtil;
+import org.jetbrains.kotlin.load.java.structure.impl.JavaModifierListOwnerImpl;
 import org.jetbrains.kotlin.name.FqName;
 
 import java.util.Collection;
@@ -35,18 +35,25 @@ public class PsiBasedExternalAnnotationResolver implements ExternalAnnotationRes
     @Nullable
     @Override
     public JavaAnnotation findExternalAnnotation(@NotNull JavaAnnotationOwner owner, @NotNull FqName fqName) {
-        PsiAnnotation psiAnnotation = findExternalAnnotation(((JavaAnnotationOwnerImpl) owner).getPsi(), fqName);
-        return psiAnnotation == null ? null : new JavaAnnotationImpl(psiAnnotation);
+        if (owner instanceof JavaModifierListOwnerImpl) {
+            JavaModifierListOwnerImpl modifierListOwner = (JavaModifierListOwnerImpl) owner;
+            PsiAnnotation psiAnnotation = findExternalAnnotation(modifierListOwner.getPsi(), fqName);
+            return psiAnnotation == null ? null : new JavaAnnotationImpl(psiAnnotation);
+        }
+        return null;
     }
 
     @NotNull
     @Override
     public Collection<JavaAnnotation> findExternalAnnotations(@NotNull JavaAnnotationOwner owner) {
-        PsiModifierListOwner psiOwner = ((JavaAnnotationOwnerImpl) owner).getPsi();
-        PsiAnnotation[] annotations = ExternalAnnotationsManager.getInstance(psiOwner.getProject()).findExternalAnnotations(psiOwner);
-        return annotations == null
-               ? Collections.<JavaAnnotation>emptyList()
-               : JavaElementCollectionFromPsiArrayUtil.annotations(annotations);
+        if (owner instanceof JavaModifierListOwnerImpl) {
+            PsiModifierListOwner psiOwner = ((JavaModifierListOwnerImpl) owner).getPsi();
+            PsiAnnotation[] annotations = ExternalAnnotationsManager.getInstance(psiOwner.getProject()).findExternalAnnotations(psiOwner);
+            return annotations == null
+                   ? Collections.<JavaAnnotation>emptyList()
+                   : JavaElementCollectionFromPsiArrayUtil.annotations(annotations);
+        }
+        return Collections.emptyList();
     }
 
     @Nullable
diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/components/TraceBasedErrorReporter.kt b/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/components/TraceBasedErrorReporter.kt
index 4325c5dacaa..1fe61137776 100644
--- a/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/components/TraceBasedErrorReporter.kt
+++ b/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/components/TraceBasedErrorReporter.kt
@@ -26,9 +26,7 @@ import org.jetbrains.kotlin.serialization.deserialization.ErrorReporter
 import org.jetbrains.kotlin.util.slicedMap.Slices
 import org.jetbrains.kotlin.util.slicedMap.WritableSlice
 
-import javax.inject.Inject
-
-public class TraceBasedErrorReporter : ErrorReporter {
+public class TraceBasedErrorReporter(private val trace: BindingTrace) : ErrorReporter {
 
     companion object {
         private val LOG = Logger.getInstance(javaClass<TraceBasedErrorReporter>())
@@ -43,24 +41,17 @@ public class TraceBasedErrorReporter : ErrorReporter {
             public val classId: ClassId
     )
 
-    private var trace: BindingTrace? = null
-
-    Inject
-    public fun setTrace(trace: BindingTrace) {
-        this.trace = trace
-    }
-
     override fun reportIncompatibleAbiVersion(classId: ClassId, filePath: String, actualVersion: Int) {
-        trace!!.record(ABI_VERSION_ERRORS, filePath, AbiVersionErrorData(actualVersion, classId))
+        trace.record(ABI_VERSION_ERRORS, filePath, AbiVersionErrorData(actualVersion, classId))
     }
 
     override fun reportIncompleteHierarchy(descriptor: ClassDescriptor, unresolvedSuperClasses: List<String>) {
         // TODO: MutableList is a workaround for KT-5792 Covariant types in Kotlin translated to wildcard types in Java
-        trace!!.record(INCOMPLETE_HIERARCHY, descriptor, unresolvedSuperClasses as MutableList)
+        trace.record(INCOMPLETE_HIERARCHY, descriptor, unresolvedSuperClasses as MutableList)
     }
 
     override fun reportCannotInferVisibility(descriptor: CallableMemberDescriptor) {
-        OverrideResolver.createCannotInferVisibilityReporter(trace!!).invoke(descriptor)
+        OverrideResolver.createCannotInferVisibilityReporter(trace).invoke(descriptor)
     }
 
     override fun reportLoadingError(message: String, exception: Exception?) {
diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/components/TraceBasedExternalSignatureResolver.java b/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/components/TraceBasedExternalSignatureResolver.java
index af409f32f2c..3cf5f75eb89 100644
--- a/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/components/TraceBasedExternalSignatureResolver.java
+++ b/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/components/TraceBasedExternalSignatureResolver.java
@@ -35,28 +35,22 @@ import org.jetbrains.kotlin.resolve.jvm.kotlinSignature.AlternativeMethodSignatu
 import org.jetbrains.kotlin.resolve.jvm.kotlinSignature.SignaturesPropagationData;
 import org.jetbrains.kotlin.types.JetType;
 
-import javax.inject.Inject;
 import java.util.Collections;
 import java.util.List;
 
 public class TraceBasedExternalSignatureResolver implements ExternalSignatureResolver {
-    private BindingTrace trace;
-    private ExternalAnnotationResolver externalAnnotationResolver;
-    private Project project;
+    @NotNull private final BindingTrace trace;
+    @NotNull private final ExternalAnnotationResolver externalAnnotationResolver;
+    @NotNull private final Project project;
 
-    @Inject
-    public void setTrace(BindingTrace trace) {
-        this.trace = trace;
-    }
-
-    @Inject
-    public void setExternalAnnotationResolver(ExternalAnnotationResolver externalAnnotationResolver) {
+    public TraceBasedExternalSignatureResolver(
+            @NotNull ExternalAnnotationResolver externalAnnotationResolver,
+            @NotNull Project project,
+            @NotNull BindingTrace trace
+    ) {
         this.externalAnnotationResolver = externalAnnotationResolver;
-    }
-
-    @Inject
-    public void setProject(Project project) {
         this.project = project;
+        this.trace = trace;
     }
 
     @Override
@@ -132,6 +126,6 @@ public class TraceBasedExternalSignatureResolver implements ExternalSignatureRes
 
     @Override
     public void reportSignatureErrors(@NotNull CallableMemberDescriptor descriptor, @NotNull List<String> signatureErrors) {
-        trace.record(JavaBindingContext.LOAD_FROM_JAVA_SIGNATURE_ERRORS, descriptor, signatureErrors);
+        trace.record(JavaBindingContext.LOAD_FROM_JAVA_SIGNATURE_ERRORS, descriptor.getOriginal(), signatureErrors);
     }
-}
+}
\ No newline at end of file
diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/sam/SamAdapterFunctionDescriptor.java b/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/sam/SamAdapterFunctionDescriptor.java
index db1a506d2e8..20c5158fa42 100644
--- a/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/sam/SamAdapterFunctionDescriptor.java
+++ b/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/sam/SamAdapterFunctionDescriptor.java
@@ -17,6 +17,10 @@
 package org.jetbrains.kotlin.load.java.sam;
 
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.jetbrains.kotlin.descriptors.DeclarationDescriptor;
+import org.jetbrains.kotlin.descriptors.FunctionDescriptor;
+import org.jetbrains.kotlin.descriptors.SimpleFunctionDescriptor;
 import org.jetbrains.kotlin.load.java.descriptors.JavaMethodDescriptor;
 import org.jetbrains.kotlin.load.java.descriptors.SamAdapterDescriptor;
 
@@ -24,8 +28,17 @@ import org.jetbrains.kotlin.load.java.descriptors.SamAdapterDescriptor;
     private final JavaMethodDescriptor declaration;
 
     public SamAdapterFunctionDescriptor(@NotNull JavaMethodDescriptor declaration) {
-        super(declaration.getContainingDeclaration(), null, declaration.getAnnotations(),
-              declaration.getName(), Kind.SYNTHESIZED, declaration.getSource());
+        this(declaration.getContainingDeclaration(), null, Kind.SYNTHESIZED, declaration);
+    }
+
+    private SamAdapterFunctionDescriptor(
+            @NotNull DeclarationDescriptor containingDeclaration,
+            @Nullable SimpleFunctionDescriptor original,
+            @NotNull Kind kind,
+            @NotNull JavaMethodDescriptor declaration
+    ) {
+        super(containingDeclaration, original, declaration.getAnnotations(),
+              declaration.getName(), kind, declaration.getSource());
         this.declaration = declaration;
         setHasStableParameterNames(declaration.hasStableParameterNames());
         setHasSynthesizedParameterNames(declaration.hasSynthesizedParameterNames());
@@ -36,4 +49,14 @@ import org.jetbrains.kotlin.load.java.descriptors.SamAdapterDescriptor;
     public JavaMethodDescriptor getOriginForSam() {
         return declaration;
     }
+
+    @NotNull
+    @Override
+    protected JavaMethodDescriptor createSubstitutedCopy(
+            @NotNull DeclarationDescriptor newOwner,
+            @Nullable FunctionDescriptor original,
+            @NotNull Kind kind
+    ) {
+        return new SamAdapterFunctionDescriptor(newOwner, (SimpleFunctionDescriptor) original, kind, declaration);
+    }
 }
diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/sam/SamAdapterOverridabilityCondition.java b/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/sam/SamAdapterOverridabilityCondition.java
index 4ee46b2ce47..59776faff0d 100644
--- a/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/sam/SamAdapterOverridabilityCondition.java
+++ b/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/sam/SamAdapterOverridabilityCondition.java
@@ -30,7 +30,7 @@ import java.util.List;
 public class SamAdapterOverridabilityCondition implements ExternalOverridabilityCondition {
     @Override
     public boolean isOverridable(@NotNull CallableDescriptor superDescriptor, @NotNull CallableDescriptor subDescriptor) {
-        if (subDescriptor instanceof PropertyDescriptor) {
+        if (!(subDescriptor instanceof SimpleFunctionDescriptor)) {
             return true;
         }
 
@@ -50,19 +50,27 @@ public class SamAdapterOverridabilityCondition implements ExternalOverridability
 
         for (ValueParameterDescriptor param1 : parameters1) {
             ValueParameterDescriptor param2 = parameters2.get(param1.getIndex());
-            if (!equalClasses(param2.getType(), param1.getType())) {
+            if (differentClasses(param2.getType(), param1.getType())) {
                 return false;
             }
         }
         return true;
     }
 
-    private static boolean equalClasses(@NotNull JetType type1, @NotNull JetType type2) {
+    private static boolean differentClasses(@NotNull JetType type1, @NotNull JetType type2) {
         DeclarationDescriptor declarationDescriptor1 = type1.getConstructor().getDeclarationDescriptor();
-        if (declarationDescriptor1 == null) return false; // No class, classes are not equal
+        if (declarationDescriptor1 == null) return true; // No class, classes are not equal
         DeclarationDescriptor declarationDescriptor2 = type2.getConstructor().getDeclarationDescriptor();
-        if (declarationDescriptor2 == null) return false; // Class of type1 is not null
-        return declarationDescriptor1.getOriginal().equals(declarationDescriptor2.getOriginal());
+        if (declarationDescriptor2 == null) return true; // Class of type1 is not null
+
+        if (declarationDescriptor1 instanceof TypeParameterDescriptor && declarationDescriptor2 instanceof TypeParameterDescriptor) {
+            // if type of value parameter is some generic parameter then their equality was checked by OverridingUtil before calling ExternalOverridabilityCondition
+            // Note that it's true unless we generate sam adapter for type parameter with SAM interface as upper bound:
+            // <K extends Runnable >void foo(K runnable) {}
+            return false;
+        }
+
+        return !declarationDescriptor1.getOriginal().equals(declarationDescriptor2.getOriginal());
     }
 
     // if function is or overrides declaration, returns null; otherwise, return original of sam adapter with substituted type parameters
diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/structure/impl/JavaAnnotationOwnerImpl.java b/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/structure/impl/JavaAnnotationOwnerImpl.java
index dab67466412..c13860e33d6 100644
--- a/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/structure/impl/JavaAnnotationOwnerImpl.java
+++ b/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/structure/impl/JavaAnnotationOwnerImpl.java
@@ -16,11 +16,11 @@
 
 package org.jetbrains.kotlin.load.java.structure.impl;
 
-import com.intellij.psi.PsiModifierListOwner;
-import org.jetbrains.annotations.NotNull;
+import com.intellij.psi.PsiAnnotationOwner;
+import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.load.java.structure.JavaAnnotationOwner;
 
 public interface JavaAnnotationOwnerImpl extends JavaAnnotationOwner {
-    @NotNull
-    PsiModifierListOwner getPsi();
+    @Nullable
+    PsiAnnotationOwner getAnnotationOwnerPsi();
 }
diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/structure/impl/JavaClassImpl.java b/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/structure/impl/JavaClassImpl.java
index 57db2aef037..d7f9e5d13dd 100644
--- a/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/structure/impl/JavaClassImpl.java
+++ b/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/structure/impl/JavaClassImpl.java
@@ -146,18 +146,6 @@ public class JavaClassImpl extends JavaClassifierImpl<PsiClass> implements JavaC
         return JavaElementUtil.getVisibility(this);
     }
 
-    @NotNull
-    @Override
-    public Collection<JavaAnnotation> getAnnotations() {
-        return JavaElementUtil.getAnnotations(this);
-    }
-
-    @Nullable
-    @Override
-    public JavaAnnotation findAnnotation(@NotNull FqName fqName) {
-        return JavaElementUtil.findAnnotation(this, fqName);
-    }
-
     @Override
     @NotNull
     public JavaClassifierType getDefaultType() {
diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/structure/impl/JavaClassifierImpl.java b/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/structure/impl/JavaClassifierImpl.java
index cbca1c0ecaf..2d43b64ab63 100644
--- a/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/structure/impl/JavaClassifierImpl.java
+++ b/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/structure/impl/JavaClassifierImpl.java
@@ -16,16 +16,28 @@
 
 package org.jetbrains.kotlin.load.java.structure.impl;
 
+import com.intellij.psi.PsiAnnotationOwner;
 import com.intellij.psi.PsiClass;
 import com.intellij.psi.PsiTypeParameter;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.jetbrains.kotlin.load.java.structure.JavaAnnotation;
 import org.jetbrains.kotlin.load.java.structure.JavaClassifier;
+import org.jetbrains.kotlin.name.FqName;
 
-public abstract class JavaClassifierImpl<Psi extends PsiClass> extends JavaElementImpl<Psi> implements JavaClassifier {
+import java.util.Collection;
+
+public abstract class JavaClassifierImpl<Psi extends PsiClass> extends JavaElementImpl<Psi> implements JavaClassifier, JavaAnnotationOwnerImpl {
     protected JavaClassifierImpl(@NotNull Psi psiClass) {
         super(psiClass);
     }
 
+    @Nullable
+    @Override
+    public PsiAnnotationOwner getAnnotationOwnerPsi() {
+        return getPsi().getModifierList();
+    }
+
     @NotNull
     /* package */ static JavaClassifier create(@NotNull PsiClass psiClass) {
         if (psiClass instanceof PsiTypeParameter) {
@@ -35,4 +47,16 @@ public abstract class JavaClassifierImpl<Psi extends PsiClass> extends JavaEleme
             return new JavaClassImpl(psiClass);
         }
     }
+
+    @NotNull
+    @Override
+    public Collection<JavaAnnotation> getAnnotations() {
+        return JavaElementUtil.getAnnotations(this);
+    }
+
+    @Nullable
+    @Override
+    public JavaAnnotation findAnnotation(@NotNull FqName fqName) {
+        return JavaElementUtil.findAnnotation(this, fqName);
+    }
 }
diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/structure/impl/JavaElementUtil.java b/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/structure/impl/JavaElementUtil.java
index 03c6cdc46d6..c0a225744c3 100644
--- a/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/structure/impl/JavaElementUtil.java
+++ b/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/structure/impl/JavaElementUtil.java
@@ -16,10 +16,7 @@
 
 package org.jetbrains.kotlin.load.java.structure.impl;
 
-import com.intellij.psi.PsiAnnotation;
-import com.intellij.psi.PsiModifier;
-import com.intellij.psi.PsiModifierList;
-import com.intellij.psi.PsiModifierListOwner;
+import com.intellij.psi.*;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.descriptors.Visibilities;
@@ -66,18 +63,18 @@ import static org.jetbrains.kotlin.load.java.structure.impl.JavaElementCollectio
 
     @NotNull
     public static Collection<JavaAnnotation> getAnnotations(@NotNull JavaAnnotationOwnerImpl owner) {
-        PsiModifierList modifierList = owner.getPsi().getModifierList();
-        if (modifierList != null) {
-            return annotations(modifierList.getAnnotations());
+        PsiAnnotationOwner annotationOwnerPsi = owner.getAnnotationOwnerPsi();
+        if (annotationOwnerPsi != null) {
+            return annotations(annotationOwnerPsi.getAnnotations());
         }
         return Collections.emptyList();
     }
 
     @Nullable
     public static JavaAnnotation findAnnotation(@NotNull JavaAnnotationOwnerImpl owner, @NotNull FqName fqName) {
-        PsiModifierList modifierList = owner.getPsi().getModifierList();
-        if (modifierList != null) {
-            PsiAnnotation psiAnnotation = modifierList.findAnnotation(fqName.asString());
+        PsiAnnotationOwner annotationOwnerPsi = owner.getAnnotationOwnerPsi();
+        if (annotationOwnerPsi != null) {
+            PsiAnnotation psiAnnotation = annotationOwnerPsi.findAnnotation(fqName.asString());
             return psiAnnotation == null ? null : new JavaAnnotationImpl(psiAnnotation);
         }
         return null;
diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/structure/impl/JavaMemberImpl.java b/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/structure/impl/JavaMemberImpl.java
index 03989fb0a0b..f730d42fc57 100644
--- a/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/structure/impl/JavaMemberImpl.java
+++ b/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/structure/impl/JavaMemberImpl.java
@@ -16,6 +16,7 @@
 
 package org.jetbrains.kotlin.load.java.structure.impl;
 
+import com.intellij.psi.PsiAnnotationOwner;
 import com.intellij.psi.PsiClass;
 import com.intellij.psi.PsiMember;
 import org.jetbrains.annotations.NotNull;
@@ -35,6 +36,12 @@ public abstract class JavaMemberImpl<Psi extends PsiMember> extends JavaElementI
         super(psiMember);
     }
 
+    @Nullable
+    @Override
+    public PsiAnnotationOwner getAnnotationOwnerPsi() {
+        return getPsi().getModifierList();
+    }
+
     @NotNull
     @Override
     public Name getName() {
diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/structure/impl/JavaMethodImpl.java b/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/structure/impl/JavaMethodImpl.java
index f3298b2e712..91927c71d3a 100644
--- a/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/structure/impl/JavaMethodImpl.java
+++ b/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/structure/impl/JavaMethodImpl.java
@@ -64,9 +64,10 @@ public class JavaMethodImpl extends JavaMemberImpl<PsiMethod> implements JavaMet
     }
 
     @Override
-    @Nullable
+    @NotNull
     public JavaType getReturnType() {
         PsiType psiType = getPsi().getReturnType();
-        return psiType == null ? null : JavaTypeImpl.create(psiType);
+        assert psiType != null : "Method is not a constructor and has no return type: " + getName();
+        return JavaTypeImpl.create(psiType);
     }
 }
diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/structure/impl/JavaPropertyInitializerEvaluatorImpl.java b/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/structure/impl/JavaPropertyInitializerEvaluatorImpl.java
deleted file mode 100644
index 09f05f5d778..00000000000
--- a/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/structure/impl/JavaPropertyInitializerEvaluatorImpl.java
+++ /dev/null
@@ -1,54 +0,0 @@
-/*
- * Copyright 2010-2015 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.kotlin.load.java.structure.impl;
-
-import com.intellij.psi.PsiExpression;
-import com.intellij.psi.impl.JavaConstantExpressionEvaluator;
-import com.intellij.psi.util.PsiUtil;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.descriptors.PropertyDescriptor;
-import org.jetbrains.kotlin.load.java.structure.JavaField;
-import org.jetbrains.kotlin.load.java.structure.JavaPropertyInitializerEvaluator;
-import org.jetbrains.kotlin.resolve.constants.CompileTimeConstant;
-import org.jetbrains.kotlin.resolve.constants.ConstantsPackage;
-import org.jetbrains.kotlin.resolve.constants.evaluate.ConstantExpressionEvaluator;
-
-public class JavaPropertyInitializerEvaluatorImpl implements JavaPropertyInitializerEvaluator {
-    @Nullable
-    @Override
-    public CompileTimeConstant<?> getInitializerConstant(@NotNull JavaField field, @NotNull PropertyDescriptor descriptor) {
-        PsiExpression initializer = ((JavaFieldImpl) field).getInitializer();
-        Object evaluatedExpression = JavaConstantExpressionEvaluator.computeConstantExpression(initializer, false);
-        if (evaluatedExpression != null) {
-            return ConstantsPackage.createCompileTimeConstant(
-                    evaluatedExpression,
-                    ConstantExpressionEvaluator.isPropertyCompileTimeConstant(descriptor),
-                    false,
-                    true,
-                    descriptor.getType());
-        }
-        return null;
-    }
-
-    @Override
-    public boolean isNotNullCompileTimeConstant(@NotNull JavaField field) {
-        // PsiUtil.isCompileTimeConstant returns false for null-initialized fields,
-        // see com.intellij.psi.util.IsConstantExpressionVisitor.visitLiteralExpression()
-        return PsiUtil.isCompileTimeConstant(((JavaFieldImpl) field).getPsi());
-    }
-}
diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/structure/impl/JavaPropertyInitializerEvaluatorImpl.kt b/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/structure/impl/JavaPropertyInitializerEvaluatorImpl.kt
new file mode 100644
index 00000000000..50229ad1676
--- /dev/null
+++ b/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/structure/impl/JavaPropertyInitializerEvaluatorImpl.kt
@@ -0,0 +1,50 @@
+/*
+ * Copyright 2010-2015 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.kotlin.load.java.structure.impl
+
+import com.intellij.psi.impl.JavaConstantExpressionEvaluator
+import com.intellij.psi.util.PsiUtil
+import org.jetbrains.kotlin.descriptors.PropertyDescriptor
+import org.jetbrains.kotlin.load.java.structure.JavaField
+import org.jetbrains.kotlin.load.java.structure.JavaPropertyInitializerEvaluator
+import org.jetbrains.kotlin.resolve.constants.ConstantValue
+import org.jetbrains.kotlin.resolve.constants.ConstantValueFactory
+import org.jetbrains.kotlin.resolve.descriptorUtil.builtIns
+
+public class JavaPropertyInitializerEvaluatorImpl : JavaPropertyInitializerEvaluator {
+    override fun getInitializerConstant(field: JavaField, descriptor: PropertyDescriptor): ConstantValue<*>? {
+        val initializer = (field as JavaFieldImpl).getInitializer()
+        val evaluated = JavaConstantExpressionEvaluator.computeConstantExpression(initializer, false) ?: return null
+        val factory = ConstantValueFactory(descriptor.builtIns)
+        when (evaluated) {
+            //Note: evaluated expression may be of class that does not match field type in some cases
+            // tested for Int, left other checks just in case
+            is Byte, is Short, is Int, is Long -> {
+                return factory.createIntegerConstantValue((evaluated as Number).toLong(), descriptor.getType())
+            }
+            else -> {
+                return factory.createConstantValue(evaluated)
+            }
+        }
+    }
+
+    override fun isNotNullCompileTimeConstant(field: JavaField): Boolean {
+        // PsiUtil.isCompileTimeConstant returns false for null-initialized fields,
+        // see com.intellij.psi.util.IsConstantExpressionVisitor.visitLiteralExpression()
+        return PsiUtil.isCompileTimeConstant((field as JavaFieldImpl).getPsi())
+    }
+}
diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/structure/impl/JavaTypeImpl.java b/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/structure/impl/JavaTypeImpl.java
index 1b55598c529..e2874bafc5a 100644
--- a/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/structure/impl/JavaTypeImpl.java
+++ b/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/structure/impl/JavaTypeImpl.java
@@ -19,10 +19,14 @@ package org.jetbrains.kotlin.load.java.structure.impl;
 import com.intellij.psi.*;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
+import org.jetbrains.kotlin.load.java.structure.JavaAnnotation;
 import org.jetbrains.kotlin.load.java.structure.JavaArrayType;
 import org.jetbrains.kotlin.load.java.structure.JavaType;
+import org.jetbrains.kotlin.name.FqName;
 
-public abstract class JavaTypeImpl<Psi extends PsiType> implements JavaType {
+import java.util.Collection;
+
+public abstract class JavaTypeImpl<Psi extends PsiType> implements JavaType, JavaAnnotationOwnerImpl {
     private final Psi psiType;
 
     public JavaTypeImpl(@NotNull Psi psiType) {
@@ -34,6 +38,12 @@ public abstract class JavaTypeImpl<Psi extends PsiType> implements JavaType {
         return psiType;
     }
 
+    @Nullable
+    @Override
+    public PsiAnnotationOwner getAnnotationOwnerPsi() {
+        return getPsi();
+    }
+
     @NotNull
     public static JavaTypeImpl<?> create(@NotNull PsiType psiType) {
         return psiType.accept(new PsiTypeVisitor<JavaTypeImpl<?>>() {
@@ -75,6 +85,19 @@ public abstract class JavaTypeImpl<Psi extends PsiType> implements JavaType {
         return new JavaArrayTypeImpl(getPsi().createArrayType());
     }
 
+    @NotNull
+    @Override
+    public Collection<JavaAnnotation> getAnnotations() {
+        return JavaElementUtil.getAnnotations(this);
+    }
+
+    @Nullable
+    @Override
+    public JavaAnnotation findAnnotation(@NotNull FqName fqName) {
+        return JavaElementUtil.findAnnotation(this, fqName);
+    }
+
+
     @Override
     public int hashCode() {
         return getPsi().hashCode();
diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/structure/impl/JavaValueParameterImpl.java b/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/structure/impl/JavaValueParameterImpl.java
index d54774cbed4..d8a03f5ad37 100644
--- a/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/structure/impl/JavaValueParameterImpl.java
+++ b/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/structure/impl/JavaValueParameterImpl.java
@@ -16,10 +16,13 @@
 
 package org.jetbrains.kotlin.load.java.structure.impl;
 
+import com.intellij.psi.PsiAnnotationOwner;
 import com.intellij.psi.PsiParameter;
 import com.intellij.psi.impl.compiled.ClsParameterImpl;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
+import org.jetbrains.kotlin.descriptors.Visibilities;
+import org.jetbrains.kotlin.descriptors.Visibility;
 import org.jetbrains.kotlin.load.java.structure.JavaAnnotation;
 import org.jetbrains.kotlin.load.java.structure.JavaType;
 import org.jetbrains.kotlin.load.java.structure.JavaValueParameter;
@@ -28,11 +31,39 @@ import org.jetbrains.kotlin.name.Name;
 
 import java.util.Collection;
 
-public class JavaValueParameterImpl extends JavaElementImpl<PsiParameter> implements JavaValueParameter, JavaAnnotationOwnerImpl {
+public class JavaValueParameterImpl extends JavaElementImpl<PsiParameter>
+        implements JavaValueParameter, JavaAnnotationOwnerImpl, JavaModifierListOwnerImpl {
     public JavaValueParameterImpl(@NotNull PsiParameter psiParameter) {
         super(psiParameter);
     }
 
+    @Nullable
+    @Override
+    public PsiAnnotationOwner getAnnotationOwnerPsi() {
+        return getPsi().getModifierList();
+    }
+
+    @Override
+    public boolean isAbstract() {
+        return false;
+    }
+
+    @Override
+    public boolean isStatic() {
+        return false;
+    }
+
+    @Override
+    public boolean isFinal() {
+        return false;
+    }
+
+    @NotNull
+    @Override
+    public Visibility getVisibility() {
+        return Visibilities.LOCAL;
+    }
+
     @NotNull
     @Override
     public Collection<JavaAnnotation> getAnnotations() {
diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/load/kotlin/JavaAnnotationCallChecker.kt b/compiler/frontend.java/src/org/jetbrains/kotlin/load/kotlin/JavaAnnotationCallChecker.kt
index 94eb2fafe8f..63ffc596c59 100644
--- a/compiler/frontend.java/src/org/jetbrains/kotlin/load/kotlin/JavaAnnotationCallChecker.kt
+++ b/compiler/frontend.java/src/org/jetbrains/kotlin/load/kotlin/JavaAnnotationCallChecker.kt
@@ -61,7 +61,7 @@ public class JavaAnnotationCallChecker : CallChecker {
             if (it.getArgumentExpression() != null) {
                 context.trace.report(
                         diagnostic.on(
-                                it.getArgumentExpression()
+                                it.getArgumentExpression()!!
                         )
                 )
             }
diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/load/kotlin/KotlinJvmCheckerProvider.kt b/compiler/frontend.java/src/org/jetbrains/kotlin/load/kotlin/KotlinJvmCheckerProvider.kt
index 63d278bb1ee..4b61deb32b2 100644
--- a/compiler/frontend.java/src/org/jetbrains/kotlin/load/kotlin/KotlinJvmCheckerProvider.kt
+++ b/compiler/frontend.java/src/org/jetbrains/kotlin/load/kotlin/KotlinJvmCheckerProvider.kt
@@ -20,16 +20,15 @@ import org.jetbrains.kotlin.cfg.WhenChecker
 import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.diagnostics.DiagnosticSink
 import org.jetbrains.kotlin.diagnostics.Errors
+import org.jetbrains.kotlin.jvm.RuntimeAssertionsTypeChecker
 import org.jetbrains.kotlin.lexer.JetTokens
 import org.jetbrains.kotlin.load.java.lazy.types.isMarkedNotNull
 import org.jetbrains.kotlin.load.java.lazy.types.isMarkedNullable
 import org.jetbrains.kotlin.load.kotlin.nativeDeclarations.NativeFunChecker
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.psi.*
-import org.jetbrains.kotlin.resolve.AdditionalCheckerProvider
-import org.jetbrains.kotlin.resolve.DeclarationChecker
-import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils
-import org.jetbrains.kotlin.resolve.DescriptorUtils
+import org.jetbrains.kotlin.resolve.*
+import org.jetbrains.kotlin.resolve.annotations.findPublicFieldAnnotation
 import org.jetbrains.kotlin.resolve.annotations.hasInlineAnnotation
 import org.jetbrains.kotlin.resolve.annotations.hasIntrinsicAnnotation
 import org.jetbrains.kotlin.resolve.annotations.hasPlatformStaticAnnotation
@@ -41,6 +40,7 @@ import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowValue
 import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowValueFactory
 import org.jetbrains.kotlin.resolve.calls.smartcasts.Nullability
 import org.jetbrains.kotlin.resolve.jvm.calls.checkers.NeedSyntheticChecker
+import org.jetbrains.kotlin.resolve.jvm.calls.checkers.ReflectionAPICallChecker
 import org.jetbrains.kotlin.resolve.jvm.calls.checkers.TraitDefaultMethodCallChecker
 import org.jetbrains.kotlin.resolve.jvm.diagnostics.ErrorsJvm
 import org.jetbrains.kotlin.resolve.jvm.diagnostics.ErrorsJvm.NullabilityInformationSource
@@ -52,23 +52,29 @@ import org.jetbrains.kotlin.types.expressions.SenselessComparisonChecker
 import org.jetbrains.kotlin.types.flexibility
 import org.jetbrains.kotlin.types.isFlexible
 
-public object KotlinJvmCheckerProvider : AdditionalCheckerProvider(
+public class KotlinJvmCheckerProvider(private val module: ModuleDescriptor) : AdditionalCheckerProvider(
         additionalDeclarationCheckers = listOf(PlatformStaticAnnotationChecker(),
                                                LocalFunInlineChecker(),
                                                ReifiedTypeParameterAnnotationChecker(),
                                                NativeFunChecker(),
-                                               OverloadsAnnotationChecker()),
+                                               OverloadsAnnotationChecker(),
+                                               PublicFieldAnnotationChecker()),
 
         additionalCallCheckers = listOf(NeedSyntheticChecker(), JavaAnnotationCallChecker(),
-                                        JavaAnnotationMethodCallChecker(), TraitDefaultMethodCallChecker()),
+                                        JavaAnnotationMethodCallChecker(), TraitDefaultMethodCallChecker(),
+                                        ReflectionAPICallChecker(module)),
 
-        additionalTypeCheckers = listOf(JavaNullabilityWarningsChecker()),
+        additionalTypeCheckers = listOf(JavaNullabilityWarningsChecker(), RuntimeAssertionsTypeChecker),
         additionalSymbolUsageValidators = listOf()
 )
 
 public class LocalFunInlineChecker : DeclarationChecker {
 
-    override fun check(declaration: JetDeclaration, descriptor: DeclarationDescriptor, diagnosticHolder: DiagnosticSink) {
+    override fun check(
+            declaration: JetDeclaration,
+            descriptor: DeclarationDescriptor,
+            diagnosticHolder: DiagnosticSink,
+            bindingContext: BindingContext) {
         if (descriptor.hasInlineAnnotation() &&
             declaration is JetNamedFunction &&
             descriptor is FunctionDescriptor &&
@@ -80,7 +86,12 @@ public class LocalFunInlineChecker : DeclarationChecker {
 
 public class PlatformStaticAnnotationChecker : DeclarationChecker {
 
-    override fun check(declaration: JetDeclaration, descriptor: DeclarationDescriptor, diagnosticHolder: DiagnosticSink) {
+    override fun check(
+            declaration: JetDeclaration,
+            descriptor: DeclarationDescriptor,
+            diagnosticHolder: DiagnosticSink,
+            bindingContext: BindingContext
+    ) {
         if (descriptor.hasPlatformStaticAnnotation()) {
             if (declaration is JetNamedFunction || declaration is JetProperty || declaration is JetPropertyAccessor) {
                 checkDeclaration(declaration, descriptor, diagnosticHolder)
@@ -119,7 +130,12 @@ public class PlatformStaticAnnotationChecker : DeclarationChecker {
 }
 
 public class OverloadsAnnotationChecker: DeclarationChecker {
-    override fun check(declaration: JetDeclaration, descriptor: DeclarationDescriptor, diagnosticHolder: DiagnosticSink) {
+    override fun check(
+            declaration: JetDeclaration,
+            descriptor: DeclarationDescriptor,
+            diagnosticHolder: DiagnosticSink,
+            bindingContext: BindingContext
+    ) {
         if (descriptor.getAnnotations().findAnnotation(FqName("kotlin.jvm.jvmOverloads")) != null) {
             checkDeclaration(declaration, descriptor, diagnosticHolder)
         }
@@ -142,9 +158,37 @@ public class OverloadsAnnotationChecker: DeclarationChecker {
     }
 }
 
+public class PublicFieldAnnotationChecker: DeclarationChecker {
+    override fun check(
+            declaration: JetDeclaration,
+            descriptor: DeclarationDescriptor,
+            diagnosticHolder: DiagnosticSink,
+            bindingContext: BindingContext
+    ) {
+        val annotation = descriptor.findPublicFieldAnnotation() ?: return
+
+        fun report() {
+            val annotationEntry = bindingContext.get(BindingContext.ANNOTATION_DESCRIPTOR_TO_PSI_ELEMENT, annotation) ?: return
+            diagnosticHolder.report(ErrorsJvm.INAPPLICABLE_PUBLIC_FIELD.on(annotationEntry))
+        }
+
+        if (descriptor !is PropertyDescriptor) {
+            report()
+        }
+        else if (!bindingContext.get<PropertyDescriptor, Boolean>(BindingContext.BACKING_FIELD_REQUIRED, descriptor)!!) {
+            report()
+        }
+    }
+}
+
 public class ReifiedTypeParameterAnnotationChecker : DeclarationChecker {
 
-    override fun check(declaration: JetDeclaration, descriptor: DeclarationDescriptor, diagnosticHolder: DiagnosticSink) {
+    override fun check(
+            declaration: JetDeclaration,
+            descriptor: DeclarationDescriptor,
+            diagnosticHolder: DiagnosticSink,
+            bindingContext: BindingContext
+    ) {
         if (descriptor.hasIntrinsicAnnotation()) return
 
         if (descriptor is CallableDescriptor && !descriptor.hasInlineAnnotation()) {
@@ -176,12 +220,18 @@ private fun checkTypeParameterDescriptorsAreNotReified(
 public class JavaNullabilityWarningsChecker : AdditionalTypeChecker {
     private fun JetType.mayBeNull(): NullabilityInformationSource? {
         if (!isError() && !isFlexible() && TypeUtils.isNullableType(this)) return NullabilityInformationSource.KOTLIN
+
+        if (isFlexible() && TypeUtils.isNullableType(flexibility().lowerBound)) return NullabilityInformationSource.KOTLIN
+
         if (getAnnotations().isMarkedNullable()) return NullabilityInformationSource.JAVA
         return null
     }
 
     private fun JetType.mustNotBeNull(): NullabilityInformationSource? {
         if (!isError() && !isFlexible() && !TypeUtils.isNullableType(this)) return NullabilityInformationSource.KOTLIN
+
+        if (isFlexible() && !TypeUtils.isNullableType(flexibility().upperBound)) return NullabilityInformationSource.KOTLIN
+
         if (!isMarkedNullable() && getAnnotations().isMarkedNotNull()) return NullabilityInformationSource.JAVA
         return null
     }
@@ -254,7 +304,7 @@ public class JavaNullabilityWarningsChecker : AdditionalTypeChecker {
                         val baseExpression = expression.getLeft()
                         val baseExpressionType = baseExpression?.let{ c.trace.getType(it) } ?: return
                         doIfNotNull(
-                                DataFlowValueFactory.createDataFlowValue(baseExpression, baseExpressionType, c),
+                                DataFlowValueFactory.createDataFlowValue(baseExpression!!, baseExpressionType, c),
                                 c
                         ) {
                             c.trace.report(Errors.USELESS_ELVIS.on(expression, baseExpressionType))
@@ -317,7 +367,7 @@ public class JavaNullabilityWarningsChecker : AdditionalTypeChecker {
         }
         else {
             doIfNotNull(dataFlowValue, c) {
-                c.trace.report(Errors.UNNECESSARY_SAFE_CALL.on(c.call.getCallOperationNode().getPsi(), receiverArgument.getType()))
+                c.trace.report(Errors.UNNECESSARY_SAFE_CALL.on(c.call.getCallOperationNode()!!.getPsi(), receiverArgument.getType()))
             }
         }
     }
diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/load/kotlin/VirtualFileKotlinClass.kt b/compiler/frontend.java/src/org/jetbrains/kotlin/load/kotlin/VirtualFileKotlinClass.kt
index ea3226f0f8a..81cb027b552 100644
--- a/compiler/frontend.java/src/org/jetbrains/kotlin/load/kotlin/VirtualFileKotlinClass.kt
+++ b/compiler/frontend.java/src/org/jetbrains/kotlin/load/kotlin/VirtualFileKotlinClass.kt
@@ -51,7 +51,7 @@ public class VirtualFileKotlinClass private constructor(
 
     companion object Factory {
         private val LOG = Logger.getInstance(javaClass<VirtualFileKotlinClass>())
-        private val perfCounter = PerformanceCounter("Binary class from Kotlin file")
+        private val perfCounter = PerformanceCounter.create("Binary class from Kotlin file")
 
         deprecated("Use KotlinBinaryClassCache")
         fun create(file: VirtualFile): VirtualFileKotlinClass? {
diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/load/kotlin/native.kt b/compiler/frontend.java/src/org/jetbrains/kotlin/load/kotlin/native.kt
index 38b2d42bd8a..0a71b4aa01e 100644
--- a/compiler/frontend.java/src/org/jetbrains/kotlin/load/kotlin/native.kt
+++ b/compiler/frontend.java/src/org/jetbrains/kotlin/load/kotlin/native.kt
@@ -28,6 +28,7 @@ import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.diagnostics.Errors
 import org.jetbrains.kotlin.resolve.jvm.diagnostics.ErrorsJvm
 import org.jetbrains.kotlin.psi.JetDeclarationWithBody
+import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.annotations.hasInlineAnnotation
 import org.jetbrains.kotlin.resolve.diagnostics.SuppressDiagnosticsByAnnotations
 import org.jetbrains.kotlin.resolve.diagnostics.FUNCTION_NO_BODY_ERRORS
@@ -41,7 +42,12 @@ public fun DeclarationDescriptor.hasNativeAnnotation(): Boolean {
 public class SuppressNoBodyErrorsForNativeDeclarations : SuppressDiagnosticsByAnnotations(FUNCTION_NO_BODY_ERRORS, NATIVE_ANNOTATION_CLASS_NAME)
 
 public class NativeFunChecker : DeclarationChecker {
-    override fun check(declaration: JetDeclaration, descriptor: DeclarationDescriptor, diagnosticHolder: DiagnosticSink) {
+    override fun check(
+            declaration: JetDeclaration,
+            descriptor: DeclarationDescriptor,
+            diagnosticHolder: DiagnosticSink,
+            bindingContext: BindingContext
+    ) {
         if (!descriptor.hasNativeAnnotation()) return
 
         if (DescriptorUtils.isTrait(descriptor.getContainingDeclaration())) {
diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/AsmTypes.java b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/AsmTypes.java
index 45aa7eed070..ea288900c2c 100644
--- a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/AsmTypes.java
+++ b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/AsmTypes.java
@@ -36,23 +36,22 @@ public class AsmTypes {
 
     public static final Type LAMBDA = Type.getObjectType("kotlin/jvm/internal/Lambda");
     public static final Type FUNCTION_REFERENCE = Type.getObjectType("kotlin/jvm/internal/FunctionReference");
+    public static final Type PROPERTY_REFERENCE0 = Type.getObjectType("kotlin/jvm/internal/PropertyReference0");
+    public static final Type PROPERTY_REFERENCE1 = Type.getObjectType("kotlin/jvm/internal/PropertyReference1");
+    public static final Type MUTABLE_PROPERTY_REFERENCE0 = Type.getObjectType("kotlin/jvm/internal/MutablePropertyReference0");
+    public static final Type MUTABLE_PROPERTY_REFERENCE1 = Type.getObjectType("kotlin/jvm/internal/MutablePropertyReference1");
 
     public static final Type K_CLASS_TYPE = reflect("KClass");
     public static final Type K_CLASS_ARRAY_TYPE = Type.getObjectType("[" + K_CLASS_TYPE.getDescriptor());
     public static final Type K_PACKAGE_TYPE = reflect("KPackage");
+    public static final Type K_DECLARATION_CONTAINER_TYPE = reflect("KDeclarationContainer");
 
     public static final Type K_FUNCTION = reflect("KFunction");
-    public static final Type K_TOP_LEVEL_FUNCTION = reflect("KTopLevelFunction");
-    public static final Type K_MEMBER_FUNCTION = reflect("KMemberFunction");
-    public static final Type K_TOP_LEVEL_EXTENSION_FUNCTION = reflect("KTopLevelExtensionFunction");
-    public static final Type K_LOCAL_FUNCTION = reflect("KLocalFunction");
 
-    public static final Type K_MEMBER_PROPERTY_TYPE = reflect("KMemberProperty");
-    public static final Type K_MUTABLE_MEMBER_PROPERTY_TYPE = reflect("KMutableMemberProperty");
-    public static final Type K_TOP_LEVEL_VARIABLE_TYPE = reflect("KTopLevelVariable");
-    public static final Type K_MUTABLE_TOP_LEVEL_VARIABLE_TYPE = reflect("KMutableTopLevelVariable");
-    public static final Type K_TOP_LEVEL_EXTENSION_PROPERTY_TYPE = reflect("KTopLevelExtensionProperty");
-    public static final Type K_MUTABLE_TOP_LEVEL_EXTENSION_PROPERTY_TYPE = reflect("KMutableTopLevelExtensionProperty");
+    public static final Type K_PROPERTY0_TYPE = reflect("KProperty0");
+    public static final Type K_PROPERTY1_TYPE = reflect("KProperty1");
+    public static final Type K_MUTABLE_PROPERTY0_TYPE = reflect("KMutableProperty0");
+    public static final Type K_MUTABLE_PROPERTY1_TYPE = reflect("KMutableProperty1");
 
     public static final String REFLECTION = "kotlin/jvm/internal/Reflection";
 
diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/TopDownAnalyzerFacadeForJVM.java b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/TopDownAnalyzerFacadeForJVM.java
index 03ea6fa532e..6fcc7b68219 100644
--- a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/TopDownAnalyzerFacadeForJVM.java
+++ b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/TopDownAnalyzerFacadeForJVM.java
@@ -58,6 +58,7 @@ public enum TopDownAnalyzerFacadeForJVM {
         List<ImportPath> list = new ArrayList<ImportPath>();
         list.add(new ImportPath("java.lang.*"));
         list.add(new ImportPath("kotlin.*"));
+        list.add(new ImportPath("kotlin.annotation.*"));
         list.add(new ImportPath("kotlin.jvm.*"));
         list.add(new ImportPath("kotlin.io.*"));
         // all classes from package "kotlin" mapped to java classes are imported explicitly so that they take priority over classes from java.lang
diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/calls/checkers/ReflectionAPICallChecker.kt b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/calls/checkers/ReflectionAPICallChecker.kt
new file mode 100644
index 00000000000..ad12ca997b4
--- /dev/null
+++ b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/calls/checkers/ReflectionAPICallChecker.kt
@@ -0,0 +1,70 @@
+/*
+ * Copyright 2010-2015 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.kotlin.resolve.jvm.calls.checkers
+
+import org.jetbrains.kotlin.builtins.KOTLIN_REFLECT_FQ_NAME
+import org.jetbrains.kotlin.builtins.ReflectionTypes
+import org.jetbrains.kotlin.descriptors.CallableDescriptor
+import org.jetbrains.kotlin.descriptors.ClassDescriptor
+import org.jetbrains.kotlin.descriptors.ModuleDescriptor
+import org.jetbrains.kotlin.descriptors.PackageFragmentDescriptor
+import org.jetbrains.kotlin.load.java.JvmAbi
+import org.jetbrains.kotlin.resolve.DescriptorUtils
+import org.jetbrains.kotlin.resolve.calls.checkers.CallChecker
+import org.jetbrains.kotlin.resolve.calls.context.BasicCallResolutionContext
+import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall
+import org.jetbrains.kotlin.resolve.jvm.diagnostics.ErrorsJvm.NO_REFLECTION_IN_CLASS_PATH
+import org.jetbrains.kotlin.serialization.deserialization.findClassAcrossModuleDependencies
+import org.jetbrains.kotlin.types.expressions.OperatorConventions
+import kotlin.reflect.jvm.java
+
+/**
+ * If there's no Kotlin reflection implementation found in the classpath, checks that there are no usages
+ * of reflection API which will fail at runtime.
+ */
+class ReflectionAPICallChecker(private val module: ModuleDescriptor) : CallChecker {
+    private val isReflectionAvailable by lazy {
+        module.findClassAcrossModuleDependencies(JvmAbi.REFLECTION_FACTORY_IMPL) != null
+    }
+
+    private val kPropertyClasses by lazy {
+        val reflectionTypes = ReflectionTypes(module)
+        setOf(reflectionTypes.kProperty0, reflectionTypes.kProperty1, reflectionTypes.kProperty2)
+    }
+
+    override fun <F : CallableDescriptor> check(resolvedCall: ResolvedCall<F>, context: BasicCallResolutionContext) {
+        if (isReflectionAvailable) return
+
+        val descriptor = resolvedCall.getResultingDescriptor()
+        val containingClass = descriptor.getContainingDeclaration() as? ClassDescriptor ?: return
+        if (!ReflectionTypes.isReflectionClass(containingClass)) return
+
+        // Skip some symbols which are supposed to work fine without kotlin-reflect.jar:
+        // - 'name' on anything
+        // - 'invoke' on functions (or on anything else for that matter)
+        // - 'get'/'set' on properties
+        val name = descriptor.getName()
+        when {
+            name == OperatorConventions.INVOKE -> return
+            name.asString() == "name" -> return
+            (name.asString() == "get" || name.asString() == "set") &&
+            kPropertyClasses.any { kProperty -> DescriptorUtils.isSubclass(containingClass, kProperty) } -> return
+        }
+
+        context.trace.report(NO_REFLECTION_IN_CLASS_PATH.on(resolvedCall.getCall().getCallElement()))
+    }
+}
diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/calls/checkers/TraitDefaultMethodCallChecker.kt b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/calls/checkers/TraitDefaultMethodCallChecker.kt
index bb556a97549..647447207fe 100644
--- a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/calls/checkers/TraitDefaultMethodCallChecker.kt
+++ b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/calls/checkers/TraitDefaultMethodCallChecker.kt
@@ -22,7 +22,7 @@ import org.jetbrains.kotlin.descriptors.ClassifierDescriptor
 import org.jetbrains.kotlin.load.java.descriptors.JavaClassDescriptor
 import org.jetbrains.kotlin.psi.JetExpression
 import org.jetbrains.kotlin.resolve.DescriptorUtils
-import org.jetbrains.kotlin.resolve.calls.CallResolverUtil
+import org.jetbrains.kotlin.resolve.calls.callResolverUtil.getSuperCallExpression
 import org.jetbrains.kotlin.resolve.calls.checkers.CallChecker
 import org.jetbrains.kotlin.resolve.calls.context.BasicCallResolutionContext
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall
@@ -31,8 +31,7 @@ import org.jetbrains.kotlin.resolve.jvm.diagnostics.ErrorsJvm
 public class TraitDefaultMethodCallChecker : CallChecker {
 
     override fun <F : CallableDescriptor> check(resolvedCall: ResolvedCall<F>, context: BasicCallResolutionContext) {
-        val jetSuperExpression = CallResolverUtil.getSuperCallExpression(resolvedCall.getCall())
-        if (jetSuperExpression == null) return
+        if (getSuperCallExpression(resolvedCall.getCall()) == null) return
 
         val targetDescriptor = resolvedCall.getResultingDescriptor().getOriginal()
         val containerDescriptor = targetDescriptor.getContainingDeclaration()
diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/diagnostics/DefaultErrorMessagesJvm.java b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/diagnostics/DefaultErrorMessagesJvm.java
index 8a96d821c42..c5c2d84881e 100644
--- a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/diagnostics/DefaultErrorMessagesJvm.java
+++ b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/diagnostics/DefaultErrorMessagesJvm.java
@@ -59,8 +59,8 @@ public class DefaultErrorMessagesJvm implements DefaultErrorMessages.Extension {
         MAP.put(ErrorsJvm.POSITIONED_VALUE_ARGUMENT_FOR_JAVA_ANNOTATION, "Only named arguments are available for Java annotations");
         MAP.put(ErrorsJvm.DEPRECATED_ANNOTATION_METHOD_CALL, "Annotation methods are deprecated. Use property instead");
 
-        MAP.put(ErrorsJvm.NO_REFLECTION_IN_CLASS_PATH, "Expression ''{0}'' uses reflection which is not found in compilation classpath. " +
-                                                       "Make sure you have kotlin-reflect.jar in the classpath", Renderers.ELEMENT_TEXT);
+        MAP.put(ErrorsJvm.NO_REFLECTION_IN_CLASS_PATH, "Call uses reflection API which is not found in compilation classpath. " +
+                                                       "Make sure you have kotlin-reflect.jar in the classpath");
 
         MAP.put(ErrorsJvm.NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS,
                 "Expected type does not accept nulls in {0}, but the value may be null in {1}", Renderers.TO_STRING, Renderers.TO_STRING);
@@ -68,6 +68,8 @@ public class DefaultErrorMessagesJvm implements DefaultErrorMessages.Extension {
         MAP.put(ErrorsJvm.TRAIT_CANT_CALL_DEFAULT_METHOD_VIA_SUPER, "Interfaces can't call Java default methods via super");
 
         MAP.put(ErrorsJvm.WHEN_ENUM_CAN_BE_NULL_IN_JAVA, "Enum argument can be null in Java, but exhaustive when contains no null branch");
+
+        MAP.put(ErrorsJvm.INAPPLICABLE_PUBLIC_FIELD, "publicField annotation is not applicable to this declaration");
     }
 
     @NotNull
diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/diagnostics/ErrorsJvm.java b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/diagnostics/ErrorsJvm.java
index 3e16df39687..1c59989e593 100644
--- a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/diagnostics/ErrorsJvm.java
+++ b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/diagnostics/ErrorsJvm.java
@@ -56,8 +56,9 @@ public interface ErrorsJvm {
 
     DiagnosticFactory0<JetElement> TRAIT_CANT_CALL_DEFAULT_METHOD_VIA_SUPER = DiagnosticFactory0.create(ERROR);
 
-    // TODO: make this a warning
-    DiagnosticFactory1<JetExpression, JetExpression> NO_REFLECTION_IN_CLASS_PATH = DiagnosticFactory1.create(ERROR);
+    DiagnosticFactory0<JetElement> INAPPLICABLE_PUBLIC_FIELD = DiagnosticFactory0.create(ERROR);
+
+    DiagnosticFactory0<JetElement> NO_REFLECTION_IN_CLASS_PATH = DiagnosticFactory0.create(WARNING);
 
     enum NullabilityInformationSource {
         KOTLIN {
diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/kotlinSignature/SignaturesPropagationData.java b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/kotlinSignature/SignaturesPropagationData.java
index ab1fe1d5c54..510ae307971 100644
--- a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/kotlinSignature/SignaturesPropagationData.java
+++ b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/kotlinSignature/SignaturesPropagationData.java
@@ -158,12 +158,13 @@ public class SignaturesPropagationData {
         if (JvmPackage.getPLATFORM_TYPES()) return autoType;
 
         List<TypeAndVariance> typesFromSuperMethods = ContainerUtil.map(superFunctions,
-                new Function<FunctionDescriptor, TypeAndVariance>() {
-                    @Override
-                    public TypeAndVariance fun(FunctionDescriptor superFunction) {
-                        return new TypeAndVariance(superFunction.getReturnType(), Variance.OUT_VARIANCE);
-                    }
-                });
+                                                                        new Function<FunctionDescriptor, TypeAndVariance>() {
+                                                                            @Override
+                                                                            public TypeAndVariance fun(FunctionDescriptor superFunction) {
+                                                                                return new TypeAndVariance(superFunction.getReturnType(),
+                                                                                                           Variance.OUT_VARIANCE);
+                                                                            }
+                                                                        });
 
         return modifyTypeAccordingToSuperMethods(autoType, typesFromSuperMethods, MEMBER_SIGNATURE_COVARIANT);
     }
@@ -629,10 +630,10 @@ public class SignaturesPropagationData {
             if (classifierFromSuper instanceof ClassDescriptor) {
                 ClassDescriptor classFromSuper = (ClassDescriptor) classifierFromSuper;
 
-                if (JavaToKotlinClassMap.INSTANCE.isMutableCollection(classFromSuper)) {
+                if (JavaToKotlinClassMap.INSTANCE.isMutable(classFromSuper)) {
                     someSupersMutable = true;
                 }
-                else if (JavaToKotlinClassMap.INSTANCE.isReadOnlyCollection(classFromSuper)) {
+                else if (JavaToKotlinClassMap.INSTANCE.isReadOnly(classFromSuper)) {
                     if (typeFromSuper.varianceOfPosition == Variance.OUT_VARIANCE) {
                         someSupersCovariantReadOnly = true;
                     }
@@ -648,12 +649,12 @@ public class SignaturesPropagationData {
             return classifier;
         }
         else if (someSupersMutable) {
-            if (JavaToKotlinClassMap.INSTANCE.isReadOnlyCollection(klass)) {
+            if (JavaToKotlinClassMap.INSTANCE.isReadOnly(klass)) {
                 return JavaToKotlinClassMap.INSTANCE.convertReadOnlyToMutable(klass);
             }
         }
         else if (someSupersNotCovariantReadOnly || someSupersCovariantReadOnly) {
-            if (JavaToKotlinClassMap.INSTANCE.isMutableCollection(klass)) {
+            if (JavaToKotlinClassMap.INSTANCE.isMutable(klass)) {
                 return JavaToKotlinClassMap.INSTANCE.convertMutableToReadOnly(klass);
             }
         }
diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/synthetic/JavaSyntheticExtensionsScope.kt b/compiler/frontend.java/src/org/jetbrains/kotlin/synthetic/JavaSyntheticExtensionsScope.kt
new file mode 100644
index 00000000000..91cc5e7d961
--- /dev/null
+++ b/compiler/frontend.java/src/org/jetbrains/kotlin/synthetic/JavaSyntheticExtensionsScope.kt
@@ -0,0 +1,308 @@
+/*
+ * Copyright 2010-2015 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.kotlin.synthetic
+
+import com.intellij.util.SmartList
+import org.jetbrains.kotlin.descriptors.*
+import org.jetbrains.kotlin.descriptors.annotations.Annotations
+import org.jetbrains.kotlin.descriptors.impl.PropertyDescriptorImpl
+import org.jetbrains.kotlin.descriptors.impl.PropertyGetterDescriptorImpl
+import org.jetbrains.kotlin.descriptors.impl.PropertySetterDescriptorImpl
+import org.jetbrains.kotlin.load.java.descriptors.JavaClassDescriptor
+import org.jetbrains.kotlin.name.Name
+import org.jetbrains.kotlin.psi.JetFile
+import org.jetbrains.kotlin.resolve.DescriptorUtils
+import org.jetbrains.kotlin.resolve.lazy.FileScopeProvider
+import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter
+import org.jetbrains.kotlin.resolve.scopes.JetScope
+import org.jetbrains.kotlin.storage.StorageManager
+import org.jetbrains.kotlin.types.*
+import org.jetbrains.kotlin.types.typeUtil.isBoolean
+import org.jetbrains.kotlin.types.typeUtil.isSubtypeOf
+import org.jetbrains.kotlin.types.typeUtil.isUnit
+import org.jetbrains.kotlin.types.typeUtil.makeNotNullable
+import org.jetbrains.kotlin.util.capitalizeDecapitalize.capitalizeFirstWord
+import org.jetbrains.kotlin.util.capitalizeDecapitalize.decapitalizeSmart
+import org.jetbrains.kotlin.utils.addIfNotNull
+import java.util.ArrayList
+import java.util.HashSet
+
+interface SyntheticJavaPropertyDescriptor : PropertyDescriptor {
+    val getMethod: FunctionDescriptor
+    val setMethod: FunctionDescriptor?
+
+    companion object {
+        fun findByGetterOrSetter(getterOrSetter: FunctionDescriptor, resolutionScope: JetScope): SyntheticJavaPropertyDescriptor? {
+            val name = getterOrSetter.getName()
+            if (name.isSpecial()) return null
+            val identifier = name.getIdentifier()
+            if (!identifier.startsWith("get") && !identifier.startsWith("is") && !identifier.startsWith("set")) return null // optimization
+
+            val owner = getterOrSetter.getContainingDeclaration() as? ClassDescriptor ?: return null
+
+            val originalGetterOrSetter = getterOrSetter.original
+            return resolutionScope.getSyntheticExtensionProperties(listOf(owner.getDefaultType()))
+                    .filterIsInstance<SyntheticJavaPropertyDescriptor>()
+                    .firstOrNull { originalGetterOrSetter == it.getMethod || originalGetterOrSetter == it.setMethod }
+        }
+
+        fun propertyNameByGetMethodName(methodName: Name): Name?
+                = propertyNameFromAccessorMethodName(methodName, "get") ?: propertyNameFromAccessorMethodName(methodName, "is", removePrefix = false)
+
+        fun propertyNameBySetMethodName(methodName: Name, withIsPrefix: Boolean): Name?
+                = propertyNameFromAccessorMethodName(methodName, "set", addPrefix = if (withIsPrefix) "is" else null)
+
+        private fun propertyNameFromAccessorMethodName(methodName: Name, prefix: String, removePrefix: Boolean = true, addPrefix: String? = null): Name? {
+            if (methodName.isSpecial()) return null
+            val identifier = methodName.getIdentifier()
+            if (!identifier.startsWith(prefix)) return null
+
+            if (addPrefix != null) {
+                assert(removePrefix)
+                return Name.identifier(addPrefix + identifier.removePrefix(prefix))
+            }
+
+            if (!removePrefix) return methodName
+            val name = identifier.removePrefix(prefix).decapitalizeSmart()
+            if (!Name.isValidIdentifier(name)) return null
+            return Name.identifier(name)
+        }
+    }
+}
+
+class AdditionalScopesWithJavaSyntheticExtensions(storageManager: StorageManager) : FileScopeProvider.AdditionalScopes {
+    private val scope = JavaSyntheticExtensionsScope(storageManager)
+
+    override fun scopes(file: JetFile) = listOf(scope)
+}
+
+class JavaSyntheticExtensionsScope(storageManager: StorageManager) : JetScope by JetScope.Empty {
+    private val syntheticPropertyInClass = storageManager.createMemoizedFunctionWithNullableValues<Pair<ClassDescriptor, Name>, PropertyDescriptor> { pair ->
+        syntheticPropertyInClassNotCached(pair.first, pair.second)
+    }
+
+    private fun syntheticPropertyInClassNotCached(ownerClass: ClassDescriptor, name: Name): PropertyDescriptor? {
+        if (name.isSpecial()) return null
+        val identifier = name.identifier
+        if (identifier.isEmpty()) return null
+        val firstChar = identifier[0]
+        if (!firstChar.isJavaIdentifierStart() || firstChar.isUpperCase()) return null
+
+        val memberScope = ownerClass.unsubstitutedMemberScope
+        val getMethod = possibleGetMethodNames(name)
+                                .flatMap { memberScope.getFunctions(it).asSequence() }
+                                .singleOrNull {
+                                    isGoodGetMethod(it) && it.hasJavaOriginInHierarchy()
+                                } ?: return null
+
+
+        val setMethod = memberScope.getFunctions(setMethodName(getMethod.name))
+                .singleOrNull { isGoodSetMethod(it, getMethod) }
+
+        val propertyType = getMethod.returnType ?: return null
+        return MyPropertyDescriptor(ownerClass, getMethod.original, setMethod?.original, name, propertyType)
+    }
+
+    private fun FunctionDescriptor.hasJavaOriginInHierarchy(): Boolean {
+        return if (overriddenDescriptors.isEmpty())
+            containingDeclaration is JavaClassDescriptor
+        else
+            overriddenDescriptors.any { it.hasJavaOriginInHierarchy() }
+    }
+
+    private fun isGoodGetMethod(descriptor: FunctionDescriptor): Boolean {
+        val returnType = descriptor.returnType ?: return false
+        if (returnType.isUnit()) return false
+        if (descriptor.name.asString().startsWith("is") && !returnType.isBoolean()) return false
+
+        return descriptor.valueParameters.isEmpty()
+               && descriptor.typeParameters.isEmpty()
+               && descriptor.visibility == Visibilities.PUBLIC //TODO: what about protected and package-local?
+    }
+
+    private fun isGoodSetMethod(descriptor: FunctionDescriptor, getMethod: FunctionDescriptor): Boolean {
+        val propertyType = getMethod.returnType ?: return false
+        val parameter = descriptor.valueParameters.singleOrNull() ?: return false
+        if (!TypeUtils.equalTypes(parameter.type, propertyType)) {
+            if (!propertyType.isSubtypeOf(parameter.type)) return false
+            if (descriptor.findOverridden {
+                val baseProperty = SyntheticJavaPropertyDescriptor.findByGetterOrSetter(it, this)
+                baseProperty?.getMethod?.name == getMethod.name
+            } == null) return false
+        }
+
+        return parameter.varargElementType == null
+               && descriptor.typeParameters.isEmpty()
+               && descriptor.returnType?.let { it.isUnit() } ?: false
+               && descriptor.visibility == Visibilities.PUBLIC
+    }
+
+    private fun FunctionDescriptor.findOverridden(condition: (FunctionDescriptor) -> Boolean): FunctionDescriptor? {
+        for (descriptor in overriddenDescriptors) {
+            if (condition(descriptor)) return descriptor
+            descriptor.findOverridden(condition)?.let { return it }
+        }
+        return null
+    }
+
+    override fun getSyntheticExtensionProperties(receiverTypes: Collection<JetType>, name: Name): Collection<PropertyDescriptor> {
+        var result: SmartList<PropertyDescriptor>? = null
+        val processedTypes: MutableSet<TypeConstructor>? = if (receiverTypes.size() > 1) HashSet<TypeConstructor>() else null
+        for (type in receiverTypes) {
+            result = collectSyntheticPropertiesByName(result, type.constructor, name, processedTypes)
+        }
+        return when {
+            result == null -> emptyList()
+            result.size() > 1 -> result.toSet()
+            else -> result
+        }
+    }
+
+    private fun collectSyntheticPropertiesByName(result: SmartList<PropertyDescriptor>?, type: TypeConstructor, name: Name, processedTypes: MutableSet<TypeConstructor>?): SmartList<PropertyDescriptor>? {
+        if (processedTypes != null && !processedTypes.add(type)) return result
+
+        @suppress("NAME_SHADOWING")
+        var result = result
+
+        val classifier = type.declarationDescriptor
+        if (classifier is ClassDescriptor) {
+            result = result.add(syntheticPropertyInClass(Pair(classifier, name)))
+        }
+        else {
+            type.supertypes.forEach { result = collectSyntheticPropertiesByName(result, it.constructor, name, processedTypes) }
+        }
+
+        return result
+    }
+
+    override fun getSyntheticExtensionProperties(receiverTypes: Collection<JetType>): Collection<PropertyDescriptor> {
+        val result = ArrayList<PropertyDescriptor>()
+        val processedTypes = HashSet<TypeConstructor>()
+        receiverTypes.forEach { result.collectSyntheticProperties(it.constructor, processedTypes) }
+        return result
+    }
+
+    private fun MutableList<PropertyDescriptor>.collectSyntheticProperties(type: TypeConstructor, processedTypes: MutableSet<TypeConstructor>) {
+        if (!processedTypes.add(type)) return
+
+        val classifier = type.declarationDescriptor
+        if (classifier is ClassDescriptor) {
+            for (descriptor in classifier.getUnsubstitutedMemberScope().getDescriptors(DescriptorKindFilter.FUNCTIONS)) {
+                if (descriptor is FunctionDescriptor) {
+                    val propertyName = SyntheticJavaPropertyDescriptor.propertyNameByGetMethodName(descriptor.getName()) ?: continue
+                    addIfNotNull(syntheticPropertyInClass(Pair(classifier, propertyName)))
+                }
+            }
+        }
+        else {
+            type.supertypes.forEach { collectSyntheticProperties(it.constructor, processedTypes) }
+        }
+    }
+
+    private fun SmartList<PropertyDescriptor>?.add(property: PropertyDescriptor?): SmartList<PropertyDescriptor>? {
+        if (property == null) return this
+        val list = if (this != null) this else SmartList()
+        list.add(property)
+        return list
+    }
+
+    //TODO: reuse code with generation?
+
+    private fun possibleGetMethodNames(propertyName: Name): Sequence<Name> {
+        val result = ArrayList<Name>(3)
+        val identifier = propertyName.identifier
+
+        if (identifier.startsWith("is")) {
+            result.add(propertyName)
+        }
+
+        val capitalize1 = identifier.capitalize()
+        val capitalize2 = identifier.capitalizeFirstWord()
+        result.add(Name.identifier("get" + capitalize1))
+        if (capitalize2 != capitalize1) {
+            result.add(Name.identifier("get" + capitalize2))
+        }
+
+        return result.asSequence()
+                .filter { SyntheticJavaPropertyDescriptor.propertyNameByGetMethodName(it) == propertyName } // don't accept "uRL" for "getURL" etc
+    }
+
+    private fun setMethodName(getMethodName: Name): Name {
+        val identifier = getMethodName.identifier
+        val prefix = when {
+            identifier.startsWith("get") -> "get"
+            identifier.startsWith("is") -> "is"
+            else -> throw IllegalArgumentException()
+        }
+        return Name.identifier("set" + identifier.removePrefix(prefix))
+    }
+
+    private class MyPropertyDescriptor(
+            ownerClass: ClassDescriptor,
+            override val getMethod: FunctionDescriptor,
+            override val setMethod: FunctionDescriptor?,
+            name: Name,
+            type: JetType
+    ) : SyntheticJavaPropertyDescriptor, PropertyDescriptorImpl(
+            DescriptorUtils.getContainingModule(ownerClass)/* TODO:is it ok? */,
+            null,
+            Annotations.EMPTY,
+            Modality.FINAL,
+            Visibilities.PUBLIC,
+            setMethod != null,
+            name,
+            CallableMemberDescriptor.Kind.SYNTHESIZED,
+            SourceElement.NO_SOURCE/*TODO?*/
+    ) {
+        init {
+            val classTypeParams = ownerClass.typeConstructor.parameters
+            val typeParameters = ArrayList<TypeParameterDescriptor>(classTypeParams.size())
+            val typeSubstitutor = DescriptorSubstitutor.substituteTypeParameters(classTypeParams, TypeSubstitutor.EMPTY, this, typeParameters)
+
+            val propertyType = typeSubstitutor.safeSubstitute(type, Variance.INVARIANT)
+            val receiverType = typeSubstitutor.safeSubstitute(ownerClass.defaultType, Variance.INVARIANT)
+            setType(propertyType, typeParameters, null, receiverType)
+
+            val getter = PropertyGetterDescriptorImpl(this,
+                                                      Annotations.EMPTY,
+                                                      Modality.FINAL,
+                                                      Visibilities.PUBLIC,
+                                                      false,
+                                                      false,
+                                                      CallableMemberDescriptor.Kind.SYNTHESIZED,
+                                                      null,
+                                                      SourceElement.NO_SOURCE/*TODO*/)
+            getter.initialize(null)
+
+            val setter = if (setMethod != null)
+                PropertySetterDescriptorImpl(this,
+                                             Annotations.EMPTY,
+                                             Modality.FINAL,
+                                             Visibilities.PUBLIC,
+                                             false,
+                                             false,
+                                             CallableMemberDescriptor.Kind.SYNTHESIZED,
+                                             null,
+                                             SourceElement.NO_SOURCE/*TODO*/)
+            else
+                null
+            setter?.initializeDefault()
+
+            initialize(getter, setter)
+        }
+    }
+}
\ No newline at end of file
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/cfg/JetControlFlowBuilder.java b/compiler/frontend/src/org/jetbrains/kotlin/cfg/JetControlFlowBuilder.java
index d7e63e1a982..4035bfba69c 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/cfg/JetControlFlowBuilder.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/cfg/JetControlFlowBuilder.java
@@ -20,7 +20,6 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.cfg.pseudocode.PseudoValue;
 import org.jetbrains.kotlin.cfg.pseudocode.Pseudocode;
-import org.jetbrains.kotlin.cfg.pseudocode.TypePredicate;
 import org.jetbrains.kotlin.cfg.pseudocode.instructions.eval.*;
 import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor;
 import org.jetbrains.kotlin.psi.*;
@@ -120,7 +119,6 @@ public interface JetControlFlowBuilder {
             @NotNull JetElement instructionElement,
             @Nullable JetElement valueElement,
             @NotNull List<PseudoValue> inputValues,
-            @NotNull Map<PseudoValue, TypePredicate> expectedTypes,
             @NotNull MagicKind kind
     );
 
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/cfg/JetControlFlowBuilderAdapter.java b/compiler/frontend/src/org/jetbrains/kotlin/cfg/JetControlFlowBuilderAdapter.java
index b3d81011e37..a5ac8a404a0 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/cfg/JetControlFlowBuilderAdapter.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/cfg/JetControlFlowBuilderAdapter.java
@@ -20,7 +20,6 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.cfg.pseudocode.PseudoValue;
 import org.jetbrains.kotlin.cfg.pseudocode.Pseudocode;
-import org.jetbrains.kotlin.cfg.pseudocode.TypePredicate;
 import org.jetbrains.kotlin.cfg.pseudocode.instructions.eval.*;
 import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor;
 import org.jetbrains.kotlin.psi.*;
@@ -71,10 +70,9 @@ public abstract class JetControlFlowBuilderAdapter implements JetControlFlowBuil
             @NotNull JetElement instructionElement,
             @Nullable JetElement valueElement,
             @NotNull List<PseudoValue> inputValues,
-            @NotNull Map<PseudoValue, TypePredicate> expectedTypes,
             @NotNull MagicKind kind
     ) {
-        return getDelegateBuilder().magic(instructionElement, valueElement, inputValues, expectedTypes, kind);
+        return getDelegateBuilder().magic(instructionElement, valueElement, inputValues, kind);
     }
 
     @NotNull
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/cfg/JetControlFlowProcessor.java b/compiler/frontend/src/org/jetbrains/kotlin/cfg/JetControlFlowProcessor.java
index f7d478e6a3b..009380aa147 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/cfg/JetControlFlowProcessor.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/cfg/JetControlFlowProcessor.java
@@ -17,20 +17,21 @@
 package org.jetbrains.kotlin.cfg;
 
 import com.google.common.collect.Lists;
-import com.google.common.collect.Sets;
 import com.intellij.psi.PsiElement;
 import com.intellij.psi.tree.IElementType;
 import com.intellij.psi.util.PsiTreeUtil;
 import com.intellij.util.SmartFMap;
 import com.intellij.util.containers.ContainerUtil;
-import com.intellij.util.containers.MultiMap;
 import kotlin.KotlinPackage;
 import kotlin.jvm.functions.Function0;
 import kotlin.jvm.functions.Function1;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
-import org.jetbrains.kotlin.cfg.pseudocode.*;
+import org.jetbrains.kotlin.cfg.pseudocode.JetControlFlowInstructionsGenerator;
+import org.jetbrains.kotlin.cfg.pseudocode.PseudoValue;
+import org.jetbrains.kotlin.cfg.pseudocode.Pseudocode;
+import org.jetbrains.kotlin.cfg.pseudocode.PseudocodeImpl;
 import org.jetbrains.kotlin.cfg.pseudocode.instructions.eval.AccessTarget;
 import org.jetbrains.kotlin.cfg.pseudocode.instructions.eval.InstructionWithValue;
 import org.jetbrains.kotlin.cfg.pseudocode.instructions.eval.MagicKind;
@@ -41,15 +42,12 @@ import org.jetbrains.kotlin.lexer.JetTokens;
 import org.jetbrains.kotlin.name.Name;
 import org.jetbrains.kotlin.psi.*;
 import org.jetbrains.kotlin.psi.psiUtil.PsiUtilPackage;
-import org.jetbrains.kotlin.renderer.DescriptorRenderer;
-import org.jetbrains.kotlin.resolve.*;
-import org.jetbrains.kotlin.resolve.bindingContextUtil.BindingContextUtilPackage;
-import org.jetbrains.kotlin.resolve.calls.ValueArgumentsToParametersMapper;
-import org.jetbrains.kotlin.resolve.calls.callUtil.CallUtilPackage;
+import org.jetbrains.kotlin.resolve.BindingContext;
+import org.jetbrains.kotlin.resolve.BindingContextUtils;
+import org.jetbrains.kotlin.resolve.BindingTrace;
+import org.jetbrains.kotlin.resolve.CompileTimeConstantUtils;
 import org.jetbrains.kotlin.resolve.calls.model.*;
 import org.jetbrains.kotlin.resolve.calls.tasks.ExplicitReceiverKind;
-import org.jetbrains.kotlin.resolve.calls.tasks.ResolutionCandidate;
-import org.jetbrains.kotlin.resolve.calls.tasks.TracingStrategy;
 import org.jetbrains.kotlin.resolve.constants.CompileTimeConstant;
 import org.jetbrains.kotlin.resolve.constants.evaluate.ConstantExpressionEvaluator;
 import org.jetbrains.kotlin.resolve.scopes.receivers.ExpressionReceiver;
@@ -142,7 +140,7 @@ public class JetControlFlowProcessor {
                 if (!generateCall(condition.getOperationReference())) {
                     JetExpression rangeExpression = condition.getRangeExpression();
                     generateInstructions(rangeExpression);
-                    createUnresolvedCall(condition, rangeExpression);
+                    createNonSyntheticValue(condition, MagicKind.UNRESOLVED_CALL, rangeExpression);
                 }
             }
 
@@ -209,7 +207,7 @@ public class JetControlFlowProcessor {
         @NotNull
         private PseudoValue createSyntheticValue(@NotNull JetElement instructionElement, @NotNull MagicKind kind, JetElement... from) {
             List<PseudoValue> values = elementsToValues(from.length > 0 ? Arrays.asList(from) : Collections.<JetElement>emptyList());
-            return builder.magic(instructionElement, null, values, defaultTypeMap(values), kind).getOutputValue();
+            return builder.magic(instructionElement, null, values, kind).getOutputValue();
         }
 
         @NotNull
@@ -217,7 +215,7 @@ public class JetControlFlowProcessor {
                 @NotNull JetElement to, @NotNull List<? extends JetElement> from, @NotNull MagicKind kind
         ) {
             List<PseudoValue> values = elementsToValues(from);
-            return builder.magic(to, to, values, defaultTypeMap(values), kind).getOutputValue();
+            return builder.magic(to, to, values, kind).getOutputValue();
         }
 
         @NotNull
@@ -225,114 +223,6 @@ public class JetControlFlowProcessor {
             return createNonSyntheticValue(to, Arrays.asList(from), kind);
         }
 
-        @Nullable
-        private Map<PseudoValue, TypePredicate> getTypeMapForUnresolvedCall(@NotNull JetElement to, List<PseudoValue> arguments) {
-            Call call = CallUtilPackage.getCall(to, trace.getBindingContext());
-            if (call == null) return null;
-
-            JetExpression callee = call.getCalleeExpression();
-            if (callee == null) return null;
-
-            Collection<FunctionDescriptor> candidates = KotlinPackage.sortBy(
-                    KotlinPackage.filterIsInstance(
-                            BindingContextUtilPackage.getReferenceTargets(callee, trace.getBindingContext()),
-                            FunctionDescriptor.class
-                    ),
-                    new Function1<FunctionDescriptor, Comparable>() {
-                        @Override
-                        public Comparable invoke(FunctionDescriptor descriptor) {
-                            return DescriptorRenderer.DEBUG_TEXT.render(descriptor);
-                        }
-                    }
-            );
-            if (candidates.isEmpty()) return null;
-
-            ReceiverValue explicitReceiver = call.getExplicitReceiver();
-            int argValueOffset = explicitReceiver.exists() ? 1 : 0;
-
-            MultiMap<PseudoValue, TypePredicate> valuesToPredicates = new MultiMap<PseudoValue, TypePredicate>(arguments.size(), 1);
-
-            candidateLoop:
-            for (FunctionDescriptor candidate : candidates) {
-                ResolvedCallImpl<FunctionDescriptor> candidateCall = ResolvedCallImpl.create(
-                        ResolutionCandidate.create(call,
-                                                   candidate,
-                                                   call.getDispatchReceiver(),
-                                                   explicitReceiver,
-                                                   ExplicitReceiverKind.NO_EXPLICIT_RECEIVER,
-                                                   null),
-                        new DelegatingBindingTrace(trace.getBindingContext(), "Compute type predicates for unresolved call arguments"),
-                        TracingStrategy.EMPTY,
-                        new DataFlowInfoForArgumentsImpl(call)
-                );
-                ValueArgumentsToParametersMapper.Status status = ValueArgumentsToParametersMapper.mapValueArgumentsToParameters(
-                        call,
-                        TracingStrategy.EMPTY,
-                        candidateCall,
-                        Sets.<ValueArgument>newLinkedHashSet()
-                );
-                if (!status.isSuccess()) continue;
-
-                if ((candidate.getExtensionReceiverParameter() == null) == candidateCall.getExtensionReceiver().exists()) continue;
-
-                Map<ValueParameterDescriptor, ResolvedValueArgument> candidateArgumentMap = candidateCall.getValueArguments();
-                List<? extends ValueArgument> callArguments = call.getValueArguments();
-                for (int i = 0; i < callArguments.size(); i++) {
-                    int valueIndex = i + argValueOffset;
-                    if (valueIndex >= arguments.size()) continue candidateLoop;
-                    PseudoValue argumentValue = arguments.get(valueIndex);
-
-                    ArgumentMapping mapping = candidateCall.getArgumentMapping(callArguments.get(i));
-                    if (!(mapping instanceof ArgumentMatch)) continue candidateLoop;
-
-                    ValueParameterDescriptor candidateParameter = ((ArgumentMatch) mapping).getValueParameter();
-                    ResolvedValueArgument resolvedArgument = candidateArgumentMap.get(candidateParameter);
-                    JetType expectedType = resolvedArgument instanceof VarargValueArgument
-                                   ? candidateParameter.getVarargElementType()
-                                   : candidateParameter.getType();
-
-                    valuesToPredicates.putValue(argumentValue, expectedType != null ? new AllSubtypes(expectedType) : AllTypes.INSTANCE$);
-                }
-            }
-
-            SmartFMap<PseudoValue, TypePredicate> result = SmartFMap.emptyMap();
-            for (Map.Entry<PseudoValue, Collection<TypePredicate>> entry : valuesToPredicates.entrySet()) {
-                result = result.plus(entry.getKey(), PseudocodePackage.or(entry.getValue()));
-            }
-
-            return result;
-        }
-
-        @NotNull
-        private PseudoValue createUnresolvedCallByValues(@NotNull JetElement to, @Nullable JetElement valueElement, List<PseudoValue> arguments) {
-            Map<PseudoValue, TypePredicate> typeMap = getTypeMapForUnresolvedCall(to, arguments);
-            if (typeMap == null) {
-                typeMap = defaultTypeMap(arguments);
-            }
-            
-            return builder.magic(to, valueElement, arguments, typeMap, MagicKind.UNRESOLVED_CALL).getOutputValue();
-        }
-
-        @NotNull
-        private PseudoValue createUnresolvedCallByValues(@NotNull JetElement to, List<PseudoValue> arguments) {
-            return createUnresolvedCallByValues(to, to, arguments);
-        }
-
-        @NotNull
-        private PseudoValue createUnresolvedCall(@NotNull JetElement to, List<? extends JetElement> from) {
-            return createUnresolvedCallByValues(to, elementsToValues(from));
-        }
-
-        @NotNull
-        private PseudoValue createUnresolvedCall(@NotNull JetElement to, JetElement... from) {
-            return createUnresolvedCall(to, Arrays.asList(from));
-        }
-
-        @NotNull
-        private Map<PseudoValue, TypePredicate> defaultTypeMap(List<PseudoValue> values) {
-            return PseudocodePackage.expectedTypeFor(AllTypes.INSTANCE$, values);
-        }
-
         private void mergeValues(@NotNull List<JetExpression> from, @NotNull JetExpression to) {
             builder.merge(to, elementsToValues(from));
         }
@@ -414,7 +304,7 @@ public class JetControlFlowProcessor {
         public void visitThisExpression(@NotNull JetThisExpression expression) {
             ResolvedCall<?> resolvedCall = getResolvedCall(expression, trace.getBindingContext());
             if (resolvedCall == null) {
-                createUnresolvedCall(expression);
+                createNonSyntheticValue(expression, MagicKind.UNRESOLVED_CALL);
                 return;
             }
 
@@ -440,7 +330,7 @@ public class JetControlFlowProcessor {
                 generateCall(variableAsFunctionResolvedCall.getVariableCall());
             }
             else if (!generateCall(expression) && !(expression.getParent() instanceof JetCallExpression)) {
-                createUnresolvedCall(expression, generateAndGetReceiverIfAny(expression));
+                createNonSyntheticValue(expression, MagicKind.UNRESOLVED_CALL, generateAndGetReceiverIfAny(expression));
             }
         }
 
@@ -553,7 +443,7 @@ public class JetControlFlowProcessor {
                 generateInstructions(right);
             }
             mark(expression);
-            createUnresolvedCall(expression, left, right);
+            createNonSyntheticValue(expression, MagicKind.UNRESOLVED_CALL, left, right);
         }
 
         private void visitAssignment(
@@ -564,7 +454,7 @@ public class JetControlFlowProcessor {
             JetExpression left = JetPsiUtil.deparenthesize(lhs);
             if (left == null) {
                 List<PseudoValue> arguments = Collections.singletonList(rhsDeferredValue.invoke());
-                builder.magic(parentExpression, parentExpression, arguments, defaultTypeMap(arguments), MagicKind.UNSUPPORTED_ELEMENT);
+                builder.magic(parentExpression, parentExpression, arguments, MagicKind.UNSUPPORTED_ELEMENT);
                 return;
             }
 
@@ -585,7 +475,15 @@ public class JetControlFlowProcessor {
                 accessTarget = getDeclarationAccessTarget(left);
             }
 
-            recordWrite(left, accessTarget, rhsDeferredValue.invoke(), receiverValues, parentExpression);
+            if (accessTarget == AccessTarget.BlackBox.INSTANCE$ && !(left instanceof JetProperty)) {
+                generateInstructions(left);
+                createSyntheticValue(left, MagicKind.VALUE_CONSUMER, left);
+            }
+
+            PseudoValue rightValue = rhsDeferredValue.invoke();
+            PseudoValue rValue =
+                    rightValue != null ? rightValue : createSyntheticValue(parentExpression, MagicKind.UNRECOGNIZED_WRITE_RHS);
+            builder.write(parentExpression, left, rValue, accessTarget, receiverValues);
         }
 
         private void generateArrayAssignment(
@@ -601,7 +499,7 @@ public class JetControlFlowProcessor {
                 List<PseudoValue> arguments = KotlinPackage.filterNotNull(
                         Arrays.asList(getBoundOrUnreachableValue(lhs), rhsDeferredValue.invoke())
                 );
-                createUnresolvedCallByValues(parentExpression, arguments);
+                builder.magic(parentExpression, parentExpression, arguments, MagicKind.UNRESOLVED_CALL);
 
                 return;
             }
@@ -663,24 +561,6 @@ public class JetControlFlowProcessor {
             return argumentValues;
         }
 
-        private void recordWrite(
-                @NotNull JetExpression left,
-                @NotNull AccessTarget target,
-                @Nullable PseudoValue rightValue,
-                @NotNull Map<PseudoValue, ReceiverValue> receiverValues,
-                @NotNull JetExpression parentExpression
-        ) {
-            if (target == AccessTarget.BlackBox.INSTANCE$) {
-                List<PseudoValue> values = ContainerUtil.createMaybeSingletonList(rightValue);
-                builder.magic(parentExpression, parentExpression, values, defaultTypeMap(values), MagicKind.UNSUPPORTED_ELEMENT);
-            }
-            else {
-                PseudoValue rValue =
-                        rightValue != null ? rightValue : createSyntheticValue(parentExpression, MagicKind.UNRECOGNIZED_WRITE_RHS);
-                builder.write(parentExpression, left, rValue, target, receiverValues);
-            }
-        }
-
         private void generateArrayAccess(JetArrayAccessExpression arrayAccessExpression, @Nullable ResolvedCall<?> resolvedCall) {
             if (builder.getBoundValue(arrayAccessExpression) != null) return;
             mark(arrayAccessExpression);
@@ -690,7 +570,7 @@ public class JetControlFlowProcessor {
         }
 
         private void generateArrayAccessWithoutCall(JetArrayAccessExpression arrayAccessExpression) {
-            createUnresolvedCall(arrayAccessExpression, generateArrayAccessArguments(arrayAccessExpression));
+            createNonSyntheticValue(arrayAccessExpression, generateArrayAccessArguments(arrayAccessExpression), MagicKind.UNRESOLVED_CALL);
         }
 
         private List<JetExpression> generateArrayAccessArguments(JetArrayAccessExpression arrayAccessExpression) {
@@ -729,7 +609,7 @@ public class JetControlFlowProcessor {
             }
             else {
                 generateInstructions(baseExpression);
-                rhsValue = createUnresolvedCall(expression, baseExpression);
+                rhsValue = createNonSyntheticValue(expression, MagicKind.UNRESOLVED_CALL, baseExpression);
             }
 
             if (incrementOrDecrement) {
@@ -927,10 +807,7 @@ public class JetControlFlowProcessor {
             }
             else {
                 assert condition != null : "Invalid while condition: " + expression.getText();
-                List<PseudoValue> values = ContainerUtil.createMaybeSingletonList(builder.getBoundValue(condition));
-                Map<PseudoValue, TypePredicate> typePredicates =
-                        PseudocodePackage.expectedTypeFor(new SingleType(KotlinBuiltIns.getInstance().getBooleanType()), values);
-                builder.magic(condition, null, values, typePredicates, MagicKind.VALUE_CONSUMER);
+                createSyntheticValue(condition, MagicKind.VALUE_CONSUMER, condition);
             }
 
             builder.enterLoopBody(expression);
@@ -1016,17 +893,10 @@ public class JetControlFlowProcessor {
             JetMultiDeclaration multiDeclaration = expression.getMultiParameter();
             JetExpression loopRange = expression.getLoopRange();
 
-            TypePredicate loopRangeTypePredicate =
-                    getTypePredicateByReceiverValue(trace.get(BindingContext.LOOP_RANGE_ITERATOR_RESOLVED_CALL, loopRange));
-
-            PseudoValue loopRangeValue = builder.getBoundValue(loopRange);
             PseudoValue value = builder.magic(
                     loopRange != null ? loopRange : expression,
                     null,
-                    ContainerUtil.createMaybeSingletonList(loopRangeValue),
-                    loopRangeValue != null
-                        ? Collections.singletonMap(loopRangeValue, loopRangeTypePredicate)
-                        : Collections.<PseudoValue, TypePredicate>emptyMap(),
+                    ContainerUtil.createMaybeSingletonList(builder.getBoundValue(loopRange)),
                     MagicKind.LOOP_RANGE_ITERATION
             ).getOutputValue();
 
@@ -1040,17 +910,6 @@ public class JetControlFlowProcessor {
             }
         }
 
-        private ReceiverValue getExplicitReceiverValue(ResolvedCall<?> resolvedCall) {
-            switch(resolvedCall.getExplicitReceiverKind()) {
-                case DISPATCH_RECEIVER:
-                    return resolvedCall.getDispatchReceiver();
-                case EXTENSION_RECEIVER:
-                    return resolvedCall.getExtensionReceiver();
-                default:
-                    return ReceiverValue.NO_RECEIVER;
-            }
-        }
-
         @Override
         public void visitBreakExpression(@NotNull JetBreakExpression expression) {
             JetElement loop = getCorrespondingLoop(expression);
@@ -1260,7 +1119,7 @@ public class JetControlFlowProcessor {
                 inputExpressions.add(generateAndGetReceiverIfAny(expression));
 
                 mark(expression);
-                createUnresolvedCall(expression, inputExpressions);
+                createNonSyntheticValue(expression, inputExpressions, MagicKind.UNRESOLVED_CALL);
             }
         }
 
@@ -1302,33 +1161,9 @@ public class JetControlFlowProcessor {
             DeclarationDescriptor descriptor = trace.get(BindingContext.DECLARATION_TO_DESCRIPTOR, property);
             if (!(descriptor instanceof PropertyDescriptor)) return;
 
-            PseudoValue delegateValue = builder.getBoundValue(delegate);
-            if (delegateValue == null) return;
+            if (builder.getBoundValue(delegate) == null) return;
 
-            List<TypePredicate> typePredicates = KotlinPackage.map(
-                    ((PropertyDescriptor) descriptor).getAccessors(),
-                    new Function1<PropertyAccessorDescriptor, TypePredicate>() {
-                        @Override
-                        public TypePredicate invoke(PropertyAccessorDescriptor descriptor) {
-                            return getTypePredicateByReceiverValue(trace.get(BindingContext.DELEGATED_PROPERTY_RESOLVED_CALL, descriptor));
-                        }
-                    }
-            );
-            Map<PseudoValue, TypePredicate> valuesToTypePredicates = SmartFMap
-                    .<PseudoValue, TypePredicate>emptyMap()
-                    .plus(delegateValue, PseudocodePackage.and(KotlinPackage.filterNotNull(typePredicates)));
-            builder.magic(property, null, Collections.singletonList(delegateValue), valuesToTypePredicates, MagicKind.VALUE_CONSUMER);
-        }
-
-        private TypePredicate getTypePredicateByReceiverValue(@Nullable ResolvedCall<?> resolvedCall) {
-            if (resolvedCall == null) return AllTypes.INSTANCE$;
-
-            ReceiverValue receiverValue = getExplicitReceiverValue(resolvedCall);
-            if (receiverValue.exists()) {
-                return PseudocodePackage.getReceiverTypePredicate(resolvedCall, receiverValue);
-            }
-
-            return AllTypes.INSTANCE$;
+            createSyntheticValue(property, MagicKind.VALUE_CONSUMER, delegate);
         }
 
         @Override
@@ -1354,8 +1189,7 @@ public class JetControlFlowProcessor {
                     ).getOutputValue();
                 }
                 else {
-                    List<PseudoValue> arguments = ContainerUtil.createMaybeSingletonList(getBoundOrUnreachableValue(initializer));
-                    writtenValue = createUnresolvedCallByValues(entry, null, arguments);
+                    writtenValue = createSyntheticValue(entry, MagicKind.UNRESOLVED_CALL, initializer);
                 }
 
                 if (generateWriteForEntries) {
@@ -1601,19 +1435,15 @@ public class JetControlFlowProcessor {
                 for (JetExpression argument : arguments) {
                     generateInstructions(argument);
                 }
-                createUnresolvedCall(call, arguments);
+                createNonSyntheticValue(call, arguments, MagicKind.UNRESOLVED_CALL);
             }
         }
 
         @Override
         public void visitDelegationByExpressionSpecifier(@NotNull JetDelegatorByExpressionSpecifier specifier) {
-            generateInstructions(specifier.getDelegateExpression());
-
-            List<PseudoValue> arguments = ContainerUtil.createMaybeSingletonList(builder.getBoundValue(specifier.getDelegateExpression()));
-            JetType jetType = trace.get(BindingContext.TYPE, specifier.getTypeReference());
-            TypePredicate expectedTypePredicate = jetType != null ? PseudocodePackage.getSubtypesPredicate(jetType) : AllTypes.INSTANCE$;
-            builder.magic(specifier, null, arguments, PseudocodePackage.expectedTypeFor(expectedTypePredicate, arguments),
-                          MagicKind.VALUE_CONSUMER);
+            JetExpression delegateExpression = specifier.getDelegateExpression();
+            generateInstructions(delegateExpression);
+            createSyntheticValue(specifier, MagicKind.VALUE_CONSUMER, delegateExpression);
         }
 
         @Override
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/JetControlFlowInstructionsGenerator.java b/compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/JetControlFlowInstructionsGenerator.java
index 49dca299a67..c4c87faaa32 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/JetControlFlowInstructionsGenerator.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/JetControlFlowInstructionsGenerator.java
@@ -432,9 +432,7 @@ public class JetControlFlowInstructionsGenerator extends JetControlFlowBuilderAd
         @NotNull
         @Override
         public InstructionWithValue loadStringTemplate(@NotNull JetStringTemplateExpression expression, @NotNull List<PseudoValue> inputValues) {
-            if (inputValues.isEmpty()) return read(expression);
-            Map<PseudoValue, TypePredicate> predicate = PseudocodePackage.expectedTypeFor(AllTypes.INSTANCE$, inputValues);
-            return magic(expression, expression, inputValues, predicate, MagicKind.STRING_TEMPLATE);
+            return inputValues.isEmpty() ? read(expression) : magic(expression, expression, inputValues, MagicKind.STRING_TEMPLATE);
         }
 
         @NotNull
@@ -443,11 +441,10 @@ public class JetControlFlowInstructionsGenerator extends JetControlFlowBuilderAd
                 @NotNull JetElement instructionElement,
                 @Nullable JetElement valueElement,
                 @NotNull List<PseudoValue> inputValues,
-                @NotNull Map<PseudoValue, TypePredicate> expectedTypes,
                 @NotNull MagicKind kind
         ) {
-            MagicInstruction instruction = MagicInstruction.Factory.create(
-                    instructionElement, valueElement, getCurrentScope(), inputValues, expectedTypes, kind, valueFactory
+            MagicInstruction instruction = new MagicInstruction(
+                    instructionElement, valueElement, getCurrentScope(), inputValues, kind, valueFactory
             );
             add(instruction);
             return instruction;
@@ -456,7 +453,7 @@ public class JetControlFlowInstructionsGenerator extends JetControlFlowBuilderAd
         @NotNull
         @Override
         public MergeInstruction merge(@NotNull JetExpression expression, @NotNull List<PseudoValue> inputValues) {
-            MergeInstruction instruction = MergeInstruction.Factory.create(expression, getCurrentScope(), inputValues, valueFactory);
+            MergeInstruction instruction = new MergeInstruction(expression, getCurrentScope(), inputValues, valueFactory);
             add(instruction);
             return instruction;
         }
@@ -480,7 +477,7 @@ public class JetControlFlowInstructionsGenerator extends JetControlFlowBuilderAd
                 @NotNull Map<PseudoValue, ValueParameterDescriptor> arguments
         ) {
             JetType returnType = resolvedCall.getResultingDescriptor().getReturnType();
-            CallInstruction instruction = CallInstruction.Factory.create(
+            CallInstruction instruction = new CallInstruction(
                     valueElement,
                     getCurrentScope(),
                     resolvedCall,
@@ -499,21 +496,7 @@ public class JetControlFlowInstructionsGenerator extends JetControlFlowBuilderAd
                 @NotNull PredefinedOperation operation,
                 @NotNull List<PseudoValue> inputValues
         ) {
-            Map<PseudoValue, TypePredicate> expectedTypes;
-            switch(operation) {
-                case AND:
-                case OR:
-                    SingleType onlyBoolean = new SingleType(KotlinBuiltIns.getInstance().getBooleanType());
-                    expectedTypes = PseudocodePackage.expectedTypeFor(onlyBoolean, inputValues);
-                    break;
-                case NOT_NULL_ASSERTION:
-                    expectedTypes = PseudocodePackage.expectedTypeFor(AllTypes.INSTANCE$, inputValues);
-                    break;
-                default:
-                    throw new IllegalArgumentException("Invalid operation: " + operation);
-            }
-
-            return magic(expression, expression, inputValues, expectedTypes, getMagicKind(operation));
+            return magic(expression, expression, inputValues, getMagicKind(operation));
         }
 
         @NotNull
@@ -537,7 +520,7 @@ public class JetControlFlowInstructionsGenerator extends JetControlFlowBuilderAd
                 @NotNull Map<PseudoValue, ReceiverValue> receiverValues
         ) {
             AccessTarget accessTarget = resolvedCall != null ? new AccessTarget.Call(resolvedCall) : AccessTarget.BlackBox.INSTANCE$;
-            ReadValueInstruction instruction = ReadValueInstruction.Factory.create(
+            ReadValueInstruction instruction = new ReadValueInstruction(
                     expression, getCurrentScope(), accessTarget, receiverValues, valueFactory
             );
             add(instruction);
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/instructions/eval/accessInstructions.kt b/compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/instructions/eval/accessInstructions.kt
index db5d57a1c1b..83cbede765f 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/instructions/eval/accessInstructions.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/instructions/eval/accessInstructions.kt
@@ -29,10 +29,10 @@ import org.jetbrains.kotlin.cfg.pseudocode.instructions.InstructionVisitorWithRe
 import org.jetbrains.kotlin.cfg.pseudocode.instructions.InstructionImpl
 import org.jetbrains.kotlin.psi.JetNamedDeclaration
 
-public trait AccessTarget {
-    public data class Declaration(val descriptor: VariableDescriptor): AccessTarget
-    public data class Call(val resolvedCall: ResolvedCall<*>): AccessTarget
-    public object BlackBox: AccessTarget
+public sealed class AccessTarget {
+    public data class Declaration(val descriptor: VariableDescriptor): AccessTarget()
+    public data class Call(val resolvedCall: ResolvedCall<*>): AccessTarget()
+    public object BlackBox: AccessTarget()
 }
 
 public abstract class AccessValueInstruction protected constructor(
@@ -49,8 +49,14 @@ public class ReadValueInstruction private constructor(
         receiverValues: Map<PseudoValue, ReceiverValue>,
         private var _outputValue: PseudoValue?
 ) : AccessValueInstruction(element, lexicalScope, target, receiverValues), InstructionWithValue {
-    private fun newResultValue(factory: PseudoValueFactory, valueElement: JetElement) {
-        _outputValue = factory.newValue(valueElement, this)
+    public constructor(
+            element: JetElement,
+            lexicalScope: LexicalScope,
+            target: AccessTarget,
+            receiverValues: Map<PseudoValue, ReceiverValue>,
+            factory: PseudoValueFactory
+    ): this(element, lexicalScope, target, receiverValues, null) {
+        _outputValue = factory.newValue(element, this)
     }
 
     override val inputValues: List<PseudoValue>
@@ -82,21 +88,6 @@ public class ReadValueInstruction private constructor(
 
     override fun createCopy(): InstructionImpl =
             ReadValueInstruction(element, lexicalScope, target, receiverValues, outputValue)
-
-    companion object Factory {
-        public fun create (
-                element: JetElement,
-                lexicalScope: LexicalScope,
-                target: AccessTarget,
-                receiverValues: Map<PseudoValue, ReceiverValue>,
-                factory: PseudoValueFactory
-        ): ReadValueInstruction {
-            return ReadValueInstruction(element, lexicalScope, target, receiverValues, null).let { instruction ->
-                instruction.newResultValue(factory, element)
-                instruction
-            }
-        }
-    }
 }
 
 public class WriteValueInstruction(
@@ -108,7 +99,7 @@ public class WriteValueInstruction(
         public val rValue: PseudoValue
 ) : AccessValueInstruction(assignment, lexicalScope, target, receiverValues) {
     override val inputValues: List<PseudoValue>
-        get() = receiverValues.keySet() + rValue
+        get() = (receiverValues.keySet() as Collection<PseudoValue>) + rValue
 
     override fun accept(visitor: InstructionVisitor) {
         visitor.visitWriteValue(this)
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/instructions/eval/operationInstructions.kt b/compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/instructions/eval/operationInstructions.kt
index 672f8172017..436d43f16b9 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/instructions/eval/operationInstructions.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/instructions/eval/operationInstructions.kt
@@ -59,7 +59,18 @@ public class CallInstruction private constructor(
         val resolvedCall: ResolvedCall<*>,
         override val receiverValues: Map<PseudoValue, ReceiverValue>,
         public val arguments: Map<PseudoValue, ValueParameterDescriptor>
-) : OperationInstruction(element, lexicalScope, receiverValues.keySet() + arguments.keySet()), InstructionWithReceivers {
+) : OperationInstruction(element, lexicalScope, (receiverValues.keySet() as Collection<PseudoValue>) + arguments.keySet()), InstructionWithReceivers {
+    public constructor (
+            element: JetElement,
+            lexicalScope: LexicalScope,
+            resolvedCall: ResolvedCall<*>,
+            receiverValues: Map<PseudoValue, ReceiverValue>,
+            arguments: Map<PseudoValue, ValueParameterDescriptor>,
+            factory: PseudoValueFactory?
+    ): this(element, lexicalScope, resolvedCall, receiverValues, arguments) {
+        setResult(factory)
+    }
+
     override fun accept(visitor: InstructionVisitor) {
         visitor.visitCallInstruction(this)
     }
@@ -73,18 +84,6 @@ public class CallInstruction private constructor(
 
     override fun toString() =
             renderInstruction("call", "${render(element)}, ${resolvedCall.getResultingDescriptor()!!.getName()}")
-
-    companion object Factory {
-        fun create (
-                element: JetElement,
-                lexicalScope: LexicalScope,
-                resolvedCall: ResolvedCall<*>,
-                receiverValues: Map<PseudoValue, ReceiverValue>,
-                arguments: Map<PseudoValue, ValueParameterDescriptor>,
-                factory: PseudoValueFactory?
-        ): CallInstruction =
-                CallInstruction(element, lexicalScope, resolvedCall, receiverValues, arguments).setResult(factory, element) as CallInstruction
-    }
 }
 
 // Introduces black-box operation
@@ -96,9 +95,19 @@ public class MagicInstruction(
         element: JetElement,
         lexicalScope: LexicalScope,
         inputValues: List<PseudoValue>,
-        val expectedTypes: Map<PseudoValue, TypePredicate>,
         val kind: MagicKind
 ) : OperationInstruction(element, lexicalScope, inputValues) {
+    public constructor (
+            element: JetElement,
+            valueElement: JetElement?,
+            lexicalScope: LexicalScope,
+            inputValues: List<PseudoValue>,
+            kind: MagicKind,
+            factory: PseudoValueFactory
+    ): this(element, lexicalScope, inputValues, kind) {
+        setResult(factory, valueElement)
+    }
+
     public val synthetic: Boolean get() = outputValue.element == null
 
     override val outputValue: PseudoValue
@@ -109,23 +118,9 @@ public class MagicInstruction(
     override fun <R> accept(visitor: InstructionVisitorWithResult<R>): R = visitor.visitMagic(this)
 
     override fun createCopy() =
-            MagicInstruction(element, lexicalScope, inputValues, expectedTypes, kind).setResult(resultValue)
+            MagicInstruction(element, lexicalScope, inputValues, kind).setResult(resultValue)
 
     override fun toString() = renderInstruction("magic[$kind]", render(element))
-
-    companion object Factory {
-        fun create(
-                element: JetElement,
-                valueElement: JetElement?,
-                lexicalScope: LexicalScope,
-                inputValues: List<PseudoValue>,
-                expectedTypes: Map<PseudoValue, TypePredicate>,
-                kind: MagicKind,
-                factory: PseudoValueFactory
-        ): MagicInstruction = MagicInstruction(
-                element, lexicalScope, inputValues, expectedTypes, kind
-        ).setResult(factory, valueElement) as MagicInstruction
-    }
 }
 
 public enum class MagicKind(val sideEffectFree: Boolean = false) {
@@ -155,6 +150,15 @@ class MergeInstruction private constructor(
         lexicalScope: LexicalScope,
         inputValues: List<PseudoValue>
 ): OperationInstruction(element, lexicalScope, inputValues) {
+    public constructor (
+            element: JetElement,
+            lexicalScope: LexicalScope,
+            inputValues: List<PseudoValue>,
+            factory: PseudoValueFactory
+    ): this(element, lexicalScope, inputValues) {
+        setResult(factory)
+    }
+
     override val outputValue: PseudoValue
         get() = resultValue!!
 
@@ -165,13 +169,4 @@ class MergeInstruction private constructor(
     override fun createCopy() = MergeInstruction(element, lexicalScope, inputValues).setResult(resultValue)
 
     override fun toString() = renderInstruction("merge", render(element))
-
-    companion object Factory {
-        fun create(
-                element: JetElement,
-                lexicalScope: LexicalScope,
-                inputValues: List<PseudoValue>,
-                factory: PseudoValueFactory
-        ): MergeInstruction = MergeInstruction(element, lexicalScope, inputValues).setResult(factory) as MergeInstruction
-    }
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/pseudocodeUtil.kt b/compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/pseudocodeUtil.kt
index b40fbd43d58..2649798f09f 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/pseudocodeUtil.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/pseudocodeUtil.kt
@@ -16,8 +16,12 @@
 
 package org.jetbrains.kotlin.cfg.pseudocode
 
+import com.google.common.collect.Sets
 import com.intellij.psi.util.PsiTreeUtil
+import com.intellij.util.SmartFMap
+import com.intellij.util.containers.MultiMap
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns
+import org.jetbrains.kotlin.cfg.pseudocode.instructions.eval.MagicKind.*
 import org.jetbrains.kotlin.cfg.pseudocode.instructions.Instruction
 import org.jetbrains.kotlin.cfg.pseudocode.instructions.eval.*
 import org.jetbrains.kotlin.cfg.pseudocode.instructions.jumps.ConditionalJumpInstruction
@@ -26,23 +30,28 @@ import org.jetbrains.kotlin.cfg.pseudocode.instructions.jumps.ThrowExceptionInst
 import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.descriptors.impl.LocalVariableDescriptor
 import org.jetbrains.kotlin.psi.*
-import org.jetbrains.kotlin.psi.psiUtil.getElementTextWithContext
-import org.jetbrains.kotlin.psi.psiUtil.getNonStrictParentOfType
-import org.jetbrains.kotlin.psi.psiUtil.parents
+import org.jetbrains.kotlin.psi.psiUtil.*
+import org.jetbrains.kotlin.renderer.DescriptorRenderer
 import org.jetbrains.kotlin.resolve.BindingContext
+import org.jetbrains.kotlin.resolve.BindingContext.*
+import org.jetbrains.kotlin.resolve.DelegatingBindingTrace
 import org.jetbrains.kotlin.resolve.OverridingUtil
+import org.jetbrains.kotlin.resolve.bindingContextUtil.getReferenceTargets
 import org.jetbrains.kotlin.resolve.bindingContextUtil.getTargetFunctionDescriptor
-import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall
-import org.jetbrains.kotlin.resolve.calls.model.VarargValueArgument
+import org.jetbrains.kotlin.resolve.calls.ValueArgumentsToParametersMapper
+import org.jetbrains.kotlin.resolve.calls.callUtil.getCall
+import org.jetbrains.kotlin.resolve.calls.model.*
+import org.jetbrains.kotlin.resolve.calls.resolvedCallUtil.getExplicitReceiverValue
+import org.jetbrains.kotlin.resolve.calls.tasks.ExplicitReceiverKind
+import org.jetbrains.kotlin.resolve.calls.tasks.ResolutionCandidate
+import org.jetbrains.kotlin.resolve.calls.tasks.TracingStrategy
 import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue
 import org.jetbrains.kotlin.types.JetType
 import org.jetbrains.kotlin.types.TypeUtils
-import java.util.ArrayList
-import java.util.LinkedHashSet
+import java.util.*
 
 fun getReceiverTypePredicate(resolvedCall: ResolvedCall<*>, receiverValue: ReceiverValue): TypePredicate? {
-    val callableDescriptor = resolvedCall.getResultingDescriptor()
-    if (callableDescriptor == null) return null
+    val callableDescriptor = resolvedCall.getResultingDescriptor() ?: return null
 
     when (receiverValue) {
         resolvedCall.getExtensionReceiver() -> {
@@ -61,13 +70,75 @@ fun getReceiverTypePredicate(resolvedCall: ResolvedCall<*>, receiverValue: Recei
 }
 
 public fun getExpectedTypePredicate(value: PseudoValue, bindingContext: BindingContext): TypePredicate {
-    val pseudocode = value.createdAt?.owner
-    if (pseudocode == null) return AllTypes
+    val pseudocode = value.createdAt?.owner ?: return AllTypes
+    val builtIns = KotlinBuiltIns.getInstance()
 
     val typePredicates = LinkedHashSet<TypePredicate?>()
 
     fun addSubtypesOf(jetType: JetType?) = typePredicates.add(jetType?.getSubtypesPredicate())
 
+    fun addByExplicitReceiver(resolvedCall: ResolvedCall<*>?) {
+        val receiverValue = (resolvedCall ?: return).getExplicitReceiverValue()
+        if (receiverValue.exists()) typePredicates.add(getReceiverTypePredicate(resolvedCall, receiverValue))
+    }
+
+    fun getTypePredicateForUnresolvedCallArgument(to: JetElement, inputValueIndex: Int): TypePredicate? {
+        if (inputValueIndex < 0) return null
+        val call = to.getCall(bindingContext) ?: return null
+        val callee = call.getCalleeExpression() ?: return null
+
+        val candidates = callee.getReferenceTargets(bindingContext)
+                .filterIsInstance<FunctionDescriptor>()
+                .sortBy { DescriptorRenderer.DEBUG_TEXT.render(it) }
+        if (candidates.isEmpty()) return null
+
+        val explicitReceiver = call.getExplicitReceiver()
+        val argValueOffset = if (explicitReceiver.exists()) 1 else 0
+
+        val predicates = ArrayList<TypePredicate>()
+
+        for (candidate in candidates) {
+            val resolutionCandidate = ResolutionCandidate.create(
+                    call,
+                    candidate,
+                    call.getDispatchReceiver(),
+                    explicitReceiver,
+                    ExplicitReceiverKind.NO_EXPLICIT_RECEIVER,
+                    null
+            )
+            val candidateCall = ResolvedCallImpl.create(
+                    resolutionCandidate,
+                    DelegatingBindingTrace(bindingContext, "Compute type predicates for unresolved call arguments"),
+                    TracingStrategy.EMPTY,
+                    DataFlowInfoForArgumentsImpl(call)
+            )
+            val status = ValueArgumentsToParametersMapper.mapValueArgumentsToParameters(call,
+                                                                                        TracingStrategy.EMPTY,
+                                                                                        candidateCall,
+                                                                                        LinkedHashSet())
+            if (!status.isSuccess()) continue
+
+            val candidateArgumentMap = candidateCall.getValueArguments()
+            val callArguments = call.getValueArguments()
+            val i = inputValueIndex - argValueOffset
+            if (i < 0 || i >= callArguments.size()) continue
+
+            val mapping = candidateCall.getArgumentMapping(callArguments.get(i))
+            if (mapping !is ArgumentMatch) continue
+
+            val candidateParameter = mapping.valueParameter
+            val resolvedArgument = candidateArgumentMap.get(candidateParameter)
+            val expectedType = if (resolvedArgument is VarargValueArgument)
+                candidateParameter.getVarargElementType()
+            else
+                candidateParameter.getType()
+
+            predicates.add(if (expectedType != null) AllSubtypes(expectedType) else AllTypes)
+        }
+
+        return or(predicates)
+    }
+
     fun addTypePredicates(value: PseudoValue) {
         pseudocode.getUsages(value).forEach {
             when (it) {
@@ -75,16 +146,16 @@ public fun getExpectedTypePredicate(value: PseudoValue, bindingContext: BindingC
                     val returnElement = it.element
                     val functionDescriptor = when(returnElement) {
                         is JetReturnExpression -> returnElement.getTargetFunctionDescriptor(bindingContext)
-                        else -> bindingContext[BindingContext.DECLARATION_TO_DESCRIPTOR, pseudocode.getCorrespondingElement()]
+                        else -> bindingContext[DECLARATION_TO_DESCRIPTOR, pseudocode.getCorrespondingElement()]
                     }
                     addSubtypesOf((functionDescriptor as? CallableDescriptor)?.getReturnType())
                 }
 
                 is ConditionalJumpInstruction ->
-                    addSubtypesOf(KotlinBuiltIns.getInstance().getBooleanType())
+                    addSubtypesOf(builtIns.getBooleanType())
 
                 is ThrowExceptionInstruction ->
-                    addSubtypesOf(KotlinBuiltIns.getInstance().getThrowable().getDefaultType())
+                    addSubtypesOf(builtIns.getThrowable().getDefaultType())
 
                 is MergeInstruction ->
                     addTypePredicates(it.outputValue)
@@ -126,8 +197,36 @@ public fun getExpectedTypePredicate(value: PseudoValue, bindingContext: BindingC
                     }
                 }
 
-                is MagicInstruction ->
-                    typePredicates.add(it.expectedTypes[value])
+                is MagicInstruction -> @suppress("NON_EXHAUSTIVE_WHEN") when (it.kind) {
+                    AND, OR ->
+                        addSubtypesOf(builtIns.getBooleanType())
+
+                    LOOP_RANGE_ITERATION ->
+                        addByExplicitReceiver(bindingContext[LOOP_RANGE_ITERATOR_RESOLVED_CALL, value.element as? JetExpression])
+
+                    VALUE_CONSUMER -> {
+                        val element = it.element
+                        when {
+                            element.getStrictParentOfType<JetWhileExpression>()?.getCondition() == element ->
+                                addSubtypesOf(builtIns.getBooleanType())
+
+                            element is JetProperty -> {
+                                val propertyDescriptor = bindingContext[DECLARATION_TO_DESCRIPTOR, element] as? PropertyDescriptor
+                                propertyDescriptor?.getAccessors()?.map {
+                                    addByExplicitReceiver(bindingContext[DELEGATED_PROPERTY_RESOLVED_CALL, it])
+                                }
+                            }
+
+                            element is JetDelegatorByExpressionSpecifier ->
+                                addSubtypesOf(bindingContext[TYPE, element.getTypeReference()])
+                        }
+                    }
+
+                    UNRESOLVED_CALL -> {
+                        val typePredicate = getTypePredicateForUnresolvedCallArgument(it.element, it.inputValues.indexOf(value))
+                        typePredicates.add(typePredicate)
+                    }
+                }
             }
         }
     }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/descriptors/ClassDescriptorWithResolutionScopes.java b/compiler/frontend/src/org/jetbrains/kotlin/descriptors/ClassDescriptorWithResolutionScopes.java
index 07d1e710ccb..b8c9e4d3ec4 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/descriptors/ClassDescriptorWithResolutionScopes.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/descriptors/ClassDescriptorWithResolutionScopes.java
@@ -33,9 +33,6 @@ public interface ClassDescriptorWithResolutionScopes extends ClassDescriptor {
     @NotNull
     JetScope getScopeForInitializerResolution();
 
-    @NotNull
-    JetScope getScopeForMemberLookup();
-
     @Nullable
     @Override
     ClassDescriptorWithResolutionScopes getCompanionObjectDescriptor();
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/descriptors/impl/MutableClassDescriptor.java b/compiler/frontend/src/org/jetbrains/kotlin/descriptors/impl/MutableClassDescriptor.java
index 785f195b879..700b51a6a35 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/descriptors/impl/MutableClassDescriptor.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/descriptors/impl/MutableClassDescriptor.java
@@ -51,7 +51,7 @@ public class MutableClassDescriptor extends ClassDescriptorBase implements Class
     // This scope contains type parameters but does not contain inner classes
     private final WritableScope scopeForSupertypeResolution;
     private JetScope scopeForInitializers; //contains members + primary constructor value parameters + map for backing fields
-    private final JetScope scopeForMemberLookup;
+    private final JetScope unsubstitutedMemberScope;
     private final JetScope staticScope = new StaticScopeForKotlinClass(this);
 
     public MutableClassDescriptor(
@@ -70,7 +70,7 @@ public class MutableClassDescriptor extends ClassDescriptorBase implements Class
 
         RedeclarationHandler redeclarationHandler = RedeclarationHandler.DO_NOTHING;
 
-        this.scopeForMemberLookup = new WritableScopeImpl(JetScope.Empty.INSTANCE$, this, redeclarationHandler, "MemberLookup", null, this)
+        this.unsubstitutedMemberScope = new WritableScopeImpl(JetScope.Empty.INSTANCE$, this, redeclarationHandler, "MemberLookup", null, this)
                                         .changeLockLevel(WritableScope.LockLevel.BOTH);
         this.scopeForSupertypeResolution = new WritableScopeImpl(outerScope, this, redeclarationHandler, "SupertypeResolution")
                 .changeLockLevel(WritableScope.LockLevel.BOTH);
@@ -256,8 +256,8 @@ public class MutableClassDescriptor extends ClassDescriptorBase implements Class
 
     @Override
     @NotNull
-    public JetScope getScopeForMemberLookup() {
-        return scopeForMemberLookup;
+    public JetScope getUnsubstitutedMemberScope() {
+        return unsubstitutedMemberScope;
     }
 
     @NotNull
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/Errors.java b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/Errors.java
index 078556686d8..e4966923dc3 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/Errors.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/Errors.java
@@ -114,6 +114,7 @@ public interface Errors {
     DiagnosticFactory2<PsiElement, JetModifierKeywordToken, JetModifierKeywordToken> REDUNDANT_MODIFIER = DiagnosticFactory2.create(WARNING);
     DiagnosticFactory0<PsiElement> INAPPLICABLE_ANNOTATION = DiagnosticFactory0.create(ERROR);
     DiagnosticFactory0<PsiElement> INAPPLICABLE_PLATFORM_NAME = DiagnosticFactory0.create(ERROR);
+    DiagnosticFactory1<PsiElement, String> WRONG_ANNOTATION_TARGET = DiagnosticFactory1.create(ERROR);
 
     // Annotations
 
@@ -124,8 +125,6 @@ public interface Errors {
     DiagnosticFactory0<PsiElement> ANNOTATION_CLASS_WITH_BODY = DiagnosticFactory0.create(ERROR);
     DiagnosticFactory0<JetTypeReference> INVALID_TYPE_OF_ANNOTATION_MEMBER = DiagnosticFactory0.create(ERROR);
     DiagnosticFactory0<JetTypeReference> NULLABLE_TYPE_OF_ANNOTATION_MEMBER = DiagnosticFactory0.create(ERROR);
-    DiagnosticFactory0<JetModifierListOwner> ILLEGAL_ANNOTATION_KEYWORD =
-            DiagnosticFactory0.create(ERROR, modifierSetPosition(JetTokens.ANNOTATION_KEYWORD));
     DiagnosticFactory0<JetExpression> ANNOTATION_PARAMETER_MUST_BE_CONST = DiagnosticFactory0.create(ERROR);
     DiagnosticFactory0<JetExpression> ANNOTATION_PARAMETER_MUST_BE_KCLASS_LITERAL = DiagnosticFactory0.create(ERROR);
     DiagnosticFactory0<JetExpression> ANNOTATION_PARAMETER_MUST_BE_ENUM_CONST = DiagnosticFactory0.create(ERROR);
@@ -458,7 +457,8 @@ public interface Errors {
     DiagnosticFactory1<PsiElement, InferenceErrorData> TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER = DiagnosticFactory1.create(ERROR);
     DiagnosticFactory1<PsiElement, InferenceErrorData> TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS = DiagnosticFactory1.create(ERROR);
     DiagnosticFactory1<PsiElement, InferenceErrorData> TYPE_INFERENCE_CANNOT_CAPTURE_TYPES = DiagnosticFactory1.create(ERROR);
-    DiagnosticFactory1<PsiElement, InferenceErrorData> TYPE_INFERENCE_TYPE_CONSTRUCTOR_MISMATCH = DiagnosticFactory1.create(ERROR);
+    DiagnosticFactory1<PsiElement, InferenceErrorData> TYPE_INFERENCE_PARAMETER_CONSTRAINT_ERROR = DiagnosticFactory1.create(ERROR);
+    DiagnosticFactory0<PsiElement> TYPE_INFERENCE_INCORPORATION_ERROR = DiagnosticFactory0.create(ERROR);
     DiagnosticFactory1<PsiElement, InferenceErrorData> TYPE_INFERENCE_UPPER_BOUND_VIOLATED = DiagnosticFactory1.create(ERROR);
     DiagnosticFactory2<JetExpression, JetType, JetType> TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH = DiagnosticFactory2.create(ERROR);
 
@@ -707,7 +707,8 @@ public interface Errors {
             UNUSED_VARIABLE, UNUSED_PARAMETER, ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE, VARIABLE_WITH_REDUNDANT_INITIALIZER,
             UNUSED_FUNCTION_LITERAL, USELESS_CAST, UNUSED_VALUE, USELESS_ELVIS);
     ImmutableSet<? extends DiagnosticFactory<?>> TYPE_INFERENCE_ERRORS = ImmutableSet.of(
-            TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER, TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS, TYPE_INFERENCE_TYPE_CONSTRUCTOR_MISMATCH,
+            TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER, TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS,
+            TYPE_INFERENCE_PARAMETER_CONSTRAINT_ERROR,
             TYPE_INFERENCE_UPPER_BOUND_VIOLATED, TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH);
 
     ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/PositioningStrategies.kt b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/PositioningStrategies.kt
index a57d3d38272..ecb07d02390 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/PositioningStrategies.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/PositioningStrategies.kt
@@ -289,7 +289,7 @@ public object PositioningStrategies {
 
     public val VARIANCE_IN_PROJECTION: PositioningStrategy<JetTypeProjection> = object : PositioningStrategy<JetTypeProjection>() {
         override fun mark(element: JetTypeProjection): List<TextRange> {
-            return markNode(element.getProjectionNode())
+            return markNode(element.getProjectionNode()!!)
         }
     }
 
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DefaultErrorMessages.java b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DefaultErrorMessages.java
index 5eed0c12740..599c79db94b 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DefaultErrorMessages.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DefaultErrorMessages.java
@@ -137,6 +137,7 @@ public class DefaultErrorMessages {
         MAP.put(REPEATED_MODIFIER, "Repeated ''{0}''", TO_STRING);
         MAP.put(INAPPLICABLE_ANNOTATION, "This annotation is only applicable to top level functions");
         MAP.put(INAPPLICABLE_PLATFORM_NAME, "platformName annotation is not applicable to this declaration");
+        MAP.put(WRONG_ANNOTATION_TARGET, "This annotation is not applicable to target ''{0}''", TO_STRING);
 
         MAP.put(REDUNDANT_MODIFIER, "Modifier ''{0}'' is redundant because ''{1}'' is present", TO_STRING, TO_STRING);
         MAP.put(ABSTRACT_MODIFIER_IN_TRAIT, "Modifier ''abstract'' is redundant in interface");
@@ -592,7 +593,8 @@ public class DefaultErrorMessages {
         MAP.put(TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS, "Type inference failed: {0}", TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS_RENDERER);
         MAP.put(TYPE_INFERENCE_CANNOT_CAPTURE_TYPES, "Type inference failed: {0}", TYPE_INFERENCE_CANNOT_CAPTURE_TYPES_RENDERER);
         MAP.put(TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER, "Type inference failed: {0}", TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER_RENDERER);
-        MAP.put(TYPE_INFERENCE_TYPE_CONSTRUCTOR_MISMATCH, "Type inference failed: {0}", TYPE_INFERENCE_TYPE_CONSTRUCTOR_MISMATCH_RENDERER);
+        MAP.put(TYPE_INFERENCE_PARAMETER_CONSTRAINT_ERROR, "Type inference failed: {0}", TYPE_INFERENCE_PARAMETER_CONSTRAINT_ERROR_RENDERER);
+        MAP.put(TYPE_INFERENCE_INCORPORATION_ERROR, "Type inference failed. Please try to specify type arguments explicitly.");
         MAP.put(TYPE_INFERENCE_UPPER_BOUND_VIOLATED, "{0}", TYPE_INFERENCE_UPPER_BOUND_VIOLATED_RENDERER);
         MAP.put(TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH, "Type inference failed. Expected type mismatch: found: {1} required: {0}", RENDER_TYPE, RENDER_TYPE);
 
@@ -612,7 +614,6 @@ public class DefaultErrorMessages {
         MAP.put(ANNOTATION_CLASS_WITH_BODY, "Body is not allowed for annotation class");
         MAP.put(INVALID_TYPE_OF_ANNOTATION_MEMBER, "Invalid type of annotation member");
         MAP.put(NULLABLE_TYPE_OF_ANNOTATION_MEMBER, "An annotation parameter cannot be nullable");
-        MAP.put(ILLEGAL_ANNOTATION_KEYWORD, "''annotation'' keyword is only applicable for class");
         MAP.put(ANNOTATION_PARAMETER_MUST_BE_CONST, "An annotation parameter must be a compile-time constant");
         MAP.put(ANNOTATION_PARAMETER_MUST_BE_ENUM_CONST, "An enum annotation parameter must be a enum constant");
         MAP.put(ANNOTATION_PARAMETER_MUST_BE_KCLASS_LITERAL, "An annotation parameter must be a class literal (T::class)");
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/Renderers.kt b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/Renderers.kt
index 40c26d70b52..13ec5c20b30 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/Renderers.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/Renderers.kt
@@ -37,6 +37,7 @@ import org.jetbrains.kotlin.resolve.calls.inference.TypeBounds.Bound
 import org.jetbrains.kotlin.resolve.calls.inference.TypeBounds.BoundKind.LOWER_BOUND
 import org.jetbrains.kotlin.resolve.calls.inference.TypeBounds.BoundKind.UPPER_BOUND
 import org.jetbrains.kotlin.resolve.calls.inference.constraintPosition.ConstraintPosition
+import org.jetbrains.kotlin.resolve.calls.inference.constraintPosition.ConstraintPositionKind
 import org.jetbrains.kotlin.resolve.calls.inference.constraintPosition.ConstraintPositionKind.RECEIVER_POSITION
 import org.jetbrains.kotlin.resolve.calls.inference.constraintPosition.ConstraintPositionKind.VALUE_PARAMETER_POSITION
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall
@@ -122,8 +123,8 @@ public object Renderers {
         renderConflictingSubstitutionsInferenceError(it, TabledDescriptorRenderer.create()).toString()
     }
 
-    public val TYPE_INFERENCE_TYPE_CONSTRUCTOR_MISMATCH_RENDERER: Renderer<InferenceErrorData> = Renderer {
-        renderTypeConstructorMismatchError(it, TabledDescriptorRenderer.create()).toString()
+    public val TYPE_INFERENCE_PARAMETER_CONSTRAINT_ERROR_RENDERER: Renderer<InferenceErrorData> = Renderer {
+        renderParameterConstraintError(it, TabledDescriptorRenderer.create()).toString()
     }
 
     public val TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER_RENDERER: Renderer<InferenceErrorData> = Renderer {
@@ -194,11 +195,11 @@ public object Renderers {
     }
 
     platformStatic
-    public fun renderTypeConstructorMismatchError(
+    public fun renderParameterConstraintError(
             inferenceErrorData: InferenceErrorData, renderer: TabledDescriptorRenderer
     ): TabledDescriptorRenderer {
         val constraintErrors = (inferenceErrorData.constraintSystem as ConstraintSystemImpl).constraintErrors
-        val errorPositions = constraintErrors.filter { it is TypeConstructorMismatch }.map { it.constraintPosition }
+        val errorPositions = constraintErrors.filter { it is ParameterConstraintError }.map { it.constraintPosition }
         return renderer.table(
                 TabledDescriptorRenderer
                         .newTable()
@@ -216,7 +217,7 @@ public object Renderers {
     ): TabledDescriptorRenderer {
         var firstUnknownParameter: TypeParameterDescriptor? = null
         for (typeParameter in inferenceErrorData.constraintSystem.getTypeVariables()) {
-            if (inferenceErrorData.constraintSystem.getTypeBounds(typeParameter).isEmpty()) {
+            if (inferenceErrorData.constraintSystem.getTypeBounds(typeParameter).values.isEmpty()) {
                 firstUnknownParameter = typeParameter
                 break
             }
@@ -228,7 +229,7 @@ public object Renderers {
 
         return result
                 .text(newText().normal("Not enough information to infer parameter ")
-                              .strong(firstUnknownParameter!!.getName())
+                              .strong(firstUnknownParameter.getName())
                               .normal(" in "))
                 .table(newTable()
                                .descriptor(inferenceErrorData.descriptor)
@@ -244,9 +245,9 @@ public object Renderers {
         LOG.assertTrue(status.hasViolatedUpperBound(),
                        renderDebugMessage("Upper bound violated renderer is applied for incorrect status", inferenceErrorData))
 
-        val systemWithoutWeakConstraints = constraintSystem.getSystemWithoutWeakConstraints()
+        val systemWithoutWeakConstraints = constraintSystem.filterConstraintsOut(ConstraintPositionKind.TYPE_BOUND_POSITION)
         val typeParameterDescriptor = inferenceErrorData.descriptor.getTypeParameters().firstOrNull { 
-            !ConstraintsUtil.checkUpperBoundIsSatisfied(systemWithoutWeakConstraints, it, true) 
+            !ConstraintsUtil.checkUpperBoundIsSatisfied(systemWithoutWeakConstraints, it, true)
         }
         if (typeParameterDescriptor == null && status.hasConflictingConstraints()) {
             return renderConflictingSubstitutionsInferenceError(inferenceErrorData, result)
@@ -256,7 +257,7 @@ public object Renderers {
             return result
         }
 
-        val inferredValueForTypeParameter = systemWithoutWeakConstraints.getTypeBounds(typeParameterDescriptor).getValue()
+        val inferredValueForTypeParameter = systemWithoutWeakConstraints.getTypeBounds(typeParameterDescriptor).value
         if (inferredValueForTypeParameter == null) {
             LOG.error(renderDebugMessage("System without weak constraints is not successful, there is no value for type parameter " + 
                                          typeParameterDescriptor.getName() + "\n: " + systemWithoutWeakConstraints, inferenceErrorData))
@@ -351,33 +352,37 @@ public object Renderers {
 
     public val RENDER_COLLECTION_OF_TYPES: Renderer<Collection<JetType>> = Renderer { renderTypes(it) }
 
-    private fun renderConstraintSystem(constraintSystem: ConstraintSystem): String {
+    private fun renderConstraintSystem(constraintSystem: ConstraintSystem, renderTypeBounds: Renderer<TypeBounds>): String {
         val typeVariables = constraintSystem.getTypeVariables()
         val typeBounds = Sets.newLinkedHashSet<TypeBounds>()
         for (variable in typeVariables) {
             typeBounds.add(constraintSystem.getTypeBounds(variable))
         }
         return "type parameter bounds:\n" +
-               StringUtil.join(typeBounds, { RENDER_TYPE_BOUNDS.render(it) }, "\n") + "\n" + "status:\n" +
+               StringUtil.join(typeBounds, { renderTypeBounds.render(it) }, "\n") + "\n\n" + "status:\n" +
                ConstraintsUtil.getDebugMessageForStatus(constraintSystem.getStatus())
     }
 
-    public val RENDER_CONSTRAINT_SYSTEM: Renderer<ConstraintSystem> = Renderer { renderConstraintSystem(it) }
+    public val RENDER_CONSTRAINT_SYSTEM: Renderer<ConstraintSystem> = Renderer { renderConstraintSystem(it, RENDER_TYPE_BOUNDS) }
+    public val RENDER_CONSTRAINT_SYSTEM_SHORT: Renderer<ConstraintSystem> = Renderer { renderConstraintSystem(it, RENDER_TYPE_BOUNDS_SHORT) }
 
-    private fun renderTypeBounds(typeBounds: TypeBounds): String {
+    private fun renderTypeBounds(typeBounds: TypeBounds, short: Boolean): String {
         val renderBound = { bound: Bound ->
             val arrow = if (bound.kind == LOWER_BOUND) ">: " else if (bound.kind == UPPER_BOUND) "<: " else ":= "
-            arrow + RENDER_TYPE.render(bound.constrainingType) + '(' + bound.position + ')'
+            val renderer = if (short) DescriptorRenderer.SHORT_NAMES_IN_TYPES else DescriptorRenderer.FQ_NAMES_IN_TYPES
+            val renderedBound = arrow + renderer.renderType(bound.constrainingType) +  if (!bound.isProper) "*" else ""
+            if (short) renderedBound else renderedBound + '(' + bound.position + ')'
         }
         val typeVariableName = typeBounds.typeVariable.getName()
-        return if (typeBounds.isEmpty()) {
+        return if (typeBounds.bounds.isEmpty()) {
             typeVariableName.asString()
         }
         else
             "$typeVariableName ${StringUtil.join(typeBounds.bounds, renderBound, ", ")}"
     }
 
-    public val RENDER_TYPE_BOUNDS: Renderer<TypeBounds> = Renderer { renderTypeBounds(it) }
+    public val RENDER_TYPE_BOUNDS: Renderer<TypeBounds> = Renderer { renderTypeBounds(it, short = false) }
+    public val RENDER_TYPE_BOUNDS_SHORT: Renderer<TypeBounds> = Renderer { renderTypeBounds(it, short = true) }
 
     private fun renderDebugMessage(message: String, inferenceErrorData: InferenceErrorData) = StringBuilder {
         append(message)
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/kdoc/psi/impl/KDocLink.kt b/compiler/frontend/src/org/jetbrains/kotlin/kdoc/psi/impl/KDocLink.kt
index f936c51275c..e7d1182d95f 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/kdoc/psi/impl/KDocLink.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/kdoc/psi/impl/KDocLink.kt
@@ -43,6 +43,6 @@ public class KDocLink(node: ASTNode) : JetElementImpl(node) {
         return if (tag != null && tag.getSubjectLink() == this) tag else null
     }
 
-    override fun getReferences(): Array<out PsiReference>? =
+    override fun getReferences(): Array<out PsiReference> =
         ReferenceProvidersRegistry.getReferencesFromProviders(this)
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/lexer/JetTokens.java b/compiler/frontend/src/org/jetbrains/kotlin/lexer/JetTokens.java
index 30d77adfab9..f3e44c2f7d1 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/lexer/JetTokens.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/lexer/JetTokens.java
@@ -145,7 +145,6 @@ public interface JetTokens {
     JetModifierKeywordToken ENUM_KEYWORD      = JetModifierKeywordToken.softKeywordModifier("enum");
     JetModifierKeywordToken OPEN_KEYWORD      = JetModifierKeywordToken.softKeywordModifier("open");
     JetModifierKeywordToken INNER_KEYWORD     = JetModifierKeywordToken.softKeywordModifier("inner");
-    JetModifierKeywordToken ANNOTATION_KEYWORD = JetModifierKeywordToken.softKeywordModifier("annotation");
     JetModifierKeywordToken OVERRIDE_KEYWORD  = JetModifierKeywordToken.softKeywordModifier("override");
     JetModifierKeywordToken PRIVATE_KEYWORD   = JetModifierKeywordToken.softKeywordModifier("private");
     JetModifierKeywordToken PUBLIC_KEYWORD    = JetModifierKeywordToken.softKeywordModifier("public");
@@ -172,7 +171,7 @@ public interface JetTokens {
     );
 
     TokenSet SOFT_KEYWORDS = TokenSet.create(FILE_KEYWORD, IMPORT_KEYWORD, WHERE_KEYWORD, BY_KEYWORD, GET_KEYWORD,
-                                             SET_KEYWORD, ABSTRACT_KEYWORD, ENUM_KEYWORD, OPEN_KEYWORD, INNER_KEYWORD, ANNOTATION_KEYWORD,
+                                             SET_KEYWORD, ABSTRACT_KEYWORD, ENUM_KEYWORD, OPEN_KEYWORD, INNER_KEYWORD,
                                              OVERRIDE_KEYWORD, PRIVATE_KEYWORD, PUBLIC_KEYWORD, INTERNAL_KEYWORD, PROTECTED_KEYWORD,
                                              CATCH_KEYWORD, FINALLY_KEYWORD, OUT_KEYWORD, FINAL_KEYWORD, VARARG_KEYWORD, REIFIED_KEYWORD,
                                              DYNAMIC_KEYWORD, COMPANION_KEYWORD, CONSTRUCTOR_KEYWORD, INIT_KEYWORD, SEALED_KEYWORD
@@ -185,7 +184,7 @@ public interface JetTokens {
      */
     JetModifierKeywordToken[] MODIFIER_KEYWORDS_ARRAY =
             new JetModifierKeywordToken[] {
-                    ABSTRACT_KEYWORD, ENUM_KEYWORD, OPEN_KEYWORD, INNER_KEYWORD, ANNOTATION_KEYWORD, OVERRIDE_KEYWORD, PRIVATE_KEYWORD,
+                    ABSTRACT_KEYWORD, ENUM_KEYWORD, OPEN_KEYWORD, INNER_KEYWORD, OVERRIDE_KEYWORD, PRIVATE_KEYWORD,
                     PUBLIC_KEYWORD, INTERNAL_KEYWORD, PROTECTED_KEYWORD, OUT_KEYWORD, IN_KEYWORD, FINAL_KEYWORD, VARARG_KEYWORD,
                     REIFIED_KEYWORD, COMPANION_KEYWORD, SEALED_KEYWORD
             };
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/parsing/JetExpressionParsing.java b/compiler/frontend/src/org/jetbrains/kotlin/parsing/JetExpressionParsing.java
index f124063866b..b91fb01d414 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/parsing/JetExpressionParsing.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/parsing/JetExpressionParsing.java
@@ -77,7 +77,6 @@ public class JetExpressionParsing extends AbstractJetParsing {
             COLONCOLON, // callable reference
 
             LPAR, // parenthesized
-            HASH, // Tuple
 
             // literal constant
             TRUE_KEYWORD, FALSE_KEYWORD,
@@ -88,8 +87,6 @@ public class JetExpressionParsing extends AbstractJetParsing {
             LBRACE, // functionLiteral
             FUN_KEYWORD, // expression function
 
-            LPAR, // tuple
-
             THIS_KEYWORD, // this
             SUPER_KEYWORD, // super
 
@@ -604,7 +601,6 @@ public class JetExpressionParsing extends AbstractJetParsing {
 
     /*
      * atomicExpression
-     *   : tupleLiteral // or parenthesized element
      *   : "this" label?
      *   : "super" ("<" type ">")? label?
      *   : objectLiteral
@@ -628,9 +624,6 @@ public class JetExpressionParsing extends AbstractJetParsing {
         if (at(LPAR)) {
             parseParenthesizedExpression();
         }
-        else if (at(HASH)) {
-            parseTupleExpression();
-        }
         else if (at(PACKAGE_KEYWORD)) {
             parseOneTokenExpression(ROOT_PACKAGE);
         }
@@ -1782,49 +1775,6 @@ public class JetExpressionParsing extends AbstractJetParsing {
         mark.done(PARENTHESIZED);
     }
 
-    /*
-     * tupleLiteral
-     *   : "#" "(" (((SimpleName "=")? expression){","})? ")"
-     *   ;
-     */
-    @Deprecated // Tuples are dropped, but parsing is left to minimize surprising. This code should be removed some time (in Kotlin 1.0?)
-    private void parseTupleExpression() {
-        assert _at(HASH);
-        PsiBuilder.Marker mark = mark();
-
-        advance(); // HASH
-        advance(); // LPAR
-        myBuilder.disableNewlines();
-        if (!at(RPAR)) {
-            while (true) {
-                while (at(COMMA)) {
-                    advance();
-                }
-
-                if (at(IDENTIFIER) && lookahead(1) == EQ) {
-                    advance(); // IDENTIFIER
-                    advance(); // EQ
-                    parseExpression();
-                }
-                else {
-                    parseExpression();
-                }
-
-                if (!at(COMMA)) break;
-                advance(); // COMMA
-
-                if (at(RPAR)) {
-                    break;
-                }
-            }
-
-        }
-        consumeIf(RPAR);
-        myBuilder.restoreNewlinesState();
-
-        mark.error("Tuples are not supported. Use data classes instead.");
-    }
-
     /*
      * "this" label?
      */
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/parsing/JetParsing.java b/compiler/frontend/src/org/jetbrains/kotlin/parsing/JetParsing.java
index 3cac49927bc..5885429de1c 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/parsing/JetParsing.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/parsing/JetParsing.java
@@ -1823,7 +1823,6 @@ public class JetParsing extends AbstractJetParsing {
      *   : selfType
      *   : functionType
      *   : userType
-     *   : tupleType
      *   : nullableType
      *   : "dynamic"
      *   ;
@@ -1857,9 +1856,6 @@ public class JetParsing extends AbstractJetParsing {
         else if (at(IDENTIFIER) || at(PACKAGE_KEYWORD) || atParenthesizedMutableForPlatformTypes(0)) {
             parseUserType();
         }
-        else if (at(HASH)) {
-            parseTupleType();
-        }
         else if (at(LPAR)) {
             PsiBuilder.Marker functionOrParenthesizedType = mark();
 
@@ -2117,51 +2113,6 @@ public class JetParsing extends AbstractJetParsing {
         createTruncatedBuilder(lastId).parseModifierList(ALLOW_UNESCAPED_REGULAR_ANNOTATIONS);
     }
 
-    /*
-     * tupleType
-     *   : "#" "(" type{","}? ")"
-     *   : "#" "(" parameter{","} ")" // tuple with named entries, the names do not affect assignment compatibility
-     *   ;
-     */
-    @Deprecated // Tuples are dropped, but parsing is left to minimize surprising. This code should be removed some time (in Kotlin 1.0?)
-    private void parseTupleType() {
-        assert _at(HASH);
-
-        PsiBuilder.Marker tuple = mark();
-
-        myBuilder.disableNewlines();
-        advance(); // HASH
-        consumeIf(LPAR);
-
-        if (!at(RPAR)) {
-            while (true) {
-                if (at(COLON)) {
-                    errorAndAdvance("Expecting a name for tuple entry");
-                }
-
-                if (at(IDENTIFIER) && lookahead(1) == COLON) {
-                    advance(); // IDENTIFIER
-                    advance(); // COLON
-                    parseTypeRef();
-                }
-                else if (TYPE_REF_FIRST.contains(tt())) {
-                    parseTypeRef();
-                }
-                else {
-                    error("Type expected");
-                    break;
-                }
-                if (!at(COMMA)) break;
-                advance(); // COMMA
-            }
-        }
-
-        consumeIf(RPAR);
-        myBuilder.restoreNewlinesState();
-
-        tuple.error("Tuples are not supported. Use data classes instead.");
-    }
-
     /*
      * functionType
      *   : "(" (parameter | modifiers type){","}? ")" "->" type?
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetClass.kt b/compiler/frontend/src/org/jetbrains/kotlin/psi/JetClass.kt
index 803db5ea1d8..3328e6c389b 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetClass.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/JetClass.kt
@@ -89,7 +89,7 @@ public open class JetClass : JetClassOrObject {
         val parts = ArrayList<String>()
         var current: JetClassOrObject? = this
         while (current != null) {
-            parts.add(current.getName())
+            parts.add(current.getName()!!)
             current = PsiTreeUtil.getParentOfType<JetClassOrObject>(current, javaClass<JetClassOrObject>())
         }
         val file = getContainingFile()
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetClassOrObject.kt b/compiler/frontend/src/org/jetbrains/kotlin/psi/JetClassOrObject.kt
index b58e39d1c60..ccd7a473169 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetClassOrObject.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/JetClassOrObject.kt
@@ -25,6 +25,7 @@ import com.intellij.psi.impl.CheckUtil
 import com.intellij.psi.impl.source.codeStyle.CodeEditUtil
 import com.intellij.psi.stubs.IStubElementType
 import org.jetbrains.kotlin.JetNodeTypes
+import org.jetbrains.kotlin.builtins.KotlinBuiltIns
 import org.jetbrains.kotlin.lexer.JetTokens
 import org.jetbrains.kotlin.psi.stubs.KotlinClassOrObjectStub
 import org.jetbrains.kotlin.psi.stubs.elements.JetStubElementTypes
@@ -64,7 +65,19 @@ abstract public class JetClassOrObject : JetTypeParameterListOwnerStub<KotlinCla
 
     public fun getSecondaryConstructors(): List<JetSecondaryConstructor> = getBody()?.getSecondaryConstructors().orEmpty()
 
-    public fun isAnnotation(): Boolean = hasModifier(JetTokens.ANNOTATION_KEYWORD)
+    deprecated(value = "It's no more possible to determine it exactly using AST. Use ClassDescriptor methods instead, e.g. getKind()")
+    public fun isAnnotation(): Boolean = getBuiltInAnnotationEntry() != null
+
+    public fun getBuiltInAnnotationEntry(): JetAnnotationEntry? = getAnnotation(KotlinBuiltIns.FQ_NAMES.annotation.shortName().asString())
+
+    private fun getAnnotation(name: String): JetAnnotationEntry? {
+        return getAnnotationEntries().firstOrNull() { entry ->
+            val typeReference = entry.getTypeReference()
+            val userType = typeReference?.getStubOrPsiChild(JetStubElementTypes.USER_TYPE)
+
+            name == userType?.getReferencedName()
+        }
+    }
 
     public override fun delete() {
         CheckUtil.checkWritable(this);
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetConstructor.kt b/compiler/frontend/src/org/jetbrains/kotlin/psi/JetConstructor.kt
index 2a10bdc2bce..32336cf1b65 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetConstructor.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/JetConstructor.kt
@@ -19,6 +19,7 @@ package org.jetbrains.kotlin.psi
 import com.intellij.lang.ASTNode
 import com.intellij.navigation.ItemPresentationProviders
 import com.intellij.psi.PsiElement
+import com.intellij.psi.search.SearchScope
 import com.intellij.util.IncorrectOperationException
 import org.jetbrains.kotlin.lexer.JetTokens
 import org.jetbrains.kotlin.name.Name
@@ -89,4 +90,8 @@ public abstract class JetConstructor<T : JetConstructor<T>> : JetDeclarationStub
                ?: getValueParameterList()?.getTextOffset()
                ?: super<JetDeclarationStub>.getTextOffset()
     }
+
+    override fun getUseScope(): SearchScope {
+        return getContainingClassOrObject().getUseScope()
+    }
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetDoubleColonExpression.kt b/compiler/frontend/src/org/jetbrains/kotlin/psi/JetDoubleColonExpression.kt
index 3a3b058918d..a540a86b24b 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetDoubleColonExpression.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/JetDoubleColonExpression.kt
@@ -24,7 +24,7 @@ import org.jetbrains.kotlin.lexer.JetTokens
 public abstract class JetDoubleColonExpression(node: ASTNode) : JetExpressionImpl(node) {
     public fun getTypeReference(): JetTypeReference? = findChildByType(JetNodeTypes.TYPE_REFERENCE)
 
-    public fun getDoubleColonTokenReference(): PsiElement = findChildByType(JetTokens.COLONCOLON)
+    public fun getDoubleColonTokenReference(): PsiElement = findChildByType(JetTokens.COLONCOLON)!!
 
     override fun <R, D> accept(visitor: JetVisitor<R, D>, data: D): R {
         return visitor.visitDoubleColonExpression(this, data)
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetElement.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/JetElement.kt
similarity index 55%
rename from compiler/frontend/src/org/jetbrains/kotlin/psi/JetElement.java
rename to compiler/frontend/src/org/jetbrains/kotlin/psi/JetElement.kt
index 2f809423585..2a727701013 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetElement.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/JetElement.kt
@@ -14,16 +14,18 @@
  * limitations under the License.
  */
 
-package org.jetbrains.kotlin.psi;
+package org.jetbrains.kotlin.psi
 
-import com.intellij.psi.NavigatablePsiElement;
-import org.jetbrains.annotations.NotNull;
+import com.intellij.psi.NavigatablePsiElement
+import com.intellij.psi.PsiReference
 
-public interface JetElement extends NavigatablePsiElement {
-    @NotNull
-    JetFile getContainingJetFile();
+public interface JetElement : NavigatablePsiElement {
+    public fun getContainingJetFile(): JetFile
 
-    <D> void acceptChildren(@NotNull JetVisitor<Void, D> visitor, D data);
+    public fun <D> acceptChildren(visitor: JetVisitor<Void, D>, data: D)
 
-    <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data);
+    public fun <R, D> accept(visitor: JetVisitor<R, D>, data: D): R
+
+    @deprecated("Don't use getReference() on JetElement for the choice is unpredictable")
+    override fun getReference(): PsiReference?
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetImportsFactory.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/JetImportsFactory.java
index 0155486c900..5b3e7fcb28f 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetImportsFactory.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/JetImportsFactory.java
@@ -24,20 +24,17 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.resolve.ImportPath;
 
-import javax.inject.Inject;
 import java.util.Collection;
 import java.util.Map;
 
 import static org.jetbrains.kotlin.psi.PsiPackage.JetPsiFactory;
 
 public class JetImportsFactory {
-    private Project project;
+    @NotNull private final Project project;
 
     private final Map<ImportPath, JetImportDirective> importsCache = Maps.newHashMap();
 
-    @Inject
-    public void setProject(@NotNull Project project) {
-        importsCache.clear();
+    public JetImportsFactory(@NotNull Project project) {
         this.project = project;
     }
 
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetNameReferenceExpression.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/JetNameReferenceExpression.java
deleted file mode 100644
index 9f7cdf5ac33..00000000000
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetNameReferenceExpression.java
+++ /dev/null
@@ -1,86 +0,0 @@
-/*
- * Copyright 2010-2015 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.kotlin.psi;
-
-import com.intellij.lang.ASTNode;
-import com.intellij.psi.PsiElement;
-import com.intellij.psi.tree.IElementType;
-import com.intellij.psi.tree.TokenSet;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.psi.stubs.KotlinNameReferenceExpressionStub;
-import org.jetbrains.kotlin.psi.stubs.elements.JetStubElementTypes;
-import org.jetbrains.kotlin.name.Name;
-import org.jetbrains.kotlin.lexer.JetTokens;
-
-import static org.jetbrains.kotlin.lexer.JetTokens.*;
-
-public class JetNameReferenceExpression extends JetExpressionImplStub<KotlinNameReferenceExpressionStub> implements JetSimpleNameExpression {
-
-    private static final TokenSet NAME_REFERENCE_EXPRESSIONS = TokenSet.create(IDENTIFIER, FIELD_IDENTIFIER, THIS_KEYWORD, SUPER_KEYWORD);
-
-    public JetNameReferenceExpression(@NotNull ASTNode node) {
-        super(node);
-    }
-
-    public JetNameReferenceExpression(@NotNull KotlinNameReferenceExpressionStub stub) {
-        super(stub, JetStubElementTypes.REFERENCE_EXPRESSION);
-    }
-
-    @Override
-    @NotNull
-    public String getReferencedName() {
-        KotlinNameReferenceExpressionStub stub = getStub();
-        if (stub != null) {
-            return stub.getReferencedName();
-        }
-        return JetSimpleNameExpressionImpl.Helper.getReferencedNameImpl(this);
-    }
-
-    @Override
-    @NotNull
-    public Name getReferencedNameAsName() {
-        return JetSimpleNameExpressionImpl.Helper.getReferencedNameAsNameImpl(this);
-    }
-
-    @Override
-    @NotNull
-    public PsiElement getReferencedNameElement() {
-        PsiElement element = findChildByType(NAME_REFERENCE_EXPRESSIONS);
-        if (element == null) {
-            return this;
-        }
-        return element;
-    }
-
-    @Override
-    @Nullable
-    public PsiElement getIdentifier() {
-        return findChildByType(JetTokens.IDENTIFIER);
-    }
-
-    @NotNull
-    @Override
-    public IElementType getReferencedNameElementType() {
-        return JetSimpleNameExpressionImpl.Helper.getReferencedNameElementTypeImpl(this);
-    }
-
-    @Override
-    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
-        return visitor.visitSimpleNameExpression(this, data);
-    }
-}
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetNameReferenceExpression.kt b/compiler/frontend/src/org/jetbrains/kotlin/psi/JetNameReferenceExpression.kt
new file mode 100644
index 00000000000..e2132dc5732
--- /dev/null
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/JetNameReferenceExpression.kt
@@ -0,0 +1,69 @@
+/*
+ * Copyright 2010-2015 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.kotlin.psi
+
+import com.intellij.lang.ASTNode
+import com.intellij.psi.PsiElement
+import com.intellij.psi.tree.IElementType
+import com.intellij.psi.tree.TokenSet
+import org.jetbrains.kotlin.psi.stubs.KotlinNameReferenceExpressionStub
+import org.jetbrains.kotlin.psi.stubs.elements.JetStubElementTypes
+import org.jetbrains.kotlin.name.Name
+import org.jetbrains.kotlin.lexer.JetTokens
+
+import org.jetbrains.kotlin.lexer.JetTokens.*
+
+public class JetNameReferenceExpression : JetExpressionImplStub<KotlinNameReferenceExpressionStub>, JetSimpleNameExpression {
+    public constructor(node: ASTNode) : super(node) {
+    }
+
+    public constructor(stub: KotlinNameReferenceExpressionStub) : super(stub, JetStubElementTypes.REFERENCE_EXPRESSION) {
+    }
+
+    override fun getReferencedName(): String {
+        val stub = getStub()
+        if (stub != null) {
+            return stub.getReferencedName()
+        }
+        return JetSimpleNameExpressionImpl.getReferencedNameImpl(this)
+    }
+
+    override fun getReferencedNameAsName(): Name {
+        return JetSimpleNameExpressionImpl.getReferencedNameAsNameImpl(this)
+    }
+
+    override fun getReferencedNameElement(): PsiElement {
+        val element = findChildByType<PsiElement>(NAME_REFERENCE_EXPRESSIONS) ?: return this
+        return element
+    }
+
+    override fun getIdentifier(): PsiElement? {
+        return findChildByType(JetTokens.IDENTIFIER)
+    }
+
+    override fun getReferencedNameElementType(): IElementType {
+        return JetSimpleNameExpressionImpl.getReferencedNameElementTypeImpl(this)
+    }
+
+    override fun <R, D> accept(visitor: JetVisitor<R, D>, data: D): R {
+        return visitor.visitSimpleNameExpression(this, data)
+    }
+
+    companion object {
+        private val NAME_REFERENCE_EXPRESSIONS = TokenSet.create(IDENTIFIER, FIELD_IDENTIFIER, THIS_KEYWORD, SUPER_KEYWORD)
+    }
+}
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetObjectDeclaration.kt b/compiler/frontend/src/org/jetbrains/kotlin/psi/JetObjectDeclaration.kt
index a1b0f6dd383..7f005751faa 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetObjectDeclaration.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/JetObjectDeclaration.kt
@@ -75,5 +75,5 @@ public class JetObjectDeclaration : JetClassOrObject {
 
     public fun isObjectLiteral(): Boolean = getStub()?.isObjectLiteral() ?: (getParent() is JetObjectLiteralExpression)
 
-    public fun getObjectKeyword(): PsiElement = findChildByType(JetTokens.OBJECT_KEYWORD)
+    public fun getObjectKeyword(): PsiElement = findChildByType(JetTokens.OBJECT_KEYWORD)!!
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetPackageDirective.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/JetPackageDirective.java
index c471010cf73..5caa6c0e827 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetPackageDirective.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/JetPackageDirective.java
@@ -32,9 +32,7 @@ import org.jetbrains.kotlin.psi.stubs.elements.JetStubElementTypes;
 import java.util.Collections;
 import java.util.List;
 
-public class JetPackageDirective
-        extends JetModifierListOwnerStub<KotlinPlaceHolderStub<JetPackageDirective>>
-        implements JetReferenceExpression {
+public class JetPackageDirective extends JetModifierListOwnerStub<KotlinPlaceHolderStub<JetPackageDirective>> {
     private String qualifiedNameCache = null;
 
     public JetPackageDirective(@NotNull ASTNode node) {
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetParameter.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/JetParameter.java
index adf8d9a5390..c02ee94de2f 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetParameter.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/JetParameter.java
@@ -182,7 +182,7 @@ public class JetParameter extends JetNamedDeclarationStub<KotlinParameterStub> i
         PsiElement parent = getParent();
         if (parent != null) {
             PsiElement grandparent = parent.getParent();
-            if (grandparent instanceof JetNamedFunction) {
+            if (grandparent instanceof JetFunction && !(grandparent instanceof JetFunctionLiteral)) {
                 return grandparent.getUseScope();
             }
         }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetPsiFactory.kt b/compiler/frontend/src/org/jetbrains/kotlin/psi/JetPsiFactory.kt
index cb1c6790cd8..b2aa4f59d09 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetPsiFactory.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/JetPsiFactory.kt
@@ -251,7 +251,7 @@ public class JetPsiFactory(private val project: Project) {
     }
 
     public fun createFunctionLiteralParameterList(text: String): JetParameterList {
-        return (createExpression("{ $text -> 0}") as JetFunctionLiteralExpression).getFunctionLiteral().getValueParameterList()
+        return (createExpression("{ $text -> 0}") as JetFunctionLiteralExpression).getFunctionLiteral().getValueParameterList()!!
     }
 
     public fun createEnumEntry(text: String): JetEnumEntry {
@@ -284,7 +284,7 @@ public class JetPsiFactory(private val project: Project) {
     }
 
     public fun createPackageDirective(fqName: FqName): JetPackageDirective {
-        return createFile("package ${fqName.asString()}").getPackageDirective()
+        return createFile("package ${fqName.asString()}").getPackageDirective()!!
     }
 
     public fun createPackageDirectiveIfNeeded(fqName: FqName): JetPackageDirective? {
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetPsiUtil.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/JetPsiUtil.java
index 54ddd225259..2d95ad9d0e6 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetPsiUtil.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/JetPsiUtil.java
@@ -373,8 +373,13 @@ public class JetPsiUtil {
 
     @Nullable
     @Contract("null, _ -> null")
-    public static PsiElement getTopmostParentOfTypes(@Nullable PsiElement element, @NotNull Class<? extends PsiElement>... parentTypes) {
+    public static PsiElement getTopmostParentOfTypes(
+            @Nullable PsiElement element,
+            @NotNull Class<? extends PsiElement>... parentTypes) {
+        if (element instanceof PsiFile) return null;
+
         PsiElement answer = PsiTreeUtil.getParentOfType(element, parentTypes);
+        if (answer instanceof PsiFile) return answer;
 
         do {
             PsiElement next = PsiTreeUtil.getParentOfType(answer, parentTypes);
@@ -775,9 +780,9 @@ public class JetPsiUtil {
         else if (declaration instanceof JetParameter) {
             PsiElement parent = declaration.getParent();
 
-            // val/var parameter of primary constructor should not be considered as local
+            // val/var parameter of primary constructor should be considered as local according to containing class
             if (((JetParameter) declaration).hasValOrVar() && parent != null && parent.getParent() instanceof JetPrimaryConstructor) {
-                return null;
+                return getEnclosingElementForLocalDeclaration(((JetPrimaryConstructor) parent.getParent()).getContainingClassOrObject(), skipParameters);
             }
 
             else if (skipParameters && parent != null && parent.getParent() instanceof JetNamedFunction) {
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetSimpleNameExpression.kt b/compiler/frontend/src/org/jetbrains/kotlin/psi/JetSimpleNameExpression.kt
index ea8976929c3..3223f76655e 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetSimpleNameExpression.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/JetSimpleNameExpression.kt
@@ -18,11 +18,12 @@ package org.jetbrains.kotlin.psi
 
 import com.intellij.lang.ASTNode
 import com.intellij.psi.PsiElement
+import com.intellij.psi.PsiReference
 import com.intellij.psi.tree.IElementType
-import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.lexer.JetTokens
+import org.jetbrains.kotlin.name.Name
 
-public trait JetSimpleNameExpression : JetReferenceExpression {
+public interface JetSimpleNameExpression : JetReferenceExpression {
 
     public fun getReferencedName(): String
 
@@ -36,33 +37,31 @@ public trait JetSimpleNameExpression : JetReferenceExpression {
 }
 
 abstract class JetSimpleNameExpressionImpl(node: ASTNode) : JetExpressionImpl(node), JetSimpleNameExpression {
-
     override fun getIdentifier(): PsiElement? = findChildByType(JetTokens.IDENTIFIER)
 
-    override fun getReferencedNameElementType() = getReferencedNameElementTypeImpl()
+    override fun getReferencedNameElementType() = getReferencedNameElementTypeImpl(this)
 
     override fun <R, D> accept(visitor: JetVisitor<R, D>, data: D): R {
         return visitor.visitSimpleNameExpression(this, data)
     }
 
-    override fun getReferencedNameAsName() = getReferencedNameAsNameImpl()
+    override fun getReferencedNameAsName() = getReferencedNameAsNameImpl(this)
 
-    override fun getReferencedName() = getReferencedNameImpl()
+    override fun getReferencedName() = getReferencedNameImpl(this)
 
     //NOTE: an unfortunate way to share an implementation between stubbed and not stubbed tree
-    companion object Helper {
-
-        fun JetSimpleNameExpression.getReferencedNameElementTypeImpl(): IElementType {
-            return this.getReferencedNameElement().getNode()!!.getElementType()!!
+    companion object {
+        fun getReferencedNameElementTypeImpl(expression: JetSimpleNameExpression): IElementType {
+            return expression.getReferencedNameElement().getNode()!!.getElementType()
         }
 
-        fun JetSimpleNameExpression.getReferencedNameAsNameImpl(): Name {
-            val name = this.getReferencedName()
+        fun getReferencedNameAsNameImpl(expresssion: JetSimpleNameExpression): Name {
+            val name = expresssion.getReferencedName()
             return Name.identifierNoValidate(name)
         }
 
-        fun JetSimpleNameExpression.getReferencedNameImpl(): String {
-            val text = this.getReferencedNameElement().getNode()!!.getText()
+        fun getReferencedNameImpl(expression: JetSimpleNameExpression): String {
+            val text = expression.getReferencedNameElement().getNode()!!.getText()
             return JetPsiUtil.unquoteIdentifierOrFieldReference(text)
         }
     }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetVisitor.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/JetVisitor.java
index 249a00b8caa..ff7e98bc42d 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetVisitor.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/JetVisitor.java
@@ -439,6 +439,6 @@ public class JetVisitor<R, D> extends PsiElementVisitor {
     }
 
     public R visitPackageDirective(@NotNull JetPackageDirective directive, D data) {
-        return visitExpression(directive, data);
+        return visitJetElement(directive, data);
     }
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/KotlinStringLiteralTextEscaper.kt b/compiler/frontend/src/org/jetbrains/kotlin/psi/KotlinStringLiteralTextEscaper.kt
index 83494aa585d..c6bb1f649f6 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/KotlinStringLiteralTextEscaper.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KotlinStringLiteralTextEscaper.kt
@@ -39,7 +39,7 @@ public class KotlinStringLiteralTextEscaper(host: JetStringTemplateExpression):
             }
             when (child) {
                 is JetLiteralStringTemplateEntry -> {
-                    val textRange = rangeInsideHost.intersection(childRange).shiftRight(-childRange.getStartOffset())
+                    val textRange = rangeInsideHost.intersection(childRange)!!.shiftRight(-childRange.getStartOffset())
                     outChars.append(child.getText(), textRange.getStartOffset(), textRange.getEndOffset())
                     textRange.getLength().times {
                         sourceOffsetsList.add(sourceOffset++)
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/addRemoveModifier.kt b/compiler/frontend/src/org/jetbrains/kotlin/psi/addRemoveModifier.kt
index 74519420943..67ee4302bc7 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/addRemoveModifier.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/addRemoveModifier.kt
@@ -102,4 +102,4 @@ private val MODIFIERS_ORDER = listOf(PUBLIC_KEYWORD, PROTECTED_KEYWORD, PRIVATE_
                                      FINAL_KEYWORD, OPEN_KEYWORD, ABSTRACT_KEYWORD,
                                      OVERRIDE_KEYWORD,
                                      INNER_KEYWORD,
-                                     ANNOTATION_KEYWORD, ENUM_KEYWORD, COMPANION_KEYWORD)
+                                     ENUM_KEYWORD, COMPANION_KEYWORD)
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/psiUtil/jetPsiUtil.kt b/compiler/frontend/src/org/jetbrains/kotlin/psi/psiUtil/jetPsiUtil.kt
index 70730cc00f3..8d3c0dbc594 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/psiUtil/jetPsiUtil.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/psiUtil/jetPsiUtil.kt
@@ -130,7 +130,7 @@ public fun JetElement.getQualifiedExpressionForSelector(): JetQualifiedExpressio
     return if (parent is JetQualifiedExpression && parent.getSelectorExpression() == this) parent else null
 }
 
-public fun JetElement.getQualifiedExpressionForSelectorOrThis(): JetElement {
+public fun JetExpression.getQualifiedExpressionForSelectorOrThis(): JetExpression {
     return getQualifiedExpressionForSelector() ?: this
 }
 
@@ -144,9 +144,9 @@ public fun JetElement.getCalleeHighlightingRange(): TextRange {
             ) ?: return getTextRange()
 
     val startOffset = annotationEntry.getAtSymbol()?.getTextRange()?.getStartOffset()
-                      ?: annotationEntry.getCalleeExpression().startOffset
+                      ?: annotationEntry.getCalleeExpression()!!.startOffset
 
-    return TextRange(startOffset, annotationEntry.getCalleeExpression().endOffset)
+    return TextRange(startOffset, annotationEntry.getCalleeExpression()!!.endOffset)
 }
 
 // ---------- Block expression -------------------------------------------------------------------------------------------------------------
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/JetFileElementType.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/JetFileElementType.java
index 5a4320a31f5..0722bc11f1f 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/JetFileElementType.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/JetFileElementType.java
@@ -36,7 +36,7 @@ import org.jetbrains.kotlin.psi.stubs.impl.KotlinFileStubImpl;
 import java.io.IOException;
 
 public class JetFileElementType extends IStubFileElementType<KotlinFileStub> {
-    public static final int STUB_VERSION = 49;
+    public static final int STUB_VERSION = 50;
 
     private static final String NAME = "kotlin.FILE";
 
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/AdditionalCheckerProvider.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/AdditionalCheckerProvider.kt
index a92008ebdf0..e66791d2c5e 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/AdditionalCheckerProvider.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/AdditionalCheckerProvider.kt
@@ -22,7 +22,7 @@ import org.jetbrains.kotlin.resolve.validation.SymbolUsageValidator
 
 private val DEFAULT_DECLARATION_CHECKERS = listOf(DataClassAnnotationChecker())
 private val DEFAULT_CALL_CHECKERS = listOf(CapturingInClosureChecker(), InlineCheckerWrapper(), ReifiedTypeParameterSubstitutionChecker())
-private val DEFAULT_TYPE_CHECKERS = listOf(TypeApproximator())
+private val DEFAULT_TYPE_CHECKERS = emptyList<AdditionalTypeChecker>()
 private val DEFAULT_VALIDATORS = listOf(DeprecatedSymbolValidator())
 
 public abstract class AdditionalCheckerProvider(
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/AllUnderImportsScope.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/AllUnderImportsScope.kt
index 3b09874fa63..f80c038a654 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/AllUnderImportsScope.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/AllUnderImportsScope.kt
@@ -18,13 +18,11 @@ package org.jetbrains.kotlin.resolve
 
 import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.name.Name
-import org.jetbrains.kotlin.platform.PlatformToKotlinClassMap
-import org.jetbrains.kotlin.resolve.scopes.FilteringScope
-import org.jetbrains.kotlin.resolve.scopes.JetScope
-import org.jetbrains.kotlin.resolve.scopes.WritableScope
-import java.util.ArrayList
 import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter
+import org.jetbrains.kotlin.resolve.scopes.JetScope
+import org.jetbrains.kotlin.types.JetType
 import org.jetbrains.kotlin.utils.Printer
+import java.util.ArrayList
 
 class AllUnderImportsScope : JetScope {
     private val scopes = ArrayList<JetScope>()
@@ -55,6 +53,14 @@ class AllUnderImportsScope : JetScope {
         return scopes.flatMap { it.getFunctions(name) }
     }
 
+    override fun getSyntheticExtensionProperties(receiverTypes: Collection<JetType>, name: Name): Collection<PropertyDescriptor> {
+        return scopes.flatMap { it.getSyntheticExtensionProperties(receiverTypes, name) }
+    }
+
+    override fun getSyntheticExtensionProperties(receiverTypes: Collection<JetType>): Collection<PropertyDescriptor> {
+        return scopes.flatMap { it.getSyntheticExtensionProperties(receiverTypes) }
+    }
+
     override fun getPackage(name: Name): PackageViewDescriptor? = null // packages are not imported by all under imports
 
     override fun getLocalVariable(name: Name): VariableDescriptor? = null
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/AnnotationResolver.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/AnnotationResolver.java
index 792730b3a45..779db10c475 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/AnnotationResolver.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/AnnotationResolver.java
@@ -17,73 +17,58 @@
 package org.jetbrains.kotlin.resolve;
 
 import com.google.common.collect.Lists;
-import com.intellij.openapi.util.Pair;
-import kotlin.KotlinPackage;
-import kotlin.jvm.functions.Function1;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
 import org.jetbrains.kotlin.descriptors.*;
 import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptor;
 import org.jetbrains.kotlin.descriptors.annotations.Annotations;
 import org.jetbrains.kotlin.descriptors.annotations.AnnotationsImpl;
 import org.jetbrains.kotlin.diagnostics.Errors;
-import org.jetbrains.kotlin.psi.*;
-import org.jetbrains.kotlin.resolve.calls.ArgumentTypeResolver;
+import org.jetbrains.kotlin.psi.JetAnnotationEntry;
+import org.jetbrains.kotlin.psi.JetModifierList;
+import org.jetbrains.kotlin.psi.JetTypeParameter;
+import org.jetbrains.kotlin.psi.JetTypeReference;
 import org.jetbrains.kotlin.resolve.calls.CallResolver;
-import org.jetbrains.kotlin.resolve.calls.callUtil.CallUtilPackage;
-import org.jetbrains.kotlin.resolve.calls.checkers.AdditionalTypeChecker;
-import org.jetbrains.kotlin.resolve.calls.checkers.CallChecker;
-import org.jetbrains.kotlin.resolve.calls.checkers.CompositeChecker;
-import org.jetbrains.kotlin.resolve.calls.context.ContextDependency;
-import org.jetbrains.kotlin.resolve.calls.context.SimpleResolutionContext;
-import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall;
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedValueArgument;
 import org.jetbrains.kotlin.resolve.calls.results.OverloadResolutionResults;
 import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo;
 import org.jetbrains.kotlin.resolve.calls.util.CallMaker;
-import org.jetbrains.kotlin.resolve.constants.ArrayValue;
-import org.jetbrains.kotlin.resolve.constants.CompileTimeConstant;
-import org.jetbrains.kotlin.resolve.constants.IntegerValueTypeConstant;
+import org.jetbrains.kotlin.resolve.constants.ConstantValue;
 import org.jetbrains.kotlin.resolve.constants.evaluate.ConstantExpressionEvaluator;
 import org.jetbrains.kotlin.resolve.lazy.ForceResolveUtil;
 import org.jetbrains.kotlin.resolve.lazy.descriptors.LazyAnnotationDescriptor;
 import org.jetbrains.kotlin.resolve.lazy.descriptors.LazyAnnotationsContextImpl;
 import org.jetbrains.kotlin.resolve.scopes.JetScope;
 import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue;
-import org.jetbrains.kotlin.resolve.validation.SymbolUsageValidator;
 import org.jetbrains.kotlin.storage.StorageManager;
 import org.jetbrains.kotlin.types.ErrorUtils;
 import org.jetbrains.kotlin.types.JetType;
-import org.jetbrains.kotlin.types.checker.JetTypeChecker;
 
 import javax.inject.Inject;
-import java.util.HashMap;
 import java.util.List;
-import java.util.Map;
 
 import static org.jetbrains.kotlin.diagnostics.Errors.NOT_AN_ANNOTATION_CLASS;
-import static org.jetbrains.kotlin.resolve.BindingContext.ANNOTATION_DESCRIPTOR_TO_PSI_ELEMENT;
 import static org.jetbrains.kotlin.types.TypeUtils.NO_EXPECTED_TYPE;
 
 public class AnnotationResolver {
+    @NotNull private final CallResolver callResolver;
+    @NotNull private final StorageManager storageManager;
+    @NotNull private TypeResolver typeResolver;
+    @NotNull private final ConstantExpressionEvaluator constantExpressionEvaluator;
 
-    private CallResolver callResolver;
-    private StorageManager storageManager;
-    private TypeResolver typeResolver;
-
-    @Inject
-    public void setCallResolver(CallResolver callResolver) {
+    public AnnotationResolver(
+            @NotNull CallResolver callResolver,
+            @NotNull ConstantExpressionEvaluator constantExpressionEvaluator,
+            @NotNull StorageManager storageManager
+    ) {
         this.callResolver = callResolver;
-    }
-
-    @Inject
-    public void setStorageManager(StorageManager storageManager) {
+        this.constantExpressionEvaluator = constantExpressionEvaluator;
         this.storageManager = storageManager;
     }
 
+    // component dependency cycle
     @Inject
-    public void setTypeResolver(TypeResolver typeResolver) {
+    public void setTypeResolver(@NotNull TypeResolver typeResolver) {
         this.typeResolver = typeResolver;
     }
 
@@ -210,155 +195,6 @@ public class AnnotationResolver {
         );
     }
 
-    @NotNull
-    public static Map<ValueParameterDescriptor, CompileTimeConstant<?>> resolveAnnotationArguments(
-            @NotNull ResolvedCall<?> resolvedCall,
-            @NotNull BindingTrace trace
-    ) {
-        Map<ValueParameterDescriptor, CompileTimeConstant<?>> arguments = new HashMap<ValueParameterDescriptor, CompileTimeConstant<?>>();
-        for (Map.Entry<ValueParameterDescriptor, ResolvedValueArgument> descriptorToArgument : resolvedCall.getValueArguments().entrySet()) {
-            ValueParameterDescriptor parameterDescriptor = descriptorToArgument.getKey();
-            ResolvedValueArgument resolvedArgument = descriptorToArgument.getValue();
-
-            CompileTimeConstant<?> value = getAnnotationArgumentValue(trace, parameterDescriptor, resolvedArgument);
-            if (value != null) {
-                arguments.put(parameterDescriptor, value);
-            }
-        }
-        return arguments;
-    }
-
-    @Nullable
-    public static CompileTimeConstant<?> getAnnotationArgumentValue(
-            BindingTrace trace,
-            ValueParameterDescriptor parameterDescriptor,
-            ResolvedValueArgument resolvedArgument
-    ) {
-        JetType varargElementType = parameterDescriptor.getVarargElementType();
-        boolean argumentsAsVararg = varargElementType != null && !hasSpread(resolvedArgument);
-        List<CompileTimeConstant<?>> constants = resolveValueArguments(
-                resolvedArgument, argumentsAsVararg ? varargElementType : parameterDescriptor.getType(), trace);
-
-        if (argumentsAsVararg) {
-
-            boolean usesVariableAsConstant = KotlinPackage.any(constants, new Function1<CompileTimeConstant<?>, Boolean>() {
-                @Override
-                public Boolean invoke(CompileTimeConstant<?> constant) {
-                    return constant.usesVariableAsConstant();
-                }
-            });
-
-            if (parameterDescriptor.declaresDefaultValue() && constants.isEmpty()) return null;
-
-            return new ArrayValue(constants, parameterDescriptor.getType(), true, usesVariableAsConstant);
-        }
-        else {
-            // we should actually get only one element, but just in case of getting many, we take the last one
-            return !constants.isEmpty() ? KotlinPackage.last(constants) : null;
-        }
-    }
-
-    private static void checkCompileTimeConstant(
-            @NotNull JetExpression argumentExpression,
-            @NotNull JetType expectedType,
-            @NotNull BindingTrace trace
-    ) {
-        JetType expressionType = trace.getType(argumentExpression);
-
-        if (expressionType == null || !JetTypeChecker.DEFAULT.isSubtypeOf(expressionType, expectedType)) {
-            // TYPE_MISMATCH should be reported otherwise
-            return;
-        }
-
-        // array(1, <!>null<!>, 3) - error should be reported on inner expression
-        if (argumentExpression instanceof JetCallExpression) {
-            Pair<List<JetExpression>, JetType> arrayArgument = getArgumentExpressionsForArrayCall((JetCallExpression) argumentExpression, trace);
-            if (arrayArgument != null) {
-                for (JetExpression expression : arrayArgument.getFirst()) {
-                    checkCompileTimeConstant(expression, arrayArgument.getSecond(), trace);
-                }
-            }
-        }
-
-        CompileTimeConstant<?> constant = ConstantExpressionEvaluator.getConstant(argumentExpression, trace.getBindingContext());
-        if (constant != null && constant.canBeUsedInAnnotations()) {
-            return;
-        }
-
-        ClassifierDescriptor descriptor = expressionType.getConstructor().getDeclarationDescriptor();
-        if (descriptor != null && DescriptorUtils.isEnumClass(descriptor)) {
-            trace.report(Errors.ANNOTATION_PARAMETER_MUST_BE_ENUM_CONST.on(argumentExpression));
-        }
-        else if (descriptor instanceof ClassDescriptor && KotlinBuiltIns.isKClass((ClassDescriptor) descriptor)) {
-            trace.report(Errors.ANNOTATION_PARAMETER_MUST_BE_KCLASS_LITERAL.on(argumentExpression));
-        }
-        else {
-            trace.report(Errors.ANNOTATION_PARAMETER_MUST_BE_CONST.on(argumentExpression));
-        }
-    }
-
-    @Nullable
-    private static Pair<List<JetExpression>, JetType> getArgumentExpressionsForArrayCall(
-            @NotNull JetCallExpression expression,
-            @NotNull BindingTrace trace
-    ) {
-        ResolvedCall<?> resolvedCall = CallUtilPackage.getResolvedCall(expression, trace.getBindingContext());
-        if (resolvedCall == null || !CompileTimeConstantUtils.isArrayMethodCall(resolvedCall)) {
-            return null;
-        }
-
-        assert resolvedCall.getValueArguments().size() == 1 : "Array function should have only one vararg parameter";
-        Map.Entry<ValueParameterDescriptor, ResolvedValueArgument> argumentEntry = resolvedCall.getValueArguments().entrySet().iterator().next();
-
-        List<JetExpression> result = Lists.newArrayList();
-        JetType elementType = argumentEntry.getKey().getVarargElementType();
-        for (ValueArgument valueArgument : argumentEntry.getValue().getArguments()) {
-            JetExpression valueArgumentExpression = valueArgument.getArgumentExpression();
-            if (valueArgumentExpression != null) {
-                if (elementType != null) {
-                    result.add(valueArgumentExpression);
-                }
-            }
-        }
-        return new Pair<List<JetExpression>, JetType>(result, elementType);
-    }
-
-    private static boolean hasSpread(@NotNull ResolvedValueArgument argument) {
-        List<ValueArgument> arguments = argument.getArguments();
-        return arguments.size() == 1 && arguments.get(0).getSpreadElement() != null;
-    }
-
-    @NotNull
-    private static List<CompileTimeConstant<?>> resolveValueArguments(
-            @NotNull ResolvedValueArgument resolvedValueArgument,
-            @NotNull JetType expectedType,
-            @NotNull BindingTrace trace
-    ) {
-        List<CompileTimeConstant<?>> constants = Lists.newArrayList();
-        for (ValueArgument argument : resolvedValueArgument.getArguments()) {
-            JetExpression argumentExpression = argument.getArgumentExpression();
-            if (argumentExpression != null) {
-                CompileTimeConstant<?> constant = ConstantExpressionEvaluator.evaluate(argumentExpression, trace, expectedType);
-                if (constant instanceof IntegerValueTypeConstant) {
-                    JetType defaultType = ((IntegerValueTypeConstant) constant).getType(expectedType);
-                    SimpleResolutionContext context =
-                            new SimpleResolutionContext(trace, JetScope.Empty.INSTANCE$, NO_EXPECTED_TYPE, DataFlowInfo.EMPTY,
-                                                        ContextDependency.INDEPENDENT,
-                                                        new CompositeChecker(Lists.<CallChecker>newArrayList()),
-                                                        SymbolUsageValidator.Empty,
-                                                        new AdditionalTypeChecker.Composite(Lists.<AdditionalTypeChecker>newArrayList()),
-                                                        StatementFilter.NONE);
-                    ArgumentTypeResolver.updateNumberType(defaultType, argumentExpression, context);
-                }
-                if (constant != null) {
-                    constants.add(constant);
-                }
-                checkCompileTimeConstant(argumentExpression, expectedType, trace);
-            }
-        }
-        return constants;
-    }
-
     public static void reportUnsupportedAnnotationForTypeParameter(@NotNull JetTypeParameter jetTypeParameter, @NotNull BindingTrace trace) {
         JetModifierList modifierList = jetTypeParameter.getModifierList();
         if (modifierList == null) return;
@@ -367,4 +203,13 @@ public class AnnotationResolver {
             trace.report(Errors.UNSUPPORTED.on(annotationEntry, "Annotations for type parameters are not supported yet"));
         }
     }
+
+    @Nullable
+    public ConstantValue<?> getAnnotationArgumentValue(
+            @NotNull BindingTrace trace,
+            @NotNull ValueParameterDescriptor valueParameter,
+            @NotNull ResolvedValueArgument resolvedArgument
+    ) {
+        return constantExpressionEvaluator.getAnnotationArgumentValue(trace, valueParameter, resolvedArgument);
+    }
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/AnnotationTargetChecker.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/AnnotationTargetChecker.kt
new file mode 100644
index 00000000000..598685f938b
--- /dev/null
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/AnnotationTargetChecker.kt
@@ -0,0 +1,125 @@
+/*
+ * Copyright 2010-2015 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.kotlin.resolve
+
+import org.jetbrains.kotlin.builtins.KotlinBuiltIns
+import org.jetbrains.kotlin.descriptors.ClassDescriptor
+import org.jetbrains.kotlin.descriptors.ClassKind
+import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptor
+import org.jetbrains.kotlin.diagnostics.Errors
+import org.jetbrains.kotlin.psi.*
+import org.jetbrains.kotlin.psi.psiUtil.getAnnotationEntries
+import org.jetbrains.kotlin.resolve.constants.ArrayValue
+import org.jetbrains.kotlin.resolve.constants.EnumValue
+import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.TypeUtils
+import java.lang.annotation.ElementType
+import java.util.*
+import org.jetbrains.kotlin.descriptors.annotations.AnnotationTarget
+import kotlin.annotation
+
+public object AnnotationTargetChecker {
+
+    public fun check(annotated: JetAnnotated, trace: BindingTrace, descriptor: ClassDescriptor? = null) {
+        if (annotated is JetTypeParameter) return // TODO: support type parameter annotations
+        val actualTargets = getActualTargetList(annotated, descriptor)
+        for (entry in annotated.getAnnotationEntries()) {
+            checkAnnotationEntry(entry, actualTargets, trace)
+        }
+        if (annotated is JetCallableDeclaration) {
+            annotated.getTypeReference()?.let { check(it, trace) }
+        }
+        if (annotated is JetFunction) {
+            for (parameter in annotated.getValueParameters()) {
+                if (!parameter.hasValOrVar()) {
+                    check(parameter, trace)
+                    if (annotated is JetFunctionLiteral) {
+                        parameter.getTypeReference()?.let { check(it, trace) }
+                    }
+                }
+            }
+        }
+        if (annotated is JetClassOrObject) {
+            for (initializer in annotated.getAnonymousInitializers()) {
+                check(initializer, trace)
+            }
+        }
+    }
+
+    public fun checkExpression(expression: JetExpression, trace: BindingTrace) {
+        for (entry in expression.getAnnotationEntries()) {
+            checkAnnotationEntry(entry, listOf(AnnotationTarget.EXPRESSION), trace)
+        }
+        if (expression is JetFunctionLiteralExpression) {
+            for (parameter in expression.getValueParameters()) {
+                parameter.getTypeReference()?.let { check(it, trace) }
+            }
+        }
+    }
+
+    public fun possibleTargetSet(classDescriptor: ClassDescriptor): Set<AnnotationTarget>? {
+        val targetEntryDescriptor = classDescriptor.getAnnotations().findAnnotation(KotlinBuiltIns.FQ_NAMES.target)
+                                    ?: return null
+        val valueArguments = targetEntryDescriptor.getAllValueArguments()
+        val valueArgument = valueArguments.entrySet().firstOrNull()?.getValue() as? ArrayValue ?: return null
+        return valueArgument.value.filterIsInstance<EnumValue>().map {
+            AnnotationTarget.valueOrNull(it.value.getName().asString())
+        }.filterNotNull().toSet()
+    }
+
+    private fun possibleTargetSet(entry: JetAnnotationEntry, trace: BindingTrace): Set<AnnotationTarget> {
+        val descriptor = trace.get(BindingContext.ANNOTATION, entry) ?: return AnnotationTarget.DEFAULT_TARGET_SET
+        // For descriptor with error type, all targets are considered as possible
+        if (descriptor.getType().isError()) return AnnotationTarget.ALL_TARGET_SET
+        val classDescriptor = TypeUtils.getClassDescriptor(descriptor.getType()) ?: return AnnotationTarget.DEFAULT_TARGET_SET
+        return possibleTargetSet(classDescriptor) ?: AnnotationTarget.DEFAULT_TARGET_SET
+    }
+
+    private fun checkAnnotationEntry(entry: JetAnnotationEntry, actualTargets: List<AnnotationTarget>, trace: BindingTrace) {
+        val possibleTargets = possibleTargetSet(entry, trace)
+        if (actualTargets.any { it in possibleTargets }) return
+        trace.report(Errors.WRONG_ANNOTATION_TARGET.on(entry, actualTargets.firstOrNull()?.description ?: "unidentified target"))
+    }
+
+    private fun getActualTargetList(annotated: JetAnnotated, descriptor: ClassDescriptor?): List<AnnotationTarget> {
+        if (annotated is JetClassOrObject) {
+            if (annotated is JetEnumEntry) return listOf(AnnotationTarget.PROPERTY, AnnotationTarget.FIELD)
+            return if (descriptor?.getKind() == ClassKind.ANNOTATION_CLASS) {
+                listOf(AnnotationTarget.ANNOTATION_CLASS, AnnotationTarget.CLASSIFIER)
+            }
+            else {
+                listOf(AnnotationTarget.CLASSIFIER)
+            }
+        }
+        if (annotated is JetProperty) {
+            return if (annotated.isLocal()) listOf(AnnotationTarget.LOCAL_VARIABLE) else listOf(AnnotationTarget.PROPERTY, AnnotationTarget.FIELD)
+        }
+        if (annotated is JetParameter) {
+            return if (annotated.hasValOrVar()) listOf(AnnotationTarget.PROPERTY, AnnotationTarget.FIELD) else listOf(AnnotationTarget.VALUE_PARAMETER)
+        }
+        if (annotated is JetConstructor<*>) return listOf(AnnotationTarget.CONSTRUCTOR)
+        if (annotated is JetFunction) return listOf(AnnotationTarget.FUNCTION)
+        if (annotated is JetPropertyAccessor) {
+            return if (annotated.isGetter()) listOf(AnnotationTarget.PROPERTY_GETTER) else listOf(AnnotationTarget.PROPERTY_SETTER)
+        }
+        if (annotated is JetPackageDirective) return listOf(AnnotationTarget.PACKAGE)
+        if (annotated is JetTypeReference) return listOf(AnnotationTarget.TYPE)
+        if (annotated is JetFile) return listOf(AnnotationTarget.FILE)
+        if (annotated is JetTypeParameter) return listOf(AnnotationTarget.TYPE_PARAMETER)
+        return listOf()
+    }
+}
\ No newline at end of file
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/AnnotationUtil.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/AnnotationUtil.kt
index 74ea88afe34..94fbbebc1e6 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/AnnotationUtil.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/AnnotationUtil.kt
@@ -32,6 +32,10 @@ public fun DeclarationDescriptor.hasPlatformStaticAnnotation(): Boolean {
     return getAnnotations().findAnnotation(FqName("kotlin.platform.platformStatic")) != null
 }
 
+public fun DeclarationDescriptor.findPublicFieldAnnotation(): AnnotationDescriptor? {
+    return getAnnotations().findAnnotation(FqName("kotlin.jvm.publicField"))
+}
+
 public fun DeclarationDescriptor.hasIntrinsicAnnotation(): Boolean {
     return getAnnotations().findAnnotation(FqName("kotlin.jvm.internal.Intrinsic")) != null
 }
@@ -55,5 +59,5 @@ private fun CallableDescriptor.isPlatformStaticIn(predicate: (DeclarationDescrip
 public fun AnnotationDescriptor.argumentValue(parameterName: String): Any? {
     return getAllValueArguments().entrySet()
             .singleOrNull { it.key.getName().asString() == parameterName }
-            ?.value?.getValue()
+            ?.value?.value
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/BindingContext.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/BindingContext.java
index efd27e7c827..952e2938faf 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/BindingContext.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/BindingContext.java
@@ -36,7 +36,6 @@ import org.jetbrains.kotlin.resolve.constants.CompileTimeConstant;
 import org.jetbrains.kotlin.resolve.diagnostics.Diagnostics;
 import org.jetbrains.kotlin.resolve.scopes.JetScope;
 import org.jetbrains.kotlin.resolve.scopes.receivers.Qualifier;
-import org.jetbrains.kotlin.types.Approximation;
 import org.jetbrains.kotlin.types.DeferredType;
 import org.jetbrains.kotlin.types.JetType;
 import org.jetbrains.kotlin.types.expressions.CaptureKind;
@@ -97,7 +96,6 @@ public interface BindingContext {
     WritableSlice<JetExpression, JetTypeInfo> EXPRESSION_TYPE_INFO = new BasicWritableSlice<JetExpression, JetTypeInfo>(DO_NOTHING);
     WritableSlice<JetExpression, JetType> EXPECTED_EXPRESSION_TYPE = new BasicWritableSlice<JetExpression, JetType>(DO_NOTHING);
     WritableSlice<JetFunction, JetType> EXPECTED_RETURN_TYPE = new BasicWritableSlice<JetFunction, JetType>(DO_NOTHING);
-    WritableSlice<JetExpression, Approximation.Info> EXPRESSION_RESULT_APPROXIMATION = new BasicWritableSlice<JetExpression, Approximation.Info>(DO_NOTHING);
     WritableSlice<JetExpression, DataFlowInfo> DATAFLOW_INFO_AFTER_CONDITION = Slices.createSimpleSlice();
 
     /**
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/BodyResolver.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/BodyResolver.java
index f08e868dff1..a8a8f85fac7 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/BodyResolver.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/BodyResolver.java
@@ -33,7 +33,6 @@ import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall;
 import org.jetbrains.kotlin.resolve.calls.results.OverloadResolutionResults;
 import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo;
 import org.jetbrains.kotlin.resolve.calls.util.CallMaker;
-import org.jetbrains.kotlin.resolve.constants.CompileTimeConstant;
 import org.jetbrains.kotlin.resolve.lazy.ForceResolveUtil;
 import org.jetbrains.kotlin.resolve.scopes.*;
 import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue;
@@ -46,7 +45,6 @@ import org.jetbrains.kotlin.util.Box;
 import org.jetbrains.kotlin.util.ReenteringLazyValueComputationException;
 import org.jetbrains.kotlin.util.slicedMap.WritableSlice;
 
-import javax.inject.Inject;
 import java.util.*;
 
 import static org.jetbrains.kotlin.descriptors.ReceiverParameterDescriptor.NO_RECEIVER_PARAMETER;
@@ -55,81 +53,47 @@ import static org.jetbrains.kotlin.resolve.BindingContext.*;
 import static org.jetbrains.kotlin.types.TypeUtils.NO_EXPECTED_TYPE;
 
 public class BodyResolver {
-    private ScriptBodyResolver scriptBodyResolverResolver;
-    private ExpressionTypingServices expressionTypingServices;
-    private CallResolver callResolver;
-    private ObservableBindingTrace trace;
-    private ControlFlowAnalyzer controlFlowAnalyzer;
-    private DeclarationsChecker declarationsChecker;
-    private AnnotationResolver annotationResolver;
-    private DelegatedPropertyResolver delegatedPropertyResolver;
-    private FunctionAnalyzerExtension functionAnalyzerExtension;
-    private AdditionalCheckerProvider additionalCheckerProvider;
-    private ValueParameterResolver valueParameterResolver;
-    private BodyResolveCache bodyResolveCache;
+    @NotNull private final ScriptBodyResolver scriptBodyResolverResolver;
+    @NotNull private final ExpressionTypingServices expressionTypingServices;
+    @NotNull private final CallResolver callResolver;
+    @NotNull private final ObservableBindingTrace trace;
+    @NotNull private final ControlFlowAnalyzer controlFlowAnalyzer;
+    @NotNull private final DeclarationsChecker declarationsChecker;
+    @NotNull private final AnnotationResolver annotationResolver;
+    @NotNull private final DelegatedPropertyResolver delegatedPropertyResolver;
+    @NotNull private final FunctionAnalyzerExtension functionAnalyzerExtension;
+    @NotNull private final AdditionalCheckerProvider additionalCheckerProvider;
+    @NotNull private final ValueParameterResolver valueParameterResolver;
+    @NotNull private final BodyResolveCache bodyResolveCache;
 
-    //<editor-fold desc="Injector Setters">
-    @Inject
-    public void setScriptBodyResolverResolver(@NotNull ScriptBodyResolver scriptBodyResolverResolver) {
-        this.scriptBodyResolverResolver = scriptBodyResolverResolver;
-    }
-
-    @Inject
-    public void setExpressionTypingServices(@NotNull ExpressionTypingServices expressionTypingServices) {
-        this.expressionTypingServices = expressionTypingServices;
-    }
-
-    @Inject
-    public void setCallResolver(@NotNull CallResolver callResolver) {
-        this.callResolver = callResolver;
-    }
-
-    @Inject
-    public void setTrace(@NotNull BindingTrace trace) {
-        this.trace = new ObservableBindingTrace(trace);
-    }
-
-    @Inject
-    public void setControlFlowAnalyzer(@NotNull ControlFlowAnalyzer controlFlowAnalyzer) {
-        this.controlFlowAnalyzer = controlFlowAnalyzer;
-    }
-
-    @Inject
-    public void setDeclarationsChecker(@NotNull DeclarationsChecker declarationsChecker) {
-        this.declarationsChecker = declarationsChecker;
-    }
-
-    @Inject
-    public void setAnnotationResolver(@NotNull AnnotationResolver annotationResolver) {
-        this.annotationResolver = annotationResolver;
-    }
-
-    @Inject
-    public void setDelegatedPropertyResolver(@NotNull DelegatedPropertyResolver delegatedPropertyResolver) {
-        this.delegatedPropertyResolver = delegatedPropertyResolver;
-    }
-
-    @Inject
-    public void setFunctionAnalyzerExtension(@NotNull FunctionAnalyzerExtension functionAnalyzerExtension) {
-        this.functionAnalyzerExtension = functionAnalyzerExtension;
-    }
-
-    @Inject
-    public void setAdditionalCheckerProvider(AdditionalCheckerProvider additionalCheckerProvider) {
+    public BodyResolver(
+            @NotNull AdditionalCheckerProvider additionalCheckerProvider,
+            @NotNull AnnotationResolver annotationResolver,
+            @NotNull BodyResolveCache bodyResolveCache,
+            @NotNull CallResolver callResolver,
+            @NotNull ControlFlowAnalyzer controlFlowAnalyzer,
+            @NotNull DeclarationsChecker declarationsChecker,
+            @NotNull DelegatedPropertyResolver delegatedPropertyResolver,
+            @NotNull ExpressionTypingServices expressionTypingServices,
+            @NotNull FunctionAnalyzerExtension functionAnalyzerExtension,
+            @NotNull ScriptBodyResolver scriptBodyResolverResolver,
+            @NotNull BindingTrace trace,
+            @NotNull ValueParameterResolver valueParameterResolver
+    ) {
         this.additionalCheckerProvider = additionalCheckerProvider;
-    }
-
-    @Inject
-    public void setValueParameterResolver(ValueParameterResolver valueParameterResolver) {
+        this.annotationResolver = annotationResolver;
+        this.bodyResolveCache = bodyResolveCache;
+        this.callResolver = callResolver;
+        this.controlFlowAnalyzer = controlFlowAnalyzer;
+        this.declarationsChecker = declarationsChecker;
+        this.delegatedPropertyResolver = delegatedPropertyResolver;
+        this.expressionTypingServices = expressionTypingServices;
+        this.functionAnalyzerExtension = functionAnalyzerExtension;
+        this.scriptBodyResolverResolver = scriptBodyResolverResolver;
+        this.trace = new ObservableBindingTrace(trace);
         this.valueParameterResolver = valueParameterResolver;
     }
 
-    @Inject
-    public void setBodyResolveCache(BodyResolveCache bodyResolveCache) {
-        this.bodyResolveCache = bodyResolveCache;
-    }
-    //</editor-fold>
-
     private void resolveBehaviorDeclarationBodies(@NotNull BodiesResolveContext c) {
         resolveDelegationSpecifierLists(c);
 
@@ -735,8 +699,7 @@ public class BodyResolver {
         JetScope propertyDeclarationInnerScope = JetScopeUtils.getPropertyDeclarationInnerScopeForInitializer(
                 propertyDescriptor, scope, propertyDescriptor.getTypeParameters(), NO_RECEIVER_PARAMETER, trace);
         JetType expectedTypeForInitializer = property.getTypeReference() != null ? propertyDescriptor.getType() : NO_EXPECTED_TYPE;
-        CompileTimeConstant<?> compileTimeInitializer = propertyDescriptor.getCompileTimeInitializer();
-        if (compileTimeInitializer == null) {
+        if (propertyDescriptor.getCompileTimeInitializer() == null) {
             expressionTypingServices.getType(propertyDeclarationInnerScope, initializer, expectedTypeForInitializer,
                                              outerDataFlowInfo, trace);
         }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/CompileTimeConstantUtils.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/CompileTimeConstantUtils.java
index b660ef8ffbb..bd8c2912b9f 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/CompileTimeConstantUtils.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/CompileTimeConstantUtils.java
@@ -31,6 +31,8 @@ import org.jetbrains.kotlin.psi.JetTypeReference;
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall;
 import org.jetbrains.kotlin.resolve.constants.BooleanValue;
 import org.jetbrains.kotlin.resolve.constants.CompileTimeConstant;
+import org.jetbrains.kotlin.resolve.constants.ConstantValue;
+import org.jetbrains.kotlin.resolve.constants.TypedCompileTimeConstant;
 import org.jetbrains.kotlin.resolve.constants.evaluate.ConstantExpressionEvaluator;
 import org.jetbrains.kotlin.types.JetType;
 import org.jetbrains.kotlin.types.TypeProjection;
@@ -113,7 +115,7 @@ public class CompileTimeConstantUtils {
                 annotatedDescriptor.getAnnotations().findAnnotation(new FqName("kotlin.jvm.internal.Intrinsic"));
         if (intrinsicAnnotation == null) return null;
 
-        Collection<CompileTimeConstant<?>> values = intrinsicAnnotation.getAllValueArguments().values();
+        Collection<ConstantValue<?>> values = intrinsicAnnotation.getAllValueArguments().values();
         if (values.isEmpty()) return null;
 
         Object value = values.iterator().next().getValue();
@@ -132,9 +134,13 @@ public class CompileTimeConstantUtils {
         if (expression == null) return false;
         CompileTimeConstant<?> compileTimeConstant =
                 ConstantExpressionEvaluator.evaluate(expression, trace, KotlinBuiltIns.getInstance().getBooleanType());
-        if (!(compileTimeConstant instanceof BooleanValue) || compileTimeConstant.usesVariableAsConstant()) return false;
+        if (!(compileTimeConstant instanceof TypedCompileTimeConstant) || compileTimeConstant.getUsesVariableAsConstant()) return false;
 
-        Boolean value = ((BooleanValue) compileTimeConstant).getValue();
+        ConstantValue constantValue = ((TypedCompileTimeConstant) compileTimeConstant).getConstantValue();
+
+        if (!(constantValue instanceof BooleanValue)) return false;
+
+        Boolean value = ((BooleanValue) constantValue).getValue();
         return expectedValue == null || expectedValue.equals(value);
     }
 
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/ControlFlowAnalyzer.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/ControlFlowAnalyzer.java
index a82abdbe6a5..1ae7671d04f 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/ControlFlowAnalyzer.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/ControlFlowAnalyzer.java
@@ -26,16 +26,14 @@ import org.jetbrains.kotlin.descriptors.SimpleFunctionDescriptor;
 import org.jetbrains.kotlin.psi.*;
 import org.jetbrains.kotlin.types.JetType;
 
-import javax.inject.Inject;
 import java.util.Map;
 
 import static org.jetbrains.kotlin.types.TypeUtils.NO_EXPECTED_TYPE;
 
 public class ControlFlowAnalyzer {
-    private BindingTrace trace;
+    @NotNull private final BindingTrace trace;
 
-    @Inject
-    public void setTrace(BindingTrace trace) {
+    public ControlFlowAnalyzer(@NotNull BindingTrace trace) {
         this.trace = trace;
     }
 
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/DataClassAnnotationChecker.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/DataClassAnnotationChecker.kt
index 6815253427e..68e44ff29c3 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/DataClassAnnotationChecker.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/DataClassAnnotationChecker.kt
@@ -23,7 +23,12 @@ import org.jetbrains.kotlin.builtins.*
 
 
 public class DataClassAnnotationChecker : DeclarationChecker {
-    override fun check(declaration: JetDeclaration, descriptor: DeclarationDescriptor, diagnosticHolder: DiagnosticSink) {
+    override fun check(
+            declaration: JetDeclaration,
+            descriptor: DeclarationDescriptor,
+            diagnosticHolder: DiagnosticSink,
+            bindingContext: BindingContext
+    ) {
         if (descriptor !is ClassDescriptor) return
         if (declaration !is JetClassOrObject) return
 
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/DeclarationChecker.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/DeclarationChecker.kt
index 47c9cb1e1f5..897ea5c6126 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/DeclarationChecker.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/DeclarationChecker.kt
@@ -20,8 +20,12 @@ import org.jetbrains.kotlin.psi.JetDeclaration
 import org.jetbrains.kotlin.diagnostics.DiagnosticSink
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 
-public trait DeclarationChecker {
+public interface DeclarationChecker {
 
-    public fun check(declaration: JetDeclaration, descriptor: DeclarationDescriptor, diagnosticHolder: DiagnosticSink);
+    public fun check(
+            declaration: JetDeclaration,
+            descriptor: DeclarationDescriptor,
+            diagnosticHolder: DiagnosticSink,
+            bindingContext: BindingContext);
 
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/DeclarationResolver.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/DeclarationResolver.kt
index 880909bc1f5..d0b94d254ba 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/DeclarationResolver.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/DeclarationResolver.kt
@@ -30,38 +30,26 @@ import org.jetbrains.kotlin.resolve.lazy.FileScopeProvider
 import org.jetbrains.kotlin.resolve.lazy.TopLevelDescriptorProvider
 import org.jetbrains.kotlin.utils.*
 
-import javax.inject.Inject
 import java.util.HashSet
 
 import org.jetbrains.kotlin.diagnostics.Errors.REDECLARATION
 import kotlin.properties.Delegates
 
-public class DeclarationResolver {
-    private var _annotationResolver: AnnotationResolver by Delegates.notNull()
-    private var _trace: BindingTrace by Delegates.notNull()
-
-    Inject
-    public fun setAnnotationResolver(annotationResolver: AnnotationResolver) {
-        this._annotationResolver = annotationResolver
-    }
-
-    Inject
-    public fun setTrace(trace: BindingTrace) {
-        this._trace = trace
-    }
+public class DeclarationResolver(private val annotationResolver: AnnotationResolver,
+                                 private val trace: BindingTrace) {
 
     public fun resolveAnnotationsOnFiles(c: TopDownAnalysisContext, scopeProvider: FileScopeProvider) {
         val filesToScope = c.getFiles().keysToMap { scopeProvider.getFileScope(it) }
         for ((file, fileScope) in filesToScope) {
-            _annotationResolver.resolveAnnotationsWithArguments(fileScope, file.getAnnotationEntries(), _trace)
-            _annotationResolver.resolveAnnotationsWithArguments(fileScope, file.getDanglingAnnotations(), _trace)
+            annotationResolver.resolveAnnotationsWithArguments(fileScope, file.getAnnotationEntries(), trace)
+            annotationResolver.resolveAnnotationsWithArguments(fileScope, file.getDanglingAnnotations(), trace)
         }
     }
 
     public fun checkRedeclarations(c: TopDownAnalysisContext) {
         for (classDescriptor in c.getDeclaredClasses().values()) {
             val descriptorMap = HashMultimap.create<Name, DeclarationDescriptor>()
-            for (desc in classDescriptor.getScopeForMemberLookup().getOwnDeclaredDescriptors()) {
+            for (desc in classDescriptor.getUnsubstitutedMemberScope().getOwnDeclaredDescriptors()) {
                 if (desc is ClassDescriptor || desc is PropertyDescriptor) {
                     descriptorMap.put(desc.getName(), desc)
                 }
@@ -95,7 +83,7 @@ public class DeclarationResolver {
             }
         }
         for ((first, second) in redeclarations) {
-            _trace.report(REDECLARATION.on(first, second.asString()))
+            trace.report(REDECLARATION.on(first, second.asString()))
         }
     }
 
@@ -110,7 +98,7 @@ public class DeclarationResolver {
                     val reportAt =
                             if (declarationOrPackageDirective is JetPackageDirective) declarationOrPackageDirective.getNameIdentifier()
                             else declarationOrPackageDirective
-                    _trace.report(Errors.REDECLARATION.on(reportAt, fqName.shortName().asString()))
+                    trace.report(Errors.REDECLARATION.on(reportAt, fqName.shortName().asString()))
                 }
             }
         }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/DeclarationsChecker.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/DeclarationsChecker.java
index f84e64e8f68..18b9fa6b54f 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/DeclarationsChecker.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/DeclarationsChecker.java
@@ -35,7 +35,6 @@ import org.jetbrains.kotlin.types.TypeConstructor;
 import org.jetbrains.kotlin.types.TypeProjection;
 import org.jetbrains.kotlin.types.checker.JetTypeChecker;
 
-import javax.inject.Inject;
 import java.util.*;
 
 import static org.jetbrains.kotlin.diagnostics.Errors.*;
@@ -45,28 +44,24 @@ import static org.jetbrains.kotlin.resolve.DescriptorUtils.classCanHaveAbstractM
 import static org.jetbrains.kotlin.resolve.DescriptorUtils.classCanHaveOpenMembers;
 
 public class DeclarationsChecker {
-    private BindingTrace trace;
-    private ModifiersChecker modifiersChecker;
-    private DescriptorResolver descriptorResolver;
+    @NotNull private final BindingTrace trace;
+    @NotNull private final ModifiersChecker modifiersChecker;
+    @NotNull private final DescriptorResolver descriptorResolver;
 
-    @Inject
-    public void setTrace(@NotNull BindingTrace trace) {
-        this.trace = trace;
-    }
-
-    @Inject
-    public void setDescriptorResolver(@NotNull DescriptorResolver descriptorResolver) {
+    public DeclarationsChecker(
+            @NotNull DescriptorResolver descriptorResolver,
+            @NotNull ModifiersChecker modifiersChecker,
+            @NotNull BindingTrace trace
+    ) {
         this.descriptorResolver = descriptorResolver;
-    }
-
-    @Inject
-    public void setModifiersChecker(@NotNull ModifiersChecker modifiersChecker) {
         this.modifiersChecker = modifiersChecker;
+        this.trace = trace;
     }
 
     public void process(@NotNull BodiesResolveContext bodiesResolveContext) {
         for (JetFile file : bodiesResolveContext.getFiles()) {
             checkModifiersAndAnnotationsInPackageDirective(file);
+            AnnotationTargetChecker.INSTANCE$.check(file, trace, null);
         }
 
         Map<JetClassOrObject, ClassDescriptorWithResolutionScopes> classes = bodiesResolveContext.getDeclaredClasses();
@@ -128,9 +123,6 @@ public class DeclarationsChecker {
         if (declaration.hasModifier(JetTokens.ENUM_KEYWORD)) {
             trace.report(ILLEGAL_ENUM_ANNOTATION.on(declaration));
         }
-        if (declaration.hasModifier(JetTokens.ANNOTATION_KEYWORD)) {
-            trace.report(ILLEGAL_ANNOTATION_KEYWORD.on(declaration));
-        }
     }
 
     private void checkModifiersAndAnnotationsInPackageDirective(JetFile file) {
@@ -149,6 +141,7 @@ public class DeclarationsChecker {
                 }
             }
         }
+        AnnotationTargetChecker.INSTANCE$.check(packageDirective, trace, null);
 
         ModifiersChecker.reportIllegalModifiers(modifierList, Arrays.asList(JetTokens.MODIFIER_KEYWORDS_ARRAY), trace);
     }
@@ -255,15 +248,20 @@ public class DeclarationsChecker {
             checkTraitModifiers(aClass);
             checkConstructorInTrait(aClass);
         }
-        else if (aClass.isAnnotation()) {
-            checkAnnotationClassWithBody(aClass);
-            checkValOnAnnotationParameter(aClass);
-        }
         else if (aClass.isEnum()) {
             checkEnumModifiers(aClass);
             if (aClass.isLocal()) {
                 trace.report(LOCAL_ENUM_NOT_ALLOWED.on(aClass, classDescriptor));
             }
+            if (classDescriptor.getKind() == ClassKind.ANNOTATION_CLASS) {
+                JetAnnotationEntry entry = aClass.getBuiltInAnnotationEntry();
+                assert entry != null : "getBuiltinAnnotationEntry() should be synchronized with isAnnotation()";
+                trace.report(WRONG_ANNOTATION_TARGET.on(entry, "enum class"));
+            }
+        }
+        else if (classDescriptor.getKind() == ClassKind.ANNOTATION_CLASS) {
+            checkAnnotationClassWithBody(aClass);
+            checkValOnAnnotationParameter(aClass);
         }
         else if (aClass.hasModifier(JetTokens.SEALED_KEYWORD)) {
             checkSealedModifiers(aClass);
@@ -305,6 +303,7 @@ public class DeclarationsChecker {
             if (typeParameter != null) {
                 DescriptorResolver.checkConflictingUpperBounds(trace, typeParameter, jetTypeParameter);
             }
+            AnnotationTargetChecker.INSTANCE$.check(jetTypeParameter, trace, null);
         }
     }
 
@@ -630,10 +629,6 @@ public class DeclarationsChecker {
     }
 
     private void checkEnumEntry(@NotNull JetEnumEntry enumEntry, @NotNull ClassDescriptor classDescriptor) {
-        DeclarationDescriptor declaration = classDescriptor.getContainingDeclaration();
-        assert DescriptorUtils.isEnumClass(declaration) : "Enum entry should be declared in enum class: " + classDescriptor;
-        ClassDescriptor enumClass = (ClassDescriptor) declaration;
-
         if (enumEntryUsesDeprecatedSuperConstructor(enumEntry)) {
             trace.report(Errors.ENUM_ENTRY_USES_DEPRECATED_SUPER_CONSTRUCTOR.on(enumEntry, classDescriptor));
         }
@@ -645,23 +640,34 @@ public class DeclarationsChecker {
             trace.report(Errors.ENUM_ENTRY_AFTER_ENUM_MEMBER.on(enumEntry, classDescriptor));
         }
 
-        List<JetDelegationSpecifier> delegationSpecifiers = enumEntry.getDelegationSpecifiers();
-        ConstructorDescriptor constructor = enumClass.getUnsubstitutedPrimaryConstructor();
-        if ((constructor == null || !constructor.getValueParameters().isEmpty()) && delegationSpecifiers.isEmpty()) {
-            trace.report(ENUM_ENTRY_SHOULD_BE_INITIALIZED.on(enumEntry, enumClass));
-        }
+        DeclarationDescriptor declaration = classDescriptor.getContainingDeclaration();
+        if (DescriptorUtils.isEnumClass(declaration)) {
+            ClassDescriptor enumClass = (ClassDescriptor) declaration;
 
-        for (JetDelegationSpecifier delegationSpecifier : delegationSpecifiers) {
-            JetTypeReference typeReference = delegationSpecifier.getTypeReference();
-            if (typeReference != null) {
-                JetType type = trace.getBindingContext().get(TYPE, typeReference);
-                if (type != null) {
-                    JetType enumType = enumClass.getDefaultType();
-                    if (!type.getConstructor().equals(enumType.getConstructor())) {
-                        trace.report(ENUM_ENTRY_ILLEGAL_TYPE.on(typeReference, enumClass));
+            List<JetDelegationSpecifier> delegationSpecifiers = enumEntry.getDelegationSpecifiers();
+            ConstructorDescriptor constructor = enumClass.getUnsubstitutedPrimaryConstructor();
+            if ((constructor == null || !constructor.getValueParameters().isEmpty()) && delegationSpecifiers.isEmpty()) {
+                trace.report(ENUM_ENTRY_SHOULD_BE_INITIALIZED.on(enumEntry, enumClass));
+            }
+
+            for (JetDelegationSpecifier delegationSpecifier : delegationSpecifiers) {
+                JetTypeReference typeReference = delegationSpecifier.getTypeReference();
+                if (typeReference != null) {
+                    JetType type = trace.getBindingContext().get(TYPE, typeReference);
+                    if (type != null) {
+                        JetType enumType = enumClass.getDefaultType();
+                        if (!type.getConstructor().equals(enumType.getConstructor())) {
+                            trace.report(ENUM_ENTRY_ILLEGAL_TYPE.on(typeReference, enumClass));
+                        }
                     }
                 }
             }
         }
+        else {
+            assert DescriptorUtils.isTrait(declaration) : "Enum entry should be declared in enum class: " +
+                                                          classDescriptor + " " +
+                                                          classDescriptor.getKind();
+        }
     }
+
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/DelegatedPropertyResolver.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/DelegatedPropertyResolver.java
index 95365bbdf35..e33c5ad9155 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/DelegatedPropertyResolver.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/DelegatedPropertyResolver.java
@@ -42,7 +42,6 @@ import org.jetbrains.kotlin.types.expressions.ExpressionTypingContext;
 import org.jetbrains.kotlin.types.expressions.ExpressionTypingServices;
 import org.jetbrains.kotlin.util.slicedMap.WritableSlice;
 
-import javax.inject.Inject;
 import java.util.List;
 
 import static org.jetbrains.kotlin.diagnostics.Errors.*;
@@ -58,29 +57,21 @@ public class DelegatedPropertyResolver {
 
     public static final Name PROPERTY_DELEGATED_FUNCTION_NAME = Name.identifier("propertyDelegated");
 
-    private ExpressionTypingServices expressionTypingServices;
-    private CallResolver callResolver;
-    private KotlinBuiltIns builtIns;
-    private AdditionalCheckerProvider additionalCheckerProvider;
+    @NotNull private final ExpressionTypingServices expressionTypingServices;
+    @NotNull private final CallResolver callResolver;
+    @NotNull private final KotlinBuiltIns builtIns;
+    @NotNull private final AdditionalCheckerProvider additionalCheckerProvider;
 
-    @Inject
-    public void setExpressionTypingServices(@NotNull ExpressionTypingServices expressionTypingServices) {
-        this.expressionTypingServices = expressionTypingServices;
-    }
-
-    @Inject
-    public void setCallResolver(@NotNull CallResolver callResolver) {
-        this.callResolver = callResolver;
-    }
-
-    @Inject
-    public void setBuiltIns(@NotNull KotlinBuiltIns builtIns) {
-        this.builtIns = builtIns;
-    }
-
-    @Inject
-    public void setAdditionalCheckerProvider(AdditionalCheckerProvider additionalCheckerProvider) {
+    public DelegatedPropertyResolver(
+            @NotNull AdditionalCheckerProvider additionalCheckerProvider,
+            @NotNull KotlinBuiltIns builtIns,
+            @NotNull CallResolver callResolver,
+            @NotNull ExpressionTypingServices expressionTypingServices
+    ) {
         this.additionalCheckerProvider = additionalCheckerProvider;
+        this.builtIns = builtIns;
+        this.callResolver = callResolver;
+        this.expressionTypingServices = expressionTypingServices;
     }
 
     @Nullable
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/DescriptorResolver.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/DescriptorResolver.java
index 94d6f0bcb33..f24215e3e6d 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/DescriptorResolver.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/DescriptorResolver.java
@@ -37,10 +37,8 @@ import org.jetbrains.kotlin.name.Name;
 import org.jetbrains.kotlin.psi.*;
 import org.jetbrains.kotlin.psi.psiUtil.PsiUtilPackage;
 import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo;
-import org.jetbrains.kotlin.resolve.constants.CompileTimeConstant;
-import org.jetbrains.kotlin.resolve.constants.IntegerValueTypeConstant;
+import org.jetbrains.kotlin.resolve.constants.ConstantValue;
 import org.jetbrains.kotlin.resolve.constants.evaluate.ConstantExpressionEvaluator;
-import org.jetbrains.kotlin.resolve.constants.evaluate.EvaluatePackage;
 import org.jetbrains.kotlin.resolve.dataClassUtils.DataClassUtilsPackage;
 import org.jetbrains.kotlin.resolve.lazy.ForceResolveUtil;
 import org.jetbrains.kotlin.resolve.scopes.JetScope;
@@ -52,7 +50,6 @@ import org.jetbrains.kotlin.types.*;
 import org.jetbrains.kotlin.types.checker.JetTypeChecker;
 import org.jetbrains.kotlin.types.expressions.ExpressionTypingServices;
 
-import javax.inject.Inject;
 import java.util.*;
 
 import static org.jetbrains.kotlin.descriptors.ReceiverParameterDescriptor.NO_RECEIVER_PARAMETER;
@@ -74,41 +71,27 @@ public class DescriptorResolver {
         MODIFIERS_ILLEGAL_ON_PARAMETERS.remove(JetTokens.VARARG_KEYWORD);
     }
 
-    private TypeResolver typeResolver;
-    private AnnotationResolver annotationResolver;
-    private ExpressionTypingServices expressionTypingServices;
-    private DelegatedPropertyResolver delegatedPropertyResolver;
-    private StorageManager storageManager;
-    private KotlinBuiltIns builtIns;
+    @NotNull private final TypeResolver typeResolver;
+    @NotNull private final AnnotationResolver annotationResolver;
+    @NotNull private final ExpressionTypingServices expressionTypingServices;
+    @NotNull private final DelegatedPropertyResolver delegatedPropertyResolver;
+    @NotNull private final StorageManager storageManager;
+    @NotNull private final KotlinBuiltIns builtIns;
 
-    @Inject
-    public void setTypeResolver(@NotNull TypeResolver typeResolver) {
-        this.typeResolver = typeResolver;
-    }
-
-    @Inject
-    public void setAnnotationResolver(@NotNull AnnotationResolver annotationResolver) {
+    public DescriptorResolver(
+            @NotNull AnnotationResolver annotationResolver,
+            @NotNull KotlinBuiltIns builtIns,
+            @NotNull DelegatedPropertyResolver delegatedPropertyResolver,
+            @NotNull ExpressionTypingServices expressionTypingServices,
+            @NotNull StorageManager storageManager,
+            @NotNull TypeResolver typeResolver
+    ) {
         this.annotationResolver = annotationResolver;
-    }
-
-    @Inject
-    public void setExpressionTypingServices(@NotNull ExpressionTypingServices expressionTypingServices) {
-        this.expressionTypingServices = expressionTypingServices;
-    }
-
-    @Inject
-    public void setDelegatedPropertyResolver(@NotNull DelegatedPropertyResolver delegatedPropertyResolver) {
-        this.delegatedPropertyResolver = delegatedPropertyResolver;
-    }
-
-    @Inject
-    public void setStorageManager(@NotNull StorageManager storageManager) {
-        this.storageManager = storageManager;
-    }
-
-    @Inject
-    public void setBuiltIns(@NotNull KotlinBuiltIns builtIns) {
         this.builtIns = builtIns;
+        this.delegatedPropertyResolver = delegatedPropertyResolver;
+        this.expressionTypingServices = expressionTypingServices;
+        this.storageManager = storageManager;
+        this.typeResolver = typeResolver;
     }
 
     public List<JetType> resolveSupertypes(
@@ -133,7 +116,7 @@ public class DescriptorResolver {
         }
 
         if (supertypes.isEmpty()) {
-            JetType defaultSupertype = getDefaultSupertype(jetClass, trace);
+            JetType defaultSupertype = getDefaultSupertype(jetClass, trace, classDescriptor.getKind() == ClassKind.ANNOTATION_CLASS);
             addValidSupertype(supertypes, defaultSupertype);
         }
 
@@ -156,7 +139,7 @@ public class DescriptorResolver {
         return false;
     }
 
-    private JetType getDefaultSupertype(JetClassOrObject jetClass, BindingTrace trace) {
+    private JetType getDefaultSupertype(JetClassOrObject jetClass, BindingTrace trace, boolean isAnnotation) {
         // TODO : beautify
         if (jetClass instanceof JetEnumEntry) {
             JetClassOrObject parent = JetStubbedPsiUtil.getContainingDeclaration(jetClass, JetClassOrObject.class);
@@ -169,7 +152,7 @@ public class DescriptorResolver {
                 return ErrorUtils.createErrorType("Supertype not specified");
             }
         }
-        else if (jetClass instanceof JetClass && ((JetClass) jetClass).isAnnotation()) {
+        else if (isAnnotation) {
             return builtIns.getAnnotationType();
         }
         return builtIns.getAnyType();
@@ -345,18 +328,7 @@ public class DescriptorResolver {
 
     @NotNull
     public ValueParameterDescriptorImpl resolveValueParameterDescriptor(
-            JetScope scope, DeclarationDescriptor declarationDescriptor,
-            JetParameter valueParameter, int index, JetType type, BindingTrace trace
-    ) {
-        return resolveValueParameterDescriptor(declarationDescriptor, valueParameter, index, type, trace,
-                annotationResolver.resolveAnnotationsWithoutArguments(scope, valueParameter.getModifierList(), trace));
-    }
-
-    @NotNull
-    private ValueParameterDescriptorImpl resolveValueParameterDescriptor(
-            DeclarationDescriptor declarationDescriptor,
-            JetParameter valueParameter, int index, JetType type, BindingTrace trace,
-            Annotations annotations
+            JetScope scope, FunctionDescriptor owner, JetParameter valueParameter, int index, JetType type, BindingTrace trace
     ) {
         JetType varargElementType = null;
         JetType variableType = type;
@@ -365,10 +337,10 @@ public class DescriptorResolver {
             variableType = getVarargParameterType(type);
         }
         ValueParameterDescriptorImpl valueParameterDescriptor = new ValueParameterDescriptorImpl(
-                declarationDescriptor,
+                owner,
                 null,
                 index,
-                annotations,
+                annotationResolver.resolveAnnotationsWithoutArguments(scope, valueParameter.getModifierList(), trace),
                 JetPsiUtil.safeName(valueParameter.getName()),
                 variableType,
                 valueParameter.hasDefaultValue(),
@@ -879,17 +851,13 @@ public class DescriptorResolver {
         if (!variable.hasInitializer()) return;
 
         variableDescriptor.setCompileTimeInitializer(
-            storageManager.createRecursionTolerantNullableLazyValue(new Function0<CompileTimeConstant<?>>() {
+            storageManager.createRecursionTolerantNullableLazyValue(new Function0<ConstantValue<?>>() {
                 @Nullable
                 @Override
-                public CompileTimeConstant<?> invoke() {
+                public ConstantValue<?> invoke() {
                     JetExpression initializer = variable.getInitializer();
                     JetType initializerType = expressionTypingServices.safeGetType(scope, initializer, variableType, dataFlowInfo, trace);
-                    CompileTimeConstant<?> constant = ConstantExpressionEvaluator.evaluate(initializer, trace, initializerType);
-                    if (constant instanceof IntegerValueTypeConstant) {
-                        return EvaluatePackage.createCompileTimeConstantWithType((IntegerValueTypeConstant) constant, initializerType);
-                    }
-                    return constant;
+                    return ConstantExpressionEvaluator.evaluateToConstantValue(initializer, trace, initializerType);
                 }
             }, null)
         );
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/FunctionAnalyzerExtension.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/FunctionAnalyzerExtension.java
index 7249c7cad07..22b8b869d3e 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/FunctionAnalyzerExtension.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/FunctionAnalyzerExtension.java
@@ -23,7 +23,6 @@ import org.jetbrains.kotlin.psi.JetNamedFunction;
 import org.jetbrains.kotlin.resolve.inline.InlineAnalyzerExtension;
 import org.jetbrains.kotlin.resolve.inline.InlineUtil;
 
-import javax.inject.Inject;
 import java.util.Collections;
 import java.util.List;
 import java.util.Map;
@@ -34,10 +33,9 @@ public class FunctionAnalyzerExtension {
         void process(@NotNull FunctionDescriptor descriptor, @NotNull JetNamedFunction function, @NotNull BindingTrace trace);
     }
 
-    private BindingTrace trace;
+    @NotNull private final BindingTrace trace;
 
-    @Inject
-    public void setTrace(@NotNull BindingTrace trace) {
+    public FunctionAnalyzerExtension(@NotNull BindingTrace trace) {
         this.trace = trace;
     }
 
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/LazyTopDownAnalyzer.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/LazyTopDownAnalyzer.kt
index 4bdb281a73d..75bc0790d0c 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/LazyTopDownAnalyzer.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/LazyTopDownAnalyzer.kt
@@ -32,78 +32,22 @@ import org.jetbrains.kotlin.resolve.lazy.*
 import org.jetbrains.kotlin.resolve.lazy.descriptors.LazyClassDescriptor
 import org.jetbrains.kotlin.resolve.varianceChecker.VarianceChecker
 import java.util.ArrayList
-import javax.inject.Inject
-
-public class LazyTopDownAnalyzer {
-    private var trace: BindingTrace? = null
-    private var declarationResolver: DeclarationResolver? = null
-    private var overrideResolver: OverrideResolver? = null
-    private var overloadResolver: OverloadResolver? = null
-    private var varianceChecker: VarianceChecker? = null
-    private var moduleDescriptor: ModuleDescriptor? = null
-    private var lazyDeclarationResolver: LazyDeclarationResolver? = null
-    private var bodyResolver: BodyResolver? = null
-    private var topLevelDescriptorProvider: TopLevelDescriptorProvider? = null
-    private var fileScopeProvider: FileScopeProvider? = null
-    private var declarationScopeProvider: DeclarationScopeProvider? = null
-
-    Inject
-    public fun setLazyDeclarationResolver(lazyDeclarationResolver: LazyDeclarationResolver) {
-        this.lazyDeclarationResolver = lazyDeclarationResolver
-    }
-
-    Inject
-    public fun setTopLevelDescriptorProvider(topLevelDescriptorProvider: TopLevelDescriptorProvider) {
-        this.topLevelDescriptorProvider = topLevelDescriptorProvider
-    }
-
-    Inject
-    public fun setFileScopeProvider(fileScopeProvider: FileScopeProvider) {
-        this.fileScopeProvider = fileScopeProvider
-    }
-
-    Inject
-    public fun setDeclarationScopeProvider(declarationScopeProvider: DeclarationScopeProviderImpl) {
-        this.declarationScopeProvider = declarationScopeProvider
-    }
-
-    Inject
-    public fun setTrace(trace: BindingTrace) {
-        this.trace = trace
-    }
-
-    Inject
-    public fun setDeclarationResolver(declarationResolver: DeclarationResolver) {
-        this.declarationResolver = declarationResolver
-    }
-
-    Inject
-    public fun setOverrideResolver(overrideResolver: OverrideResolver) {
-        this.overrideResolver = overrideResolver
-    }
-
-    Inject
-    public fun setVarianceChecker(varianceChecker: VarianceChecker) {
-        this.varianceChecker = varianceChecker
-    }
-
-    Inject
-    public fun setOverloadResolver(overloadResolver: OverloadResolver) {
-        this.overloadResolver = overloadResolver
-    }
-
-    Inject
-    public fun setModuleDescriptor(moduleDescriptor: ModuleDescriptor) {
-        this.moduleDescriptor = moduleDescriptor
-    }
-
-    Inject
-    public fun setBodyResolver(bodyResolver: BodyResolver) {
-        this.bodyResolver = bodyResolver
-    }
 
+public class LazyTopDownAnalyzer(
+        private val trace: BindingTrace,
+        private val declarationResolver: DeclarationResolver,
+        private val overrideResolver: OverrideResolver,
+        private val overloadResolver: OverloadResolver,
+        private val varianceChecker: VarianceChecker,
+        private val moduleDescriptor: ModuleDescriptor,
+        private val lazyDeclarationResolver: LazyDeclarationResolver,
+        private val bodyResolver: BodyResolver,
+        private val topLevelDescriptorProvider: TopLevelDescriptorProvider,
+        private val fileScopeProvider: FileScopeProvider,
+        private val declarationScopeProvider: DeclarationScopeProvider
+) {
     public fun analyzeDeclarations(topDownAnalysisMode: TopDownAnalysisMode, declarations: Collection<PsiElement>, outerDataFlowInfo: DataFlowInfo): TopDownAnalysisContext {
-        val c = TopDownAnalysisContext(topDownAnalysisMode, outerDataFlowInfo, declarationScopeProvider!!)
+        val c = TopDownAnalysisContext(topDownAnalysisMode, outerDataFlowInfo, declarationScopeProvider)
 
         val topLevelFqNames = HashMultimap.create<FqName, JetElement>()
 
@@ -127,8 +71,8 @@ public class LazyTopDownAnalyzer {
                     if (file.isScript()) {
                         val script = file.getScript() ?: throw AssertionError("getScript() is null for file: $file")
 
-                        DescriptorResolver.registerFileInPackage(trace!!, file)
-                        c.getScripts().put(script, topLevelDescriptorProvider!!.getScriptDescriptor(script))
+                        DescriptorResolver.registerFileInPackage(trace, file)
+                        c.getScripts().put(script, topLevelDescriptorProvider.getScriptDescriptor(script))
                     }
                     else {
                         val packageDirective = file.getPackageDirective()
@@ -137,7 +81,7 @@ public class LazyTopDownAnalyzer {
                         c.addFile(file)
 
                         packageDirective!!.accept(this)
-                        DescriptorResolver.registerFileInPackage(trace!!, file)
+                        DescriptorResolver.registerFileInPackage(trace, file)
 
                         registerDeclarations(file.getDeclarations())
 
@@ -146,16 +90,16 @@ public class LazyTopDownAnalyzer {
                 }
 
                 override fun visitPackageDirective(directive: JetPackageDirective) {
-                    DescriptorResolver.resolvePackageHeader(directive, moduleDescriptor!!, trace!!)
+                    DescriptorResolver.resolvePackageHeader(directive, moduleDescriptor, trace)
                 }
 
                 override fun visitImportDirective(importDirective: JetImportDirective) {
-                    val fileScope = fileScopeProvider!!.getFileScope(importDirective.getContainingJetFile()) as LazyFileScope
+                    val fileScope = fileScopeProvider.getFileScope(importDirective.getContainingJetFile())
                     fileScope.forceResolveImport(importDirective)
                 }
 
                 override fun visitClassOrObject(classOrObject: JetClassOrObject) {
-                    val descriptor = lazyDeclarationResolver!!.getClassDescriptor(classOrObject) as ClassDescriptorWithResolutionScopes
+                    val descriptor = lazyDeclarationResolver.getClassDescriptor(classOrObject) as ClassDescriptorWithResolutionScopes
 
                     c.getDeclaredClasses().put(classOrObject, descriptor)
                     registerDeclarations(classOrObject.getDeclarations())
@@ -169,16 +113,16 @@ public class LazyTopDownAnalyzer {
                     for (jetDeclaration in classOrObject.getDeclarations()) {
                         if (jetDeclaration is JetObjectDeclaration && jetDeclaration.isCompanion()) {
                             if (companionObjectAlreadyFound) {
-                                trace!!.report(MANY_COMPANION_OBJECTS.on(jetDeclaration))
+                                trace.report(MANY_COMPANION_OBJECTS.on(jetDeclaration))
                             }
                             companionObjectAlreadyFound = true
                         }
                         else if (jetDeclaration is JetSecondaryConstructor) {
                             if (DescriptorUtils.isSingletonOrAnonymousObject(classDescriptor)) {
-                                trace!!.report(CONSTRUCTOR_IN_OBJECT.on(jetDeclaration))
+                                trace.report(CONSTRUCTOR_IN_OBJECT.on(jetDeclaration))
                             }
                             else if (classDescriptor.getKind() == ClassKind.INTERFACE) {
-                                trace!!.report(CONSTRUCTOR_IN_TRAIT.on(jetDeclaration))
+                                trace.report(CONSTRUCTOR_IN_TRAIT.on(jetDeclaration))
                             }
                         }
                     }
@@ -192,13 +136,13 @@ public class LazyTopDownAnalyzer {
                 private fun registerPrimaryConstructorParameters(klass: JetClass) {
                     for (jetParameter in klass.getPrimaryConstructorParameters()) {
                         if (jetParameter.hasValOrVar()) {
-                            c.getPrimaryConstructorParameterProperties().put(jetParameter, lazyDeclarationResolver!!.resolveToDescriptor(jetParameter) as PropertyDescriptor)
+                            c.getPrimaryConstructorParameterProperties().put(jetParameter, lazyDeclarationResolver.resolveToDescriptor(jetParameter) as PropertyDescriptor)
                         }
                     }
                 }
 
                 override fun visitSecondaryConstructor(constructor: JetSecondaryConstructor) {
-                    c.getSecondaryConstructors().put(constructor, lazyDeclarationResolver!!.resolveToDescriptor(constructor) as ConstructorDescriptor)
+                    c.getSecondaryConstructors().put(constructor, lazyDeclarationResolver.resolveToDescriptor(constructor) as ConstructorDescriptor)
                 }
 
                 override fun visitEnumEntry(enumEntry: JetEnumEntry) {
@@ -210,12 +154,12 @@ public class LazyTopDownAnalyzer {
                 }
 
                 override fun visitAnonymousInitializer(initializer: JetClassInitializer) {
-                    val classOrObject = PsiTreeUtil.getParentOfType<JetClassOrObject>(initializer, javaClass<JetClassOrObject>())
-                    c.getAnonymousInitializers().put(initializer, lazyDeclarationResolver!!.resolveToDescriptor(classOrObject) as ClassDescriptorWithResolutionScopes)
+                    val classOrObject = PsiTreeUtil.getParentOfType<JetClassOrObject>(initializer, javaClass<JetClassOrObject>())!!
+                    c.getAnonymousInitializers().put(initializer, lazyDeclarationResolver.resolveToDescriptor(classOrObject) as ClassDescriptorWithResolutionScopes)
                 }
 
                 override fun visitTypedef(typedef: JetTypedef) {
-                    trace!!.report(UNSUPPORTED.on(typedef, "Typedefs are not supported"))
+                    trace.report(UNSUPPORTED.on(typedef, "Typedefs are not supported"))
                 }
 
                 override fun visitMultiDeclaration(multiDeclaration: JetMultiDeclaration) {
@@ -238,18 +182,18 @@ public class LazyTopDownAnalyzer {
 
         resolveAllHeadersInClasses(c)
 
-        declarationResolver!!.checkRedeclarationsInPackages(topLevelDescriptorProvider!!, topLevelFqNames)
-        declarationResolver!!.checkRedeclarations(c)
+        declarationResolver.checkRedeclarationsInPackages(topLevelDescriptorProvider, topLevelFqNames)
+        declarationResolver.checkRedeclarations(c)
 
-        overrideResolver!!.check(c)
+        overrideResolver.check(c)
 
-        varianceChecker!!.check(c)
+        varianceChecker.check(c)
 
-        declarationResolver!!.resolveAnnotationsOnFiles(c, fileScopeProvider!!)
+        declarationResolver.resolveAnnotationsOnFiles(c, fileScopeProvider)
 
-        overloadResolver!!.process(c)
+        overloadResolver.process(c)
 
-        bodyResolver!!.resolveBodies(c)
+        bodyResolver.resolveBodies(c)
 
         return c
     }
@@ -262,7 +206,7 @@ public class LazyTopDownAnalyzer {
 
     private fun createPropertyDescriptors(c: TopDownAnalysisContext, topLevelFqNames: Multimap<FqName, JetElement>, properties: List<JetProperty>) {
         for (property in properties) {
-            val descriptor = lazyDeclarationResolver!!.resolveToDescriptor(property) as PropertyDescriptor
+            val descriptor = lazyDeclarationResolver.resolveToDescriptor(property) as PropertyDescriptor
 
             c.getProperties().put(property, descriptor)
             ForceResolveUtil.forceResolveAllContents(descriptor.getAnnotations())
@@ -272,7 +216,7 @@ public class LazyTopDownAnalyzer {
 
     private fun createFunctionDescriptors(c: TopDownAnalysisContext, functions: List<JetNamedFunction>) {
         for (function in functions) {
-            val simpleFunctionDescriptor = lazyDeclarationResolver!!.resolveToDescriptor(function) as SimpleFunctionDescriptor
+            val simpleFunctionDescriptor = lazyDeclarationResolver.resolveToDescriptor(function) as SimpleFunctionDescriptor
             c.getFunctions().put(function, simpleFunctionDescriptor)
             ForceResolveUtil.forceResolveAllContents(simpleFunctionDescriptor.getAnnotations())
             for (parameterDescriptor in simpleFunctionDescriptor.getValueParameters()) {
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/LazyTopDownAnalyzerForTopLevel.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/LazyTopDownAnalyzerForTopLevel.java
index 4f7a08dfd1b..34137d62142 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/LazyTopDownAnalyzerForTopLevel.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/LazyTopDownAnalyzerForTopLevel.java
@@ -28,24 +28,21 @@ import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo;
 import org.jetbrains.kotlin.resolve.lazy.KotlinCodeAnalyzer;
 import org.jetbrains.kotlin.resolve.lazy.LazyFileScope;
 
-import javax.inject.Inject;
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.List;
 
 public class LazyTopDownAnalyzerForTopLevel {
 
-    private KotlinCodeAnalyzer resolveSession;
-    private LazyTopDownAnalyzer lazyTopDownAnalyzer;
+    @NotNull private final KotlinCodeAnalyzer codeAnalyzer;
+    @NotNull private final LazyTopDownAnalyzer lazyTopDownAnalyzer;
 
-    @Inject
-    public void setKotlinCodeAnalyzer(@NotNull KotlinCodeAnalyzer kotlinCodeAnalyzer) {
-        this.resolveSession = kotlinCodeAnalyzer;
-    }
-
-    @Inject
-    public void setLazyTopDownAnalyzer(@NotNull LazyTopDownAnalyzer lazyTopDownAnalyzer) {
+    public LazyTopDownAnalyzerForTopLevel(
+            @NotNull LazyTopDownAnalyzer lazyTopDownAnalyzer,
+            @NotNull KotlinCodeAnalyzer codeAnalyzer
+    ) {
         this.lazyTopDownAnalyzer = lazyTopDownAnalyzer;
+        this.codeAnalyzer = codeAnalyzer;
     }
 
     @NotNull
@@ -56,15 +53,15 @@ public class LazyTopDownAnalyzerForTopLevel {
     ) {
         PackageFragmentProvider provider;
         if (additionalProviders.isEmpty()) {
-            provider = resolveSession.getPackageFragmentProvider();
+            provider = codeAnalyzer.getPackageFragmentProvider();
         }
         else {
             provider = new CompositePackageFragmentProvider(KotlinPackage.plus(
-                    Arrays.asList(resolveSession.getPackageFragmentProvider()),
+                    Arrays.asList(codeAnalyzer.getPackageFragmentProvider()),
                     additionalProviders));
         }
 
-        ((ModuleDescriptorImpl) resolveSession.getModuleDescriptor()).initialize(provider);
+        ((ModuleDescriptorImpl) codeAnalyzer.getModuleDescriptor()).initialize(provider);
 
         return analyzeDeclarations(topDownAnalysisMode, files);
     }
@@ -76,7 +73,7 @@ public class LazyTopDownAnalyzerForTopLevel {
     ) {
         TopDownAnalysisContext c = lazyTopDownAnalyzer.analyzeDeclarations(topDownAnalysisMode, elements, DataFlowInfo.EMPTY);
 
-        resolveImportsInAllFiles(c, resolveSession);
+        resolveImportsInAllFiles(c, codeAnalyzer);
 
         return c;
     }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/ModifiersChecker.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/ModifiersChecker.java
index 18154c9e66c..eefa3944fb5 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/ModifiersChecker.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/ModifiersChecker.java
@@ -26,13 +26,13 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.descriptors.*;
 import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptor;
-import org.jetbrains.kotlin.diagnostics.*;
+import org.jetbrains.kotlin.diagnostics.Errors;
 import org.jetbrains.kotlin.lexer.JetModifierKeywordToken;
 import org.jetbrains.kotlin.lexer.JetTokens;
 import org.jetbrains.kotlin.name.FqName;
 import org.jetbrains.kotlin.name.Name;
 import org.jetbrains.kotlin.psi.*;
-import org.jetbrains.kotlin.resolve.constants.CompileTimeConstant;
+import org.jetbrains.kotlin.resolve.constants.ConstantValue;
 import org.jetbrains.kotlin.resolve.constants.StringValue;
 
 import java.util.*;
@@ -150,6 +150,8 @@ public class ModifiersChecker {
         }
         checkPlatformNameApplicability(descriptor);
         runDeclarationCheckers(modifierListOwner, descriptor);
+        AnnotationTargetChecker.INSTANCE$.check(modifierListOwner, trace,
+                                                descriptor instanceof ClassDescriptor ? (ClassDescriptor) descriptor : null);
     }
 
     private void checkVarargsModifiers(@NotNull JetDeclaration owner, @NotNull MemberDescriptor descriptor) {
@@ -163,6 +165,8 @@ public class ModifiersChecker {
         reportIllegalVisibilityModifiers(modifierListOwner);
         checkPlatformNameApplicability(descriptor);
         runDeclarationCheckers(modifierListOwner, descriptor);
+        AnnotationTargetChecker.INSTANCE$.check(modifierListOwner, trace,
+                                                descriptor instanceof ClassDescriptor ? (ClassDescriptor) descriptor : null);
     }
 
     public void reportIllegalModalityModifiers(@NotNull JetModifierListOwner modifierListOwner) {
@@ -300,9 +304,9 @@ public class ModifiersChecker {
         }
 
         String value = null;
-        Collection<CompileTimeConstant<?>> values = annotation.getAllValueArguments().values();
+        Collection<ConstantValue<?>> values = annotation.getAllValueArguments().values();
         if (!values.isEmpty()) {
-            CompileTimeConstant<?> name = values.iterator().next();
+            ConstantValue<?> name = values.iterator().next();
             if (name instanceof StringValue) {
                 value = ((StringValue) name).getValue();
             }
@@ -421,7 +425,7 @@ public class ModifiersChecker {
 
     private void runDeclarationCheckers(@NotNull JetDeclaration declaration, @NotNull DeclarationDescriptor descriptor) {
         for (DeclarationChecker checker : additionalCheckerProvider.getDeclarationCheckers()) {
-            checker.check(declaration, descriptor, trace);
+            checker.check(declaration, descriptor, trace, trace.getBindingContext());
         }
     }
 
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/OverloadResolver.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/OverloadResolver.java
index cc651b6b51a..2e7bd8747cd 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/OverloadResolver.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/OverloadResolver.java
@@ -29,7 +29,6 @@ import org.jetbrains.kotlin.psi.JetDeclaration;
 import org.jetbrains.kotlin.psi.JetObjectDeclaration;
 import org.jetbrains.kotlin.psi.JetSecondaryConstructor;
 
-import javax.inject.Inject;
 import java.util.Collection;
 import java.util.Map;
 import java.util.Set;
@@ -37,10 +36,9 @@ import java.util.Set;
 import static org.jetbrains.kotlin.resolve.DescriptorUtils.getFqName;
 
 public class OverloadResolver {
-    private BindingTrace trace;
+    @NotNull private final BindingTrace trace;
 
-    @Inject
-    public void setTrace(BindingTrace trace) {
+    public OverloadResolver(@NotNull BindingTrace trace) {
         this.trace = trace;
     }
 
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/OverrideResolver.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/OverrideResolver.java
index e9400dff332..487ae768abb 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/OverrideResolver.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/OverrideResolver.java
@@ -35,14 +35,13 @@ import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptor;
 import org.jetbrains.kotlin.lexer.JetTokens;
 import org.jetbrains.kotlin.name.Name;
 import org.jetbrains.kotlin.psi.*;
-import org.jetbrains.kotlin.resolve.calls.CallResolverUtil;
+import org.jetbrains.kotlin.resolve.calls.callResolverUtil.CallResolverUtilPackage;
 import org.jetbrains.kotlin.resolve.dataClassUtils.DataClassUtilsPackage;
 import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue;
 import org.jetbrains.kotlin.types.*;
 import org.jetbrains.kotlin.types.checker.JetTypeChecker;
 import org.jetbrains.kotlin.utils.HashSetUtil;
 
-import javax.inject.Inject;
 import java.util.*;
 
 import static org.jetbrains.kotlin.descriptors.CallableMemberDescriptor.Kind.*;
@@ -53,15 +52,12 @@ import static org.jetbrains.kotlin.resolve.descriptorUtil.DescriptorUtilPackage.
 
 public class OverrideResolver {
 
-    private BindingTrace trace;
+    @NotNull private final BindingTrace trace;
 
-    @Inject
-    public void setTrace(BindingTrace trace) {
+    public OverrideResolver(@NotNull BindingTrace trace) {
         this.trace = trace;
     }
 
-
-
     public void check(@NotNull TopDownAnalysisContext c) {
         checkVisibility(c);
         checkOverrides(c);
@@ -361,7 +357,7 @@ public class OverrideResolver {
             @NotNull List<CallableMemberDescriptor> concreteOverridden
     ) {
         for (CallableMemberDescriptor overridden : allOverriddenDeclarations) {
-            if (!CallResolverUtil.isOrOverridesSynthesized(overridden)) {
+            if (!CallResolverUtilPackage.isOrOverridesSynthesized(overridden)) {
                 if (overridden.getModality() == Modality.ABSTRACT) {
                     abstractOverridden.add(overridden);
                 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/QualifiedExpressionResolver.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/QualifiedExpressionResolver.java
index e29fd460656..98f647407c3 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/QualifiedExpressionResolver.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/QualifiedExpressionResolver.java
@@ -33,7 +33,6 @@ import org.jetbrains.kotlin.resolve.scopes.JetScope;
 import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue;
 import org.jetbrains.kotlin.resolve.validation.SymbolUsageValidator;
 
-import javax.inject.Inject;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.Set;
@@ -41,18 +40,10 @@ import java.util.Set;
 import static org.jetbrains.kotlin.diagnostics.Errors.*;
 
 public class QualifiedExpressionResolver {
-    private SymbolUsageValidator symbolUsageValidator;
-    private final ImportDirectiveProcessor importDirectiveProcessor = new ImportDirectiveProcessor(this);
+    @NotNull private final SymbolUsageValidator symbolUsageValidator;
+    @NotNull private final ImportDirectiveProcessor importDirectiveProcessor = new ImportDirectiveProcessor(this);
 
-    /**
-     * @deprecated Instance of this class should be obtained from the Injector
-     */
-    @Deprecated
-    public QualifiedExpressionResolver() {
-    }
-
-    @Inject
-    public void setSymbolUsageValidator(@NotNull SymbolUsageValidator symbolUsageValidator) {
+    public QualifiedExpressionResolver(@NotNull SymbolUsageValidator symbolUsageValidator) {
         this.symbolUsageValidator = symbolUsageValidator;
     }
 
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/ScriptBodyResolver.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/ScriptBodyResolver.java
index a457e9d7e16..86e06a64666 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/ScriptBodyResolver.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/ScriptBodyResolver.java
@@ -27,7 +27,6 @@ import org.jetbrains.kotlin.types.expressions.CoercionStrategy;
 import org.jetbrains.kotlin.types.expressions.ExpressionTypingContext;
 import org.jetbrains.kotlin.types.expressions.ExpressionTypingServices;
 
-import javax.inject.Inject;
 import java.util.Map;
 
 import static org.jetbrains.kotlin.types.TypeUtils.NO_EXPECTED_TYPE;
@@ -36,17 +35,15 @@ import static org.jetbrains.kotlin.types.TypeUtils.NO_EXPECTED_TYPE;
 // SCRIPT: resolve symbols in scripts
 public class ScriptBodyResolver {
 
-    private ExpressionTypingServices expressionTypingServices;
-    private AdditionalCheckerProvider additionalCheckerProvider;
+    @NotNull private final ExpressionTypingServices expressionTypingServices;
+    @NotNull private final AdditionalCheckerProvider additionalCheckerProvider;
 
-    @Inject
-    public void setExpressionTypingServices(@NotNull ExpressionTypingServices expressionTypingServices) {
-        this.expressionTypingServices = expressionTypingServices;
-    }
-
-    @Inject
-    public void setAdditionalCheckerProvider(AdditionalCheckerProvider additionalCheckerProvider) {
+    public ScriptBodyResolver(
+            @NotNull AdditionalCheckerProvider additionalCheckerProvider,
+            @NotNull ExpressionTypingServices expressionTypingServices
+    ) {
         this.additionalCheckerProvider = additionalCheckerProvider;
+        this.expressionTypingServices = expressionTypingServices;
     }
 
     public void resolveScriptBodies(@NotNull BodiesResolveContext c) {
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/ScriptParameterResolver.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/ScriptParameterResolver.java
deleted file mode 100644
index f666db45388..00000000000
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/ScriptParameterResolver.java
+++ /dev/null
@@ -1,66 +0,0 @@
-/*
- * Copyright 2010-2015 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.kotlin.resolve;
-
-import com.google.common.collect.Lists;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.kotlin.descriptors.ScriptDescriptor;
-import org.jetbrains.kotlin.descriptors.SourceElement;
-import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor;
-import org.jetbrains.kotlin.descriptors.annotations.Annotations;
-import org.jetbrains.kotlin.descriptors.impl.ValueParameterDescriptorImpl;
-import org.jetbrains.kotlin.parsing.JetScriptDefinition;
-import org.jetbrains.kotlin.parsing.JetScriptDefinitionProvider;
-import org.jetbrains.kotlin.psi.JetFile;
-import org.jetbrains.kotlin.psi.JetScript;
-
-import java.util.List;
-
-// SCRIPT: Resolve script parameters
-public final class ScriptParameterResolver {
-    @NotNull
-    public static List<ValueParameterDescriptor> resolveScriptParameters(
-            @NotNull JetScript declaration,
-            @NotNull ScriptDescriptor scriptDescriptor
-    ) {
-        List<ValueParameterDescriptor> valueParameters = Lists.newArrayList();
-
-        JetFile file = declaration.getContainingJetFile();
-        JetScriptDefinition scriptDefinition = JetScriptDefinitionProvider.getInstance(file.getProject()).findScriptDefinition(file);
-
-        int index = 0;
-        for (AnalyzerScriptParameter scriptParameter : scriptDefinition.getScriptParameters()) {
-            ValueParameterDescriptor parameter = resolveScriptParameter(scriptParameter, index, scriptDescriptor);
-            valueParameters.add(parameter);
-            ++index;
-        }
-        return valueParameters;
-    }
-
-    @NotNull
-    private static ValueParameterDescriptor resolveScriptParameter(
-            @NotNull AnalyzerScriptParameter scriptParameter,
-            int index,
-            @NotNull ScriptDescriptor script
-    ) {
-        return new ValueParameterDescriptorImpl(script, null, index, Annotations.EMPTY, scriptParameter.getName(),
-                                                scriptParameter.getType(), false, null, SourceElement.NO_SOURCE);
-    }
-
-    private ScriptParameterResolver() {
-    }
-}
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/SingleImportScope.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/SingleImportScope.kt
index 9f918a70b6e..6b84617d723 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/SingleImportScope.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/SingleImportScope.kt
@@ -19,10 +19,11 @@ package org.jetbrains.kotlin.resolve
 import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter
-import org.jetbrains.kotlin.resolve.scopes.JetScope
+import org.jetbrains.kotlin.resolve.scopes.JetScopeImpl
+import org.jetbrains.kotlin.types.JetType
 import org.jetbrains.kotlin.utils.Printer
 
-class SingleImportScope(private val aliasName: Name, private val descriptors: Collection<DeclarationDescriptor>) : JetScope {
+class SingleImportScope(private val aliasName: Name, private val descriptors: Collection<DeclarationDescriptor>) : JetScopeImpl() {
     override fun getClassifier(name: Name)
             = if (name == aliasName) descriptors.filterIsInstance<ClassifierDescriptor>().singleOrNull() else null
 
@@ -35,18 +36,10 @@ class SingleImportScope(private val aliasName: Name, private val descriptors: Co
     override fun getFunctions(name: Name)
             = if (name == aliasName) descriptors.filterIsInstance<FunctionDescriptor>() else emptyList()
 
-    override fun getLocalVariable(name: Name): VariableDescriptor? = null
-
     override fun getContainingDeclaration(): DeclarationDescriptor = throw UnsupportedOperationException()
 
-    override fun getDeclarationsByLabel(labelName: Name): Collection<DeclarationDescriptor> = emptyList()
-
     override fun getDescriptors(kindFilter: DescriptorKindFilter, nameFilter: (Name) -> Boolean) = descriptors
 
-    override fun getImplicitReceiversHierarchy(): List<ReceiverParameterDescriptor> = emptyList()
-
-    override fun getOwnDeclaredDescriptors(): Collection<DeclarationDescriptor> = emptyList()
-
     override fun printScopeStructure(p: Printer) {
         p.println(javaClass.getSimpleName(), ": ", aliasName)
     }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/TypeResolver.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/TypeResolver.kt
index 573d33af5b6..55c3ea047b3 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/TypeResolver.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/TypeResolver.kt
@@ -226,7 +226,7 @@ public class TypeResolver(
                 val receiverTypeRef = type.getReceiverTypeReference()
                 val receiverType = if (receiverTypeRef == null) null else resolveType(c.noBareTypes(), receiverTypeRef)
 
-                val parameterTypes = type.getParameters().map { resolveType(c.noBareTypes(), it.getTypeReference()) }
+                val parameterTypes = type.getParameters().map { resolveType(c.noBareTypes(), it.getTypeReference()!!) }
 
                 val returnTypeRef = type.getReturnTypeReference()
                 val returnType = if (returnTypeRef != null)
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/VarianceChecker.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/VarianceChecker.kt
index 9e0d73ef638..2ac5e9e8a06 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/VarianceChecker.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/VarianceChecker.kt
@@ -176,7 +176,7 @@ class VarianceChecker(private val trace: BindingTrace) {
             for (argumentBinding in getArgumentBindings()) {
                 if (argumentBinding == null || argumentBinding.typeParameterDescriptor == null) continue
 
-                val projectionKind = getEffectiveProjectionKind(argumentBinding.typeParameterDescriptor, argumentBinding.typeProjection)!!
+                val projectionKind = getEffectiveProjectionKind(argumentBinding.typeParameterDescriptor!!, argumentBinding.typeProjection)!!
                 val newPosition = when (projectionKind) {
                     OUT -> position
                     IN -> position.opposite()
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/ArgumentTypeResolver.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/ArgumentTypeResolver.java
index e3ad15b08ef..87ef35c94e9 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/ArgumentTypeResolver.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/ArgumentTypeResolver.java
@@ -24,6 +24,7 @@ import org.jetbrains.kotlin.descriptors.annotations.Annotations;
 import org.jetbrains.kotlin.diagnostics.Errors;
 import org.jetbrains.kotlin.psi.*;
 import org.jetbrains.kotlin.resolve.*;
+import org.jetbrains.kotlin.resolve.calls.callResolverUtil.ResolveArgumentsMode;
 import org.jetbrains.kotlin.resolve.calls.callUtil.CallUtilPackage;
 import org.jetbrains.kotlin.resolve.calls.context.CallResolutionContext;
 import org.jetbrains.kotlin.resolve.calls.context.CheckValueArgumentsMode;
@@ -45,39 +46,31 @@ import org.jetbrains.kotlin.types.expressions.ExpressionTypingServices;
 import org.jetbrains.kotlin.types.expressions.JetTypeInfo;
 import org.jetbrains.kotlin.types.expressions.typeInfoFactory.TypeInfoFactoryPackage;
 
-import javax.inject.Inject;
 import java.util.Collections;
 import java.util.List;
 
 import static org.jetbrains.kotlin.resolve.BindingContextUtils.getRecordedTypeInfo;
-import static org.jetbrains.kotlin.resolve.calls.CallResolverUtil.ResolveArgumentsMode;
-import static org.jetbrains.kotlin.resolve.calls.CallResolverUtil.ResolveArgumentsMode.RESOLVE_FUNCTION_ARGUMENTS;
-import static org.jetbrains.kotlin.resolve.calls.CallResolverUtil.ResolveArgumentsMode.SHAPE_FUNCTION_ARGUMENTS;
+import static org.jetbrains.kotlin.resolve.calls.callResolverUtil.ResolveArgumentsMode.RESOLVE_FUNCTION_ARGUMENTS;
+import static org.jetbrains.kotlin.resolve.calls.callResolverUtil.ResolveArgumentsMode.SHAPE_FUNCTION_ARGUMENTS;
 import static org.jetbrains.kotlin.resolve.calls.context.ContextDependency.DEPENDENT;
 import static org.jetbrains.kotlin.resolve.calls.context.ContextDependency.INDEPENDENT;
-import static org.jetbrains.kotlin.resolve.calls.inference.InferencePackage.createCorrespondingFunctionTypeForFunctionPlaceholder;
+import static org.jetbrains.kotlin.resolve.calls.inference.InferencePackage.createTypeForFunctionPlaceholder;
 import static org.jetbrains.kotlin.types.TypeUtils.DONT_CARE;
 import static org.jetbrains.kotlin.types.TypeUtils.NO_EXPECTED_TYPE;
 
 public class ArgumentTypeResolver {
+    @NotNull private final TypeResolver typeResolver;
+    @NotNull private final ExpressionTypingServices expressionTypingServices;
+    @NotNull private final KotlinBuiltIns builtIns;
 
-    private TypeResolver typeResolver;
-    private ExpressionTypingServices expressionTypingServices;
-    private KotlinBuiltIns builtIns;
-
-    @Inject
-    public void setTypeResolver(@NotNull TypeResolver typeResolver) {
-        this.typeResolver = typeResolver;
-    }
-
-    @Inject
-    public void setExpressionTypingServices(@NotNull ExpressionTypingServices expressionTypingServices) {
-        this.expressionTypingServices = expressionTypingServices;
-    }
-
-    @Inject
-    public void setBuiltIns(@NotNull KotlinBuiltIns builtIns) {
+    public ArgumentTypeResolver(
+            @NotNull KotlinBuiltIns builtIns,
+            @NotNull ExpressionTypingServices expressionTypingServices,
+            @NotNull TypeResolver typeResolver
+    ) {
         this.builtIns = builtIns;
+        this.expressionTypingServices = expressionTypingServices;
+        this.typeResolver = typeResolver;
     }
 
     public static boolean isSubtypeOfForArgumentType(
@@ -85,7 +78,7 @@ public class ArgumentTypeResolver {
             @NotNull JetType expectedType
     ) {
         if (ErrorUtils.isFunctionPlaceholder(actualType)) {
-            JetType functionType = createCorrespondingFunctionTypeForFunctionPlaceholder(actualType, expectedType);
+            JetType functionType = createTypeForFunctionPlaceholder(actualType, expectedType);
             return JetTypeChecker.DEFAULT.isSubtypeOf(functionType, expectedType);
         }
         return JetTypeChecker.DEFAULT.isSubtypeOf(actualType, expectedType);
@@ -158,7 +151,7 @@ public class ArgumentTypeResolver {
     private static JetFunction getFunctionLiteralArgumentIfAny(
             @NotNull JetExpression expression, @NotNull ResolutionContext context
     ) {
-        JetExpression deparenthesizedExpression = getLastElementDeparenthesized(expression, context);
+        JetExpression deparenthesizedExpression = getLastElementDeparenthesized(expression, context.statementFilter);
         if (deparenthesizedExpression instanceof JetFunctionLiteralExpression) {
             return ((JetFunctionLiteralExpression) deparenthesizedExpression).getFunctionLiteral();
         }
@@ -171,7 +164,7 @@ public class ArgumentTypeResolver {
     @Nullable
     public static JetExpression getLastElementDeparenthesized(
             @Nullable JetExpression expression,
-            @NotNull ResolutionContext context
+            @NotNull StatementFilter statementFilter
     ) {
         JetExpression deparenthesizedExpression = JetPsiUtil.deparenthesize(expression, false);
         if (deparenthesizedExpression instanceof JetBlockExpression) {
@@ -180,9 +173,9 @@ public class ArgumentTypeResolver {
             // This case is a temporary hack for 'if' branches.
             // The right way to implement this logic is to interpret 'if' branches as function literals with explicitly-typed signatures
             // (no arguments and no receiver) and therefore analyze them straight away (not in the 'complete' phase).
-            JetExpression lastStatementInABlock = ResolvePackage.getLastStatementInABlock(context.statementFilter, blockExpression);
+            JetExpression lastStatementInABlock = ResolvePackage.getLastStatementInABlock(statementFilter, blockExpression);
             if (lastStatementInABlock != null) {
-                return getLastElementDeparenthesized(lastStatementInABlock, context);
+                return getLastElementDeparenthesized(lastStatementInABlock, statementFilter);
             }
         }
         return deparenthesizedExpression;
@@ -310,7 +303,7 @@ public class ArgumentTypeResolver {
             if (type.getConstructor() instanceof IntegerValueTypeConstructor) {
                 IntegerValueTypeConstructor constructor = (IntegerValueTypeConstructor) type.getConstructor();
                 JetType primitiveType = TypeUtils.getPrimitiveNumberType(constructor, context.expectedType);
-                updateNumberType(primitiveType, expression, context);
+                updateNumberType(primitiveType, expression, context.statementFilter, context.trace);
                 return primitiveType;
             }
         }
@@ -320,19 +313,20 @@ public class ArgumentTypeResolver {
     public static void updateNumberType(
             @NotNull JetType numberType,
             @Nullable JetExpression expression,
-            @NotNull ResolutionContext context
+            @NotNull StatementFilter statementFilter,
+            @NotNull BindingTrace trace
     ) {
         if (expression == null) return;
-        BindingContextUtils.updateRecordedType(numberType, expression, context.trace, false);
+        BindingContextUtils.updateRecordedType(numberType, expression, trace, false);
 
         if (!(expression instanceof JetConstantExpression)) {
-            JetExpression deparenthesized = getLastElementDeparenthesized(expression, context);
+            JetExpression deparenthesized = getLastElementDeparenthesized(expression, statementFilter);
             if (deparenthesized != expression) {
-                updateNumberType(numberType, deparenthesized, context);
+                updateNumberType(numberType, deparenthesized, statementFilter, trace);
             }
             return;
         }
 
-        ConstantExpressionEvaluator.evaluate(expression, context.trace, numberType);
+        ConstantExpressionEvaluator.evaluate(expression, trace, numberType);
     }
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallCompleter.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallCompleter.kt
index faaa381b422..b5cf244d821 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallCompleter.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallCompleter.kt
@@ -16,39 +16,37 @@
 
 package org.jetbrains.kotlin.resolve.calls
 
-import org.jetbrains.kotlin.descriptors.CallableDescriptor
-import org.jetbrains.kotlin.resolve.calls.context.BasicCallResolutionContext
-import org.jetbrains.kotlin.resolve.calls.results.OverloadResolutionResultsImpl
-import org.jetbrains.kotlin.resolve.calls.tasks.TracingStrategy
-import org.jetbrains.kotlin.resolve.calls.context.CheckValueArgumentsMode
-import org.jetbrains.kotlin.types.JetType
-import org.jetbrains.kotlin.resolve.BindingTrace
-import org.jetbrains.kotlin.resolve.calls.inference.ConstraintSystem
-import org.jetbrains.kotlin.types.TypeUtils
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns
+import org.jetbrains.kotlin.descriptors.CallableDescriptor
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.resolve.BindingContext.CONSTRAINT_SYSTEM_COMPLETER
-import org.jetbrains.kotlin.resolve.calls.inference.ConstraintSystemImpl
-import org.jetbrains.kotlin.resolve.calls.context.CallCandidateResolutionContext
-import org.jetbrains.kotlin.resolve.calls.results.ResolutionStatus
-import org.jetbrains.kotlin.resolve.calls.inference.InferenceErrorData
-import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo
-import org.jetbrains.kotlin.resolve.BindingContext
-import org.jetbrains.kotlin.resolve.calls.context.ResolutionContext
-import org.jetbrains.kotlin.resolve.calls.callUtil.*
 import org.jetbrains.kotlin.resolve.BindingContextUtils
-import org.jetbrains.kotlin.resolve.calls.context.CallResolutionContext
-import org.jetbrains.kotlin.types.expressions.DataFlowUtils
-import org.jetbrains.kotlin.types.expressions.ExpressionTypingUtils
-import org.jetbrains.kotlin.resolve.calls.CallResolverUtil.ResolveArgumentsMode.RESOLVE_FUNCTION_ARGUMENTS
+import org.jetbrains.kotlin.resolve.BindingTrace
 import org.jetbrains.kotlin.resolve.TemporaryBindingTrace
-import java.util.ArrayList
+import org.jetbrains.kotlin.resolve.calls.callResolverUtil.ResolveArgumentsMode.RESOLVE_FUNCTION_ARGUMENTS
+import org.jetbrains.kotlin.resolve.calls.callResolverUtil.getEffectiveExpectedType
+import org.jetbrains.kotlin.resolve.calls.callResolverUtil.isInvokeCallOnVariable
+import org.jetbrains.kotlin.resolve.calls.context.BasicCallResolutionContext
+import org.jetbrains.kotlin.resolve.calls.context.CallCandidateResolutionContext
+import org.jetbrains.kotlin.resolve.calls.context.CheckValueArgumentsMode
+import org.jetbrains.kotlin.resolve.calls.inference.ConstraintSystemImpl
+import org.jetbrains.kotlin.resolve.calls.inference.InferenceErrorData
 import org.jetbrains.kotlin.resolve.calls.inference.constraintPosition.ConstraintPositionKind.*
 import org.jetbrains.kotlin.resolve.calls.model.*
+import org.jetbrains.kotlin.resolve.calls.results.OverloadResolutionResultsImpl
+import org.jetbrains.kotlin.resolve.calls.results.ResolutionStatus
+import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo
+import org.jetbrains.kotlin.resolve.calls.tasks.TracingStrategy
+import org.jetbrains.kotlin.types.ErrorUtils
+import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.TypeUtils
+import org.jetbrains.kotlin.types.expressions.DataFlowUtils
+import java.util.ArrayList
 
 public class CallCompleter(
         val argumentTypeResolver: ArgumentTypeResolver,
-        val candidateResolver: CandidateResolver
+        val candidateResolver: CandidateResolver,
+        val builtIns: KotlinBuiltIns
 ) {
     fun <D : CallableDescriptor> completeCall(
             context: BasicCallResolutionContext,
@@ -60,7 +58,7 @@ public class CallCompleter(
 
         // for the case 'foo(a)' where 'foo' is a variable, the call 'foo.invoke(a)' shouldn't be completed separately,
         // it's completed when the outer (variable as function call) is completed
-        if (!CallResolverUtil.isInvokeCallOnVariable(context.call)) {
+        if (!isInvokeCallOnVariable(context.call)) {
 
             val temporaryTrace = TemporaryBindingTrace.create(context.trace, "Trace to complete a resulting call")
 
@@ -77,7 +75,7 @@ public class CallCompleter(
                 resolvedCall.variableCall.getCall().getCalleeExpression()
             else
                 resolvedCall.getCall().getCalleeExpression()
-            context.symbolUsageValidator.validateCall(resolvedCall.getResultingDescriptor(), context.trace, element)
+            context.symbolUsageValidator.validateCall(resolvedCall.getResultingDescriptor(), context.trace, element!!)
         }
 
         if (results.isSingleResult() && results.getResultingCall().getStatus().isSuccess()) {
@@ -130,8 +128,8 @@ public class CallCompleter(
             expectedType: JetType,
             trace: BindingTrace
     ) {
-        fun updateSystemIfSuccessful(update: (ConstraintSystem) -> Boolean) {
-            val copy = (getConstraintSystem() as ConstraintSystemImpl).copy()
+        fun updateSystemIfSuccessful(update: (ConstraintSystemImpl) -> Boolean) {
+            val copy = (getConstraintSystem() as ConstraintSystemImpl).copy() as ConstraintSystemImpl
             if (update(copy)) {
                 setConstraintSystem(copy)
             }
@@ -144,24 +142,27 @@ public class CallCompleter(
 
         val constraintSystemCompleter = trace[CONSTRAINT_SYSTEM_COMPLETER, getCall().getCalleeExpression()]
         if (constraintSystemCompleter != null) {
-            //todo improve error reporting with errors in constraints from completer
+            // todo improve error reporting with errors in constraints from completer
+            // todo add constraints from completer unconditionally; improve constraints from completer for generic methods
+            // add the constraints only if they don't lead to errors (except errors from upper bounds to improve diagnostics)
             updateSystemIfSuccessful {
                 system ->
                 constraintSystemCompleter.completeConstraintSystem(system, this)
-                !system.getStatus().hasOnlyErrorsFromPosition(FROM_COMPLETER.position())
+                !system.filterConstraintsOut(TYPE_BOUND_POSITION).getStatus().hasOnlyErrorsDerivedFrom(FROM_COMPLETER)
             }
         }
 
-        (getConstraintSystem() as ConstraintSystemImpl).processDeclaredBoundConstraints()
-
         if (returnType != null && expectedType === TypeUtils.UNIT_EXPECTED_TYPE) {
             updateSystemIfSuccessful {
                 system ->
-                system.addSupertypeConstraint(KotlinBuiltIns.getInstance().getUnitType(), returnType, EXPECTED_TYPE_POSITION.position())
+                system.addSupertypeConstraint(builtIns.getUnitType(), returnType, EXPECTED_TYPE_POSITION.position())
                 system.getStatus().isSuccessful()
             }
         }
 
+        val constraintSystem = getConstraintSystem() as ConstraintSystemImpl
+        constraintSystem.fixVariables()
+
         setResultingSubstitutor(getConstraintSystem()!!.getResultingSubstitutor())
     }
 
@@ -170,8 +171,7 @@ public class CallCompleter(
             tracing: TracingStrategy
     ) {
         val contextWithResolvedCall = CallCandidateResolutionContext.createForCallBeingAnalyzed(this, context, tracing)
-        val valueArgumentsCheckingResult = candidateResolver.checkAllValueArguments(
-                contextWithResolvedCall, context.trace, RESOLVE_FUNCTION_ARGUMENTS)
+        val valueArgumentsCheckingResult = candidateResolver.checkAllValueArguments(contextWithResolvedCall, RESOLVE_FUNCTION_ARGUMENTS)
 
         val status = getStatus()
         if (getConstraintSystem()!!.getStatus().isSuccessful()) {
@@ -211,7 +211,7 @@ public class CallCompleter(
         for (valueArgument in context.call.getValueArguments()) {
             val argumentMapping = getArgumentMapping(valueArgument!!)
             val expectedType = when (argumentMapping) {
-                is ArgumentMatch -> CandidateResolver.getEffectiveExpectedType(argumentMapping.valueParameter, valueArgument)
+                is ArgumentMatch -> getEffectiveExpectedType(argumentMapping.valueParameter, valueArgument)
                 else -> TypeUtils.NO_EXPECTED_TYPE
             }
             val newContext = context.replaceDataFlowInfo(getDataFlowInfoForArgument(valueArgument)).replaceExpectedType(expectedType)
@@ -226,8 +226,7 @@ public class CallCompleter(
         if (valueArgument.isExternal()) return
 
         val expression = valueArgument.getArgumentExpression() ?: return
-        val deparenthesized = ArgumentTypeResolver.getLastElementDeparenthesized(expression, context)
-        if (deparenthesized == null) return
+        val deparenthesized = ArgumentTypeResolver.getLastElementDeparenthesized(expression, context.statementFilter) ?: return
 
         val recordedType = expression.let { context.trace.getType(it) }
         var updatedType: JetType? = recordedType
@@ -261,15 +260,9 @@ public class CallCompleter(
             expression: JetExpression,
             context: BasicCallResolutionContext
     ): OverloadResolutionResultsImpl<*>? {
-        if (!ExpressionTypingUtils.dependsOnExpectedType(expression)) return null
+        val cachedData = getResolutionResultsCachedData(expression, context) ?: return null
+        val (cachedResolutionResults, cachedContext, tracing) = cachedData
 
-        val argumentCall = expression.getCall(context.trace.getBindingContext())
-        if (argumentCall == null) return null
-
-        val cachedDataForCall = context.resolutionResultsCache[argumentCall]
-        if (cachedDataForCall == null) return null
-
-        val (cachedResolutionResults, cachedContext, tracing) = cachedDataForCall
         @suppress("UNCHECKED_CAST")
         val cachedResults = cachedResolutionResults as OverloadResolutionResultsImpl<CallableDescriptor>
         val contextForArgument = cachedContext.replaceBindingTrace(context.trace)
@@ -284,7 +277,8 @@ public class CallCompleter(
             argumentExpression: JetExpression,
             trace: BindingTrace
     ): JetType? {
-        if (recordedType == updatedType || updatedType == null) return updatedType
+        //workaround for KT-8218
+        if ((!ErrorUtils.containsErrorType(recordedType) && recordedType == updatedType) || updatedType == null) return updatedType
 
         fun deparenthesizeOrGetSelector(expression: JetExpression?): JetExpression? {
             val deparenthesized = JetPsiUtil.deparenthesizeOnce(expression, /* deparenthesizeBinaryExpressionWithTypeRHS = */ false)
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallExpressionResolver.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallExpressionResolver.java
index c8018e605c4..1cb3a6cdac8 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallExpressionResolver.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallExpressionResolver.java
@@ -39,7 +39,6 @@ import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo;
 import org.jetbrains.kotlin.resolve.calls.util.CallMaker;
 import org.jetbrains.kotlin.resolve.calls.util.FakeCallableDescriptorForObject;
 import org.jetbrains.kotlin.resolve.constants.CompileTimeConstant;
-import org.jetbrains.kotlin.resolve.constants.IntegerValueConstant;
 import org.jetbrains.kotlin.resolve.constants.evaluate.ConstantExpressionEvaluator;
 import org.jetbrains.kotlin.resolve.scopes.receivers.*;
 import org.jetbrains.kotlin.types.ErrorUtils;
@@ -61,15 +60,16 @@ import static org.jetbrains.kotlin.types.TypeUtils.NO_EXPECTED_TYPE;
 public class CallExpressionResolver {
 
     private final CallResolver callResolver;
-    private final KotlinBuiltIns builtIns;
+    private final ConstantExpressionEvaluator constantExpressionEvaluator;
 
-    public CallExpressionResolver(@NotNull CallResolver callResolver, @NotNull KotlinBuiltIns builtIns) {
+    public CallExpressionResolver(@NotNull CallResolver callResolver, @NotNull ConstantExpressionEvaluator constantExpressionEvaluator) {
         this.callResolver = callResolver;
-        this.builtIns = builtIns;
+        this.constantExpressionEvaluator = constantExpressionEvaluator;
     }
 
     private ExpressionTypingServices expressionTypingServices;
 
+    // component dependency cycle
     @Inject
     public void setExpressionTypingServices(@NotNull ExpressionTypingServices expressionTypingServices) {
         this.expressionTypingServices = expressionTypingServices;
@@ -269,7 +269,7 @@ public class CallExpressionResolver {
         else if (parent instanceof JetParameter) {
             JetClass jetClass = PsiTreeUtil.getParentOfType(parent, JetClass.class);
             if (jetClass != null) {
-                return jetClass.hasModifier(JetTokens.ANNOTATION_KEYWORD);
+                return jetClass.isAnnotation();
             }
         }
         return false;
@@ -370,9 +370,9 @@ public class CallExpressionResolver {
             context.trace.recordType(selectorExpression, selectorReturnType);
         }
 
-        CompileTimeConstant<?> value = ConstantExpressionEvaluator.evaluate(expression, context.trace, context.expectedType);
-        if (value instanceof IntegerValueConstant && ((IntegerValueConstant) value).isPure()) {
-            return ExpressionTypingUtils.createCompileTimeConstantTypeInfo(value, expression, context, builtIns);
+        CompileTimeConstant<?> value = constantExpressionEvaluator.evaluateExpression(expression, context.trace, context.expectedType);
+        if (value != null && value.getIsPure()) {
+            return ExpressionTypingUtils.createCompileTimeConstantTypeInfo(value, expression, context);
         }
 
         JetTypeInfo typeInfo;
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallResolver.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallResolver.java
index f0eecb9209a..11ac9867533 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallResolver.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallResolver.java
@@ -17,16 +17,19 @@
 package org.jetbrains.kotlin.resolve.calls;
 
 import com.google.common.collect.Lists;
+import com.intellij.openapi.util.Condition;
+import com.intellij.util.containers.ContainerUtil;
 import kotlin.Unit;
 import kotlin.jvm.functions.Function0;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.progress.ProgressIndicatorAndCompilationCanceledStatus;
 import org.jetbrains.kotlin.descriptors.*;
 import org.jetbrains.kotlin.lexer.JetTokens;
 import org.jetbrains.kotlin.name.Name;
+import org.jetbrains.kotlin.progress.ProgressIndicatorAndCompilationCanceledStatus;
 import org.jetbrains.kotlin.psi.*;
 import org.jetbrains.kotlin.resolve.*;
+import org.jetbrains.kotlin.resolve.calls.callResolverUtil.CallResolverUtilPackage;
 import org.jetbrains.kotlin.resolve.calls.callUtil.CallUtilPackage;
 import org.jetbrains.kotlin.resolve.calls.checkers.CallChecker;
 import org.jetbrains.kotlin.resolve.calls.context.*;
@@ -48,6 +51,7 @@ import org.jetbrains.kotlin.types.JetType;
 import org.jetbrains.kotlin.types.TypeSubstitutor;
 import org.jetbrains.kotlin.types.expressions.ExpressionTypingContext;
 import org.jetbrains.kotlin.types.expressions.ExpressionTypingServices;
+import org.jetbrains.kotlin.types.expressions.ExpressionTypingVisitorDispatcher;
 import org.jetbrains.kotlin.types.expressions.OperatorConventions;
 import org.jetbrains.kotlin.util.PerformanceCounter;
 
@@ -58,8 +62,10 @@ import java.util.List;
 
 import static org.jetbrains.kotlin.diagnostics.Errors.*;
 import static org.jetbrains.kotlin.resolve.bindingContextUtil.BindingContextUtilPackage.recordScopeAndDataFlowInfo;
-import static org.jetbrains.kotlin.resolve.calls.CallResolverUtil.ResolveArgumentsMode.RESOLVE_FUNCTION_ARGUMENTS;
-import static org.jetbrains.kotlin.resolve.calls.CallResolverUtil.ResolveArgumentsMode.SHAPE_FUNCTION_ARGUMENTS;
+import static org.jetbrains.kotlin.resolve.calls.callResolverUtil.ResolveArgumentsMode.RESOLVE_FUNCTION_ARGUMENTS;
+import static org.jetbrains.kotlin.resolve.calls.callResolverUtil.ResolveArgumentsMode.SHAPE_FUNCTION_ARGUMENTS;
+import static org.jetbrains.kotlin.resolve.calls.context.CandidateResolveMode.EXIT_ON_FIRST_ERROR;
+import static org.jetbrains.kotlin.resolve.calls.context.CandidateResolveMode.FULLY;
 import static org.jetbrains.kotlin.resolve.calls.results.OverloadResolutionResults.Code.CANDIDATES_WITH_WRONG_RECEIVER;
 import static org.jetbrains.kotlin.resolve.calls.results.OverloadResolutionResults.Code.INCOMPLETE_TYPE_INFERENCE;
 import static org.jetbrains.kotlin.types.TypeUtils.NO_EXPECTED_TYPE;
@@ -70,48 +76,58 @@ public class CallResolver {
     private TypeResolver typeResolver;
     private CandidateResolver candidateResolver;
     private ArgumentTypeResolver argumentTypeResolver;
+    private GenericCandidateResolver genericCandidateResolver;
     private CallCompleter callCompleter;
-    private TaskPrioritizer taskPrioritizer;
-    private AdditionalCheckerProvider additionalCheckerProvider;
+    @NotNull private final TaskPrioritizer taskPrioritizer;
+    @NotNull private final AdditionalCheckerProvider additionalCheckerProvider;
     
-    private static final PerformanceCounter callResolvePerfCounter = new PerformanceCounter("Call resolve", true);
-    private static final PerformanceCounter candidatePerfCounter = new PerformanceCounter("Call resolve candidate analysis", true);
+    private static final PerformanceCounter callResolvePerfCounter = PerformanceCounter.Companion.create("Call resolve", ExpressionTypingVisitorDispatcher.typeInfoPerfCounter);
+    private static final PerformanceCounter candidatePerfCounter = PerformanceCounter.Companion.create("Call resolve candidate analysis", true);
 
+    public CallResolver(
+            @NotNull TaskPrioritizer taskPrioritizer,
+            @NotNull AdditionalCheckerProvider additionalCheckerProvider
+    ) {
+        this.taskPrioritizer = taskPrioritizer;
+        this.additionalCheckerProvider = additionalCheckerProvider;
+    }
+
+    // component dependency cycle
     @Inject
     public void setExpressionTypingServices(@NotNull ExpressionTypingServices expressionTypingServices) {
         this.expressionTypingServices = expressionTypingServices;
     }
 
+    // component dependency cycle
     @Inject
     public void setTypeResolver(@NotNull TypeResolver typeResolver) {
         this.typeResolver = typeResolver;
     }
 
+    // component dependency cycle
     @Inject
     public void setCandidateResolver(@NotNull CandidateResolver candidateResolver) {
         this.candidateResolver = candidateResolver;
     }
 
+    // component dependency cycle
     @Inject
     public void setArgumentTypeResolver(@NotNull ArgumentTypeResolver argumentTypeResolver) {
         this.argumentTypeResolver = argumentTypeResolver;
     }
 
+    // component dependency cycle
+    @Inject
+    public void setGenericCandidateResolver(GenericCandidateResolver genericCandidateResolver) {
+        this.genericCandidateResolver = genericCandidateResolver;
+    }
+
+    // component dependency cycle
     @Inject
     public void setCallCompleter(@NotNull CallCompleter callCompleter) {
         this.callCompleter = callCompleter;
     }
 
-    @Inject
-    public void setTaskPrioritizer(@NotNull TaskPrioritizer taskPrioritizer) {
-        this.taskPrioritizer = taskPrioritizer;
-    }
-
-    @Inject
-    public void setAdditionalCheckerProvider(AdditionalCheckerProvider additionalCheckerProvider) {
-        this.additionalCheckerProvider = additionalCheckerProvider;
-    }
-
     @NotNull
     public OverloadResolutionResults<VariableDescriptor> resolveSimpleProperty(@NotNull BasicCallResolutionContext context) {
         JetExpression calleeExpression = context.call.getCalleeExpression();
@@ -433,28 +449,17 @@ public class CallResolver {
         Call call = context.call;
         tracing.bindCall(context.trace, call);
 
-        OverloadResolutionResultsImpl<F> results = null;
         TemporaryBindingTrace traceToResolveCall = TemporaryBindingTrace.create(context.trace, "trace to resolve call", call);
-        if (!CallResolverUtil.isInvokeCallOnVariable(call)) {
-            ResolutionResultsCache.CachedData data = context.resolutionResultsCache.get(call);
-            if (data != null) {
-                DelegatingBindingTrace deltasTraceForResolve = data.getResolutionTrace();
-                deltasTraceForResolve.addOwnDataTo(traceToResolveCall);
-                //noinspection unchecked
-                results = (OverloadResolutionResultsImpl<F>) data.getResolutionResults();
-            }
-        }
-        if (results == null) {
-            BasicCallResolutionContext newContext = context.replaceBindingTrace(traceToResolveCall);
-            recordScopeAndDataFlowInfo(newContext, newContext.call.getCalleeExpression());
-            results = doResolveCall(newContext, prioritizedTasks, callTransformer, tracing);
-            DelegatingBindingTrace deltasTraceForTypeInference = ((OverloadResolutionResultsImpl) results).getTrace();
-            if (deltasTraceForTypeInference != null) {
-                deltasTraceForTypeInference.addOwnDataTo(traceToResolveCall);
-            }
-            completeTypeInferenceDependentOnFunctionLiterals(newContext, results, tracing);
-            cacheResults(context, results, traceToResolveCall, tracing);
+        BasicCallResolutionContext newContext = context.replaceBindingTrace(traceToResolveCall);
+
+        recordScopeAndDataFlowInfo(newContext, newContext.call.getCalleeExpression());
+        OverloadResolutionResultsImpl<F> results = doResolveCall(newContext, prioritizedTasks, callTransformer, tracing);
+        DelegatingBindingTrace deltasTraceForTypeInference = ((OverloadResolutionResultsImpl) results).getTrace();
+        if (deltasTraceForTypeInference != null) {
+            deltasTraceForTypeInference.addOwnDataTo(traceToResolveCall);
         }
+        completeTypeInferenceDependentOnFunctionLiterals(newContext, results, tracing);
+        cacheResults(context, results, traceToResolveCall, tracing);
         traceToResolveCall.commit();
 
         if (context.contextDependency == ContextDependency.INDEPENDENT) {
@@ -469,7 +474,7 @@ public class CallResolver {
             @NotNull OverloadResolutionResultsImpl<D> results,
             @NotNull TracingStrategy tracing
     ) {
-        if (CallResolverUtil.isInvokeCallOnVariable(context.call)) return;
+        if (CallResolverUtilPackage.isInvokeCallOnVariable(context.call)) return;
         if (!results.isSingleResult()) {
             if (results.getResultCode() == INCOMPLETE_TYPE_INFERENCE) {
                 argumentTypeResolver.checkTypesWithNoCallee(context, RESOLVE_FUNCTION_ARGUMENTS);
@@ -479,7 +484,7 @@ public class CallResolver {
 
         CallCandidateResolutionContext<D> candidateContext = CallCandidateResolutionContext.createForCallBeingAnalyzed(
                 results.getResultingCall(), context, tracing);
-        candidateResolver.completeTypeInferenceDependentOnFunctionLiteralsForCall(candidateContext);
+        genericCandidateResolver.completeTypeInferenceDependentOnFunctionLiteralsForCall(candidateContext);
     }
 
     private static <F extends CallableDescriptor> void cacheResults(
@@ -489,7 +494,7 @@ public class CallResolver {
             @NotNull TracingStrategy tracing
     ) {
         Call call = context.call;
-        if (CallResolverUtil.isInvokeCallOnVariable(call)) return;
+        if (CallResolverUtilPackage.isInvokeCallOnVariable(call)) return;
 
         DelegatingBindingTrace deltasTraceToCacheResolve = new DelegatingBindingTrace(
                 BindingContext.EMPTY, "delta trace for caching resolve of", context.call);
@@ -568,37 +573,22 @@ public class CallResolver {
 
     @NotNull
     private <D extends CallableDescriptor, F extends D> OverloadResolutionResultsImpl<F> performResolution(
-            @NotNull final ResolutionTask<D, F> task,
-            @NotNull final CallTransformer<D, F> callTransformer
+            @NotNull ResolutionTask<D, F> task,
+            @NotNull CallTransformer<D, F> callTransformer
     ) {
+        List<CallCandidateResolutionContext<D>> contexts = collectCallCandidateContext(task, callTransformer, EXIT_ON_FIRST_ERROR);
+        boolean isSuccess = ContainerUtil.exists(contexts, new Condition<CallCandidateResolutionContext<D>>() {
+            @Override
+            public boolean value(CallCandidateResolutionContext<D> context) {
+                return context.candidateCall.getStatus().possibleTransformToSuccess();
+            }
+        });
+        if (!isSuccess) {
+            contexts = collectCallCandidateContext(task, callTransformer, FULLY);
+        }
 
-        for (final ResolutionCandidate<D> resolutionCandidate : task.getCandidates()) {
-            candidatePerfCounter.time(new Function0<Unit>() {
-                @Override
-                public Unit invoke() {
-                    TemporaryBindingTrace candidateTrace = TemporaryBindingTrace.create(
-                            task.trace, "trace to resolve candidate");
-                    Collection<CallCandidateResolutionContext<D>> contexts = callTransformer.createCallContexts(resolutionCandidate, task, candidateTrace);
-                    for (CallCandidateResolutionContext<D> context : contexts) {
-
-                        candidateResolver.performResolutionForCandidateCall(context, task);
-
-                /* important for 'variable as function case': temporary bind reference to descriptor (will be rewritten)
-                to have a binding to variable while 'invoke' call resolve */
-                        task.tracing.bindReference(context.candidateCall.getTrace(), context.candidateCall);
-
-                        Collection<MutableResolvedCall<F>> resolvedCalls = callTransformer.transformCall(context, CallResolver.this, task);
-
-                        for (MutableResolvedCall<F> resolvedCall : resolvedCalls) {
-                            BindingTrace trace = resolvedCall.getTrace();
-                            task.tracing.bindReference(trace, resolvedCall);
-                            task.tracing.bindResolvedCall(trace, resolvedCall);
-                            task.addResolvedCall(resolvedCall);
-                        }
-                    }
-                    return Unit.INSTANCE$;
-                }
-            });
+        for (CallCandidateResolutionContext<D> context : contexts) {
+            addResolvedCall(task, callTransformer, context);
         }
 
         OverloadResolutionResultsImpl<F> results = ResolutionResultsHandler.INSTANCE.computeResultAndReportErrors(
@@ -608,4 +598,48 @@ public class CallResolver {
         }
         return results;
     }
+
+    @NotNull
+    private <D extends CallableDescriptor, F extends D> List<CallCandidateResolutionContext<D>> collectCallCandidateContext(
+            @NotNull final ResolutionTask<D, F> task,
+            @NotNull final CallTransformer<D, F> callTransformer,
+            @NotNull final CandidateResolveMode candidateResolveMode
+    ) {
+        final List<CallCandidateResolutionContext<D>> candidateResolutionContexts = ContainerUtil.newArrayList();
+        for (final ResolutionCandidate<D> resolutionCandidate : task.getCandidates()) {
+            candidatePerfCounter.time(new Function0<Unit>() {
+                @Override
+                public Unit invoke() {
+                    TemporaryBindingTrace candidateTrace = TemporaryBindingTrace.create(
+                            task.trace, "trace to resolve candidate");
+                    Collection<CallCandidateResolutionContext<D>> contexts =
+                            callTransformer.createCallContexts(resolutionCandidate, task, candidateTrace, candidateResolveMode);
+                    for (CallCandidateResolutionContext<D> context : contexts) {
+                        candidateResolver.performResolutionForCandidateCall(context, task);
+                        candidateResolutionContexts.add(context);
+                    }
+                    return Unit.INSTANCE$;
+                }
+            });
+        }
+        return candidateResolutionContexts;
+    }
+
+    private <D extends CallableDescriptor, F extends D> void addResolvedCall(
+            @NotNull ResolutionTask<D, F> task,
+            @NotNull CallTransformer<D, F> callTransformer,
+            @NotNull CallCandidateResolutionContext<D> context) {
+        /* important for 'variable as function case': temporary bind reference to descriptor (will be rewritten)
+        to have a binding to variable while 'invoke' call resolve */
+        task.tracing.bindReference(context.candidateCall.getTrace(), context.candidateCall);
+
+        Collection<MutableResolvedCall<F>> resolvedCalls = callTransformer.transformCall(context, this, task);
+
+        for (MutableResolvedCall<F> resolvedCall : resolvedCalls) {
+            BindingTrace trace = resolvedCall.getTrace();
+            task.tracing.bindReference(trace, resolvedCall);
+            task.tracing.bindResolvedCall(trace, resolvedCall);
+            task.addResolvedCall(resolvedCall);
+        }
+    }
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallResolverUtil.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallResolverUtil.java
deleted file mode 100644
index 904b0c54e8e..00000000000
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallResolverUtil.java
+++ /dev/null
@@ -1,166 +0,0 @@
-/*
- * Copyright 2010-2015 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.kotlin.resolve.calls;
-
-import com.google.common.collect.Lists;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
-import org.jetbrains.kotlin.descriptors.CallableDescriptor;
-import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor;
-import org.jetbrains.kotlin.descriptors.ReceiverParameterDescriptor;
-import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor;
-import org.jetbrains.kotlin.psi.Call;
-import org.jetbrains.kotlin.psi.JetExpression;
-import org.jetbrains.kotlin.psi.JetSimpleNameExpression;
-import org.jetbrains.kotlin.psi.JetSuperExpression;
-import org.jetbrains.kotlin.resolve.calls.inference.ConstraintSystem;
-import org.jetbrains.kotlin.resolve.scopes.receivers.ExpressionReceiver;
-import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue;
-import org.jetbrains.kotlin.types.*;
-
-import java.util.Collections;
-import java.util.List;
-
-import static org.jetbrains.kotlin.resolve.calls.inference.constraintPosition.ConstraintPositionKind.EXPECTED_TYPE_POSITION;
-import static org.jetbrains.kotlin.types.TypeUtils.DONT_CARE;
-
-public class CallResolverUtil {
-    public static enum ResolveArgumentsMode {
-        RESOLVE_FUNCTION_ARGUMENTS,
-        SHAPE_FUNCTION_ARGUMENTS
-    }
-
-    private CallResolverUtil() {}
-
-
-    public static boolean hasUnknownFunctionParameter(@NotNull JetType type) {
-        assert KotlinBuiltIns.isFunctionOrExtensionFunctionType(type);
-        List<TypeProjection> arguments = type.getArguments();
-        // last argument is return type of function type
-        List<TypeProjection> functionParameters = arguments.subList(0, arguments.size() - 1);
-        for (TypeProjection functionParameter : functionParameters) {
-            if (TypeUtils.containsSpecialType(functionParameter.getType(), DONT_CARE)
-                || ErrorUtils.containsUninferredParameter(functionParameter.getType())) {
-                return true;
-            }
-        }
-        return false;
-    }
-
-    public static boolean hasUnknownReturnType(@NotNull JetType type) {
-        assert KotlinBuiltIns.isFunctionOrExtensionFunctionType(type);
-        JetType returnTypeFromFunctionType = KotlinBuiltIns.getReturnTypeFromFunctionType(type);
-        return ErrorUtils.containsErrorType(returnTypeFromFunctionType);
-    }
-
-    public static JetType replaceReturnTypeByUnknown(@NotNull JetType type) {
-        assert KotlinBuiltIns.isFunctionOrExtensionFunctionType(type);
-        List<TypeProjection> arguments = type.getArguments();
-        List<TypeProjection> newArguments = Lists.newArrayList();
-        newArguments.addAll(arguments.subList(0, arguments.size() - 1));
-        newArguments.add(new TypeProjectionImpl(Variance.INVARIANT, DONT_CARE));
-        return new JetTypeImpl(type.getAnnotations(), type.getConstructor(), type.isMarkedNullable(), newArguments, type.getMemberScope());
-    }
-
-    private static boolean hasReturnTypeDependentOnUninferredParams(
-            @NotNull CallableDescriptor candidateDescriptor,
-            @NotNull ConstraintSystem constraintSystem
-    ) {
-        JetType returnType = candidateDescriptor.getReturnType();
-        if (returnType == null) return false;
-
-        for (TypeParameterDescriptor typeVariable : constraintSystem.getTypeVariables()) {
-            JetType inferredValueForTypeVariable = constraintSystem.getTypeBounds(typeVariable).getValue();
-            if (inferredValueForTypeVariable == null) {
-                if (TypeUtils.dependsOnTypeParameters(returnType, Collections.singleton(typeVariable))) {
-                    return true;
-                }
-            }
-        }
-        return false;
-    }
-
-    public static boolean hasInferredReturnType(
-            @NotNull CallableDescriptor candidateDescriptor,
-            @NotNull ConstraintSystem constraintSystem
-    ) {
-        if (hasReturnTypeDependentOnUninferredParams(candidateDescriptor, constraintSystem)) return false;
-
-        // Expected type mismatch was reported before as 'TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH'
-        if (constraintSystem.getStatus().hasOnlyErrorsFromPosition(EXPECTED_TYPE_POSITION.position())) return false;
-        return true;
-    }
-
-    @NotNull
-    public static JetType getErasedReceiverType(
-            @NotNull ReceiverParameterDescriptor receiverParameterDescriptor,
-            @NotNull CallableDescriptor descriptor
-    ) {
-        JetType receiverType = receiverParameterDescriptor.getType();
-        for (TypeParameterDescriptor typeParameter : descriptor.getTypeParameters()) {
-            if (typeParameter.getTypeConstructor().equals(receiverType.getConstructor())) {
-                receiverType = typeParameter.getUpperBoundsAsType();
-            }
-        }
-        List<TypeProjection> fakeTypeArguments = Lists.newArrayList();
-        for (TypeProjection typeProjection : receiverType.getArguments()) {
-            fakeTypeArguments.add(new TypeProjectionImpl(typeProjection.getProjectionKind(), DONT_CARE));
-        }
-        return new JetTypeImpl(
-                receiverType.getAnnotations(), receiverType.getConstructor(), receiverType.isMarkedNullable(),
-                fakeTypeArguments, ErrorUtils.createErrorScope("Error scope for erased receiver type", /*throwExceptions=*/true));
-    }
-
-    public static boolean isOrOverridesSynthesized(@NotNull CallableMemberDescriptor descriptor) {
-        if (descriptor.getKind() == CallableMemberDescriptor.Kind.SYNTHESIZED) {
-            return true;
-        }
-        if (descriptor.getKind() == CallableMemberDescriptor.Kind.FAKE_OVERRIDE) {
-            for (CallableMemberDescriptor overridden : descriptor.getOverriddenDescriptors()) {
-                if (!isOrOverridesSynthesized(overridden)) {
-                    return false;
-                }
-            }
-            return true;
-        }
-        return false;
-    }
-
-    public static boolean isInvokeCallOnVariable(@NotNull Call call) {
-        if (call.getCallType() != Call.CallType.INVOKE) return false;
-        ReceiverValue dispatchReceiver = call.getDispatchReceiver();
-        //calleeExpressionAsDispatchReceiver for invoke is always ExpressionReceiver, see CallForImplicitInvoke
-        JetExpression expression = ((ExpressionReceiver) dispatchReceiver).getExpression();
-        return expression instanceof JetSimpleNameExpression;
-    }
-
-    public static boolean isInvokeCallOnExpressionWithBothReceivers(@NotNull Call call) {
-        if (call.getCallType() != Call.CallType.INVOKE || isInvokeCallOnVariable(call)) return false;
-        return call.getExplicitReceiver().exists() && call.getDispatchReceiver().exists();
-    }
-
-    public static JetSuperExpression getSuperCallExpression(@NotNull Call call) {
-        ReceiverValue explicitReceiver = call.getExplicitReceiver();
-        if (explicitReceiver instanceof ExpressionReceiver) {
-            JetExpression receiverExpression = ((ExpressionReceiver) explicitReceiver).getExpression();
-            if (receiverExpression instanceof JetSuperExpression) {
-                return (JetSuperExpression) receiverExpression;
-            }
-        }
-        return null;
-    }
-}
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallResolverUtil.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallResolverUtil.kt
new file mode 100644
index 00000000000..0e24b91d302
--- /dev/null
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallResolverUtil.kt
@@ -0,0 +1,143 @@
+/*
+ * Copyright 2010-2015 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.kotlin.resolve.calls.callResolverUtil
+
+import com.google.common.collect.Lists
+import com.intellij.util.containers.ContainerUtil
+import org.jetbrains.kotlin.builtins.KotlinBuiltIns
+import org.jetbrains.kotlin.descriptors.CallableDescriptor
+import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor
+import org.jetbrains.kotlin.descriptors.ReceiverParameterDescriptor
+import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor
+import org.jetbrains.kotlin.psi.Call
+import org.jetbrains.kotlin.psi.JetSimpleNameExpression
+import org.jetbrains.kotlin.psi.JetSuperExpression
+import org.jetbrains.kotlin.psi.ValueArgument
+import org.jetbrains.kotlin.resolve.calls.inference.ConstraintSystem
+import org.jetbrains.kotlin.resolve.calls.inference.ConstraintSystemImpl
+import org.jetbrains.kotlin.resolve.calls.inference.constraintPosition.ConstraintPositionKind.EXPECTED_TYPE_POSITION
+import org.jetbrains.kotlin.resolve.scopes.receivers.ExpressionReceiver
+import org.jetbrains.kotlin.types.*
+import org.jetbrains.kotlin.types.TypeUtils.DONT_CARE
+
+public enum class ResolveArgumentsMode {
+    RESOLVE_FUNCTION_ARGUMENTS,
+    SHAPE_FUNCTION_ARGUMENTS
+}
+
+
+public fun hasUnknownFunctionParameter(type: JetType): Boolean {
+    assert(KotlinBuiltIns.isFunctionOrExtensionFunctionType(type))
+    val arguments = type.getArguments()
+    // last argument is return type of function type
+    val functionParameters = arguments.subList(0, arguments.size() - 1)
+    return functionParameters.any {
+        TypeUtils.containsSpecialType(it.getType(), DONT_CARE) || ErrorUtils.containsUninferredParameter(it.getType())
+    }
+}
+
+public fun hasUnknownReturnType(type: JetType): Boolean {
+    assert(KotlinBuiltIns.isFunctionOrExtensionFunctionType(type))
+    val returnTypeFromFunctionType = KotlinBuiltIns.getReturnTypeFromFunctionType(type)
+    return ErrorUtils.containsErrorType(returnTypeFromFunctionType)
+}
+
+public fun replaceReturnTypeByUnknown(type: JetType): JetType {
+    assert(KotlinBuiltIns.isFunctionOrExtensionFunctionType(type))
+    val arguments = type.getArguments()
+    val newArguments = Lists.newArrayList<TypeProjection>()
+    newArguments.addAll(arguments.subList(0, arguments.size() - 1))
+    newArguments.add(TypeProjectionImpl(Variance.INVARIANT, DONT_CARE))
+    return JetTypeImpl(type.getAnnotations(), type.getConstructor(), type.isMarkedNullable(), newArguments, type.getMemberScope())
+}
+
+private fun CallableDescriptor.hasReturnTypeDependentOnUninferredParams(constraintSystem: ConstraintSystem): Boolean {
+    val returnType = getReturnType() ?: return false
+
+    val nestedTypeVariables = with (constraintSystem as ConstraintSystemImpl) {
+        returnType.getNestedTypeVariables()
+    }
+    return nestedTypeVariables.any { constraintSystem.getTypeBounds(it).value == null }
+}
+
+public fun CallableDescriptor.hasInferredReturnType(constraintSystem: ConstraintSystem): Boolean {
+    if (hasReturnTypeDependentOnUninferredParams(constraintSystem)) return false
+
+    // Expected type mismatch was reported before as 'TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH'
+    if (constraintSystem.getStatus().hasOnlyErrorsDerivedFrom(EXPECTED_TYPE_POSITION)) return false
+    return true
+}
+
+public fun getErasedReceiverType(receiverParameterDescriptor: ReceiverParameterDescriptor, descriptor: CallableDescriptor): JetType {
+    var receiverType = receiverParameterDescriptor.getType()
+    for (typeParameter in descriptor.getTypeParameters()) {
+        if (typeParameter.getTypeConstructor() == receiverType.getConstructor()) {
+            receiverType = typeParameter.getUpperBoundsAsType()
+        }
+    }
+    val fakeTypeArguments = ContainerUtil.newSmartList<TypeProjection>()
+    for (typeProjection in receiverType.getArguments()) {
+        fakeTypeArguments.add(TypeProjectionImpl(typeProjection.getProjectionKind(), DONT_CARE))
+    }
+    return JetTypeImpl(receiverType.getAnnotations(), receiverType.getConstructor(), receiverType.isMarkedNullable(), fakeTypeArguments,
+                       ErrorUtils.createErrorScope("Error scope for erased receiver type", /*throwExceptions=*/true))
+}
+
+public fun isOrOverridesSynthesized(descriptor: CallableMemberDescriptor): Boolean {
+    if (descriptor.getKind() == CallableMemberDescriptor.Kind.SYNTHESIZED) {
+        return true
+    }
+    if (descriptor.getKind() == CallableMemberDescriptor.Kind.FAKE_OVERRIDE) {
+        return descriptor.getOverriddenDescriptors().all {
+            isOrOverridesSynthesized(it)
+        }
+    }
+    return false
+}
+
+public fun isInvokeCallOnVariable(call: Call): Boolean {
+    if (call.getCallType() !== Call.CallType.INVOKE) return false
+    val dispatchReceiver = call.getDispatchReceiver()
+    //calleeExpressionAsDispatchReceiver for invoke is always ExpressionReceiver, see CallForImplicitInvoke
+    val expression = (dispatchReceiver as ExpressionReceiver).getExpression()
+    return expression is JetSimpleNameExpression
+}
+
+public fun isInvokeCallOnExpressionWithBothReceivers(call: Call): Boolean {
+    if (call.getCallType() !== Call.CallType.INVOKE || isInvokeCallOnVariable(call)) return false
+    return call.getExplicitReceiver().exists() && call.getDispatchReceiver().exists()
+}
+
+public fun getSuperCallExpression(call: Call): JetSuperExpression? {
+    return (call.getExplicitReceiver() as? ExpressionReceiver)?.getExpression() as? JetSuperExpression
+}
+
+public fun getEffectiveExpectedType(parameterDescriptor: ValueParameterDescriptor, argument: ValueArgument): JetType {
+    if (argument.getSpreadElement() != null) {
+        if (parameterDescriptor.getVarargElementType() == null) {
+            // Spread argument passed to a non-vararg parameter, an error is already reported by ValueArgumentsToParametersMapper
+            return DONT_CARE
+        }
+        return parameterDescriptor.getType()
+    }
+    val varargElementType = parameterDescriptor.getVarargElementType()
+    if (varargElementType != null) {
+        return varargElementType
+    }
+
+    return parameterDescriptor.getType()
+}
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallTransformer.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallTransformer.java
index c30606d5a0c..f87fb75d18d 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallTransformer.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallTransformer.java
@@ -31,6 +31,7 @@ import org.jetbrains.kotlin.resolve.DelegatingBindingTrace;
 import org.jetbrains.kotlin.resolve.TemporaryBindingTrace;
 import org.jetbrains.kotlin.resolve.calls.context.BasicCallResolutionContext;
 import org.jetbrains.kotlin.resolve.calls.context.CallCandidateResolutionContext;
+import org.jetbrains.kotlin.resolve.calls.context.CandidateResolveMode;
 import org.jetbrains.kotlin.resolve.calls.context.ContextDependency;
 import org.jetbrains.kotlin.resolve.calls.model.MutableResolvedCall;
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedCallImpl;
@@ -73,10 +74,12 @@ public class CallTransformer<D extends CallableDescriptor, F extends D> {
     @NotNull
     public Collection<CallCandidateResolutionContext<D>> createCallContexts(@NotNull ResolutionCandidate<D> candidate,
             @NotNull ResolutionTask<D, F> task,
-            @NotNull TemporaryBindingTrace candidateTrace
+            @NotNull TemporaryBindingTrace candidateTrace,
+            @NotNull CandidateResolveMode candidateResolveMode
     ) {
         ResolvedCallImpl<D> candidateCall = ResolvedCallImpl.create(candidate, candidateTrace, task.tracing, task.dataFlowInfoForArguments);
-        return Collections.singleton(CallCandidateResolutionContext.create(candidateCall, task, candidateTrace, task.tracing));
+        return Collections.singleton(CallCandidateResolutionContext.create(candidateCall, task, candidateTrace, task.tracing, task.call,
+                                                                           ReceiverValue.NO_RECEIVER, candidateResolveMode));
     }
 
     /**
@@ -100,10 +103,12 @@ public class CallTransformer<D extends CallableDescriptor, F extends D> {
         @NotNull
         @Override
         public Collection<CallCandidateResolutionContext<CallableDescriptor>> createCallContexts(@NotNull ResolutionCandidate<CallableDescriptor> candidate,
-                @NotNull ResolutionTask<CallableDescriptor, FunctionDescriptor> task, @NotNull TemporaryBindingTrace candidateTrace) {
+                @NotNull ResolutionTask<CallableDescriptor, FunctionDescriptor> task, @NotNull TemporaryBindingTrace candidateTrace,
+                @NotNull CandidateResolveMode candidateResolveMode
+        ) {
 
             if (candidate.getDescriptor() instanceof FunctionDescriptor) {
-                return super.createCallContexts(candidate, task, candidateTrace);
+                return super.createCallContexts(candidate, task, candidateTrace, candidateResolveMode);
             }
 
             assert candidate.getDescriptor() instanceof VariableDescriptor;
@@ -120,11 +125,11 @@ public class CallTransformer<D extends CallableDescriptor, F extends D> {
             if (!hasReceiver) {
                 CallCandidateResolutionContext<CallableDescriptor> context = CallCandidateResolutionContext.create(
                         ResolvedCallImpl.create(variableCandidate, candidateTrace, task.tracing, task.dataFlowInfoForArguments),
-                        task, candidateTrace, task.tracing, variableCall);
+                        task, candidateTrace, task.tracing, variableCall, ReceiverValue.NO_RECEIVER, candidateResolveMode);
                 return Collections.singleton(context);
             }
             CallCandidateResolutionContext<CallableDescriptor> contextWithReceiver = createContextWithChainedTrace(
-                    variableCandidate, variableCall, candidateTrace, task, ReceiverValue.NO_RECEIVER);
+                    variableCandidate, variableCall, candidateTrace, task, ReceiverValue.NO_RECEIVER, candidateResolveMode);
 
             Call variableCallWithoutReceiver = stripReceiver(variableCall);
             ResolutionCandidate<CallableDescriptor> candidateWithoutReceiver = ResolutionCandidate.create(
@@ -135,18 +140,21 @@ public class CallTransformer<D extends CallableDescriptor, F extends D> {
                     ExplicitReceiverKind.NO_EXPLICIT_RECEIVER, null);
 
             CallCandidateResolutionContext<CallableDescriptor> contextWithoutReceiver = createContextWithChainedTrace(
-                    candidateWithoutReceiver, variableCallWithoutReceiver, candidateTrace, task, variableCall.getExplicitReceiver());
+                    candidateWithoutReceiver, variableCallWithoutReceiver, candidateTrace, task, variableCall.getExplicitReceiver(),
+                    candidateResolveMode);
 
             return Lists.newArrayList(contextWithReceiver, contextWithoutReceiver);
         }
 
         private CallCandidateResolutionContext<CallableDescriptor> createContextWithChainedTrace(
                 @NotNull ResolutionCandidate<CallableDescriptor> candidate, @NotNull Call call, @NotNull TemporaryBindingTrace temporaryTrace,
-                @NotNull ResolutionTask<CallableDescriptor, FunctionDescriptor> task, @NotNull ReceiverValue receiverValue
+                @NotNull ResolutionTask<CallableDescriptor, FunctionDescriptor> task, @NotNull ReceiverValue receiverValue,
+                @NotNull CandidateResolveMode candidateResolveMode
         ) {
             ChainedTemporaryBindingTrace chainedTrace = ChainedTemporaryBindingTrace.create(temporaryTrace, "chained trace to resolve candidate", candidate);
             ResolvedCallImpl<CallableDescriptor> resolvedCall = ResolvedCallImpl.create(candidate, chainedTrace, task.tracing, task.dataFlowInfoForArguments);
-            return CallCandidateResolutionContext.create(resolvedCall, task, chainedTrace, task.tracing, call, receiverValue);
+            return CallCandidateResolutionContext.create(resolvedCall, task, chainedTrace, task.tracing, call, receiverValue,
+                                                         candidateResolveMode);
         }
 
         private Call stripCallArguments(@NotNull Call call) {
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CandidateResolver.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CandidateResolver.java
deleted file mode 100644
index 8dd1a19901b..00000000000
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CandidateResolver.java
+++ /dev/null
@@ -1,737 +0,0 @@
-/*
- * Copyright 2010-2015 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.kotlin.resolve.calls;
-
-import com.google.common.collect.Lists;
-import com.google.common.collect.Maps;
-import com.google.common.collect.Sets;
-import kotlin.jvm.functions.Function1;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
-import org.jetbrains.kotlin.progress.ProgressIndicatorAndCompilationCanceledStatus;
-import org.jetbrains.kotlin.descriptors.*;
-import org.jetbrains.kotlin.psi.*;
-import org.jetbrains.kotlin.resolve.*;
-import org.jetbrains.kotlin.resolve.calls.callUtil.CallUtilPackage;
-import org.jetbrains.kotlin.resolve.calls.context.*;
-import org.jetbrains.kotlin.resolve.calls.inference.ConstraintSystem;
-import org.jetbrains.kotlin.resolve.calls.inference.ConstraintSystemImpl;
-import org.jetbrains.kotlin.resolve.calls.model.*;
-import org.jetbrains.kotlin.resolve.calls.results.ResolutionStatus;
-import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo;
-import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowValue;
-import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowValueFactory;
-import org.jetbrains.kotlin.resolve.calls.smartcasts.SmartCastUtils;
-import org.jetbrains.kotlin.resolve.calls.tasks.ResolutionTask;
-import org.jetbrains.kotlin.resolve.calls.tasks.TasksPackage;
-import org.jetbrains.kotlin.resolve.calls.util.FakeCallableDescriptorForObject;
-import org.jetbrains.kotlin.resolve.lazy.ForceResolveUtil;
-import org.jetbrains.kotlin.resolve.scopes.receivers.ExpressionReceiver;
-import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue;
-import org.jetbrains.kotlin.types.*;
-import org.jetbrains.kotlin.types.checker.JetTypeChecker;
-import org.jetbrains.kotlin.types.expressions.ExpressionTypingUtils;
-import org.jetbrains.kotlin.types.expressions.JetTypeInfo;
-
-import javax.inject.Inject;
-import java.util.*;
-
-import static org.jetbrains.kotlin.diagnostics.Errors.PROJECTION_ON_NON_CLASS_TYPE_ARGUMENT;
-import static org.jetbrains.kotlin.diagnostics.Errors.SUPER_CANT_BE_EXTENSION_RECEIVER;
-import static org.jetbrains.kotlin.resolve.calls.ArgumentTypeResolver.getLastElementDeparenthesized;
-import static org.jetbrains.kotlin.resolve.calls.CallResolverUtil.ResolveArgumentsMode.RESOLVE_FUNCTION_ARGUMENTS;
-import static org.jetbrains.kotlin.resolve.calls.CallResolverUtil.ResolveArgumentsMode.SHAPE_FUNCTION_ARGUMENTS;
-import static org.jetbrains.kotlin.resolve.calls.CallTransformer.CallForImplicitInvoke;
-import static org.jetbrains.kotlin.resolve.calls.context.ContextDependency.INDEPENDENT;
-import static org.jetbrains.kotlin.resolve.calls.inference.constraintPosition.ConstraintPositionKind.RECEIVER_POSITION;
-import static org.jetbrains.kotlin.resolve.calls.inference.constraintPosition.ConstraintPositionKind.VALUE_PARAMETER_POSITION;
-import static org.jetbrains.kotlin.resolve.calls.results.ResolutionStatus.*;
-import static org.jetbrains.kotlin.types.TypeUtils.*;
-
-public class CandidateResolver {
-    @NotNull
-    private ArgumentTypeResolver argumentTypeResolver;
-
-    @Inject
-    public void setArgumentTypeResolver(@NotNull ArgumentTypeResolver argumentTypeResolver) {
-        this.argumentTypeResolver = argumentTypeResolver;
-    }
-
-    public <D extends CallableDescriptor, F extends D> void performResolutionForCandidateCall(
-            @NotNull CallCandidateResolutionContext<D> context,
-            @NotNull ResolutionTask<D, F> task) {
-
-        ProgressIndicatorAndCompilationCanceledStatus.checkCanceled();
-
-        MutableResolvedCall<D> candidateCall = context.candidateCall;
-        D candidate = candidateCall.getCandidateDescriptor();
-
-        candidateCall.addStatus(checkReceiverTypeError(context));
-
-        if (ErrorUtils.isError(candidate)) {
-            candidateCall.addStatus(SUCCESS);
-            return;
-        }
-
-        if (!checkOuterClassMemberIsAccessible(context)) {
-            candidateCall.addStatus(OTHER_ERROR);
-            return;
-        }
-
-
-        ReceiverValue receiverValue = ExpressionTypingUtils.normalizeReceiverValueForVisibility(candidateCall.getDispatchReceiver(), context.trace.getBindingContext());
-        DeclarationDescriptorWithVisibility invisibleMember =
-                Visibilities.findInvisibleMember(receiverValue, candidate, context.scope.getContainingDeclaration());
-        if (invisibleMember != null) {
-            candidateCall.addStatus(OTHER_ERROR);
-            context.tracing.invisibleMember(context.trace, invisibleMember);
-        }
-
-        if (task.checkArguments == CheckValueArgumentsMode.ENABLED) {
-            ValueArgumentsToParametersMapper.Status argumentMappingStatus = ValueArgumentsToParametersMapper.mapValueArgumentsToParameters(
-                    context.call, context.tracing, candidateCall, Sets.<ValueArgument>newLinkedHashSet()
-            );
-            if (!argumentMappingStatus.isSuccess()) {
-                candidateCall.addStatus(OTHER_ERROR);
-            }
-        }
-
-        checkExtensionReceiver(context);
-
-        if (!checkDispatchReceiver(context)) {
-            candidateCall.addStatus(OTHER_ERROR);
-        }
-
-        List<JetTypeProjection> jetTypeArguments = context.call.getTypeArguments();
-        if (!jetTypeArguments.isEmpty()) {
-            // Explicit type arguments passed
-
-            List<JetType> typeArguments = new ArrayList<JetType>();
-            for (JetTypeProjection projection : jetTypeArguments) {
-                if (projection.getProjectionKind() != JetProjectionKind.NONE) {
-                    context.trace.report(PROJECTION_ON_NON_CLASS_TYPE_ARGUMENT.on(projection));
-                    ModifiersChecker.checkIncompatibleVarianceModifiers(projection.getModifierList(), context.trace);
-                }
-                JetType type = argumentTypeResolver.resolveTypeRefWithDefault(
-                        projection.getTypeReference(), context.scope, context.trace,
-                        ErrorUtils.createErrorType("Star projection in a call")
-                );
-                ForceResolveUtil.forceResolveAllContents(type);
-                typeArguments.add(type);
-            }
-            int expectedTypeArgumentCount = candidate.getTypeParameters().size();
-            for (int index = jetTypeArguments.size(); index < expectedTypeArgumentCount; index++) {
-                typeArguments.add(ErrorUtils.createErrorType(
-                        "Explicit type argument expected for " + candidate.getTypeParameters().get(index).getName()));
-            }
-            Map<TypeConstructor, TypeProjection> substitutionContext =
-                    FunctionDescriptorUtil.createSubstitutionContext((FunctionDescriptor) candidate, typeArguments);
-            TypeSubstitutor substitutor = TypeSubstitutor.create(substitutionContext);
-
-            if (expectedTypeArgumentCount != jetTypeArguments.size()) {
-                candidateCall.addStatus(OTHER_ERROR);
-                context.tracing.wrongNumberOfTypeArguments(context.trace, expectedTypeArgumentCount);
-            }
-            else {
-                checkGenericBoundsInAFunctionCall(jetTypeArguments, typeArguments, candidate, substitutor, context.trace);
-            }
-
-            candidateCall.setResultingSubstitutor(substitutor);
-        }
-        else if (candidateCall.getKnownTypeParametersSubstitutor() != null) {
-            candidateCall.setResultingSubstitutor(candidateCall.getKnownTypeParametersSubstitutor());
-        }
-
-        if (jetTypeArguments.isEmpty() &&
-            !candidate.getTypeParameters().isEmpty() &&
-            candidateCall.getKnownTypeParametersSubstitutor() == null) {
-            candidateCall.addStatus(inferTypeArguments(context));
-        }
-        else {
-            candidateCall.addStatus(checkAllValueArguments(context, SHAPE_FUNCTION_ARGUMENTS).status);
-        }
-
-        checkAbstractAndSuper(context);
-
-        checkNonExtensionCalledWithReceiver(context);
-    }
-
-    private static <D extends CallableDescriptor> void checkExtensionReceiver(@NotNull CallCandidateResolutionContext<D> context) {
-        MutableResolvedCall<D> candidateCall = context.candidateCall;
-        ReceiverParameterDescriptor receiverParameter = candidateCall.getCandidateDescriptor().getExtensionReceiverParameter();
-        ReceiverValue receiverArgument = candidateCall.getExtensionReceiver();
-        if (receiverParameter != null &&!receiverArgument.exists()) {
-            context.tracing.missingReceiver(candidateCall.getTrace(), receiverParameter);
-            candidateCall.addStatus(OTHER_ERROR);
-        }
-        if (receiverParameter == null && receiverArgument.exists()) {
-            context.tracing.noReceiverAllowed(candidateCall.getTrace());
-            if (context.call.getCalleeExpression() instanceof JetSimpleNameExpression) {
-                candidateCall.addStatus(RECEIVER_PRESENCE_ERROR);
-            }
-            else {
-                candidateCall.addStatus(OTHER_ERROR);
-            }
-        }
-    }
-
-    private static boolean checkDispatchReceiver(@NotNull CallCandidateResolutionContext<?> context) {
-        MutableResolvedCall<? extends CallableDescriptor> candidateCall = context.candidateCall;
-        CallableDescriptor candidateDescriptor = candidateCall.getCandidateDescriptor();
-        ReceiverValue dispatchReceiver = candidateCall.getDispatchReceiver();
-        if (dispatchReceiver.exists()) {
-            ClassDescriptor nestedClass = null;
-            if (candidateDescriptor instanceof ConstructorDescriptor
-                && DescriptorUtils.isStaticNestedClass(candidateDescriptor.getContainingDeclaration())) {
-                nestedClass = (ClassDescriptor) candidateDescriptor.getContainingDeclaration();
-            }
-            else if (candidateDescriptor instanceof FakeCallableDescriptorForObject) {
-                nestedClass = ((FakeCallableDescriptorForObject) candidateDescriptor).getReferencedDescriptor();
-            }
-            if (nestedClass != null) {
-                context.tracing.nestedClassAccessViaInstanceReference(context.trace, nestedClass, candidateCall.getExplicitReceiverKind());
-                return false;
-            }
-        }
-
-        assert (dispatchReceiver.exists() == (candidateCall.getResultingDescriptor().getDispatchReceiverParameter() != null))
-                : "Shouldn't happen because of TaskPrioritizer: " + candidateDescriptor;
-
-        return true;
-    }
-
-    private static boolean checkOuterClassMemberIsAccessible(@NotNull CallCandidateResolutionContext<?> context) {
-        // In "this@Outer.foo()" the error will be reported on "this@Outer" instead
-        if (context.call.getExplicitReceiver().exists() || context.call.getDispatchReceiver().exists()) return true;
-
-        ClassDescriptor candidateThis = getDeclaringClass(context.candidateCall.getCandidateDescriptor());
-        if (candidateThis == null || candidateThis.getKind().isSingleton()) return true;
-
-        return DescriptorResolver.checkHasOuterClassInstance(context.scope, context.trace, context.call.getCallElement(), candidateThis);
-    }
-
-    private static <D extends CallableDescriptor> void checkAbstractAndSuper(@NotNull CallCandidateResolutionContext<D> context) {
-        MutableResolvedCall<D> candidateCall = context.candidateCall;
-        CallableDescriptor descriptor = candidateCall.getCandidateDescriptor();
-        JetExpression expression = context.candidateCall.getCall().getCalleeExpression();
-
-        if (expression instanceof JetSimpleNameExpression) {
-            // 'B' in 'class A: B()' is JetConstructorCalleeExpression
-            if (descriptor instanceof ConstructorDescriptor) {
-                Modality modality = ((ConstructorDescriptor) descriptor).getContainingDeclaration().getModality();
-                if (modality == Modality.ABSTRACT) {
-                    context.tracing.instantiationOfAbstractClass(context.trace);
-                }
-            }
-        }
-
-        JetSuperExpression superDispatchReceiver = getReceiverSuper(candidateCall.getDispatchReceiver());
-        if (superDispatchReceiver != null) {
-            if (descriptor instanceof MemberDescriptor && ((MemberDescriptor) descriptor).getModality() == Modality.ABSTRACT) {
-                context.tracing.abstractSuperCall(context.trace);
-                candidateCall.addStatus(OTHER_ERROR);
-            }
-        }
-
-        // 'super' cannot be passed as an argument, for receiver arguments expression typer does not track this
-        // See TaskPrioritizer for more
-        JetSuperExpression superExtensionReceiver = getReceiverSuper(candidateCall.getExtensionReceiver());
-        if (superExtensionReceiver != null) {
-            context.trace.report(SUPER_CANT_BE_EXTENSION_RECEIVER.on(superExtensionReceiver, superExtensionReceiver.getText()));
-            candidateCall.addStatus(OTHER_ERROR);
-        }
-    }
-
-    private static void checkNonExtensionCalledWithReceiver(@NotNull CallCandidateResolutionContext<?> context) {
-        MutableResolvedCall<?> candidateCall = context.candidateCall;
-
-        if (TasksPackage.isSynthesizedInvoke(candidateCall.getCandidateDescriptor()) &&
-            !KotlinBuiltIns.isExtensionFunctionType(candidateCall.getDispatchReceiver().getType())) {
-            context.tracing.freeFunctionCalledAsExtension(context.trace);
-            candidateCall.addStatus(OTHER_ERROR);
-        }
-    }
-
-    @Nullable
-    private static JetSuperExpression getReceiverSuper(@NotNull ReceiverValue receiver) {
-        if (receiver instanceof ExpressionReceiver) {
-            ExpressionReceiver expressionReceiver = (ExpressionReceiver) receiver;
-            JetExpression expression = expressionReceiver.getExpression();
-            if (expression instanceof JetSuperExpression) {
-                return (JetSuperExpression) expression;
-            }
-        }
-        return null;
-    }
-
-    @Nullable
-    private static ClassDescriptor getDeclaringClass(@NotNull CallableDescriptor candidate) {
-        ReceiverParameterDescriptor expectedThis = candidate.getDispatchReceiverParameter();
-        if (expectedThis == null) return null;
-        DeclarationDescriptor descriptor = expectedThis.getContainingDeclaration();
-        return descriptor instanceof ClassDescriptor ? (ClassDescriptor) descriptor : null;
-    }
-
-    public <D extends CallableDescriptor> void completeTypeInferenceDependentOnFunctionLiteralsForCall(
-            CallCandidateResolutionContext<D> context
-    ) {
-        MutableResolvedCall<D> resolvedCall = context.candidateCall;
-        ConstraintSystem constraintSystem = resolvedCall.getConstraintSystem();
-        if (constraintSystem == null) return;
-
-        // constraints for function literals
-        // Value parameters
-        for (Map.Entry<ValueParameterDescriptor, ResolvedValueArgument> entry : resolvedCall.getValueArguments().entrySet()) {
-            ResolvedValueArgument resolvedValueArgument = entry.getValue();
-            ValueParameterDescriptor valueParameterDescriptor = entry.getKey();
-
-            for (ValueArgument valueArgument : resolvedValueArgument.getArguments()) {
-                addConstraintForFunctionLiteral(valueArgument, valueParameterDescriptor, constraintSystem, context);
-            }
-        }
-        resolvedCall.setResultingSubstitutor(constraintSystem.getResultingSubstitutor());
-    }
-
-    private <D extends CallableDescriptor> void addConstraintForFunctionLiteral(
-            @NotNull ValueArgument valueArgument,
-            @NotNull ValueParameterDescriptor valueParameterDescriptor,
-            @NotNull ConstraintSystem constraintSystem,
-            @NotNull CallCandidateResolutionContext<D> context
-    ) {
-        JetExpression argumentExpression = valueArgument.getArgumentExpression();
-        if (argumentExpression == null) return;
-        if (!ArgumentTypeResolver.isFunctionLiteralArgument(argumentExpression, context)) return;
-
-        JetFunction functionLiteral = ArgumentTypeResolver.getFunctionLiteralArgument(argumentExpression, context);
-
-        JetType effectiveExpectedType = getEffectiveExpectedType(valueParameterDescriptor, valueArgument);
-        JetType expectedType = constraintSystem.getCurrentSubstitutor().substitute(effectiveExpectedType, Variance.INVARIANT);
-        if (expectedType == null || TypeUtils.isDontCarePlaceholder(expectedType)) {
-            expectedType = argumentTypeResolver.getShapeTypeOfFunctionLiteral(functionLiteral, context.scope, context.trace, false);
-        }
-        if (expectedType == null || !KotlinBuiltIns.isFunctionOrExtensionFunctionType(expectedType)
-                || CallResolverUtil.hasUnknownFunctionParameter(expectedType)) {
-            return;
-        }
-        MutableDataFlowInfoForArguments dataFlowInfoForArguments = context.candidateCall.getDataFlowInfoForArguments();
-        DataFlowInfo dataFlowInfoForArgument = dataFlowInfoForArguments.getInfo(valueArgument);
-
-        //todo analyze function literal body once in 'dependent' mode, then complete it with respect to expected type
-        boolean hasExpectedReturnType = !CallResolverUtil.hasUnknownReturnType(expectedType);
-        if (hasExpectedReturnType) {
-            TemporaryTraceAndCache temporaryToResolveFunctionLiteral = TemporaryTraceAndCache.create(
-                    context, "trace to resolve function literal with expected return type", argumentExpression);
-
-            JetExpression statementExpression = JetPsiUtil.getExpressionOrLastStatementInBlock(functionLiteral.getBodyExpression());
-            if (statementExpression == null) return;
-            boolean[] mismatch = new boolean[1];
-            ObservableBindingTrace errorInterceptingTrace = ExpressionTypingUtils.makeTraceInterceptingTypeMismatch(
-                    temporaryToResolveFunctionLiteral.trace, statementExpression, mismatch);
-            CallCandidateResolutionContext<D> newContext = context
-                    .replaceBindingTrace(errorInterceptingTrace).replaceExpectedType(expectedType)
-                    .replaceDataFlowInfo(dataFlowInfoForArgument).replaceResolutionResultsCache(temporaryToResolveFunctionLiteral.cache)
-                    .replaceContextDependency(INDEPENDENT);
-            JetType type = argumentTypeResolver.getFunctionLiteralTypeInfo(
-                    argumentExpression, functionLiteral, newContext, RESOLVE_FUNCTION_ARGUMENTS).getType();
-            if (!mismatch[0]) {
-                constraintSystem.addSubtypeConstraint(
-                        type, effectiveExpectedType, VALUE_PARAMETER_POSITION.position(valueParameterDescriptor.getIndex()));
-                temporaryToResolveFunctionLiteral.commit();
-                return;
-            }
-        }
-        JetType expectedTypeWithoutReturnType = hasExpectedReturnType ? CallResolverUtil.replaceReturnTypeByUnknown(expectedType) : expectedType;
-        CallCandidateResolutionContext<D> newContext = context
-                .replaceExpectedType(expectedTypeWithoutReturnType).replaceDataFlowInfo(dataFlowInfoForArgument)
-                .replaceContextDependency(INDEPENDENT);
-        JetType type = argumentTypeResolver.getFunctionLiteralTypeInfo(argumentExpression, functionLiteral, newContext,
-                                                                       RESOLVE_FUNCTION_ARGUMENTS).getType();
-        constraintSystem.addSubtypeConstraint(
-                type, effectiveExpectedType, VALUE_PARAMETER_POSITION.position(valueParameterDescriptor.getIndex()));
-    }
-
-    private <D extends CallableDescriptor> ResolutionStatus inferTypeArguments(CallCandidateResolutionContext<D> context) {
-        MutableResolvedCall<D> candidateCall = context.candidateCall;
-        final D candidate = candidateCall.getCandidateDescriptor();
-
-        ConstraintSystemImpl constraintSystem = new ConstraintSystemImpl();
-
-        // If the call is recursive, e.g.
-        //   fun foo<T>(t : T) : T = foo(t)
-        // we can't use same descriptor objects for T's as actual type values and same T's as unknowns,
-        // because constraints become trivial (T :< T), and inference fails
-        //
-        // Thus, we replace the parameters of our descriptor with fresh objects (perform alpha-conversion)
-        CallableDescriptor candidateWithFreshVariables = FunctionDescriptorUtil.alphaConvertTypeParameters(candidate);
-
-        Map<TypeParameterDescriptor, Variance> typeVariables = Maps.newLinkedHashMap();
-        for (TypeParameterDescriptor typeParameterDescriptor : candidateWithFreshVariables.getTypeParameters()) {
-            typeVariables.put(typeParameterDescriptor, Variance.INVARIANT); // TODO: variance of the occurrences
-        }
-        constraintSystem.registerTypeVariables(typeVariables);
-
-        TypeSubstitutor substituteDontCare =
-                makeConstantSubstitutor(candidateWithFreshVariables.getTypeParameters(), DONT_CARE);
-
-        // Value parameters
-        for (Map.Entry<ValueParameterDescriptor, ResolvedValueArgument> entry : candidateCall.getValueArguments().entrySet()) {
-            ResolvedValueArgument resolvedValueArgument = entry.getValue();
-            ValueParameterDescriptor valueParameterDescriptor = candidateWithFreshVariables.getValueParameters().get(entry.getKey().getIndex());
-
-
-            for (ValueArgument valueArgument : resolvedValueArgument.getArguments()) {
-                // TODO : more attempts, with different expected types
-
-                // Here we type check expecting an error type (DONT_CARE, substitution with substituteDontCare)
-                // and throw the results away
-                // We'll type check the arguments later, with the inferred types expected
-                addConstraintForValueArgument(valueArgument, valueParameterDescriptor, substituteDontCare, constraintSystem,
-                                              context, SHAPE_FUNCTION_ARGUMENTS);
-            }
-        }
-
-        // Receiver
-        // Error is already reported if something is missing
-        ReceiverValue receiverArgument = candidateCall.getExtensionReceiver();
-        ReceiverParameterDescriptor receiverParameter = candidateWithFreshVariables.getExtensionReceiverParameter();
-        if (receiverArgument.exists() && receiverParameter != null) {
-            JetType receiverType =
-                    context.candidateCall.isSafeCall()
-                    ? TypeUtils.makeNotNullable(receiverArgument.getType())
-                    : receiverArgument.getType();
-            if (receiverArgument instanceof ExpressionReceiver) {
-                receiverType = updateResultTypeForSmartCasts(
-                        receiverType, ((ExpressionReceiver) receiverArgument).getExpression(), context);
-            }
-            constraintSystem.addSubtypeConstraint(receiverType, receiverParameter.getType(), RECEIVER_POSITION.position());
-        }
-
-        // Restore type variables before alpha-conversion
-        ConstraintSystem constraintSystemWithRightTypeParameters = constraintSystem.substituteTypeVariables(
-                new Function1<TypeParameterDescriptor, TypeParameterDescriptor>() {
-                    @Override
-                    public TypeParameterDescriptor invoke(@NotNull TypeParameterDescriptor typeParameterDescriptor) {
-                        return candidate.getTypeParameters().get(typeParameterDescriptor.getIndex());
-                    }
-                }
-        );
-        candidateCall.setConstraintSystem(constraintSystemWithRightTypeParameters);
-
-
-        // Solution
-        boolean hasContradiction = constraintSystem.getStatus().hasContradiction();
-        if (!hasContradiction) {
-            return INCOMPLETE_TYPE_INFERENCE;
-        }
-        return OTHER_ERROR;
-    }
-
-    private void addConstraintForValueArgument(
-            @NotNull ValueArgument valueArgument,
-            @NotNull ValueParameterDescriptor valueParameterDescriptor,
-            @NotNull TypeSubstitutor substitutor,
-            @NotNull ConstraintSystem constraintSystem,
-            @NotNull CallCandidateResolutionContext<?> context,
-            @NotNull CallResolverUtil.ResolveArgumentsMode resolveFunctionArgumentBodies) {
-
-        JetType effectiveExpectedType = getEffectiveExpectedType(valueParameterDescriptor, valueArgument);
-        JetExpression argumentExpression = valueArgument.getArgumentExpression();
-
-        JetType expectedType = substitutor.substitute(effectiveExpectedType, Variance.INVARIANT);
-        DataFlowInfo dataFlowInfoForArgument = context.candidateCall.getDataFlowInfoForArguments().getInfo(valueArgument);
-        CallResolutionContext<?> newContext = context.replaceExpectedType(expectedType).replaceDataFlowInfo(dataFlowInfoForArgument);
-
-        JetTypeInfo typeInfoForCall = argumentTypeResolver.getArgumentTypeInfo(
-                argumentExpression, newContext, resolveFunctionArgumentBodies);
-        context.candidateCall.getDataFlowInfoForArguments().updateInfo(valueArgument, typeInfoForCall.getDataFlowInfo());
-
-        JetType type = updateResultTypeForSmartCasts(
-                typeInfoForCall.getType(), argumentExpression, context.replaceDataFlowInfo(dataFlowInfoForArgument));
-        constraintSystem.addSubtypeConstraint(
-                type, effectiveExpectedType, VALUE_PARAMETER_POSITION.position(valueParameterDescriptor.getIndex()));
-    }
-
-    @Nullable
-    private static JetType updateResultTypeForSmartCasts(
-            @Nullable JetType type,
-            @Nullable JetExpression argumentExpression,
-            @NotNull ResolutionContext context
-    ) {
-        JetExpression deparenthesizedArgument = getLastElementDeparenthesized(argumentExpression, context);
-        if (deparenthesizedArgument == null || type == null) return type;
-
-        DataFlowValue dataFlowValue = DataFlowValueFactory.createDataFlowValue(deparenthesizedArgument, type, context);
-        if (!dataFlowValue.isPredictable()) return type;
-
-        Set<JetType> possibleTypes = context.dataFlowInfo.getPossibleTypes(dataFlowValue);
-        if (possibleTypes.isEmpty()) return type;
-
-        return TypeUtils.intersect(JetTypeChecker.DEFAULT, possibleTypes);
-    }
-
-    @NotNull
-    private <D extends CallableDescriptor> ValueArgumentsCheckingResult checkAllValueArguments(
-            @NotNull CallCandidateResolutionContext<D> context,
-            @NotNull CallResolverUtil.ResolveArgumentsMode resolveFunctionArgumentBodies) {
-        return checkAllValueArguments(context, context.candidateCall.getTrace(), resolveFunctionArgumentBodies);
-    }
-
-    @NotNull
-    public <D extends CallableDescriptor> ValueArgumentsCheckingResult checkAllValueArguments(
-            @NotNull CallCandidateResolutionContext<D> context,
-            @NotNull BindingTrace trace,
-            @NotNull CallResolverUtil.ResolveArgumentsMode resolveFunctionArgumentBodies
-    ) {
-        ValueArgumentsCheckingResult checkingResult = checkValueArgumentTypes(
-                context, context.candidateCall, trace, resolveFunctionArgumentBodies);
-        ResolutionStatus resultStatus = checkingResult.status;
-        resultStatus = resultStatus.combine(checkReceivers(context, trace));
-
-        return new ValueArgumentsCheckingResult(resultStatus, checkingResult.argumentTypes);
-    }
-
-    private static <D extends CallableDescriptor> ResolutionStatus checkReceivers(
-            @NotNull CallCandidateResolutionContext<D> context,
-            @NotNull BindingTrace trace
-    ) {
-        ResolutionStatus resultStatus = SUCCESS;
-        ResolvedCall<D> candidateCall = context.candidateCall;
-
-        resultStatus = resultStatus.combine(checkReceiverTypeError(context));
-
-        // Comment about a very special case.
-        // Call 'b.foo(1)' where class 'Foo' has an extension member 'fun B.invoke(Int)' should be checked two times for safe call (in 'checkReceiver'), because
-        // both 'b' (receiver) and 'foo' (this object) might be nullable. In the first case we mark dot, in the second 'foo'.
-        // Class 'CallForImplicitInvoke' helps up to recognise this case, and parameter 'implicitInvokeCheck' helps us to distinguish whether we check receiver or this object.
-
-        resultStatus = resultStatus.combine(checkReceiver(
-                context, candidateCall, trace,
-                candidateCall.getResultingDescriptor().getExtensionReceiverParameter(),
-                candidateCall.getExtensionReceiver(), candidateCall.getExplicitReceiverKind().isExtensionReceiver(), false));
-
-        resultStatus = resultStatus.combine(checkReceiver(
-                context, candidateCall, trace,
-                candidateCall.getResultingDescriptor().getDispatchReceiverParameter(), candidateCall.getDispatchReceiver(),
-                candidateCall.getExplicitReceiverKind().isDispatchReceiver(),
-                // for the invocation 'foo(1)' where foo is a variable of function type we should mark 'foo' if there is unsafe call error
-                context.call instanceof CallForImplicitInvoke));
-        return resultStatus;
-    }
-
-    @NotNull
-    private <D extends CallableDescriptor, C extends CallResolutionContext<C>> ValueArgumentsCheckingResult checkValueArgumentTypes(
-            @NotNull CallResolutionContext<C> context,
-            @NotNull MutableResolvedCall<D> candidateCall,
-            @NotNull BindingTrace trace,
-            @NotNull CallResolverUtil.ResolveArgumentsMode resolveFunctionArgumentBodies) {
-        ResolutionStatus resultStatus = SUCCESS;
-        List<JetType> argumentTypes = Lists.newArrayList();
-        MutableDataFlowInfoForArguments infoForArguments = candidateCall.getDataFlowInfoForArguments();
-        for (Map.Entry<ValueParameterDescriptor, ResolvedValueArgument> entry : candidateCall.getValueArguments().entrySet()) {
-            ValueParameterDescriptor parameterDescriptor = entry.getKey();
-            ResolvedValueArgument resolvedArgument = entry.getValue();
-
-
-            for (ValueArgument argument : resolvedArgument.getArguments()) {
-                JetExpression expression = argument.getArgumentExpression();
-                if (expression == null) continue;
-
-                JetType expectedType = getEffectiveExpectedType(parameterDescriptor, argument);
-
-                CallResolutionContext<?> newContext = context.replaceDataFlowInfo(infoForArguments.getInfo(argument))
-                        .replaceBindingTrace(trace).replaceExpectedType(expectedType);
-                JetTypeInfo typeInfoForCall = argumentTypeResolver.getArgumentTypeInfo(
-                        expression, newContext, resolveFunctionArgumentBodies);
-                JetType type = typeInfoForCall.getType();
-                infoForArguments.updateInfo(argument, typeInfoForCall.getDataFlowInfo());
-
-                ArgumentMatchStatus matchStatus = ArgumentMatchStatus.SUCCESS;
-                JetType resultingType = type;
-                if (type == null || (type.isError() && !ErrorUtils.isFunctionPlaceholder(type))) {
-                    matchStatus = ArgumentMatchStatus.ARGUMENT_HAS_NO_TYPE;
-                }
-                else if (!noExpectedType(expectedType)) {
-                    if (!ArgumentTypeResolver.isSubtypeOfForArgumentType(type, expectedType)) {
-                        JetType smartCast = smartCastValueArgumentTypeIfPossible(expression, newContext.expectedType, type, newContext);
-                        if (smartCast == null) {
-                            resultStatus = OTHER_ERROR;
-                            matchStatus = ArgumentMatchStatus.TYPE_MISMATCH;
-                        }
-                        else {
-                            resultingType = smartCast;
-                        }
-                    }
-                    else if (ErrorUtils.containsUninferredParameter(expectedType)) {
-                        matchStatus = ArgumentMatchStatus.MATCH_MODULO_UNINFERRED_TYPES;
-                    }
-                }
-                argumentTypes.add(resultingType);
-                candidateCall.recordArgumentMatchStatus(argument, matchStatus);
-            }
-        }
-        return new ValueArgumentsCheckingResult(resultStatus, argumentTypes);
-    }
-
-    @Nullable
-    private static JetType smartCastValueArgumentTypeIfPossible(
-            @NotNull JetExpression expression,
-            @NotNull JetType expectedType,
-            @NotNull JetType actualType,
-            @NotNull ResolutionContext<?> context
-    ) {
-        ExpressionReceiver receiverToCast = new ExpressionReceiver(JetPsiUtil.safeDeparenthesize(expression, false), actualType);
-        Collection<JetType> variants = SmartCastUtils.getSmartCastVariantsExcludingReceiver(context, receiverToCast);
-        for (JetType possibleType : variants) {
-            if (JetTypeChecker.DEFAULT.isSubtypeOf(possibleType, expectedType)) {
-                return possibleType;
-            }
-        }
-        return null;
-    }
-
-    private static <D extends CallableDescriptor> ResolutionStatus checkReceiverTypeError(
-            @NotNull CallCandidateResolutionContext<D> context
-    ) {
-        MutableResolvedCall<D> candidateCall = context.candidateCall;
-        D candidateDescriptor = candidateCall.getCandidateDescriptor();
-
-        ReceiverParameterDescriptor extensionReceiver = candidateDescriptor.getExtensionReceiverParameter();
-        ReceiverParameterDescriptor dispatchReceiver = candidateDescriptor.getDispatchReceiverParameter();
-        ResolutionStatus status = SUCCESS;
-        // For the expressions like '42.(f)()' where f: String.() -> Unit we'd like to generate a type mismatch error on '1',
-        // not to throw away the candidate, so the following check is skipped.
-        if (!CallResolverUtil.isInvokeCallOnExpressionWithBothReceivers(context.call)) {
-            status = status.combine(checkReceiverTypeError(context, extensionReceiver, candidateCall.getExtensionReceiver()));
-        }
-        status = status.combine(checkReceiverTypeError(context, dispatchReceiver, candidateCall.getDispatchReceiver()));
-        return status;
-    }
-
-    private static <D extends CallableDescriptor> ResolutionStatus checkReceiverTypeError(
-            @NotNull CallCandidateResolutionContext<D> context,
-            @Nullable ReceiverParameterDescriptor receiverParameterDescriptor,
-            @NotNull ReceiverValue receiverArgument
-    ) {
-        if (receiverParameterDescriptor == null || !receiverArgument.exists()) return SUCCESS;
-
-        D candidateDescriptor = context.candidateCall.getCandidateDescriptor();
-
-        JetType erasedReceiverType = CallResolverUtil.getErasedReceiverType(receiverParameterDescriptor, candidateDescriptor);
-
-        boolean isSubtypeBySmartCast = SmartCastUtils.isSubTypeBySmartCastIgnoringNullability(receiverArgument, erasedReceiverType, context);
-        if (!isSubtypeBySmartCast) {
-            return RECEIVER_TYPE_ERROR;
-        }
-
-        return SUCCESS;
-    }
-
-    private static <D extends CallableDescriptor> ResolutionStatus checkReceiver(
-            @NotNull CallCandidateResolutionContext<D> context,
-            @NotNull ResolvedCall<D> candidateCall,
-            @NotNull BindingTrace trace,
-            @Nullable ReceiverParameterDescriptor receiverParameter,
-            @NotNull ReceiverValue receiverArgument,
-            boolean isExplicitReceiver,
-            boolean implicitInvokeCheck
-    ) {
-        if (receiverParameter == null || !receiverArgument.exists()) return SUCCESS;
-        D candidateDescriptor = candidateCall.getCandidateDescriptor();
-        if (TypeUtils.dependsOnTypeParameters(receiverParameter.getType(), candidateDescriptor.getTypeParameters())) return SUCCESS;
-
-        boolean safeAccess = isExplicitReceiver && !implicitInvokeCheck && CallUtilPackage.isExplicitSafeCall(candidateCall.getCall());
-        boolean isSubtypeBySmartCast = SmartCastUtils.isSubTypeBySmartCastIgnoringNullability(
-                receiverArgument, receiverParameter.getType(), context);
-        if (!isSubtypeBySmartCast) {
-            context.tracing.wrongReceiverType(trace, receiverParameter, receiverArgument);
-            return OTHER_ERROR;
-        }
-        if (!SmartCastUtils.recordSmartCastIfNecessary(receiverArgument, receiverParameter.getType(), context, safeAccess)) {
-            return OTHER_ERROR;
-        }
-
-        JetType receiverArgumentType = receiverArgument.getType();
-
-        BindingContext bindingContext = trace.getBindingContext();
-        if (!safeAccess && !receiverParameter.getType().isMarkedNullable() && receiverArgumentType.isMarkedNullable()) {
-            if (!SmartCastUtils.canBeSmartCast(receiverParameter, receiverArgument, context)) {
-                context.tracing.unsafeCall(trace, receiverArgumentType, implicitInvokeCheck);
-                return UNSAFE_CALL_ERROR;
-            }
-        }
-        DataFlowValue receiverValue = DataFlowValueFactory.createDataFlowValue(receiverArgument, bindingContext, context.scope.getContainingDeclaration());
-        if (safeAccess && !context.dataFlowInfo.getNullability(receiverValue).canBeNull()) {
-            context.tracing.unnecessarySafeCall(trace, receiverArgumentType);
-        }
-
-        context.additionalTypeChecker.checkReceiver(receiverParameter, receiverArgument, safeAccess, context);
-
-        return SUCCESS;
-    }
-
-    public static class ValueArgumentsCheckingResult {
-        @NotNull
-        public final List<JetType> argumentTypes;
-        @NotNull
-        public final ResolutionStatus status;
-
-        private ValueArgumentsCheckingResult(@NotNull ResolutionStatus status, @NotNull List<JetType> argumentTypes) {
-            this.status = status;
-            this.argumentTypes = argumentTypes;
-        }
-    }
-
-    @NotNull
-    public static JetType getEffectiveExpectedType(ValueParameterDescriptor parameterDescriptor, ValueArgument argument) {
-        if (argument.getSpreadElement() != null) {
-            if (parameterDescriptor.getVarargElementType() == null) {
-                // Spread argument passed to a non-vararg parameter, an error is already reported by ValueArgumentsToParametersMapper
-                return DONT_CARE;
-            }
-            else {
-                return parameterDescriptor.getType();
-            }
-        }
-        else {
-            JetType varargElementType = parameterDescriptor.getVarargElementType();
-            if (varargElementType != null) {
-                return varargElementType;
-            }
-
-            return parameterDescriptor.getType();
-        }
-    }
-
-    private static void checkGenericBoundsInAFunctionCall(
-            @NotNull List<JetTypeProjection> jetTypeArguments,
-            @NotNull List<JetType> typeArguments,
-            @NotNull CallableDescriptor functionDescriptor,
-            @NotNull TypeSubstitutor substitutor,
-            @NotNull BindingTrace trace
-    ) {
-        List<TypeParameterDescriptor> typeParameters = functionDescriptor.getTypeParameters();
-        for (int i = 0; i < Math.min(typeParameters.size(), jetTypeArguments.size()); i++) {
-            TypeParameterDescriptor typeParameterDescriptor = typeParameters.get(i);
-            JetType typeArgument = typeArguments.get(i);
-            JetTypeReference typeReference = jetTypeArguments.get(i).getTypeReference();
-            if (typeReference != null) {
-                DescriptorResolver.checkBounds(typeReference, typeArgument, typeParameterDescriptor, substitutor, trace);
-            }
-        }
-    }
-}
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CandidateResolver.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CandidateResolver.kt
new file mode 100644
index 00000000000..812ec018040
--- /dev/null
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CandidateResolver.kt
@@ -0,0 +1,481 @@
+/*
+ * Copyright 2010-2015 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.kotlin.resolve.calls
+
+import com.google.common.collect.Lists
+import com.google.common.collect.Sets
+import org.jetbrains.kotlin.builtins.KotlinBuiltIns
+import org.jetbrains.kotlin.descriptors.*
+import org.jetbrains.kotlin.diagnostics.Errors.PROJECTION_ON_NON_CLASS_TYPE_ARGUMENT
+import org.jetbrains.kotlin.diagnostics.Errors.SUPER_CANT_BE_EXTENSION_RECEIVER
+import org.jetbrains.kotlin.progress.ProgressIndicatorAndCompilationCanceledStatus
+import org.jetbrains.kotlin.psi.*
+import org.jetbrains.kotlin.resolve.*
+import org.jetbrains.kotlin.resolve.calls.CallTransformer.CallForImplicitInvoke
+import org.jetbrains.kotlin.resolve.calls.callResolverUtil.ResolveArgumentsMode
+import org.jetbrains.kotlin.resolve.calls.callResolverUtil.ResolveArgumentsMode.SHAPE_FUNCTION_ARGUMENTS
+import org.jetbrains.kotlin.resolve.calls.callResolverUtil.getEffectiveExpectedType
+import org.jetbrains.kotlin.resolve.calls.callResolverUtil.getErasedReceiverType
+import org.jetbrains.kotlin.resolve.calls.callResolverUtil.isInvokeCallOnExpressionWithBothReceivers
+import org.jetbrains.kotlin.resolve.calls.callUtil.isExplicitSafeCall
+import org.jetbrains.kotlin.resolve.calls.context.*
+import org.jetbrains.kotlin.resolve.calls.model.ArgumentMatchStatus
+import org.jetbrains.kotlin.resolve.calls.model.MutableResolvedCall
+import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall
+import org.jetbrains.kotlin.resolve.calls.results.ResolutionStatus
+import org.jetbrains.kotlin.resolve.calls.results.ResolutionStatus.*
+import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowValueFactory
+import org.jetbrains.kotlin.resolve.calls.smartcasts.SmartCastUtils.canBeSmartCast
+import org.jetbrains.kotlin.resolve.calls.smartcasts.SmartCastUtils.getSmartCastVariantsExcludingReceiver
+import org.jetbrains.kotlin.resolve.calls.smartcasts.SmartCastUtils.isSubTypeBySmartCastIgnoringNullability
+import org.jetbrains.kotlin.resolve.calls.smartcasts.SmartCastUtils.recordSmartCastIfNecessary
+import org.jetbrains.kotlin.resolve.calls.tasks.ResolutionTask
+import org.jetbrains.kotlin.resolve.calls.tasks.isSynthesizedInvoke
+import org.jetbrains.kotlin.resolve.calls.util.FakeCallableDescriptorForObject
+import org.jetbrains.kotlin.resolve.lazy.ForceResolveUtil
+import org.jetbrains.kotlin.resolve.scopes.receivers.ExpressionReceiver
+import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue
+import org.jetbrains.kotlin.types.ErrorUtils
+import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.TypeSubstitutor
+import org.jetbrains.kotlin.types.TypeUtils
+import org.jetbrains.kotlin.types.TypeUtils.noExpectedType
+import org.jetbrains.kotlin.types.checker.JetTypeChecker
+import org.jetbrains.kotlin.types.expressions.ExpressionTypingUtils
+import java.util.ArrayList
+
+public class CandidateResolver(
+        private val argumentTypeResolver: ArgumentTypeResolver,
+        private val genericCandidateResolver: GenericCandidateResolver
+){
+
+    public fun <D : CallableDescriptor, F : D> performResolutionForCandidateCall(context: CallCandidateResolutionContext<D>,
+                                                                                 task: ResolutionTask<D, F>): Unit = with(context) {
+        ProgressIndicatorAndCompilationCanceledStatus.checkCanceled()
+
+        if (ErrorUtils.isError(candidateDescriptor)) {
+            candidateCall.addStatus(SUCCESS)
+            return
+        }
+
+        if (!checkOuterClassMemberIsAccessible(this)) {
+            candidateCall.addStatus(OTHER_ERROR)
+            return
+        }
+
+        checkVisibility()
+        mapArguments(task)
+
+        checkReceiverTypeError()
+        checkExtensionReceiver()
+        checkDispatchReceiver()
+
+        processTypeArguments()
+        checkValueArguments()
+
+        checkAbstractAndSuper()
+        checkNonExtensionCalledWithReceiver()
+    }
+
+    private fun CallCandidateResolutionContext<*>.checkValueArguments() = checkAndReport {
+        if (call.getTypeArguments().isEmpty()
+            && !candidateDescriptor.getTypeParameters().isEmpty()
+            && candidateCall.getKnownTypeParametersSubstitutor() == null
+        ) {
+            genericCandidateResolver.inferTypeArguments(this)
+        }
+        else {
+            checkAllValueArguments(this, SHAPE_FUNCTION_ARGUMENTS).status
+        }
+    }
+
+    private fun CallCandidateResolutionContext<*>.processTypeArguments() = check {
+        val jetTypeArguments = call.getTypeArguments()
+        if (!jetTypeArguments.isEmpty()) {
+            // Explicit type arguments passed
+
+            val typeArguments = ArrayList<JetType>()
+            for (projection in jetTypeArguments) {
+                if (projection.getProjectionKind() != JetProjectionKind.NONE) {
+                    trace.report(PROJECTION_ON_NON_CLASS_TYPE_ARGUMENT.on(projection))
+                    ModifiersChecker.checkIncompatibleVarianceModifiers(projection.getModifierList(), trace)
+                }
+                val type = argumentTypeResolver.resolveTypeRefWithDefault(
+                        projection.getTypeReference(), scope, trace,
+                        ErrorUtils.createErrorType("Star projection in a call"))!!
+                ForceResolveUtil.forceResolveAllContents(type)
+                typeArguments.add(type)
+            }
+            val expectedTypeArgumentCount = candidateDescriptor.getTypeParameters().size()
+            for (index in jetTypeArguments.size()..expectedTypeArgumentCount - 1) {
+                typeArguments.add(ErrorUtils.createErrorType(
+                        "Explicit type argument expected for " + candidateDescriptor.getTypeParameters().get(index).getName()))
+            }
+            val substitutionContext = FunctionDescriptorUtil.createSubstitutionContext(candidateDescriptor as FunctionDescriptor, typeArguments)
+            val substitutor = TypeSubstitutor.create(substitutionContext)
+
+            if (expectedTypeArgumentCount != jetTypeArguments.size()) {
+                candidateCall.addStatus(OTHER_ERROR)
+                tracing.wrongNumberOfTypeArguments(trace, expectedTypeArgumentCount)
+            }
+            else {
+                checkGenericBoundsInAFunctionCall(jetTypeArguments, typeArguments, candidateDescriptor, substitutor, trace)
+            }
+
+            candidateCall.setResultingSubstitutor(substitutor)
+        }
+        else if (candidateCall.getKnownTypeParametersSubstitutor() != null) {
+            candidateCall.setResultingSubstitutor(candidateCall.getKnownTypeParametersSubstitutor()!!)
+        }
+    }
+
+    private fun <D : CallableDescriptor, F : D> CallCandidateResolutionContext<D>.mapArguments(task: ResolutionTask<D, F>) = check {
+        if (task.checkArguments == CheckValueArgumentsMode.ENABLED) {
+            val argumentMappingStatus = ValueArgumentsToParametersMapper.mapValueArgumentsToParameters(
+                    call, tracing, candidateCall, Sets.newLinkedHashSet<ValueArgument>())
+            if (!argumentMappingStatus.isSuccess()) {
+                candidateCall.addStatus(OTHER_ERROR)
+            }
+        }
+    }
+
+    private fun CallCandidateResolutionContext<*>.checkVisibility() = checkAndReport {
+        val receiverValue = ExpressionTypingUtils.normalizeReceiverValueForVisibility(candidateCall.getDispatchReceiver(),
+                                                                                      trace.getBindingContext())
+        val invisibleMember = Visibilities.findInvisibleMember(receiverValue, candidateDescriptor, scope.getContainingDeclaration())
+        if (invisibleMember != null) {
+            tracing.invisibleMember(trace, invisibleMember)
+            OTHER_ERROR
+        } else {
+            SUCCESS
+        }
+    }
+
+    private fun CallCandidateResolutionContext<*>.checkExtensionReceiver() = checkAndReport {
+        val receiverParameter = candidateCall.getCandidateDescriptor().getExtensionReceiverParameter()
+        val receiverArgument = candidateCall.getExtensionReceiver()
+        if (receiverParameter != null && !receiverArgument.exists()) {
+            tracing.missingReceiver(candidateCall.getTrace(), receiverParameter)
+            OTHER_ERROR
+        }
+        else if (receiverParameter == null && receiverArgument.exists()) {
+            tracing.noReceiverAllowed(candidateCall.getTrace())
+            if (call.getCalleeExpression() is JetSimpleNameExpression) {
+                RECEIVER_PRESENCE_ERROR
+            }
+            else {
+                OTHER_ERROR
+            }
+        }
+        else {
+            SUCCESS
+        }
+    }
+
+    private fun CallCandidateResolutionContext<*>.checkDispatchReceiver() = checkAndReport {
+        val candidateDescriptor = candidateDescriptor
+        val dispatchReceiver = candidateCall.getDispatchReceiver()
+        if (dispatchReceiver.exists()) {
+            var nestedClass: ClassDescriptor? = null
+            if (candidateDescriptor is ConstructorDescriptor
+                && DescriptorUtils.isStaticNestedClass(candidateDescriptor.getContainingDeclaration())
+            ) {
+                nestedClass = candidateDescriptor.getContainingDeclaration()
+            }
+            else if (candidateDescriptor is FakeCallableDescriptorForObject) {
+                nestedClass = candidateDescriptor.getReferencedDescriptor()
+            }
+            if (nestedClass != null) {
+                tracing.nestedClassAccessViaInstanceReference(trace, nestedClass, candidateCall.getExplicitReceiverKind())
+                return@checkAndReport OTHER_ERROR
+            }
+        }
+
+        assert((dispatchReceiver.exists() == (candidateCall.getResultingDescriptor().getDispatchReceiverParameter() != null))) {
+            "Shouldn't happen because of TaskPrioritizer: $candidateDescriptor"
+        }
+
+        SUCCESS
+    }
+
+    private fun checkOuterClassMemberIsAccessible(context: CallCandidateResolutionContext<*>): Boolean {
+        // In "this@Outer.foo()" the error will be reported on "this@Outer" instead
+        if (context.call.getExplicitReceiver().exists() || context.call.getDispatchReceiver().exists()) return true
+
+        val candidateThis = getDeclaringClass(context.candidateCall.getCandidateDescriptor())
+        if (candidateThis == null || candidateThis.getKind().isSingleton()) return true
+
+        return DescriptorResolver.checkHasOuterClassInstance(context.scope, context.trace, context.call.getCallElement(), candidateThis)
+    }
+
+    private fun CallCandidateResolutionContext<*>.checkAbstractAndSuper() = check {
+        val descriptor = candidateDescriptor
+        val expression = candidateCall.getCall().getCalleeExpression()
+
+        if (expression is JetSimpleNameExpression) {
+            // 'B' in 'class A: B()' is JetConstructorCalleeExpression
+            if (descriptor is ConstructorDescriptor) {
+                val modality = descriptor.getContainingDeclaration().getModality()
+                if (modality == Modality.ABSTRACT) {
+                    tracing.instantiationOfAbstractClass(trace)
+                }
+            }
+        }
+
+        val superDispatchReceiver = getReceiverSuper(candidateCall.getDispatchReceiver())
+        if (superDispatchReceiver != null) {
+            if (descriptor is MemberDescriptor && descriptor.getModality() == Modality.ABSTRACT) {
+                tracing.abstractSuperCall(trace)
+                candidateCall.addStatus(OTHER_ERROR)
+            }
+        }
+
+        // 'super' cannot be passed as an argument, for receiver arguments expression typer does not track this
+        // See TaskPrioritizer for more
+        val superExtensionReceiver = getReceiverSuper(candidateCall.getExtensionReceiver())
+        if (superExtensionReceiver != null) {
+            trace.report(SUPER_CANT_BE_EXTENSION_RECEIVER.on(superExtensionReceiver, superExtensionReceiver.getText()))
+            candidateCall.addStatus(OTHER_ERROR)
+        }
+    }
+
+    private fun CallCandidateResolutionContext<*>.checkNonExtensionCalledWithReceiver() = checkAndReport {
+        if (isSynthesizedInvoke(candidateCall.getCandidateDescriptor())
+            && !KotlinBuiltIns.isExtensionFunctionType(candidateCall.getDispatchReceiver().getType())
+        ) {
+            tracing.freeFunctionCalledAsExtension(trace)
+            OTHER_ERROR
+        } else {
+            SUCCESS
+        }
+    }
+
+    private fun getReceiverSuper(receiver: ReceiverValue): JetSuperExpression? {
+        if (receiver is ExpressionReceiver) {
+            val expression = receiver.getExpression()
+            if (expression is JetSuperExpression) {
+                return expression
+            }
+        }
+        return null
+    }
+
+    private fun getDeclaringClass(candidate: CallableDescriptor): ClassDescriptor? {
+        val expectedThis = candidate.getDispatchReceiverParameter() ?: return null
+        val descriptor = expectedThis.getContainingDeclaration()
+        return if (descriptor is ClassDescriptor) descriptor else null
+    }
+
+    public fun <D : CallableDescriptor> checkAllValueArguments(
+            context: CallCandidateResolutionContext<D>,
+            resolveFunctionArgumentBodies: ResolveArgumentsMode): ValueArgumentsCheckingResult {
+        val checkingResult = checkValueArgumentTypes(context, context.candidateCall, resolveFunctionArgumentBodies)
+        var resultStatus = checkingResult.status
+        resultStatus = resultStatus.combine(checkReceivers(context))
+
+        return ValueArgumentsCheckingResult(resultStatus, checkingResult.argumentTypes)
+    }
+
+    private fun <D : CallableDescriptor> checkReceivers(context: CallCandidateResolutionContext<D>): ResolutionStatus {
+        var resultStatus = SUCCESS
+        val candidateCall = context.candidateCall
+
+        // Comment about a very special case.
+        // Call 'b.foo(1)' where class 'Foo' has an extension member 'fun B.invoke(Int)' should be checked two times for safe call (in 'checkReceiver'), because
+        // both 'b' (receiver) and 'foo' (this object) might be nullable. In the first case we mark dot, in the second 'foo'.
+        // Class 'CallForImplicitInvoke' helps up to recognise this case, and parameter 'implicitInvokeCheck' helps us to distinguish whether we check receiver or this object.
+
+        resultStatus = resultStatus.combine(context.checkReceiver(
+                candidateCall,
+                candidateCall.getResultingDescriptor().getExtensionReceiverParameter(),
+                candidateCall.getExtensionReceiver(), candidateCall.getExplicitReceiverKind().isExtensionReceiver(), false))
+
+        resultStatus = resultStatus.combine(context.checkReceiver(candidateCall,
+                candidateCall.getResultingDescriptor().getDispatchReceiverParameter(), candidateCall.getDispatchReceiver(),
+                candidateCall.getExplicitReceiverKind().isDispatchReceiver(),
+                // for the invocation 'foo(1)' where foo is a variable of function type we should mark 'foo' if there is unsafe call error
+                context.call is CallForImplicitInvoke))
+        return resultStatus
+    }
+
+    private fun <D : CallableDescriptor, C : CallResolutionContext<C>> checkValueArgumentTypes(
+            context: CallResolutionContext<C>,
+            candidateCall: MutableResolvedCall<D>,
+            resolveFunctionArgumentBodies: ResolveArgumentsMode): ValueArgumentsCheckingResult {
+        var resultStatus = SUCCESS
+        val argumentTypes = Lists.newArrayList<JetType>()
+        val infoForArguments = candidateCall.getDataFlowInfoForArguments()
+        for (entry in candidateCall.getValueArguments().entrySet()) {
+            val parameterDescriptor = entry.getKey()
+            val resolvedArgument = entry.getValue()
+
+
+            for (argument in resolvedArgument.getArguments()) {
+                val expression = argument.getArgumentExpression() ?: continue
+
+                val expectedType = getEffectiveExpectedType(parameterDescriptor, argument)
+
+                val newContext = context.replaceDataFlowInfo(infoForArguments.getInfo(argument)).replaceExpectedType(expectedType)
+                val typeInfoForCall = argumentTypeResolver.getArgumentTypeInfo(
+                        expression, newContext, resolveFunctionArgumentBodies)
+                val type = typeInfoForCall.type
+                infoForArguments.updateInfo(argument, typeInfoForCall.dataFlowInfo)
+
+                var matchStatus = ArgumentMatchStatus.SUCCESS
+                var resultingType: JetType? = type
+                if (type == null || (type.isError() && !ErrorUtils.isFunctionPlaceholder(type))) {
+                    matchStatus = ArgumentMatchStatus.ARGUMENT_HAS_NO_TYPE
+                }
+                else if (!noExpectedType(expectedType)) {
+                    if (!ArgumentTypeResolver.isSubtypeOfForArgumentType(type, expectedType)) {
+                        val smartCast = smartCastValueArgumentTypeIfPossible(expression, newContext.expectedType, type, newContext)
+                        if (smartCast == null) {
+                            resultStatus = OTHER_ERROR
+                            matchStatus = ArgumentMatchStatus.TYPE_MISMATCH
+                        }
+                        else {
+                            resultingType = smartCast
+                        }
+                    }
+                    else if (ErrorUtils.containsUninferredParameter(expectedType)) {
+                        matchStatus = ArgumentMatchStatus.MATCH_MODULO_UNINFERRED_TYPES
+                    }
+                }
+                argumentTypes.add(resultingType)
+                candidateCall.recordArgumentMatchStatus(argument, matchStatus)
+            }
+        }
+        return ValueArgumentsCheckingResult(resultStatus, argumentTypes)
+    }
+
+    private fun smartCastValueArgumentTypeIfPossible(
+            expression: JetExpression,
+            expectedType: JetType,
+            actualType: JetType,
+            context: ResolutionContext<*>): JetType? {
+        val receiverToCast = ExpressionReceiver(JetPsiUtil.safeDeparenthesize(expression, false), actualType)
+        val variants = getSmartCastVariantsExcludingReceiver(context, receiverToCast)
+        for (possibleType in variants) {
+            if (JetTypeChecker.DEFAULT.isSubtypeOf(possibleType, expectedType)) {
+                return possibleType
+            }
+        }
+        return null
+    }
+
+    private fun CallCandidateResolutionContext<*>.checkReceiverTypeError(): Unit = check {
+        val extensionReceiver = candidateDescriptor.getExtensionReceiverParameter()
+        val dispatchReceiver = candidateDescriptor.getDispatchReceiverParameter()
+
+        // For the expressions like '42.(f)()' where f: String.() -> Unit we'd like to generate a type mismatch error on '1',
+        // not to throw away the candidate, so the following check is skipped.
+        if (!isInvokeCallOnExpressionWithBothReceivers(call)) {
+            checkReceiverTypeError(extensionReceiver, candidateCall.getExtensionReceiver())
+        }
+        checkReceiverTypeError(dispatchReceiver, candidateCall.getDispatchReceiver())
+    }
+
+    private fun CallCandidateResolutionContext<*>.checkReceiverTypeError(
+            receiverParameterDescriptor: ReceiverParameterDescriptor?,
+            receiverArgument: ReceiverValue
+    ) = checkAndReport {
+        if (receiverParameterDescriptor == null || !receiverArgument.exists()) return@checkAndReport SUCCESS
+
+        val erasedReceiverType = getErasedReceiverType(receiverParameterDescriptor, candidateDescriptor)
+
+        if (!isSubTypeBySmartCastIgnoringNullability(receiverArgument, erasedReceiverType, this)) {
+            RECEIVER_TYPE_ERROR
+        } else {
+            SUCCESS
+        }
+    }
+
+    private fun <D : CallableDescriptor> CallCandidateResolutionContext<D>.checkReceiver(
+            candidateCall: ResolvedCall<D>,
+            receiverParameter: ReceiverParameterDescriptor?,
+            receiverArgument: ReceiverValue,
+            isExplicitReceiver: Boolean,
+            implicitInvokeCheck: Boolean): ResolutionStatus {
+        if (receiverParameter == null || !receiverArgument.exists()) return SUCCESS
+        val candidateDescriptor = candidateCall.getCandidateDescriptor()
+        if (TypeUtils.dependsOnTypeParameters(receiverParameter.getType(), candidateDescriptor.getTypeParameters())) return SUCCESS
+
+        val safeAccess = isExplicitReceiver && !implicitInvokeCheck && candidateCall.getCall().isExplicitSafeCall()
+        val isSubtypeBySmartCast = isSubTypeBySmartCastIgnoringNullability(
+                receiverArgument, receiverParameter.getType(), this)
+        if (!isSubtypeBySmartCast) {
+            tracing.wrongReceiverType(trace, receiverParameter, receiverArgument)
+            return OTHER_ERROR
+        }
+        if (!recordSmartCastIfNecessary(receiverArgument, receiverParameter.getType(), this, safeAccess)) {
+            return OTHER_ERROR
+        }
+
+        val receiverArgumentType = receiverArgument.getType()
+
+        val bindingContext = trace.getBindingContext()
+        if (!safeAccess && !receiverParameter.getType().isMarkedNullable() && receiverArgumentType.isMarkedNullable()) {
+            if (!canBeSmartCast(receiverParameter, receiverArgument, this)) {
+                tracing.unsafeCall(trace, receiverArgumentType, implicitInvokeCheck)
+                return UNSAFE_CALL_ERROR
+            }
+        }
+        val receiverValue = DataFlowValueFactory.createDataFlowValue(receiverArgument, bindingContext, scope.getContainingDeclaration())
+        if (safeAccess && !dataFlowInfo.getNullability(receiverValue).canBeNull()) {
+            tracing.unnecessarySafeCall(trace, receiverArgumentType)
+        }
+
+        additionalTypeChecker.checkReceiver(receiverParameter, receiverArgument, safeAccess, this)
+
+        return SUCCESS
+    }
+
+    public inner class ValueArgumentsCheckingResult(public val status: ResolutionStatus, public val argumentTypes: List<JetType>)
+
+    private fun checkGenericBoundsInAFunctionCall(
+            jetTypeArguments: List<JetTypeProjection>,
+            typeArguments: List<JetType>,
+            functionDescriptor: CallableDescriptor,
+            substitutor: TypeSubstitutor,
+            trace: BindingTrace) {
+        val typeParameters = functionDescriptor.getTypeParameters()
+        for (i in 0..Math.min(typeParameters.size(), jetTypeArguments.size()) - 1) {
+            val typeParameterDescriptor = typeParameters.get(i)
+            val typeArgument = typeArguments.get(i)
+            val typeReference = jetTypeArguments.get(i).getTypeReference()
+            if (typeReference != null) {
+                DescriptorResolver.checkBounds(typeReference, typeArgument, typeParameterDescriptor, substitutor, trace)
+            }
+        }
+    }
+
+    private fun <D : CallableDescriptor> CallCandidateResolutionContext<D>.shouldContinue() =
+            candidateResolveMode == CandidateResolveMode.FULLY || candidateCall.getStatus().possibleTransformToSuccess()
+
+    private inline fun <D : CallableDescriptor> CallCandidateResolutionContext<D>
+            .check(checker: CallCandidateResolutionContext<D>.() -> Unit): Unit = if (shouldContinue()) checker()
+
+    private inline fun <D : CallableDescriptor> CallCandidateResolutionContext<D>.
+            checkAndReport(checker: CallCandidateResolutionContext<D>.() -> ResolutionStatus) {
+        if (shouldContinue()) {
+            candidateCall.addStatus(checker())
+        }
+    }
+
+    private val CallCandidateResolutionContext<*>.candidateDescriptor: CallableDescriptor get() = candidateCall.getCandidateDescriptor()
+
+}
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/GenericCandidateResolver.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/GenericCandidateResolver.kt
new file mode 100644
index 00000000000..129d4d252c9
--- /dev/null
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/GenericCandidateResolver.kt
@@ -0,0 +1,277 @@
+/*
+ * Copyright 2010-2015 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.kotlin.resolve.calls
+
+import org.jetbrains.kotlin.builtins.KotlinBuiltIns
+import org.jetbrains.kotlin.descriptors.CallableDescriptor
+import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor
+import org.jetbrains.kotlin.psi.JetExpression
+import org.jetbrains.kotlin.psi.JetPsiUtil
+import org.jetbrains.kotlin.psi.ValueArgument
+import org.jetbrains.kotlin.resolve.FunctionDescriptorUtil
+import org.jetbrains.kotlin.resolve.calls.ArgumentTypeResolver.getLastElementDeparenthesized
+import org.jetbrains.kotlin.resolve.calls.callResolverUtil.*
+import org.jetbrains.kotlin.resolve.calls.callResolverUtil.ResolveArgumentsMode.RESOLVE_FUNCTION_ARGUMENTS
+import org.jetbrains.kotlin.resolve.calls.callResolverUtil.ResolveArgumentsMode.SHAPE_FUNCTION_ARGUMENTS
+import org.jetbrains.kotlin.resolve.calls.callUtil.getCall
+import org.jetbrains.kotlin.resolve.calls.context.CallCandidateResolutionContext
+import org.jetbrains.kotlin.resolve.calls.context.ContextDependency.INDEPENDENT
+import org.jetbrains.kotlin.resolve.calls.context.ResolutionContext
+import org.jetbrains.kotlin.resolve.calls.context.ResolutionResultsCache
+import org.jetbrains.kotlin.resolve.calls.context.TemporaryTraceAndCache
+import org.jetbrains.kotlin.resolve.calls.inference.ConstraintSystem
+import org.jetbrains.kotlin.resolve.calls.inference.ConstraintSystemImpl
+import org.jetbrains.kotlin.resolve.calls.inference.constraintPosition.ConstraintPosition
+import org.jetbrains.kotlin.resolve.calls.inference.constraintPosition.ConstraintPositionKind
+import org.jetbrains.kotlin.resolve.calls.inference.constraintPosition.ConstraintPositionKind.RECEIVER_POSITION
+import org.jetbrains.kotlin.resolve.calls.inference.constraintPosition.ConstraintPositionKind.VALUE_PARAMETER_POSITION
+import org.jetbrains.kotlin.resolve.calls.results.ResolutionStatus
+import org.jetbrains.kotlin.resolve.calls.results.ResolutionStatus.INCOMPLETE_TYPE_INFERENCE
+import org.jetbrains.kotlin.resolve.calls.results.ResolutionStatus.OTHER_ERROR
+import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowValueFactory
+import org.jetbrains.kotlin.resolve.scopes.receivers.ExpressionReceiver
+import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.TypeSubstitutor
+import org.jetbrains.kotlin.types.TypeUtils
+import org.jetbrains.kotlin.types.TypeUtils.DONT_CARE
+import org.jetbrains.kotlin.types.TypeUtils.makeConstantSubstitutor
+import org.jetbrains.kotlin.types.Variance
+import org.jetbrains.kotlin.types.checker.JetTypeChecker
+import org.jetbrains.kotlin.types.expressions.ExpressionTypingUtils
+
+
+class GenericCandidateResolver(
+        val argumentTypeResolver: ArgumentTypeResolver
+) {
+
+    fun <D : CallableDescriptor> inferTypeArguments(context: CallCandidateResolutionContext<D>): ResolutionStatus {
+        val candidateCall = context.candidateCall
+        val candidate = candidateCall.getCandidateDescriptor()
+
+        val constraintSystem = ConstraintSystemImpl()
+        candidateCall.setConstraintSystem(constraintSystem)
+
+        // If the call is recursive, e.g.
+        //   fun foo<T>(t : T) : T = foo(t)
+        // we can't use same descriptor objects for T's as actual type values and same T's as unknowns,
+        // because constraints become trivial (T :< T), and inference fails
+        //
+        // Thus, we replace the parameters of our descriptor with fresh objects (perform alpha-conversion)
+        val candidateWithFreshVariables = FunctionDescriptorUtil.alphaConvertTypeParameters(candidate)
+
+        val conversionToOriginal = candidateWithFreshVariables.getTypeParameters().zip(candidate.getTypeParameters()).toMap()
+        constraintSystem.registerTypeVariables(candidateWithFreshVariables.getTypeParameters(), { Variance.INVARIANT }, { conversionToOriginal[it]!! })
+
+        val substituteDontCare = makeConstantSubstitutor(candidate.getTypeParameters(), DONT_CARE)
+
+        // Value parameters
+        for (entry in candidateCall.getValueArguments().entrySet()) {
+            val resolvedValueArgument = entry.getValue()
+            val valueParameterDescriptor = candidate.getValueParameters().get(entry.getKey().getIndex())
+
+
+            for (valueArgument in resolvedValueArgument.getArguments()) {
+                // TODO : more attempts, with different expected types
+
+                // Here we type check expecting an error type (DONT_CARE, substitution with substituteDontCare)
+                // and throw the results away
+                // We'll type check the arguments later, with the inferred types expected
+                addConstraintForValueArgument(valueArgument, valueParameterDescriptor, substituteDontCare,
+                                              constraintSystem, context, SHAPE_FUNCTION_ARGUMENTS)
+            }
+        }
+
+        // Receiver
+        // Error is already reported if something is missing
+        val receiverArgument = candidateCall.getExtensionReceiver()
+        val receiverParameter = candidate.getExtensionReceiverParameter()
+        if (receiverArgument.exists() && receiverParameter != null) {
+            var receiverType: JetType? = if (context.candidateCall.isSafeCall())
+                TypeUtils.makeNotNullable(receiverArgument.getType())
+            else
+                receiverArgument.getType()
+            if (receiverArgument is ExpressionReceiver) {
+                receiverType = updateResultTypeForSmartCasts(receiverType, receiverArgument.getExpression(), context)
+            }
+            constraintSystem.addSubtypeConstraint(receiverType, receiverParameter.getType(), RECEIVER_POSITION.position())
+        }
+
+        // Solution
+        val hasContradiction = constraintSystem.getStatus().hasContradiction()
+        if (!hasContradiction) {
+            return INCOMPLETE_TYPE_INFERENCE
+        }
+        return OTHER_ERROR
+    }
+
+    fun addConstraintForValueArgument(
+            valueArgument: ValueArgument,
+            valueParameterDescriptor: ValueParameterDescriptor,
+            substitutor: TypeSubstitutor,
+            constraintSystem: ConstraintSystem,
+            context: CallCandidateResolutionContext<*>,
+            resolveFunctionArgumentBodies: ResolveArgumentsMode
+    ) {
+
+        val effectiveExpectedType = getEffectiveExpectedType(valueParameterDescriptor, valueArgument)
+        val argumentExpression = valueArgument.getArgumentExpression()
+
+        val expectedType = substitutor.substitute(effectiveExpectedType, Variance.INVARIANT)
+        val dataFlowInfoForArgument = context.candidateCall.getDataFlowInfoForArguments().getInfo(valueArgument)
+        val newContext = context.replaceExpectedType(expectedType).replaceDataFlowInfo(dataFlowInfoForArgument)
+
+        val typeInfoForCall = argumentTypeResolver.getArgumentTypeInfo(argumentExpression, newContext, resolveFunctionArgumentBodies)
+        context.candidateCall.getDataFlowInfoForArguments().updateInfo(valueArgument, typeInfoForCall.dataFlowInfo)
+
+        val constraintPosition = VALUE_PARAMETER_POSITION.position(valueParameterDescriptor.getIndex())
+
+        if (addConstraintForNestedCall(argumentExpression, constraintPosition, constraintSystem, newContext, effectiveExpectedType)) return
+
+        val type = updateResultTypeForSmartCasts(typeInfoForCall.type, argumentExpression, context.replaceDataFlowInfo(dataFlowInfoForArgument))
+        constraintSystem.addSubtypeConstraint(type, effectiveExpectedType, constraintPosition)
+    }
+
+    private fun addConstraintForNestedCall(
+            argumentExpression: JetExpression?,
+            constraintPosition: ConstraintPosition,
+            constraintSystem: ConstraintSystem,
+            context: CallCandidateResolutionContext<*>,
+            effectiveExpectedType: JetType
+    ): Boolean {
+        val resolutionResults = getResolutionResultsCachedData(argumentExpression, context)?.resolutionResults
+        if (resolutionResults == null || !resolutionResults.isSingleResult()) return false
+
+        val resultingCall = resolutionResults.getResultingCall()
+        if (resultingCall.isCompleted()) return false
+
+        val argumentConstraintSystem = resultingCall.getConstraintSystem() as ConstraintSystemImpl? ?: return false
+
+        val candidateDescriptor = resultingCall.getCandidateDescriptor()
+        val returnType = candidateDescriptor.getReturnType() ?: return false
+
+        val nestedTypeVariables = with (argumentConstraintSystem) {
+            returnType.getNestedTypeVariables()
+        }
+        // we add an additional type variable only if no information is inferred for it.
+        // otherwise we add currently inferred return type as before
+        if (nestedTypeVariables.any { argumentConstraintSystem.getTypeBounds(it).bounds.isNotEmpty() }) return false
+
+        val candidateWithFreshVariables = FunctionDescriptorUtil.alphaConvertTypeParameters(candidateDescriptor)
+        val conversion = candidateDescriptor.getTypeParameters().zip(candidateWithFreshVariables.getTypeParameters()).toMap()
+
+        val freshVariables = nestedTypeVariables.map { conversion[it] }.filterNotNull()
+        constraintSystem.registerTypeVariables(freshVariables, { Variance.INVARIANT }, { it }, external = true)
+
+        constraintSystem.addSubtypeConstraint(candidateWithFreshVariables.getReturnType(), effectiveExpectedType, constraintPosition)
+        return true
+    }
+
+    private fun updateResultTypeForSmartCasts(
+            type: JetType?,
+            argumentExpression: JetExpression?,
+            context: ResolutionContext<*>
+    ): JetType? {
+        val deparenthesizedArgument = getLastElementDeparenthesized(argumentExpression, context.statementFilter)
+        if (deparenthesizedArgument == null || type == null) return type
+
+        val dataFlowValue = DataFlowValueFactory.createDataFlowValue(deparenthesizedArgument, type, context)
+        if (!dataFlowValue.isPredictable()) return type
+
+        val possibleTypes = context.dataFlowInfo.getPossibleTypes(dataFlowValue)
+        if (possibleTypes.isEmpty()) return type
+
+        return TypeUtils.intersect(JetTypeChecker.DEFAULT, possibleTypes)
+    }
+
+    public fun <D : CallableDescriptor> completeTypeInferenceDependentOnFunctionLiteralsForCall(
+            context: CallCandidateResolutionContext<D>
+    ) {
+        val resolvedCall = context.candidateCall
+        val constraintSystem = resolvedCall.getConstraintSystem() ?: return
+
+        // constraints for function literals
+        // Value parameters
+        for (entry in resolvedCall.getValueArguments().entrySet()) {
+            val resolvedValueArgument = entry.getValue()
+            val valueParameterDescriptor = entry.getKey()
+
+            for (valueArgument in resolvedValueArgument.getArguments()) {
+                addConstraintForFunctionLiteral(valueArgument, valueParameterDescriptor, constraintSystem, context)
+            }
+        }
+        resolvedCall.setResultingSubstitutor(constraintSystem.getResultingSubstitutor())
+    }
+
+    private fun <D : CallableDescriptor> addConstraintForFunctionLiteral(
+            valueArgument: ValueArgument,
+            valueParameterDescriptor: ValueParameterDescriptor,
+            constraintSystem: ConstraintSystem,
+            context: CallCandidateResolutionContext<D>
+    ) {
+        val argumentExpression = valueArgument.getArgumentExpression() ?: return
+        if (!ArgumentTypeResolver.isFunctionLiteralArgument(argumentExpression, context)) return
+
+        val functionLiteral = ArgumentTypeResolver.getFunctionLiteralArgument(argumentExpression, context)
+
+        val effectiveExpectedType = getEffectiveExpectedType(valueParameterDescriptor, valueArgument)
+        var expectedType = constraintSystem.getCurrentSubstitutor().substitute(effectiveExpectedType, Variance.INVARIANT)
+        if (expectedType == null || TypeUtils.isDontCarePlaceholder(expectedType)) {
+            expectedType = argumentTypeResolver.getShapeTypeOfFunctionLiteral(functionLiteral, context.scope, context.trace, false)
+        }
+        if (expectedType == null || !KotlinBuiltIns.isFunctionOrExtensionFunctionType(expectedType)
+            || hasUnknownFunctionParameter(expectedType)) {
+            return
+        }
+        val dataFlowInfoForArguments = context.candidateCall.getDataFlowInfoForArguments()
+        val dataFlowInfoForArgument = dataFlowInfoForArguments.getInfo(valueArgument)
+
+        //todo analyze function literal body once in 'dependent' mode, then complete it with respect to expected type
+        val hasExpectedReturnType = !hasUnknownReturnType(expectedType)
+        val position = VALUE_PARAMETER_POSITION.position(valueParameterDescriptor.getIndex())
+        if (hasExpectedReturnType) {
+            val temporaryToResolveFunctionLiteral = TemporaryTraceAndCache.create(
+                    context, "trace to resolve function literal with expected return type", argumentExpression)
+
+            val statementExpression = JetPsiUtil.getExpressionOrLastStatementInBlock(functionLiteral.getBodyExpression()) ?: return
+            val mismatch = BooleanArray(1)
+            val errorInterceptingTrace = ExpressionTypingUtils.makeTraceInterceptingTypeMismatch(
+                    temporaryToResolveFunctionLiteral.trace, statementExpression, mismatch)
+            val newContext = context.replaceBindingTrace(errorInterceptingTrace).replaceExpectedType(expectedType)
+                    .replaceDataFlowInfo(dataFlowInfoForArgument).replaceResolutionResultsCache(temporaryToResolveFunctionLiteral.cache)
+                    .replaceContextDependency(INDEPENDENT)
+            val type = argumentTypeResolver.getFunctionLiteralTypeInfo(
+                    argumentExpression, functionLiteral, newContext, RESOLVE_FUNCTION_ARGUMENTS).type
+            if (!mismatch[0]) {
+                constraintSystem.addSubtypeConstraint(type, effectiveExpectedType, position)
+                temporaryToResolveFunctionLiteral.commit()
+                return
+            }
+        }
+        val expectedTypeWithoutReturnType = if (hasExpectedReturnType) replaceReturnTypeByUnknown(expectedType) else expectedType
+        val newContext = context.replaceExpectedType(expectedTypeWithoutReturnType).replaceDataFlowInfo(dataFlowInfoForArgument)
+                .replaceContextDependency(INDEPENDENT)
+        val type = argumentTypeResolver.getFunctionLiteralTypeInfo(argumentExpression, functionLiteral, newContext, RESOLVE_FUNCTION_ARGUMENTS).type
+        constraintSystem.addSubtypeConstraint(type, effectiveExpectedType, position)
+    }
+}
+
+fun getResolutionResultsCachedData(expression: JetExpression?, context: ResolutionContext<*>): ResolutionResultsCache.CachedData? {
+    if (!ExpressionTypingUtils.dependsOnExpectedType(expression)) return null
+    val argumentCall = expression?.getCall(context.trace.getBindingContext()) ?: return null
+
+    return context.resolutionResultsCache[argumentCall]
+}
\ No newline at end of file
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/checkers/CapturingInClosureChecker.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/checkers/CapturingInClosureChecker.kt
index 6611164be24..0abee398898 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/checkers/CapturingInClosureChecker.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/checkers/CapturingInClosureChecker.kt
@@ -74,7 +74,7 @@ class CapturingInClosureChecker : CallChecker {
         if (InlineUtil.isInlinedArgument(scopeDeclaration as JetFunction, context, false)) {
             val scopeContainerParent = scopeContainer.getContainingDeclaration()
             assert(scopeContainerParent != null) { "parent is null for " + scopeContainer }
-            return !isCapturedVariable(variableParent, scopeContainerParent) || isCapturedInInline(context, scopeContainerParent, variableParent)
+            return !isCapturedVariable(variableParent, scopeContainerParent!!) || isCapturedInInline(context, scopeContainerParent, variableParent)
         }
         return false
     }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/checkers/TypeApproximator.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/checkers/TypeApproximator.kt
deleted file mode 100644
index f95f420b617..00000000000
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/checkers/TypeApproximator.kt
+++ /dev/null
@@ -1,61 +0,0 @@
-/*
- * Copyright 2010-2015 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.kotlin.resolve.calls.checkers
-
-import org.jetbrains.kotlin.psi.JetExpression
-import org.jetbrains.kotlin.types.JetType
-import org.jetbrains.kotlin.resolve.calls.context.ResolutionContext
-
-import org.jetbrains.kotlin.types.TypeUtils.noExpectedType
-import org.jetbrains.kotlin.types.getApproximationTo
-import org.jetbrains.kotlin.types.Approximation
-import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowValueFactory
-import com.intellij.openapi.util.text.StringUtil
-import org.jetbrains.kotlin.resolve.BindingContext
-import org.jetbrains.kotlin.descriptors.ReceiverParameterDescriptor
-import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue
-import org.jetbrains.kotlin.resolve.calls.context.CallResolutionContext
-
-public class TypeApproximator : AdditionalTypeChecker {
-    override fun checkType(expression: JetExpression, expressionType: JetType, c: ResolutionContext<*>) {
-        if (noExpectedType(c.expectedType)) return
-
-        val approximationInfo = expressionType.getApproximationTo(
-                c.expectedType,
-                object : Approximation.DataFlowExtras {
-                    override val canBeNull: Boolean
-                        get() = c.dataFlowInfo.getNullability(dataFlowValue).canBeNull()
-                    override val possibleTypes: Set<JetType>
-                        get() = c.dataFlowInfo.getPossibleTypes(dataFlowValue)
-                    override val presentableText: String
-                        get() = StringUtil.trimMiddle(expression.getText(), 50)
-
-                    private val dataFlowValue = DataFlowValueFactory.createDataFlowValue(expression, expressionType, c)
-                }
-        )
-        if (approximationInfo != null) {
-            c.trace.record(BindingContext.EXPRESSION_RESULT_APPROXIMATION, expression, approximationInfo)
-        }
-    }
-
-    override fun checkReceiver(
-            receiverParameter: ReceiverParameterDescriptor,
-            receiverArgument: ReceiverValue,
-            safeAccess: Boolean,
-            c: CallResolutionContext<*>
-    ) { }
-}
\ No newline at end of file
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/context/CallCandidateResolutionContext.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/context/CallCandidateResolutionContext.java
index c33ae1c6f91..afd630c4cee 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/context/CallCandidateResolutionContext.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/context/CallCandidateResolutionContext.java
@@ -40,6 +40,8 @@ public final class CallCandidateResolutionContext<D extends CallableDescriptor>
     public final TracingStrategy tracing;
     @NotNull
     public final ReceiverValue explicitExtensionReceiverForInvoke;
+    @NotNull
+    public final CandidateResolveMode candidateResolveMode;
 
     private CallCandidateResolutionContext(
             @NotNull MutableResolvedCall<D> candidateCall,
@@ -58,6 +60,7 @@ public final class CallCandidateResolutionContext<D extends CallableDescriptor>
             @NotNull AdditionalTypeChecker additionalTypeChecker,
             @NotNull StatementFilter statementFilter,
             @NotNull ReceiverValue explicitExtensionReceiverForInvoke,
+            @NotNull CandidateResolveMode candidateResolveMode,
             boolean isAnnotationContext,
             boolean collectAllCandidates,
             boolean insideSafeCallChain
@@ -68,11 +71,13 @@ public final class CallCandidateResolutionContext<D extends CallableDescriptor>
         this.candidateCall = candidateCall;
         this.tracing = tracing;
         this.explicitExtensionReceiverForInvoke = explicitExtensionReceiverForInvoke;
+        this.candidateResolveMode = candidateResolveMode;
     }
 
     public static <D extends CallableDescriptor> CallCandidateResolutionContext<D> create(
             @NotNull MutableResolvedCall<D> candidateCall, @NotNull CallResolutionContext<?> context, @NotNull BindingTrace trace,
-            @NotNull TracingStrategy tracing, @NotNull Call call, @NotNull ReceiverValue explicitExtensionReceiverForInvoke
+            @NotNull TracingStrategy tracing, @NotNull Call call, @NotNull ReceiverValue explicitExtensionReceiverForInvoke,
+            @NotNull CandidateResolveMode candidateResolveMode
     ) {
         candidateCall.getDataFlowInfoForArguments().setInitialDataFlowInfo(context.dataFlowInfo);
         return new CallCandidateResolutionContext<D>(
@@ -80,20 +85,7 @@ public final class CallCandidateResolutionContext<D extends CallableDescriptor>
                 context.dataFlowInfo, context.contextDependency, context.checkArguments,
                 context.resolutionResultsCache, context.dataFlowInfoForArguments,
                 context.callChecker, context.symbolUsageValidator, context.additionalTypeChecker, context.statementFilter, explicitExtensionReceiverForInvoke,
-                context.isAnnotationContext, context.collectAllCandidates, context.insideCallChain);
-    }
-
-    public static <D extends CallableDescriptor> CallCandidateResolutionContext<D> create(
-            @NotNull MutableResolvedCall<D> candidateCall, @NotNull CallResolutionContext<?> context, @NotNull BindingTrace trace,
-            @NotNull TracingStrategy tracing, @NotNull Call call
-    ) {
-        return create(candidateCall, context, trace, tracing, call, ReceiverValue.NO_RECEIVER);
-    }
-
-    public static <D extends CallableDescriptor> CallCandidateResolutionContext<D> create(
-            @NotNull MutableResolvedCall<D> candidateCall, @NotNull CallResolutionContext<?> context, @NotNull BindingTrace trace,
-            @NotNull TracingStrategy tracing) {
-        return create(candidateCall, context, trace, tracing, context.call);
+                candidateResolveMode, context.isAnnotationContext, context.collectAllCandidates, context.insideCallChain);
     }
 
     @NotNull
@@ -104,7 +96,7 @@ public final class CallCandidateResolutionContext<D extends CallableDescriptor>
                 candidateCall, tracing, context.trace, context.scope, context.call, context.expectedType,
                 context.dataFlowInfo, context.contextDependency, context.checkArguments, context.resolutionResultsCache,
                 context.dataFlowInfoForArguments, context.callChecker, context.symbolUsageValidator, context.additionalTypeChecker, context.statementFilter,
-                ReceiverValue.NO_RECEIVER, context.isAnnotationContext, context.collectAllCandidates, context.insideCallChain);
+                ReceiverValue.NO_RECEIVER, CandidateResolveMode.FULLY, context.isAnnotationContext, context.collectAllCandidates, context.insideCallChain);
     }
 
     @Override
@@ -122,6 +114,6 @@ public final class CallCandidateResolutionContext<D extends CallableDescriptor>
         return new CallCandidateResolutionContext<D>(
                 candidateCall, tracing, trace, scope, call, expectedType, dataFlowInfo, contextDependency, checkArguments,
                 resolutionResultsCache, dataFlowInfoForArguments, callChecker, symbolUsageValidator, additionalTypeChecker, statementFilter,
-                explicitExtensionReceiverForInvoke, isAnnotationContext, collectAllCandidates, insideSafeCallChain);
+                explicitExtensionReceiverForInvoke, candidateResolveMode, isAnnotationContext, collectAllCandidates, insideSafeCallChain);
     }
 }
diff --git a/core/builtins/src/kotlin/reflect/KTopLevelFunction.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/context/CandidateResolveMode.java
similarity index 81%
rename from core/builtins/src/kotlin/reflect/KTopLevelFunction.kt
rename to compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/context/CandidateResolveMode.java
index 2f0d18f09bf..7e2ac6fb467 100644
--- a/core/builtins/src/kotlin/reflect/KTopLevelFunction.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/context/CandidateResolveMode.java
@@ -14,9 +14,9 @@
  * limitations under the License.
  */
 
-package kotlin.reflect
+package org.jetbrains.kotlin.resolve.calls.context;
 
-/**
- * Represents a function declared in a package.
- */
-public interface KTopLevelFunction<out R> : KFunction<R>
+public enum CandidateResolveMode {
+    FULLY,
+    EXIT_ON_FIRST_ERROR
+}
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/model/ArgumentMapping.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/model/ArgumentMapping.kt
index 876de88efc3..39caf37c688 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/model/ArgumentMapping.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/model/ArgumentMapping.kt
@@ -18,7 +18,7 @@ package org.jetbrains.kotlin.resolve.calls.model
 
 import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor
 
-public trait ArgumentMapping {
+public interface ArgumentMapping {
     public fun isError(): Boolean
 }
 
@@ -33,7 +33,9 @@ public enum class ArgumentMatchStatus(val isError: Boolean = true) {
 
     // The case when there is no type mismatch, but parameter has uninferred types:
     // fun <T> foo(l: List<T>) {}; val l = foo(emptyList())
-    MATCH_MODULO_UNINFERRED_TYPES()
+    MATCH_MODULO_UNINFERRED_TYPES(),
+
+    UNKNOWN()
 }
 
 public trait ArgumentMatch : ArgumentMapping {
@@ -45,11 +47,14 @@ public trait ArgumentMatch : ArgumentMapping {
 
 class ArgumentMatchImpl(override val valueParameter: ValueParameterDescriptor): ArgumentMatch {
     private var _status: ArgumentMatchStatus? = null
+
     override val status: ArgumentMatchStatus
-        get() = _status!!
+        get() = _status ?: ArgumentMatchStatus.UNKNOWN
+
     fun recordMatchStatus(status: ArgumentMatchStatus) {
         _status = status
     }
+
     fun replaceValueParameter(newValueParameter: ValueParameterDescriptor): ArgumentMatchImpl {
         val newArgumentMatch = ArgumentMatchImpl(newValueParameter)
         newArgumentMatch._status = _status
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/model/ResolvedCallImpl.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/model/ResolvedCallImpl.java
index c2ecc238381..5b6ac901d68 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/model/ResolvedCallImpl.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/model/ResolvedCallImpl.java
@@ -26,7 +26,7 @@ import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor;
 import org.jetbrains.kotlin.psi.Call;
 import org.jetbrains.kotlin.psi.ValueArgument;
 import org.jetbrains.kotlin.resolve.DelegatingBindingTrace;
-import org.jetbrains.kotlin.resolve.calls.CallResolverUtil;
+import org.jetbrains.kotlin.resolve.calls.callResolverUtil.CallResolverUtilPackage;
 import org.jetbrains.kotlin.resolve.calls.callUtil.CallUtilPackage;
 import org.jetbrains.kotlin.resolve.calls.inference.ConstraintSystem;
 import org.jetbrains.kotlin.resolve.calls.results.ResolutionStatus;
@@ -300,7 +300,8 @@ public class ResolvedCallImpl<D extends CallableDescriptor> implements MutableRe
     @Override
     public boolean hasInferredReturnType() {
         if (!completed) {
-            hasInferredReturnType = constraintSystem == null || CallResolverUtil.hasInferredReturnType(candidateDescriptor, constraintSystem);
+            hasInferredReturnType = constraintSystem == null ||
+                                    CallResolverUtilPackage.hasInferredReturnType(candidateDescriptor, constraintSystem);
         }
         assert hasInferredReturnType != null : "The property 'hasInferredReturnType' was not set when the call was completed.";
         return hasInferredReturnType;
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/resolvedCallUtil.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/resolvedCallUtil.kt
index da03a928a6b..44bca5ea909 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/resolvedCallUtil.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/resolvedCallUtil.kt
@@ -26,8 +26,10 @@ import org.jetbrains.kotlin.psi.JetThisExpression
 import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.DescriptorUtils
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall
+import org.jetbrains.kotlin.resolve.calls.tasks.ExplicitReceiverKind
 import org.jetbrains.kotlin.resolve.descriptorUtil.getOwnerForEffectiveDispatchReceiverParameter
 import org.jetbrains.kotlin.resolve.scopes.receivers.ExpressionReceiver
+import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue
 import org.jetbrains.kotlin.resolve.scopes.receivers.ThisReceiver
 
 // it returns true if call has no dispatch receiver (e.g. resulting descriptor is top-level function or local variable)
@@ -66,3 +68,10 @@ private fun ResolvedCall<*>.hasThisOrNoDispatchReceiver(
     return dispatchReceiverDescriptor == getResultingDescriptor().getOwnerForEffectiveDispatchReceiverParameter()
 }
 
+public fun ResolvedCall<*>.getExplicitReceiverValue(): ReceiverValue {
+    return when (getExplicitReceiverKind()) {
+        ExplicitReceiverKind.DISPATCH_RECEIVER -> getDispatchReceiver()
+        ExplicitReceiverKind.EXTENSION_RECEIVER, ExplicitReceiverKind.BOTH_RECEIVERS -> getExtensionReceiver()
+        else -> ReceiverValue.NO_RECEIVER
+    }
+}
\ No newline at end of file
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/results/ResolutionResultsHandler.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/results/ResolutionResultsHandler.java
index 348c526a932..dccbe67d9ea 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/results/ResolutionResultsHandler.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/results/ResolutionResultsHandler.java
@@ -179,24 +179,24 @@ public class ResolutionResultsHandler {
             return OverloadResolutionResultsImpl.success(candidates.iterator().next());
         }
 
-        MutableResolvedCall<D> maximallySpecific = OverloadingConflictResolver.INSTANCE.findMaximallySpecific(candidates, false);
+        Set<MutableResolvedCall<D>> noOverrides = OverrideResolver.filterOutOverridden(candidates, MAP_TO_RESULT);
+        if (noOverrides.size() == 1) {
+            return OverloadResolutionResultsImpl.success(noOverrides.iterator().next());
+        }
+
+        MutableResolvedCall<D> maximallySpecific = OverloadingConflictResolver.INSTANCE.findMaximallySpecific(noOverrides, false);
         if (maximallySpecific != null) {
             return OverloadResolutionResultsImpl.success(maximallySpecific);
         }
 
         if (discriminateGenerics) {
             MutableResolvedCall<D> maximallySpecificGenericsDiscriminated = OverloadingConflictResolver.INSTANCE.findMaximallySpecific(
-                    candidates, true);
+                    noOverrides, true);
             if (maximallySpecificGenericsDiscriminated != null) {
                 return OverloadResolutionResultsImpl.success(maximallySpecificGenericsDiscriminated);
             }
         }
 
-        Set<MutableResolvedCall<D>> noOverrides = OverrideResolver.filterOutOverridden(candidates, MAP_TO_RESULT);
-        if (noOverrides.size() == 1) {
-                return OverloadResolutionResultsImpl.success(noOverrides.iterator().next());
-        }
-
         return OverloadResolutionResultsImpl.ambiguity(noOverrides);
     }
 
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/results/ResolutionStatus.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/results/ResolutionStatus.java
index e3dc280c23b..389f754689a 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/results/ResolutionStatus.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/results/ResolutionStatus.java
@@ -57,6 +57,10 @@ public enum ResolutionStatus {
         return success;
     }
 
+    public boolean possibleTransformToSuccess() {
+        return this == UNKNOWN_STATUS || this == INCOMPLETE_TYPE_INFERENCE || this == SUCCESS;
+    }
+
     @NotNull
     public ResolutionStatus combine(ResolutionStatus other) {
         if (this == UNKNOWN_STATUS) return other;
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/AbstractTracingStrategy.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/AbstractTracingStrategy.java
index a3f1ceaf1f6..f7747eb3395 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/AbstractTracingStrategy.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/AbstractTracingStrategy.java
@@ -208,12 +208,12 @@ public abstract class AbstractTracingStrategy implements TracingStrategy {
             // (it's useful, when the arguments, e.g. lambdas or calls are incomplete)
             return;
         }
-        if (status.hasOnlyErrorsFromPosition(EXPECTED_TYPE_POSITION.position())) {
+        if (status.hasOnlyErrorsDerivedFrom(EXPECTED_TYPE_POSITION)) {
             JetType declaredReturnType = data.descriptor.getReturnType();
             if (declaredReturnType == null) return;
 
             ConstraintSystem systemWithoutExpectedTypeConstraint =
-                    ((ConstraintSystemImpl) constraintSystem).filterConstraintsOut(EXPECTED_TYPE_POSITION.position());
+                    ((ConstraintSystemImpl) constraintSystem).filterConstraintsOut(EXPECTED_TYPE_POSITION);
             JetType substitutedReturnType = systemWithoutExpectedTypeConstraint.getResultingSubstitutor().substitute(
                     declaredReturnType, Variance.OUT_VARIANCE);
             assert substitutedReturnType != null; //todo
@@ -227,12 +227,15 @@ public abstract class AbstractTracingStrategy implements TracingStrategy {
         else if (status.hasViolatedUpperBound()) {
             trace.report(TYPE_INFERENCE_UPPER_BOUND_VIOLATED.on(reference, data));
         }
-        else if (status.hasTypeConstructorMismatch()) {
-            trace.report(TYPE_INFERENCE_TYPE_CONSTRUCTOR_MISMATCH.on(reference, data));
+        else if (status.hasParameterConstraintError()) {
+            trace.report(TYPE_INFERENCE_PARAMETER_CONSTRAINT_ERROR.on(reference, data));
         }
         else if (status.hasConflictingConstraints()) {
             trace.report(TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS.on(reference, data));
         }
+        else if (status.hasTypeInferenceIncorporationError()) {
+            trace.report(TYPE_INFERENCE_INCORPORATION_ERROR.on(reference));
+        }
         else {
             assert status.hasUnknownParameters();
             trace.report(TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER.on(reference, data));
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/CallableDescriptorCollectors.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/CallableDescriptorCollectors.kt
index ce0d4a0f67a..2625c5d35de 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/CallableDescriptorCollectors.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/CallableDescriptorCollectors.kt
@@ -39,7 +39,7 @@ public trait CallableDescriptorCollector<D : CallableDescriptor> {
 
     public fun getStaticMembersByName(receiver: JetType, name: Name, bindingTrace: BindingTrace): Collection<D>
 
-    public fun getExtensionsByName(scope: JetScope, name: Name, bindingTrace: BindingTrace): Collection<D>
+    public fun getExtensionsByName(scope: JetScope, name: Name, receiverTypes: Collection<JetType>, bindingTrace: BindingTrace): Collection<D>
 }
 
 private fun <D : CallableDescriptor> CallableDescriptorCollector<D>.withDefaultFilter() = filtered { !LibrarySourceHacks.shouldSkip(it) }
@@ -97,7 +97,7 @@ private object FunctionCollector : CallableDescriptorCollector<FunctionDescripto
         return getConstructors(receiver.getMemberScope(), name, { isStaticNestedClass(it) })
     }
 
-    override fun getExtensionsByName(scope: JetScope, name: Name, bindingTrace: BindingTrace): Collection<FunctionDescriptor> {
+    override fun getExtensionsByName(scope: JetScope, name: Name, receiverTypes: Collection<JetType>, bindingTrace: BindingTrace): Collection<FunctionDescriptor> {
         val functions = scope.getFunctions(name)
         val (extensions, nonExtensions) = functions.partition { it.getExtensionReceiverParameter() != null }
 
@@ -151,9 +151,9 @@ private object VariableCollector : CallableDescriptorCollector<VariableDescripto
         return listOf()
     }
 
-    override fun getExtensionsByName(scope: JetScope, name: Name, bindingTrace: BindingTrace): Collection<VariableDescriptor> {
+    override fun getExtensionsByName(scope: JetScope, name: Name, receiverTypes: Collection<JetType>, bindingTrace: BindingTrace): Collection<VariableDescriptor> {
         // property may have an extension function type, we check the applicability later to avoid an early computing of deferred types
-        return (listOf(scope.getLocalVariable(name)) + scope.getProperties(name)).filterNotNull()
+        return (listOf(scope.getLocalVariable(name)) + scope.getProperties(name) + scope.getSyntheticExtensionProperties(receiverTypes, name)).filterNotNull()
     }
 
     override fun toString() = "VARIABLES"
@@ -175,8 +175,8 @@ private object PropertyCollector : CallableDescriptorCollector<VariableDescripto
         return filterProperties(VARIABLES_COLLECTOR.getStaticMembersByName(receiver, name, bindingTrace))
     }
 
-    override fun getExtensionsByName(scope: JetScope, name: Name, bindingTrace: BindingTrace): Collection<VariableDescriptor> {
-        return filterProperties(VARIABLES_COLLECTOR.getExtensionsByName(scope, name, bindingTrace))
+    override fun getExtensionsByName(scope: JetScope, name: Name, receiverTypes: Collection<JetType>, bindingTrace: BindingTrace): Collection<VariableDescriptor> {
+        return filterProperties(VARIABLES_COLLECTOR.getExtensionsByName(scope, name, receiverTypes, bindingTrace))
     }
 
     override fun toString() = "PROPERTIES"
@@ -197,8 +197,8 @@ private fun <D : CallableDescriptor> CallableDescriptorCollector<D>.filtered(fil
             return delegate.getStaticMembersByName(receiver, name, bindingTrace).filter(filter)
         }
 
-        override fun getExtensionsByName(scope: JetScope, name: Name, bindingTrace: BindingTrace): Collection<D> {
-            return delegate.getExtensionsByName(scope, name, bindingTrace).filter(filter)
+        override fun getExtensionsByName(scope: JetScope, name: Name, receiverTypes: Collection<JetType>, bindingTrace: BindingTrace): Collection<D> {
+            return delegate.getExtensionsByName(scope, name, receiverTypes, bindingTrace).filter(filter)
         }
 
         override fun toString(): String {
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/ResolutionTask.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/ResolutionTask.java
index 304b573f017..2dc4f79e5a2 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/ResolutionTask.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/ResolutionTask.java
@@ -16,7 +16,7 @@
 
 package org.jetbrains.kotlin.resolve.calls.tasks;
 
-import com.google.common.collect.Lists;
+import com.intellij.util.SmartList;
 import kotlin.jvm.functions.Function0;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
@@ -82,7 +82,7 @@ public class ResolutionTask<D extends CallableDescriptor, F extends D> extends C
              context.expectedType, context.dataFlowInfo, context.contextDependency, context.checkArguments,
              context.resolutionResultsCache, context.dataFlowInfoForArguments,
              context.callChecker, context.symbolUsageValidator, context.additionalTypeChecker,
-             context.statementFilter, Lists.<MutableResolvedCall<F>>newArrayList(),
+             context.statementFilter, new SmartList<MutableResolvedCall<F>>(),
              context.isAnnotationContext, context.collectAllCandidates, context.insideCallChain);
     }
 
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/ResolutionTaskHolder.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/ResolutionTaskHolder.kt
index 13e4117743c..edafbdb4cd4 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/ResolutionTaskHolder.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/ResolutionTaskHolder.kt
@@ -58,7 +58,7 @@ public class ResolutionTaskHolder<D : CallableDescriptor, F : D>(
                     val lazyCandidates = {
                         candidatesList[candidateIndex]().filter { priorityProvider.getPriority(it) == priority }.toReadOnlyList()
                     }
-                    tasks.add(ResolutionTask(basicCallResolutionContext, tracing, lazyCandidates))
+                    tasks.add(ResolutionTask<D, F>(basicCallResolutionContext, tracing, lazyCandidates))
                 }
             }
 
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/TaskPrioritizer.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/TaskPrioritizer.kt
index dadc7605f71..702e18c17bc 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/TaskPrioritizer.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/TaskPrioritizer.kt
@@ -18,13 +18,14 @@ package org.jetbrains.kotlin.resolve.calls.tasks
 
 import com.google.common.collect.Lists
 import com.google.common.collect.Sets
-import org.jetbrains.kotlin.progress.ProgressIndicatorAndCompilationCanceledStatus
 import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.name.Name
+import org.jetbrains.kotlin.progress.ProgressIndicatorAndCompilationCanceledStatus
 import org.jetbrains.kotlin.psi.Call
 import org.jetbrains.kotlin.resolve.DescriptorUtils
-import org.jetbrains.kotlin.resolve.calls.CallResolverUtil.isOrOverridesSynthesized
+import org.jetbrains.kotlin.resolve.calls.callResolverUtil.isOrOverridesSynthesized
 import org.jetbrains.kotlin.resolve.calls.context.BasicCallResolutionContext
+import org.jetbrains.kotlin.resolve.calls.context.ResolutionContext
 import org.jetbrains.kotlin.resolve.calls.smartcasts.SmartCastUtils
 import org.jetbrains.kotlin.resolve.calls.tasks.ExplicitReceiverKind.BOTH_RECEIVERS
 import org.jetbrains.kotlin.resolve.calls.tasks.ExplicitReceiverKind.DISPATCH_RECEIVER
@@ -41,6 +42,7 @@ import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue
 import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue.NO_RECEIVER
 import org.jetbrains.kotlin.storage.StorageManager
 import org.jetbrains.kotlin.types.ErrorUtils
+import org.jetbrains.kotlin.types.JetType
 import org.jetbrains.kotlin.types.checker.JetTypeChecker
 import org.jetbrains.kotlin.types.expressions.ExpressionTypingUtils
 import org.jetbrains.kotlin.types.isDynamic
@@ -112,29 +114,37 @@ public class TaskPrioritizer(private val storageManager: StorageManager) {
     private fun <D : CallableDescriptor, F : D> doComputeTasks(receiver: ReceiverValue, c: TaskPrioritizerContext<D, F>) {
         ProgressIndicatorAndCompilationCanceledStatus.checkCanceled()
 
+        val receiverWithTypes = ReceiverWithTypes(receiver, c.context)
+
         val resolveInvoke = c.context.call.getDispatchReceiver().exists()
         if (resolveInvoke) {
-            addCandidatesForInvoke(receiver, c)
+            addCandidatesForInvoke(receiverWithTypes, c)
             return
         }
         val implicitReceivers = Sets.newLinkedHashSet<ReceiverValue>(JetScopeUtils.getImplicitReceiversHierarchyValues(c.scope))
         if (receiver.exists()) {
-            addCandidatesForExplicitReceiver(receiver, implicitReceivers, c, isExplicit = true)
-            addMembers(receiver, c, staticMembers = true, isExplicit = true)
+            addCandidatesForExplicitReceiver(receiverWithTypes, implicitReceivers, c, isExplicit = true)
+            addMembers(receiverWithTypes, c, staticMembers = true, isExplicit = true)
             return
         }
         addCandidatesForNoReceiver(implicitReceivers, c)
     }
 
+    private class ReceiverWithTypes(
+            val value: ReceiverValue,
+            private val context: ResolutionContext<*>) {
+        val types: Collection<JetType> by lazy { SmartCastUtils.getSmartCastVariants(value, context) }
+    }
+
     private fun <D : CallableDescriptor, F : D> addCandidatesForExplicitReceiver(
-            explicitReceiver: ReceiverValue,
+            explicitReceiver: ReceiverWithTypes,
             implicitReceivers: Collection<ReceiverValue>,
             c: TaskPrioritizerContext<D, F>,
             isExplicit: Boolean
     ) {
         addMembers(explicitReceiver, c, staticMembers = false, isExplicit = isExplicit)
 
-        if (explicitReceiver.getType().isDynamic()) {
+        if (explicitReceiver.value.type.isDynamic()) {
             addCandidatesForDynamicReceiver(explicitReceiver, implicitReceivers, c, isExplicit)
         }
         else {
@@ -143,7 +153,7 @@ public class TaskPrioritizer(private val storageManager: StorageManager) {
     }
 
     private fun <D : CallableDescriptor, F : D> addExtensionCandidates(
-            explicitReceiver: ReceiverValue,
+            explicitReceiver: ReceiverWithTypes,
             implicitReceivers: Collection<ReceiverValue>,
             c: TaskPrioritizerContext<D, F>,
             isExplicit: Boolean
@@ -163,8 +173,8 @@ public class TaskPrioritizer(private val storageManager: StorageManager) {
             c.result.addCandidates {
                 convertWithImpliedThis(
                         c.scope,
-                        explicitReceiver,
-                        callableDescriptorCollector.getExtensionsByName(c.scope, c.name, c.context.trace),
+                        explicitReceiver.value,
+                        callableDescriptorCollector.getExtensionsByName(c.scope, c.name, explicitReceiver.types, c.context.trace),
                         createKind(EXTENSION_RECEIVER, isExplicit),
                         c.context.call
                 )
@@ -173,16 +183,15 @@ public class TaskPrioritizer(private val storageManager: StorageManager) {
     }
 
     private fun <D : CallableDescriptor, F : D> addMembers(
-            explicitReceiver: ReceiverValue,
+            explicitReceiver: ReceiverWithTypes,
             c: TaskPrioritizerContext<D, F>,
             staticMembers: Boolean,
             isExplicit: Boolean
     ) {
         for (callableDescriptorCollector in c.callableDescriptorCollectors) {
             c.result.addCandidates {
-                val variantsForExplicitReceiver = SmartCastUtils.getSmartCastVariants(explicitReceiver, c.context)
                 val members = Lists.newArrayList<ResolutionCandidate<D>>()
-                for (type in variantsForExplicitReceiver) {
+                for (type in explicitReceiver.types) {
                     val membersForThisVariant = if (staticMembers) {
                         callableDescriptorCollector.getStaticMembersByName(type, c.name, c.context.trace)
                     }
@@ -191,7 +200,7 @@ public class TaskPrioritizer(private val storageManager: StorageManager) {
                     }
                     convertWithReceivers(
                             membersForThisVariant,
-                            explicitReceiver,
+                            explicitReceiver.value,
                             NO_RECEIVER,
                             members,
                             createKind(DISPATCH_RECEIVER, isExplicit),
@@ -204,7 +213,7 @@ public class TaskPrioritizer(private val storageManager: StorageManager) {
     }
 
     private fun <D : CallableDescriptor, F : D> addCandidatesForDynamicReceiver(
-            explicitReceiver: ReceiverValue,
+            explicitReceiver: ReceiverWithTypes,
             implicitReceivers: Collection<ReceiverValue>,
             c: TaskPrioritizerContext<D, F>,
             isExplicit: Boolean
@@ -219,7 +228,7 @@ public class TaskPrioritizer(private val storageManager: StorageManager) {
                 it.getNonExtensionsByName(dynamicScope, c.name, c.context.trace)
             }
 
-            convertWithReceivers(dynamicDescriptors, explicitReceiver, NO_RECEIVER, createKind(DISPATCH_RECEIVER, isExplicit), c.context.call)
+            convertWithReceivers(dynamicDescriptors, explicitReceiver.value, NO_RECEIVER, createKind(DISPATCH_RECEIVER, isExplicit), c.context.call)
         }
     }
 
@@ -230,15 +239,15 @@ public class TaskPrioritizer(private val storageManager: StorageManager) {
 
     private fun <D : CallableDescriptor, F : D> addMemberExtensionCandidates(
             dispatchReceiver: ReceiverValue,
-            receiverParameter: ReceiverValue,
+            receiverParameter: ReceiverWithTypes,
             callableDescriptorCollector: CallableDescriptorCollector<D>,
             c: TaskPrioritizerContext<D, F>,
             receiverKind: ExplicitReceiverKind
     ) {
         c.result.addCandidates {
             val memberExtensions =
-                    callableDescriptorCollector.getExtensionsByName(dispatchReceiver.getType().getMemberScope(), c.name, c.context.trace)
-            convertWithReceivers(memberExtensions, dispatchReceiver, receiverParameter, receiverKind, c.context.call)
+                    callableDescriptorCollector.getExtensionsByName(dispatchReceiver.type.memberScope, c.name, receiverParameter.types, c.context.trace)
+            convertWithReceivers(memberExtensions, dispatchReceiver, receiverParameter.value, receiverKind, c.context.call)
         }
     }
 
@@ -269,8 +278,10 @@ public class TaskPrioritizer(private val storageManager: StorageManager) {
         //locals
         c.result.addCandidates(localsList)
 
+        val implicitReceiversWithTypes = implicitReceivers.map { ReceiverWithTypes(it, c.context) }
+
         //try all implicit receivers as explicit
-        for (implicitReceiver in implicitReceivers) {
+        for (implicitReceiver in implicitReceiversWithTypes) {
             addCandidatesForExplicitReceiver(implicitReceiver, implicitReceivers, c, isExplicit = false)
         }
 
@@ -278,12 +289,12 @@ public class TaskPrioritizer(private val storageManager: StorageManager) {
         c.result.addCandidates(nonlocalsList)
 
         //static (only for better error reporting)
-        for (implicitReceiver in implicitReceivers) {
+        for (implicitReceiver in implicitReceiversWithTypes) {
             addMembers(implicitReceiver, c, staticMembers = true, isExplicit = false)
         }
     }
 
-    private fun <D : CallableDescriptor, F : D> addCandidatesForInvoke(explicitReceiver: ReceiverValue, c: TaskPrioritizerContext<D, F>) {
+    private fun <D : CallableDescriptor, F : D> addCandidatesForInvoke(explicitReceiver: ReceiverWithTypes, c: TaskPrioritizerContext<D, F>) {
         val implicitReceivers = JetScopeUtils.getImplicitReceiversHierarchyValues(c.scope)
 
         // For 'a.foo()' where foo has function type,
@@ -296,8 +307,8 @@ public class TaskPrioritizer(private val storageManager: StorageManager) {
         // or for 'invoke' function.
 
         // (1) a.foo + foo.invoke()
-        if (!explicitReceiver.exists()) {
-            addCandidatesForExplicitReceiver(variableReceiver, implicitReceivers, c, isExplicit = true)
+        if (!explicitReceiver.value.exists()) {
+            addCandidatesForExplicitReceiver(ReceiverWithTypes(variableReceiver, c.context), implicitReceivers, c, isExplicit = true)
         }
 
         // (2) foo + a.invoke()
@@ -306,20 +317,20 @@ public class TaskPrioritizer(private val storageManager: StorageManager) {
         //trait A
         //trait Foo { fun A.invoke() }
 
-        if (explicitReceiver.exists()) {
+        if (explicitReceiver.value.exists()) {
             //a.foo()
             addCandidatesWhenInvokeIsMemberAndExtensionToExplicitReceiver(variableReceiver, explicitReceiver, c, BOTH_RECEIVERS)
             return
         }
         // with (a) { foo() }
         for (implicitReceiver in implicitReceivers) {
-            addCandidatesWhenInvokeIsMemberAndExtensionToExplicitReceiver(variableReceiver, implicitReceiver, c, DISPATCH_RECEIVER)
+            addCandidatesWhenInvokeIsMemberAndExtensionToExplicitReceiver(variableReceiver, ReceiverWithTypes(implicitReceiver, c.context), c, DISPATCH_RECEIVER)
         }
     }
 
     private fun <D : CallableDescriptor, F : D> addCandidatesWhenInvokeIsMemberAndExtensionToExplicitReceiver(
             dispatchReceiver: ReceiverValue,
-            receiverParameter: ReceiverValue,
+            receiverParameter: ReceiverWithTypes,
             c: TaskPrioritizerContext<D, F>,
             receiverKind: ExplicitReceiverKind
     ) {
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/dynamicCalls.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/dynamicCalls.kt
index b46e928cab8..528cdb6eed2 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/dynamicCalls.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/dynamicCalls.kt
@@ -16,46 +16,28 @@
 
 package org.jetbrains.kotlin.resolve.calls.tasks
 
-import org.jetbrains.kotlin.psi.Call
-import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
-import org.jetbrains.kotlin.descriptors.impl.SimpleFunctionDescriptorImpl
+import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.descriptors.annotations.Annotations
-import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor
-import org.jetbrains.kotlin.descriptors.SourceElement
-import org.jetbrains.kotlin.descriptors.impl.ReceiverParameterDescriptorImpl
-import org.jetbrains.kotlin.types.DynamicType
-import org.jetbrains.kotlin.descriptors.Modality
-import org.jetbrains.kotlin.descriptors.Visibilities
-import org.jetbrains.kotlin.descriptors.CallableDescriptor
-import org.jetbrains.kotlin.descriptors.impl.PropertyDescriptorImpl
-import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor
-import org.jetbrains.kotlin.descriptors.impl.TypeParameterDescriptorImpl
-import org.jetbrains.kotlin.types.Variance
-import org.jetbrains.kotlin.name.Name
-import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor
-import org.jetbrains.kotlin.types.JetType
-import kotlin.platform.platformStatic
-import org.jetbrains.kotlin.resolve.scopes.receivers.TransientReceiver
-import org.jetbrains.kotlin.types.isDynamic
-import org.jetbrains.kotlin.resolve.calls.tasks.collectors.CallableDescriptorCollector
-import org.jetbrains.kotlin.resolve.scopes.JetScope
-import org.jetbrains.kotlin.resolve.BindingTrace
-import org.jetbrains.kotlin.resolve.calls.tasks.collectors.CallableDescriptorCollectors
-import org.jetbrains.kotlin.resolve.scopes.JetScopeImpl
-import org.jetbrains.kotlin.utils.Printer
-import org.jetbrains.kotlin.descriptors.FunctionDescriptor
-import org.jetbrains.kotlin.descriptors.VariableDescriptor
+import org.jetbrains.kotlin.descriptors.impl.*
 import org.jetbrains.kotlin.lexer.JetTokens
-import org.jetbrains.kotlin.types.expressions.OperatorConventions
-import org.jetbrains.kotlin.psi.JetOperationReferenceExpression
+import org.jetbrains.kotlin.name.Name
+import org.jetbrains.kotlin.psi.*
+import org.jetbrains.kotlin.resolve.BindingTrace
 import org.jetbrains.kotlin.resolve.DescriptorFactory
-import org.jetbrains.kotlin.descriptors.impl.ValueParameterDescriptorImpl
-import org.jetbrains.kotlin.builtins.KotlinBuiltIns
-import org.jetbrains.kotlin.psi.ValueArgument
-import java.util.ArrayList
-import org.jetbrains.kotlin.psi.JetFunctionLiteralExpression
-import org.jetbrains.kotlin.psi.JetPsiUtil
+import org.jetbrains.kotlin.resolve.calls.tasks.collectors.CallableDescriptorCollector
+import org.jetbrains.kotlin.resolve.calls.tasks.collectors.CallableDescriptorCollectors
 import org.jetbrains.kotlin.resolve.descriptorUtil.builtIns
+import org.jetbrains.kotlin.resolve.scopes.JetScope
+import org.jetbrains.kotlin.resolve.scopes.JetScopeImpl
+import org.jetbrains.kotlin.resolve.scopes.receivers.TransientReceiver
+import org.jetbrains.kotlin.types.DynamicType
+import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.Variance
+import org.jetbrains.kotlin.types.expressions.OperatorConventions
+import org.jetbrains.kotlin.types.isDynamic
+import org.jetbrains.kotlin.utils.Printer
+import java.util.ArrayList
+import kotlin.platform.platformStatic
 
 object DynamicCallableDescriptors {
 
@@ -150,11 +132,7 @@ object DynamicCallableDescriptors {
     }
 
     private fun createDynamicDispatchReceiverParameter(owner: CallableDescriptor): ReceiverParameterDescriptorImpl {
-        return ReceiverParameterDescriptorImpl(
-                owner,
-                DynamicType,
-                TransientReceiver(DynamicType)
-        )
+        return ReceiverParameterDescriptorImpl(owner, TransientReceiver(DynamicType))
     }
 
     private fun createTypeParameters(owner: DeclarationDescriptor, call: Call): List<TypeParameterDescriptor> = call.getTypeArguments().indices.map {
@@ -170,8 +148,7 @@ object DynamicCallableDescriptors {
         )
     }
 
-    private fun createValueParameters(owner: DeclarationDescriptor, call: Call): List<ValueParameterDescriptor> {
-
+    private fun createValueParameters(owner: FunctionDescriptor, call: Call): List<ValueParameterDescriptor> {
         val parameters = ArrayList<ValueParameterDescriptor>()
 
         fun addParameter(arg : ValueArgument, outType: JetType, varargElementType: JetType?) {
@@ -246,8 +223,8 @@ public fun DeclarationDescriptor.isDynamic(): Boolean {
 }
 
 class CollectorForDynamicReceivers<D: CallableDescriptor>(val delegate: CallableDescriptorCollector<D>) : CallableDescriptorCollector<D> by delegate {
-    override fun getExtensionsByName(scope: JetScope, name: Name, bindingTrace: BindingTrace): Collection<D> {
-        return delegate.getExtensionsByName(scope, name, bindingTrace).filter {
+    override fun getExtensionsByName(scope: JetScope, name: Name, receiverTypes: Collection<JetType>, bindingTrace: BindingTrace): Collection<D> {
+        return delegate.getExtensionsByName(scope, name, receiverTypes, bindingTrace).filter {
             it.getExtensionReceiverParameter()?.getType()?.isDynamic() ?: false
         }
     }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/synthesizedInvokes.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/synthesizedInvokes.kt
index 9a33c481df4..8ede6660859 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/synthesizedInvokes.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/synthesizedInvokes.kt
@@ -52,7 +52,7 @@ fun createSynthesizedInvokes(functions: Collection<FunctionDescriptor>): Collect
             fakeOverride
         }
 
-        result.add(synthesized.substitute(TypeSubstitutor.create(invoke.getDispatchReceiverParameter()!!.getType())))
+        result.add(synthesized.substitute(TypeSubstitutor.create(invoke.getDispatchReceiverParameter()!!.getType()))!!)
     }
 
     return result
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/util/FakeCallableDescriptorForObject.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/util/FakeCallableDescriptorForObject.kt
index ac78cd3b963..8ba9e0bc3a7 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/util/FakeCallableDescriptorForObject.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/util/FakeCallableDescriptorForObject.kt
@@ -17,7 +17,6 @@
 package org.jetbrains.kotlin.resolve.calls.util
 
 import org.jetbrains.kotlin.descriptors.*
-import org.jetbrains.kotlin.resolve.constants.CompileTimeConstant
 import org.jetbrains.kotlin.resolve.descriptorUtil.classObjectType
 import org.jetbrains.kotlin.resolve.descriptorUtil.getClassObjectReferenceTarget
 import org.jetbrains.kotlin.resolve.descriptorUtil.hasClassObjectType
@@ -59,7 +58,7 @@ public class FakeCallableDescriptorForObject(
 
     override fun getOriginal(): CallableDescriptor = this
 
-    override fun getCompileTimeInitializer(): CompileTimeConstant<out Any?>? = null
+    override fun getCompileTimeInitializer() = null
 
     override fun getSource(): SourceElement = classDescriptor.getSource()
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/util/callUtil.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/util/callUtil.kt
index fc9d4f6b9a8..fc2352154f1 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/util/callUtil.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/util/callUtil.kt
@@ -35,7 +35,7 @@ import org.jetbrains.kotlin.utils.sure
 // resolved call
 
 public fun <D : CallableDescriptor> ResolvedCall<D>.noErrorsInValueArguments(): Boolean {
-    return getCall().getValueArguments().all { argument -> argument.getArgumentExpression() != null/* isError() crashes otherwise!*/ && !getArgumentMapping(argument!!).isError() }
+    return getCall().getValueArguments().all { argument -> !getArgumentMapping(argument!!).isError() }
 }
 
 public fun <D : CallableDescriptor> ResolvedCall<D>.hasUnmappedArguments(): Boolean {
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/constants/CompileTimeConstantChecker.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/constants/CompileTimeConstantChecker.java
index 77839c93515..5699547eae1 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/constants/CompileTimeConstantChecker.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/constants/CompileTimeConstantChecker.java
@@ -51,7 +51,7 @@ public class CompileTimeConstantChecker {
 
     // return true if there is an error
     public boolean checkConstantExpressionType(
-            @Nullable CompileTimeConstant compileTimeConstant,
+            @Nullable ConstantValue<?> compileTimeConstant,
             @NotNull JetConstantExpression expression,
             @NotNull JetType expectedType
     ) {
@@ -76,7 +76,7 @@ public class CompileTimeConstantChecker {
     }
 
     private boolean checkIntegerValue(
-            @Nullable CompileTimeConstant value,
+            @Nullable ConstantValue<?> value,
             @NotNull JetType expectedType,
             @NotNull JetConstantExpression expression
     ) {
@@ -89,7 +89,7 @@ public class CompileTimeConstantChecker {
         }
 
         if (!noExpectedTypeOrError(expectedType)) {
-            JetType valueType = value.getType(builtIns);
+            JetType valueType = value.getType();
             if (!JetTypeChecker.DEFAULT.isSubtypeOf(valueType, expectedType)) {
                 return reportError(CONSTANT_EXPECTED_TYPE_MISMATCH.on(expression, "integer", expectedType));
             }
@@ -98,7 +98,7 @@ public class CompileTimeConstantChecker {
     }
 
     private boolean checkFloatValue(
-            @Nullable CompileTimeConstant value,
+            @Nullable ConstantValue<?> value,
             @NotNull JetType expectedType,
             @NotNull JetConstantExpression expression
     ) {
@@ -106,7 +106,7 @@ public class CompileTimeConstantChecker {
             return reportError(FLOAT_LITERAL_OUT_OF_RANGE.on(expression));
         }
         if (!noExpectedTypeOrError(expectedType)) {
-            JetType valueType = value.getType(builtIns);
+            JetType valueType = value.getType();
             if (!JetTypeChecker.DEFAULT.isSubtypeOf(valueType, expectedType)) {
                 return reportError(CONSTANT_EXPECTED_TYPE_MISMATCH.on(expression, "floating-point", expectedType));
             }
@@ -125,7 +125,7 @@ public class CompileTimeConstantChecker {
         return false;
     }
 
-    private boolean checkCharValue(CompileTimeConstant<?> constant, JetType expectedType, JetConstantExpression expression) {
+    private boolean checkCharValue(ConstantValue<?> constant, JetType expectedType, JetConstantExpression expression) {
         if (!noExpectedTypeOrError(expectedType)
             && !JetTypeChecker.DEFAULT.isSubtypeOf(builtIns.getCharType(), expectedType)) {
             return reportError(CONSTANT_EXPECTED_TYPE_MISMATCH.on(expression, "character", expectedType));
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/constants/evaluate/ConstantExpressionEvaluator.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/constants/evaluate/ConstantExpressionEvaluator.kt
index a5e4178acd9..a7240b3f284 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/constants/evaluate/ConstantExpressionEvaluator.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/constants/evaluate/ConstantExpressionEvaluator.kt
@@ -17,61 +17,213 @@
 package org.jetbrains.kotlin.resolve.constants.evaluate
 
 import com.intellij.psi.util.PsiTreeUtil
-import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptorImpl
-import org.jetbrains.kotlin.descriptors.*
-import org.jetbrains.kotlin.psi.*
-import org.jetbrains.kotlin.resolve.*
-import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall
-import org.jetbrains.kotlin.resolve.constants.*
-import org.jetbrains.kotlin.types.JetType
-import org.jetbrains.kotlin.types.expressions.OperatorConventions
-import org.jetbrains.kotlin.builtins.KotlinBuiltIns
-import org.jetbrains.kotlin.lexer.JetTokens
-import org.jetbrains.kotlin.resolve.calls.tasks.ExplicitReceiverKind
-import org.jetbrains.kotlin.types.TypeUtils
-import org.jetbrains.kotlin.resolve.calls.model.ResolvedValueArgument
 import org.jetbrains.kotlin.JetNodeTypes
-import org.jetbrains.kotlin.diagnostics.DiagnosticUtils
-import java.math.BigInteger
+import org.jetbrains.kotlin.builtins.KotlinBuiltIns
+import org.jetbrains.kotlin.descriptors.ClassDescriptor
+import org.jetbrains.kotlin.descriptors.ConstructorDescriptor
+import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor
+import org.jetbrains.kotlin.descriptors.VariableDescriptor
+import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptorImpl
 import org.jetbrains.kotlin.diagnostics.Errors
-import org.jetbrains.kotlin.diagnostics.rendering.DefaultErrorMessages
-import org.jetbrains.kotlin.resolve.calls.callUtil.getResolvedCall
+import org.jetbrains.kotlin.lexer.JetTokens
+import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.getStrictParentOfType
+import org.jetbrains.kotlin.resolve.*
+import org.jetbrains.kotlin.resolve.calls.ArgumentTypeResolver
+import org.jetbrains.kotlin.resolve.calls.callUtil.getResolvedCall
+import org.jetbrains.kotlin.resolve.calls.checkers.AdditionalTypeChecker
+import org.jetbrains.kotlin.resolve.calls.checkers.CompositeChecker
+import org.jetbrains.kotlin.resolve.calls.context.ContextDependency
+import org.jetbrains.kotlin.resolve.calls.context.SimpleResolutionContext
+import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall
+import org.jetbrains.kotlin.resolve.calls.model.ResolvedValueArgument
+import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo
+import org.jetbrains.kotlin.resolve.calls.tasks.ExplicitReceiverKind
+import org.jetbrains.kotlin.resolve.constants.*
+import org.jetbrains.kotlin.resolve.scopes.JetScope
+import org.jetbrains.kotlin.resolve.validation.SymbolUsageValidator
+import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.TypeUtils
+import org.jetbrains.kotlin.types.checker.JetTypeChecker
+import org.jetbrains.kotlin.types.expressions.OperatorConventions
+import java.math.BigInteger
+import java.util.ArrayList
+import java.util.HashMap
 import kotlin.platform.platformStatic
 
-public class ConstantExpressionEvaluator private constructor(val trace: BindingTrace) : JetVisitor<CompileTimeConstant<*>, JetType>() {
+public class ConstantExpressionEvaluator(
+        internal val constantValueFactory: ConstantValueFactory,
+        internal val builtIns: KotlinBuiltIns
+) {
 
-    companion object {
-        platformStatic public fun evaluate(expression: JetExpression, trace: BindingTrace, expectedType: JetType? = TypeUtils.NO_EXPECTED_TYPE): CompileTimeConstant<*>? {
-            val evaluator = ConstantExpressionEvaluator(trace)
-            val constant = evaluator.evaluate(expression, expectedType)
-            return if (constant !is ErrorValue) constant else null
-        }
-
-        platformStatic public fun isPropertyCompileTimeConstant(descriptor: VariableDescriptor): Boolean {
-            if (descriptor.isVar()) {
-                return false
+    internal fun resolveAnnotationArguments(
+            resolvedCall: ResolvedCall<*>,
+            trace: BindingTrace
+    ): Map<ValueParameterDescriptor, ConstantValue<*>> {
+        val arguments = HashMap<ValueParameterDescriptor, ConstantValue<*>>()
+        for ((parameterDescriptor, resolvedArgument) in resolvedCall.getValueArguments().entrySet()) {
+            val value = getAnnotationArgumentValue(trace, parameterDescriptor, resolvedArgument)
+            if (value != null) {
+                arguments.put(parameterDescriptor, value)
             }
-            if (DescriptorUtils.isObject(descriptor.getContainingDeclaration()) ||
-                DescriptorUtils.isStaticDeclaration(descriptor)) {
-                val returnType = descriptor.getType()
-                return KotlinBuiltIns.isPrimitiveType(returnType) || KotlinBuiltIns.isString(returnType)
-            }
-            return false
         }
+        return arguments
+    }
 
-        platformStatic public fun getConstant(expression: JetExpression, bindingContext: BindingContext): CompileTimeConstant<*>? {
-            val constant = getPossiblyErrorConstant(expression, bindingContext)
-            return if (constant !is ErrorValue) constant else null
+    public fun getAnnotationArgumentValue(
+            trace: BindingTrace,
+            parameterDescriptor: ValueParameterDescriptor,
+            resolvedArgument: ResolvedValueArgument
+    ): ConstantValue<*>? {
+        val varargElementType = parameterDescriptor.getVarargElementType()
+        val argumentsAsVararg = varargElementType != null && !hasSpread(resolvedArgument)
+        val constantType = if (argumentsAsVararg) varargElementType else parameterDescriptor.getType()
+        val compileTimeConstants = resolveValueArguments(resolvedArgument, constantType!!, trace)
+        val constants = compileTimeConstants.map { it.toConstantValue(constantType) }
+
+        if (argumentsAsVararg) {
+            if (parameterDescriptor.declaresDefaultValue() && compileTimeConstants.isEmpty()) return null
+
+            return constantValueFactory.createArrayValue(constants, parameterDescriptor.getType())
         }
-
-        platformStatic private fun getPossiblyErrorConstant(expression: JetExpression, bindingContext: BindingContext): CompileTimeConstant<*>? {
-            return bindingContext.get(BindingContext.COMPILE_TIME_VALUE, expression)
+        else {
+            // we should actually get only one element, but just in case of getting many, we take the last one
+            return constants.lastOrNull()
         }
     }
 
-    private fun evaluate(expression: JetExpression, expectedType: JetType?): CompileTimeConstant<*>? {
-        val recordedCompileTimeConstant = getPossiblyErrorConstant(expression, trace.getBindingContext())
+    private fun checkCompileTimeConstant(
+            argumentExpression: JetExpression,
+            expectedType: JetType,
+            trace: BindingTrace
+    ) {
+        val expressionType = trace.getType(argumentExpression)
+
+        if (expressionType == null || !JetTypeChecker.DEFAULT.isSubtypeOf(expressionType, expectedType)) {
+            // TYPE_MISMATCH should be reported otherwise
+            return
+        }
+
+        // array(1, <!>null<!>, 3) - error should be reported on inner expression
+        if (argumentExpression is JetCallExpression) {
+            val arrayArgument = getArgumentExpressionsForArrayCall(argumentExpression, trace)
+            if (arrayArgument != null) {
+                for (expression in arrayArgument.first) {
+                    checkCompileTimeConstant(expression, arrayArgument.second!!, trace)
+                }
+            }
+        }
+
+        val constant = ConstantExpressionEvaluator.getConstant(argumentExpression, trace.getBindingContext())
+        if (constant != null && constant.canBeUsedInAnnotations) {
+            return
+        }
+
+        val descriptor = expressionType.getConstructor().getDeclarationDescriptor()
+        if (descriptor != null && DescriptorUtils.isEnumClass(descriptor)) {
+            trace.report(Errors.ANNOTATION_PARAMETER_MUST_BE_ENUM_CONST.on(argumentExpression))
+        }
+        else if (descriptor is ClassDescriptor && KotlinBuiltIns.isKClass(descriptor)) {
+            trace.report(Errors.ANNOTATION_PARAMETER_MUST_BE_KCLASS_LITERAL.on(argumentExpression))
+        }
+        else {
+            trace.report(Errors.ANNOTATION_PARAMETER_MUST_BE_CONST.on(argumentExpression))
+        }
+    }
+
+    private fun getArgumentExpressionsForArrayCall(
+            expression: JetCallExpression,
+            trace: BindingTrace
+    ): Pair<List<JetExpression>, JetType?>? {
+        val resolvedCall = expression.getResolvedCall(trace.getBindingContext())
+        if (resolvedCall == null || !CompileTimeConstantUtils.isArrayMethodCall(resolvedCall)) {
+            return null
+        }
+
+        val argumentEntry = resolvedCall.getValueArguments().entrySet().single()
+
+        val elementType = argumentEntry.getKey().getVarargElementType() ?: return null
+
+        val result = arrayListOf<JetExpression>()
+        for (valueArgument in argumentEntry.getValue().getArguments()) {
+            val valueArgumentExpression = valueArgument.getArgumentExpression()
+            if (valueArgumentExpression != null) {
+                result.add(valueArgumentExpression)
+            }
+        }
+
+        return Pair<List<JetExpression>, JetType>(result, elementType)
+    }
+
+    private fun hasSpread(argument: ResolvedValueArgument): Boolean {
+        val arguments = argument.getArguments()
+        return arguments.size() == 1 && arguments.get(0).getSpreadElement() != null
+    }
+
+    private fun resolveValueArguments(
+            resolvedValueArgument: ResolvedValueArgument,
+            expectedType: JetType,
+            trace: BindingTrace): List<CompileTimeConstant<*>> {
+        val constants = ArrayList<CompileTimeConstant<*>>()
+        for (argument in resolvedValueArgument.getArguments()) {
+            val argumentExpression = argument.getArgumentExpression() ?: continue
+            val constant = ConstantExpressionEvaluator.evaluate(argumentExpression, trace, expectedType)
+            if (constant is IntegerValueTypeConstant) {
+                val defaultType = constant.getType(expectedType)
+                ArgumentTypeResolver.updateNumberType(defaultType, argumentExpression, StatementFilter.NONE, trace)
+            }
+            if (constant != null) {
+                constants.add(constant)
+            }
+            checkCompileTimeConstant(argumentExpression, expectedType, trace)
+        }
+        return constants
+    }
+
+    public fun evaluateExpression(
+            expression: JetExpression,
+            trace: BindingTrace,
+            expectedType: JetType? = TypeUtils.NO_EXPECTED_TYPE
+    ): CompileTimeConstant<*>? {
+        val visitor = ConstantExpressionEvaluatorVisitor(this, trace)
+        val constant = visitor.evaluate(expression, expectedType) ?: return null
+        return if (!constant.isError) constant else null
+    }
+
+    companion object {
+        platformStatic public fun evaluate(expression: JetExpression, trace: BindingTrace, expectedType: JetType? = TypeUtils.NO_EXPECTED_TYPE): CompileTimeConstant<*>? {
+            val builtIns = KotlinBuiltIns.getInstance()
+            return ConstantExpressionEvaluator(ConstantValueFactory(builtIns), builtIns).evaluateExpression(expression, trace, expectedType)
+        }
+
+        platformStatic public fun evaluateToConstantValue(
+                expression: JetExpression,
+                trace: BindingTrace,
+                expectedType: JetType
+        ): ConstantValue<*>? {
+            return evaluate(expression, trace, expectedType)?.toConstantValue(expectedType)
+        }
+
+        platformStatic public fun getConstant(expression: JetExpression, bindingContext: BindingContext): CompileTimeConstant<*>? {
+            val constant = getPossiblyErrorConstant(expression, bindingContext) ?: return null
+            return if (!constant.isError) constant else null
+        }
+
+        platformStatic fun getPossiblyErrorConstant(expression: JetExpression, bindingContext: BindingContext): CompileTimeConstant<*>? {
+            return bindingContext.get(BindingContext.COMPILE_TIME_VALUE, expression)
+        }
+    }
+}
+
+private class ConstantExpressionEvaluatorVisitor(
+        private val constantExpressionEvaluator: ConstantExpressionEvaluator,
+        private val trace: BindingTrace
+) : JetVisitor<CompileTimeConstant<*>?, JetType>() {
+
+    private val factory = constantExpressionEvaluator.constantValueFactory
+
+    fun evaluate(expression: JetExpression, expectedType: JetType?): CompileTimeConstant<*>? {
+        val recordedCompileTimeConstant = ConstantExpressionEvaluator.getPossiblyErrorConstant(expression, trace.getBindingContext())
         if (recordedCompileTimeConstant != null) {
             return recordedCompileTimeConstant
         }
@@ -84,41 +236,49 @@ public class ConstantExpressionEvaluator private constructor(val trace: BindingT
         return null
     }
 
-    private val stringExpressionEvaluator = object : JetVisitor<StringValue, Nothing>() {
-        fun evaluate(entry: JetStringTemplateEntry): StringValue? {
+    private val stringExpressionEvaluator = object : JetVisitor<TypedCompileTimeConstant<String>, Nothing?>() {
+        private fun createStringConstant(compileTimeConstant: CompileTimeConstant<*>): TypedCompileTimeConstant<String>? {
+            val constantValue = compileTimeConstant.toConstantValue(TypeUtils.NO_EXPECTED_TYPE)
+            return when (constantValue) {
+                is ErrorValue, is EnumValue -> return null
+                is NullValue -> factory.createStringValue("null")
+                else -> factory.createStringValue(constantValue.value.toString())
+            }.wrap(compileTimeConstant.parameters)
+        }
+
+        fun evaluate(entry: JetStringTemplateEntry): TypedCompileTimeConstant<String>? {
             return entry.accept(this, null)
         }
 
-        override fun visitStringTemplateEntryWithExpression(entry: JetStringTemplateEntryWithExpression, data: Nothing?): StringValue? {
-            val expression = entry.getExpression()
-            if (expression == null) return null
+        override fun visitStringTemplateEntryWithExpression(entry: JetStringTemplateEntryWithExpression, data: Nothing?): TypedCompileTimeConstant<String>? {
+            val expression = entry.getExpression() ?: return null
 
-            return createStringConstant(this@ConstantExpressionEvaluator.evaluate(expression, KotlinBuiltIns.getInstance().getStringType()))
+            return evaluate(expression, constantExpressionEvaluator.builtIns.getStringType())?.let {
+                createStringConstant(it)
+            }
         }
 
-        override fun visitLiteralStringTemplateEntry(entry: JetLiteralStringTemplateEntry, data: Nothing?) = StringValue(entry.getText(), true, false)
+        override fun visitLiteralStringTemplateEntry(entry: JetLiteralStringTemplateEntry, data: Nothing?) = factory.createStringValue(entry.getText()).wrap()
 
-        override fun visitEscapeStringTemplateEntry(entry: JetEscapeStringTemplateEntry, data: Nothing?) = StringValue(entry.getUnescapedValue(), true, false)
+        override fun visitEscapeStringTemplateEntry(entry: JetEscapeStringTemplateEntry, data: Nothing?) = factory.createStringValue(entry.getUnescapedValue()).wrap()
     }
 
     override fun visitConstantExpression(expression: JetConstantExpression, expectedType: JetType?): CompileTimeConstant<*>? {
-        val text = expression.getText()
-        if (text == null) return null
+        val text = expression.getText() ?: return null
 
         val nodeElementType = expression.getNode().getElementType()
-        if (nodeElementType == JetNodeTypes.NULL) return NullValue.NULL
+        if (nodeElementType == JetNodeTypes.NULL) return factory.createNullValue().wrap()
 
         val result: Any? = when (nodeElementType) {
-            JetNodeTypes.INTEGER_CONSTANT -> parseLong(text)
-            JetNodeTypes.FLOAT_CONSTANT -> parseFloatingLiteral(text)
-            JetNodeTypes.BOOLEAN_CONSTANT -> parseBoolean(text)
-            JetNodeTypes.CHARACTER_CONSTANT -> CompileTimeConstantChecker.parseChar(expression)
-            else -> throw IllegalArgumentException("Unsupported constant: " + expression)
-        }
-        if (result == null) return null
+                               JetNodeTypes.INTEGER_CONSTANT -> parseLong(text)
+                               JetNodeTypes.FLOAT_CONSTANT -> parseFloatingLiteral(text)
+                               JetNodeTypes.BOOLEAN_CONSTANT -> parseBoolean(text)
+                               JetNodeTypes.CHARACTER_CONSTANT -> CompileTimeConstantChecker.parseChar(expression)
+                               else -> throw IllegalArgumentException("Unsupported constant: " + expression)
+                           } ?: return null
 
         fun isLongWithSuffix() = nodeElementType == JetNodeTypes.INTEGER_CONSTANT && hasLongSuffix(text)
-        return createCompileTimeConstant(result, expectedType, !isLongWithSuffix(), true, false)
+        return createConstant(result, expectedType, CompileTimeConstant.Parameters(true, !isLongWithSuffix(), false))
     }
 
     override fun visitParenthesizedExpression(expression: JetParenthesizedExpression, expectedType: JetType?): CompileTimeConstant<*>? {
@@ -149,48 +309,57 @@ public class ConstantExpressionEvaluator private constructor(val trace: BindingT
                 break
             }
             else {
-                if (!constant.canBeUsedInAnnotations()) canBeUsedInAnnotation = false
-                if (constant.usesVariableAsConstant()) usesVariableAsConstant = true
-                sb.append(constant.getValue())
+                if (!constant.canBeUsedInAnnotations) canBeUsedInAnnotation = false
+                if (constant.usesVariableAsConstant) usesVariableAsConstant = true
+                sb.append(constant.constantValue.value)
             }
         }
         return if (!interupted)
-                    createCompileTimeConstant(sb.toString(), expectedType,
-                                               isPure = true, canBeUsedInAnnotation = canBeUsedInAnnotation,
-                                               usesVariableAsConstant = usesVariableAsConstant)
-               else null
+            createConstant(
+                    sb.toString(),
+                    expectedType,
+                    CompileTimeConstant.Parameters(
+                            isPure = false,
+                            canBeUsedInAnnotation = canBeUsedInAnnotation,
+                            usesVariableAsConstant = usesVariableAsConstant
+                    )
+            )
+        else null
     }
 
     override fun visitBinaryWithTypeRHSExpression(expression: JetBinaryExpressionWithTypeRHS, expectedType: JetType?): CompileTimeConstant<*>? =
-        evaluate(expression.getLeft(), expectedType)
+            evaluate(expression.getLeft(), expectedType)
 
     override fun visitBinaryExpression(expression: JetBinaryExpression, expectedType: JetType?): CompileTimeConstant<*>? {
-        val leftExpression = expression.getLeft()
-        if (leftExpression == null) return null
+        val leftExpression = expression.getLeft() ?: return null
 
         val operationToken = expression.getOperationToken()
         if (OperatorConventions.BOOLEAN_OPERATIONS.containsKey(operationToken)) {
-            val booleanType = KotlinBuiltIns.getInstance().getBooleanType()
+            val booleanType = constantExpressionEvaluator.builtIns.getBooleanType()
             val leftConstant = evaluate(leftExpression, booleanType)
             if (leftConstant == null) return null
 
-            val rightExpression = expression.getRight()
-            if (rightExpression == null) return null
+            val rightExpression = expression.getRight() ?: return null
 
-            val rightConstant = evaluate(rightExpression, booleanType)
-            if (rightConstant == null) return null
+            val rightConstant = evaluate(rightExpression, booleanType) ?: return null
 
-            val leftValue = leftConstant.getValue()
-            val rightValue = rightConstant.getValue()
+            val leftValue = leftConstant.getValue(booleanType)
+            val rightValue = rightConstant.getValue(booleanType)
 
             if (leftValue !is Boolean || rightValue !is Boolean) return null
-            val result = when(operationToken) {
+            val result = when (operationToken) {
                 JetTokens.ANDAND -> leftValue && rightValue
                 JetTokens.OROR -> leftValue || rightValue
                 else -> throw IllegalArgumentException("Unknown boolean operation token ${operationToken}")
             }
-            val usesVariableAsConstant = leftConstant.usesVariableAsConstant() || rightConstant.usesVariableAsConstant()
-            return createCompileTimeConstant(result, expectedType, true, true, usesVariableAsConstant)
+            return createConstant(
+                    result, expectedType,
+                    CompileTimeConstant.Parameters(
+                            canBeUsedInAnnotation = true,
+                            isPure = false,
+                            usesVariableAsConstant = leftConstant.usesVariableAsConstant || rightConstant.usesVariableAsConstant
+                    )
+            )
         }
         else {
             return evaluateCall(expression.getOperationReference(), leftExpression, expectedType)
@@ -214,11 +383,14 @@ public class ConstantExpressionEvaluator private constructor(val trace: BindingT
             val canBeUsedInAnnotation = canBeUsedInAnnotation(argumentForReceiver.expression)
             val usesVariableAsConstant = usesVariableAsConstant(argumentForReceiver.expression)
             val isNumberConversionMethod = resultingDescriptorName in OperatorConventions.NUMBER_CONVERSIONS
-            return createCompileTimeConstant(result,
-                                             expectedType,
-                                             !isNumberConversionMethod && isArgumentPure,
-                                             canBeUsedInAnnotation,
-                                             usesVariableAsConstant)
+            return createConstant(
+                    result,
+                    expectedType,
+                    CompileTimeConstant.Parameters(
+                            canBeUsedInAnnotation,
+                            !isNumberConversionMethod && isArgumentPure,
+                            usesVariableAsConstant)
+            )
         }
         else if (argumentsEntrySet.size() == 1) {
             val (parameter, argument) = argumentsEntrySet.first()
@@ -226,9 +398,9 @@ public class ConstantExpressionEvaluator private constructor(val trace: BindingT
             if (argumentForParameter == null) return null
 
             if (isDivisionByZero(resultingDescriptorName.asString(), argumentForParameter.value)) {
-                val parentExpression: JetExpression = PsiTreeUtil.getParentOfType(receiverExpression, javaClass())
+                val parentExpression: JetExpression = PsiTreeUtil.getParentOfType(receiverExpression, javaClass())!!
                 trace.report(Errors.DIVISION_BY_ZERO.on(parentExpression))
-                return ErrorValue.create("Division by zero")
+                return factory.createErrorValue("Division by zero").wrap()
             }
 
             val result = evaluateBinaryAndCheck(argumentForReceiver, argumentForParameter, resultingDescriptorName.asString(), callExpression)
@@ -237,12 +409,12 @@ public class ConstantExpressionEvaluator private constructor(val trace: BindingT
             val areArgumentsPure = isPureConstant(argumentForReceiver.expression) && isPureConstant(argumentForParameter.expression)
             val canBeUsedInAnnotation = canBeUsedInAnnotation(argumentForReceiver.expression) && canBeUsedInAnnotation(argumentForParameter.expression)
             val usesVariableAsConstant = usesVariableAsConstant(argumentForReceiver.expression) || usesVariableAsConstant(argumentForParameter.expression)
-            val c = EvaluatorContext(canBeUsedInAnnotation, areArgumentsPure, usesVariableAsConstant)
-            return when(resultingDescriptorName) {
-                OperatorConventions.COMPARE_TO -> createCompileTimeConstantForCompareTo(result, callExpression, c)
-                OperatorConventions.EQUALS -> createCompileTimeConstantForEquals(result, callExpression, c)
+            val parameters = CompileTimeConstant.Parameters(canBeUsedInAnnotation, areArgumentsPure, usesVariableAsConstant)
+            return when (resultingDescriptorName) {
+                OperatorConventions.COMPARE_TO -> createCompileTimeConstantForCompareTo(result, callExpression, factory)?.wrap(parameters)
+                OperatorConventions.EQUALS -> createCompileTimeConstantForEquals(result, callExpression, factory)?.wrap(parameters)
                 else -> {
-                    createCompileTimeConstant(result, expectedType, areArgumentsPure, canBeUsedInAnnotation, usesVariableAsConstant)
+                    createConstant(result, expectedType, parameters)
                 }
             }
         }
@@ -250,17 +422,11 @@ public class ConstantExpressionEvaluator private constructor(val trace: BindingT
         return null
     }
 
-    private fun usesVariableAsConstant(expression: JetExpression) = getConstant(expression, trace.getBindingContext())?.usesVariableAsConstant() ?: false
+    private fun usesVariableAsConstant(expression: JetExpression) = ConstantExpressionEvaluator.getConstant(expression, trace.getBindingContext())?.usesVariableAsConstant ?: false
 
-    private fun canBeUsedInAnnotation(expression: JetExpression) = getConstant(expression, trace.getBindingContext())?.canBeUsedInAnnotations() ?: false
+    private fun canBeUsedInAnnotation(expression: JetExpression) = ConstantExpressionEvaluator.getConstant(expression, trace.getBindingContext())?.canBeUsedInAnnotations ?: false
 
-    private fun isPureConstant(expression: JetExpression): Boolean {
-        val compileTimeConstant = getConstant(expression, trace.getBindingContext())
-        if (compileTimeConstant is IntegerValueConstant) {
-            return compileTimeConstant.isPure()
-        }
-        return false
-    }
+    private fun isPureConstant(expression: JetExpression) = ConstantExpressionEvaluator.getConstant(expression, trace.getBindingContext())?.isPure ?: false
 
     private fun evaluateUnaryAndCheck(receiver: OperationArgument, name: String, callExpression: JetExpression): Any? {
         val functions = unaryOperations[UnaryOperationKey(receiver.ctcType, name)]
@@ -287,7 +453,8 @@ public class ConstantExpressionEvaluator private constructor(val trace: BindingT
         val (function, checker) = functions
         val actualResult = try {
             function(receiver.value, parameter.value)
-        } catch (e: Exception) {
+        }
+        catch (e: Exception) {
             null
         }
         if (checker == emptyBinaryFun) {
@@ -327,29 +494,41 @@ public class ConstantExpressionEvaluator private constructor(val trace: BindingT
     override fun visitSimpleNameExpression(expression: JetSimpleNameExpression, expectedType: JetType?): CompileTimeConstant<*>? {
         val enumDescriptor = trace.getBindingContext().get(BindingContext.REFERENCE_TARGET, expression);
         if (enumDescriptor != null && DescriptorUtils.isEnumEntry(enumDescriptor)) {
-            return EnumValue(enumDescriptor as ClassDescriptor, false);
+            return factory.createEnumValue(enumDescriptor as ClassDescriptor).wrap()
         }
 
         val resolvedCall = expression.getResolvedCall(trace.getBindingContext())
         if (resolvedCall != null) {
             val callableDescriptor = resolvedCall.getResultingDescriptor()
             if (callableDescriptor is VariableDescriptor) {
-                val compileTimeConstant = callableDescriptor.getCompileTimeInitializer()
-                if (compileTimeConstant == null) return null
+                val variableInitializer = callableDescriptor.getCompileTimeInitializer() ?: return null
 
-                val value: Any? =
-                        if (compileTimeConstant is IntegerValueTypeConstant)
-                            compileTimeConstant.getValue(expectedType ?: TypeUtils.NO_EXPECTED_TYPE)
-                        else
-                            compileTimeConstant.getValue()
-                return createCompileTimeConstant(value, expectedType, isPure = false,
-                                                 canBeUsedInAnnotation = isPropertyCompileTimeConstant(callableDescriptor),
-                                                 usesVariableAsConstant = true)
+                return createConstant(
+                        variableInitializer.value,
+                        expectedType,
+                        CompileTimeConstant.Parameters(
+                                canBeUsedInAnnotation = isPropertyCompileTimeConstant(callableDescriptor),
+                                isPure = false,
+                                usesVariableAsConstant = true
+                        )
+                )
             }
         }
         return null
     }
 
+    private fun isPropertyCompileTimeConstant(descriptor: VariableDescriptor): Boolean {
+        if (descriptor.isVar()) {
+            return false
+        }
+        if (DescriptorUtils.isObject(descriptor.getContainingDeclaration()) ||
+            DescriptorUtils.isStaticDeclaration(descriptor)) {
+            val returnType = descriptor.getType()
+            return KotlinBuiltIns.isPrimitiveType(returnType) || KotlinBuiltIns.isString(returnType)
+        }
+        return false
+    }
+
     override fun visitQualifiedExpression(expression: JetQualifiedExpression, expectedType: JetType?): CompileTimeConstant<*>? {
         val selectorExpression = expression.getSelectorExpression()
         // 1.toInt(); 1.plus(1);
@@ -387,7 +566,11 @@ public class ConstantExpressionEvaluator private constructor(val trace: BindingT
             val varargType = resultingDescriptor.getValueParameters().first().getVarargElementType()!!
 
             val arguments = call.getValueArguments().values().flatMap { resolveArguments(it.getArguments(), varargType) }
-            return ArrayValue(arguments, resultingDescriptor.getReturnType()!!, true, arguments.any() { it.usesVariableAsConstant() })
+
+            return factory.createArrayValue(arguments.map { it.toConstantValue(varargType) }, resultingDescriptor.getReturnType()!!).
+                    wrap(
+                            usesVariableAsConstant = arguments.any { it.usesVariableAsConstant }
+                    )
         }
 
         // Ann()
@@ -396,9 +579,9 @@ public class ConstantExpressionEvaluator private constructor(val trace: BindingT
             if (DescriptorUtils.isAnnotationClass(classDescriptor)) {
                 val descriptor = AnnotationDescriptorImpl(
                         classDescriptor.getDefaultType(),
-                        AnnotationResolver.resolveAnnotationArguments(call, trace)
+                        constantExpressionEvaluator.resolveAnnotationArguments(call, trace)
                 )
-                return AnnotationValue(descriptor)
+                return AnnotationValue(descriptor).wrap()
             }
         }
 
@@ -406,9 +589,9 @@ public class ConstantExpressionEvaluator private constructor(val trace: BindingT
     }
 
     override fun visitClassLiteralExpression(expression: JetClassLiteralExpression, expectedType: JetType?): CompileTimeConstant<*>? {
-        val jetType = trace.getType(expression)
+        val jetType = trace.getType(expression)!!
         if (jetType.isError()) return null
-        return KClassValue(jetType)
+        return KClassValue(jetType).wrap()
     }
 
     private fun resolveArguments(valueArguments: List<ValueArgument>, expectedType: JetType): List<CompileTimeConstant<*>> {
@@ -454,32 +637,63 @@ public class ConstantExpressionEvaluator private constructor(val trace: BindingT
     }
 
     private fun createOperationArgument(expression: JetExpression, expressionType: JetType, compileTimeType: CompileTimeType<*>): OperationArgument? {
-        val evaluatedConstant = evaluate(expression, trace, expressionType)
-        if (evaluatedConstant == null) return null
-
-        if (evaluatedConstant is IntegerValueTypeConstant) {
-            val evaluationResultWithNewType = evaluatedConstant.getValue(expressionType)
-            return OperationArgument(evaluationResultWithNewType, compileTimeType, expression)
-        }
-
-        val evaluationResult = evaluatedConstant.getValue()
-        if (evaluationResult == null) return null
-
+        val compileTimeConstant = constantExpressionEvaluator.evaluateExpression(expression, trace, expressionType) ?: return null
+        val evaluationResult = compileTimeConstant.getValue(expressionType) ?: return null
         return OperationArgument(evaluationResult, compileTimeType, expression)
     }
 
-    fun createCompileTimeConstant(value: Any?,
-                                  expectedType: JetType?,
-                                  isPure: Boolean = true,
-                                  canBeUsedInAnnotation: Boolean = true,
-                                  usesVariableAsConstant: Boolean = false): CompileTimeConstant<*>? {
-        val c = EvaluatorContext(canBeUsedInAnnotation, isPure, usesVariableAsConstant)
-        return createCompileTimeConstant(value, c, if (isPure) expectedType ?: TypeUtils.NO_EXPECTED_TYPE else null)
+    private fun createConstant(
+            value: Any?,
+            expectedType: JetType?,
+            parameters: CompileTimeConstant.Parameters
+    ): CompileTimeConstant<*>? {
+        return if (parameters.isPure) {
+            return createCompileTimeConstant(value, parameters, expectedType ?: TypeUtils.NO_EXPECTED_TYPE)
+        }
+        else {
+            factory.createConstantValue(value)?.wrap(parameters)
+        }
     }
-}
 
-public fun IntegerValueTypeConstant.createCompileTimeConstantWithType(expectedType: JetType): CompileTimeConstant<*>?
-        = createCompileTimeConstant(this.getValue(expectedType), EvaluatorContext(this.canBeUsedInAnnotations(), true))
+    private fun createCompileTimeConstant(
+            value: Any?,
+            parameters: CompileTimeConstant.Parameters,
+            expectedType: JetType
+    ): CompileTimeConstant<*>? {
+        return when (value) {
+            is Byte, is Short, is Int, is Long -> createIntegerCompileTimeConstant((value as Number).toLong(), parameters, expectedType)
+            else -> factory.createConstantValue(value)?.wrap(parameters)
+        }
+    }
+
+    private fun createIntegerCompileTimeConstant(
+            value: Long,
+            parameters: CompileTimeConstant.Parameters,
+            expectedType: JetType
+    ): CompileTimeConstant<*>? {
+        if (TypeUtils.noExpectedType(expectedType) || expectedType.isError()) {
+            return IntegerValueTypeConstant(value, parameters)
+        }
+        val integerValue = factory.createIntegerConstantValue(value, expectedType)
+        if (integerValue != null) {
+            return integerValue.wrap(parameters)
+        }
+        return when (value) {
+            value.toInt().toLong() -> factory.createIntValue(value.toInt())
+            else -> factory.createLongValue(value)
+        }.wrap(parameters)
+    }
+
+    private fun <T> ConstantValue<T>.wrap(parameters: CompileTimeConstant.Parameters): TypedCompileTimeConstant<T>
+            = TypedCompileTimeConstant(this, parameters)
+
+    private fun <T> ConstantValue<T>.wrap(
+            canBeUsedInAnnotation: Boolean = this !is NullValue,
+            isPure: Boolean = false,
+            usesVariableAsConstant: Boolean = false
+    ): TypedCompileTimeConstant<T>
+            = wrap(CompileTimeConstant.Parameters(canBeUsedInAnnotation, isPure, usesVariableAsConstant))
+}
 
 private fun hasLongSuffix(text: String) = text.endsWith('l') || text.endsWith('L')
 
@@ -536,35 +750,36 @@ private fun parseBoolean(text: String): Boolean {
 }
 
 
-private fun createCompileTimeConstantForEquals(result: Any?, operationReference: JetExpression, c: EvaluatorContext): CompileTimeConstant<*>? {
+private fun createCompileTimeConstantForEquals(result: Any?, operationReference: JetExpression, factory: ConstantValueFactory): ConstantValue<*>? {
     if (result is Boolean) {
         assert(operationReference is JetSimpleNameExpression, "This method should be called only for equals operations")
         val operationToken = (operationReference as JetSimpleNameExpression).getReferencedNameElementType()
-        return when (operationToken) {
-            JetTokens.EQEQ -> BooleanValue(result, c.canBeUsedInAnnotation, c.usesVariableAsConstant)
-            JetTokens.EXCLEQ -> BooleanValue(!result, c.canBeUsedInAnnotation, c.usesVariableAsConstant)
+        val value: Boolean = when (operationToken) {
+            JetTokens.EQEQ -> result
+            JetTokens.EXCLEQ -> !result
             JetTokens.IDENTIFIER -> {
                 assert (operationReference.getReferencedNameAsName() == OperatorConventions.EQUALS, "This method should be called only for equals operations")
-                return BooleanValue(result, c.canBeUsedInAnnotation, c.usesVariableAsConstant)
+                result
             }
             else -> throw IllegalStateException("Unknown equals operation token: $operationToken ${operationReference.getText()}")
         }
+        return factory.createBooleanValue(value)
     }
     return null
 }
 
-private fun createCompileTimeConstantForCompareTo(result: Any?, operationReference: JetExpression, c: EvaluatorContext): CompileTimeConstant<*>? {
+private fun createCompileTimeConstantForCompareTo(result: Any?, operationReference: JetExpression, factory: ConstantValueFactory): ConstantValue<*>? {
     if (result is Int) {
         assert(operationReference is JetSimpleNameExpression, "This method should be called only for compareTo operations")
         val operationToken = (operationReference as JetSimpleNameExpression).getReferencedNameElementType()
         return when (operationToken) {
-            JetTokens.LT -> BooleanValue(result < 0, c.canBeUsedInAnnotation, c.usesVariableAsConstant)
-            JetTokens.LTEQ -> BooleanValue(result <= 0, c.canBeUsedInAnnotation, c.usesVariableAsConstant)
-            JetTokens.GT -> BooleanValue(result > 0, c.canBeUsedInAnnotation, c.usesVariableAsConstant)
-            JetTokens.GTEQ -> BooleanValue(result >= 0, c.canBeUsedInAnnotation, c.usesVariableAsConstant)
+            JetTokens.LT -> factory.createBooleanValue(result < 0)
+            JetTokens.LTEQ -> factory.createBooleanValue(result <= 0)
+            JetTokens.GT -> factory.createBooleanValue(result > 0)
+            JetTokens.GTEQ -> factory.createBooleanValue(result >= 0)
             JetTokens.IDENTIFIER -> {
                 assert (operationReference.getReferencedNameAsName() == OperatorConventions.COMPARE_TO, "This method should be called only for compareTo operations")
-                return IntValue(result, c.canBeUsedInAnnotation, c.isPure, c.usesVariableAsConstant)
+                return factory.createIntValue(result)
             }
             else -> throw IllegalStateException("Unknown compareTo operation token: $operationToken")
         }
@@ -572,23 +787,6 @@ private fun createCompileTimeConstantForCompareTo(result: Any?, operationReferen
     return null
 }
 
-private fun createStringConstant(value: CompileTimeConstant<*>?): StringValue? {
-    return when (value) {
-        is IntegerValueTypeConstant -> StringValue(value.getValue(TypeUtils.NO_EXPECTED_TYPE).toString(), value.canBeUsedInAnnotations(), value.usesVariableAsConstant())
-        is StringValue -> value
-        is IntValue, is ByteValue, is ShortValue, is LongValue,
-        is CharValue,
-        is DoubleValue, is FloatValue,
-        is BooleanValue,
-        is NullValue -> StringValue("${value.getValue()}", value.canBeUsedInAnnotations(), value.usesVariableAsConstant())
-        else -> null
-    }
-}
-
-private fun createCompileTimeConstant(value: Any?, c: EvaluatorContext, expectedType: JetType? = null): CompileTimeConstant<*>? {
-    return createCompileTimeConstant(value, c.canBeUsedInAnnotation, c.isPure, c.usesVariableAsConstant, expectedType)
-}
-
 fun isIntegerType(value: Any?) = value is Byte || value is Short || value is Int || value is Long
 
 private fun getReceiverExpressionType(resolvedCall: ResolvedCall<*>): JetType? {
@@ -618,8 +816,6 @@ private fun getCompileTimeType(c: JetType): CompileTimeType<out Any>? {
     }
 }
 
-private class EvaluatorContext(val canBeUsedInAnnotation: Boolean, val isPure: Boolean, val usesVariableAsConstant: Boolean = false)
-
 private class CompileTimeType<T>
 
 private val BYTE = CompileTimeType<Byte>()
@@ -652,4 +848,3 @@ private fun <A> unaryOperation(
 
 private data class BinaryOperationKey<A, B>(val f: CompileTimeType<out A>, val s: CompileTimeType<out B>, val functionName: String)
 private data class UnaryOperationKey<A>(val f: CompileTimeType<out A>, val functionName: String)
-
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/constants/evaluate/OperationsMapGenerated.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/constants/evaluate/OperationsMapGenerated.kt
index 6b8824c4241..8febef7e49b 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/constants/evaluate/OperationsMapGenerated.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/constants/evaluate/OperationsMapGenerated.kt
@@ -38,8 +38,6 @@ private val unaryOperations: HashMap<UnaryOperationKey<*>, Pair<Function1<Any?,
     unaryOperation(BYTE, "toLong", { a -> a.toLong() }, emptyUnaryFun),
     unaryOperation(BYTE, "toShort", { a -> a.toShort() }, emptyUnaryFun),
     unaryOperation(BYTE, "toString", { a -> a.toString() }, emptyUnaryFun),
-    unaryOperation(CHAR, "minus", { a -> a.minus() }, emptyUnaryFun),
-    unaryOperation(CHAR, "plus", { a -> a.plus() }, emptyUnaryFun),
     unaryOperation(CHAR, "toByte", { a -> a.toByte() }, emptyUnaryFun),
     unaryOperation(CHAR, "toChar", { a -> a.toChar() }, emptyUnaryFun),
     unaryOperation(CHAR, "toDouble", { a -> a.toDouble() }, emptyUnaryFun),
@@ -112,124 +110,78 @@ private val binaryOperations: HashMap<BinaryOperationKey<*, *>, Pair<Function2<A
     binaryOperation(BOOLEAN, BOOLEAN, "xor", { a, b -> a.xor(b) }, emptyBinaryFun),
     binaryOperation(BOOLEAN, ANY, "equals", { a, b -> a.equals(b) }, emptyBinaryFun),
     binaryOperation(BYTE, BYTE, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
-    binaryOperation(BYTE, CHAR, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
     binaryOperation(BYTE, DOUBLE, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
     binaryOperation(BYTE, FLOAT, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
     binaryOperation(BYTE, INT, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
     binaryOperation(BYTE, LONG, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
     binaryOperation(BYTE, SHORT, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
     binaryOperation(BYTE, BYTE, "div", { a, b -> a.div(b) }, { a, b -> a.divide(b) }),
-    binaryOperation(BYTE, CHAR, "div", { a, b -> a.div(b) }, emptyBinaryFun),
     binaryOperation(BYTE, DOUBLE, "div", { a, b -> a.div(b) }, emptyBinaryFun),
     binaryOperation(BYTE, FLOAT, "div", { a, b -> a.div(b) }, emptyBinaryFun),
     binaryOperation(BYTE, INT, "div", { a, b -> a.div(b) }, { a, b -> a.divide(b) }),
     binaryOperation(BYTE, LONG, "div", { a, b -> a.div(b) }, { a, b -> a.divide(b) }),
     binaryOperation(BYTE, SHORT, "div", { a, b -> a.div(b) }, { a, b -> a.divide(b) }),
     binaryOperation(BYTE, BYTE, "minus", { a, b -> a.minus(b) }, { a, b -> a.subtract(b) }),
-    binaryOperation(BYTE, CHAR, "minus", { a, b -> a.minus(b) }, emptyBinaryFun),
     binaryOperation(BYTE, DOUBLE, "minus", { a, b -> a.minus(b) }, emptyBinaryFun),
     binaryOperation(BYTE, FLOAT, "minus", { a, b -> a.minus(b) }, emptyBinaryFun),
     binaryOperation(BYTE, INT, "minus", { a, b -> a.minus(b) }, { a, b -> a.subtract(b) }),
     binaryOperation(BYTE, LONG, "minus", { a, b -> a.minus(b) }, { a, b -> a.subtract(b) }),
     binaryOperation(BYTE, SHORT, "minus", { a, b -> a.minus(b) }, { a, b -> a.subtract(b) }),
     binaryOperation(BYTE, BYTE, "mod", { a, b -> a.mod(b) }, { a, b -> a.mod(b) }),
-    binaryOperation(BYTE, CHAR, "mod", { a, b -> a.mod(b) }, emptyBinaryFun),
     binaryOperation(BYTE, DOUBLE, "mod", { a, b -> a.mod(b) }, emptyBinaryFun),
     binaryOperation(BYTE, FLOAT, "mod", { a, b -> a.mod(b) }, emptyBinaryFun),
     binaryOperation(BYTE, INT, "mod", { a, b -> a.mod(b) }, { a, b -> a.mod(b) }),
     binaryOperation(BYTE, LONG, "mod", { a, b -> a.mod(b) }, { a, b -> a.mod(b) }),
     binaryOperation(BYTE, SHORT, "mod", { a, b -> a.mod(b) }, { a, b -> a.mod(b) }),
     binaryOperation(BYTE, BYTE, "plus", { a, b -> a.plus(b) }, { a, b -> a.add(b) }),
-    binaryOperation(BYTE, CHAR, "plus", { a, b -> a.plus(b) }, emptyBinaryFun),
     binaryOperation(BYTE, DOUBLE, "plus", { a, b -> a.plus(b) }, emptyBinaryFun),
     binaryOperation(BYTE, FLOAT, "plus", { a, b -> a.plus(b) }, emptyBinaryFun),
     binaryOperation(BYTE, INT, "plus", { a, b -> a.plus(b) }, { a, b -> a.add(b) }),
     binaryOperation(BYTE, LONG, "plus", { a, b -> a.plus(b) }, { a, b -> a.add(b) }),
     binaryOperation(BYTE, SHORT, "plus", { a, b -> a.plus(b) }, { a, b -> a.add(b) }),
     binaryOperation(BYTE, BYTE, "times", { a, b -> a.times(b) }, { a, b -> a.multiply(b) }),
-    binaryOperation(BYTE, CHAR, "times", { a, b -> a.times(b) }, emptyBinaryFun),
     binaryOperation(BYTE, DOUBLE, "times", { a, b -> a.times(b) }, emptyBinaryFun),
     binaryOperation(BYTE, FLOAT, "times", { a, b -> a.times(b) }, emptyBinaryFun),
     binaryOperation(BYTE, INT, "times", { a, b -> a.times(b) }, { a, b -> a.multiply(b) }),
     binaryOperation(BYTE, LONG, "times", { a, b -> a.times(b) }, { a, b -> a.multiply(b) }),
     binaryOperation(BYTE, SHORT, "times", { a, b -> a.times(b) }, { a, b -> a.multiply(b) }),
     binaryOperation(BYTE, ANY, "equals", { a, b -> a.equals(b) }, emptyBinaryFun),
-    binaryOperation(CHAR, BYTE, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
     binaryOperation(CHAR, CHAR, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
-    binaryOperation(CHAR, DOUBLE, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
-    binaryOperation(CHAR, FLOAT, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
-    binaryOperation(CHAR, INT, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
-    binaryOperation(CHAR, LONG, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
-    binaryOperation(CHAR, SHORT, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
-    binaryOperation(CHAR, BYTE, "div", { a, b -> a.div(b) }, emptyBinaryFun),
-    binaryOperation(CHAR, DOUBLE, "div", { a, b -> a.div(b) }, emptyBinaryFun),
-    binaryOperation(CHAR, FLOAT, "div", { a, b -> a.div(b) }, emptyBinaryFun),
-    binaryOperation(CHAR, INT, "div", { a, b -> a.div(b) }, emptyBinaryFun),
-    binaryOperation(CHAR, LONG, "div", { a, b -> a.div(b) }, emptyBinaryFun),
-    binaryOperation(CHAR, SHORT, "div", { a, b -> a.div(b) }, emptyBinaryFun),
-    binaryOperation(CHAR, BYTE, "minus", { a, b -> a.minus(b) }, emptyBinaryFun),
     binaryOperation(CHAR, CHAR, "minus", { a, b -> a.minus(b) }, emptyBinaryFun),
-    binaryOperation(CHAR, DOUBLE, "minus", { a, b -> a.minus(b) }, emptyBinaryFun),
-    binaryOperation(CHAR, FLOAT, "minus", { a, b -> a.minus(b) }, emptyBinaryFun),
     binaryOperation(CHAR, INT, "minus", { a, b -> a.minus(b) }, emptyBinaryFun),
-    binaryOperation(CHAR, LONG, "minus", { a, b -> a.minus(b) }, emptyBinaryFun),
-    binaryOperation(CHAR, SHORT, "minus", { a, b -> a.minus(b) }, emptyBinaryFun),
-    binaryOperation(CHAR, BYTE, "mod", { a, b -> a.mod(b) }, emptyBinaryFun),
-    binaryOperation(CHAR, DOUBLE, "mod", { a, b -> a.mod(b) }, emptyBinaryFun),
-    binaryOperation(CHAR, FLOAT, "mod", { a, b -> a.mod(b) }, emptyBinaryFun),
-    binaryOperation(CHAR, INT, "mod", { a, b -> a.mod(b) }, emptyBinaryFun),
-    binaryOperation(CHAR, LONG, "mod", { a, b -> a.mod(b) }, emptyBinaryFun),
-    binaryOperation(CHAR, SHORT, "mod", { a, b -> a.mod(b) }, emptyBinaryFun),
-    binaryOperation(CHAR, BYTE, "plus", { a, b -> a.plus(b) }, emptyBinaryFun),
-    binaryOperation(CHAR, DOUBLE, "plus", { a, b -> a.plus(b) }, emptyBinaryFun),
-    binaryOperation(CHAR, FLOAT, "plus", { a, b -> a.plus(b) }, emptyBinaryFun),
     binaryOperation(CHAR, INT, "plus", { a, b -> a.plus(b) }, emptyBinaryFun),
-    binaryOperation(CHAR, LONG, "plus", { a, b -> a.plus(b) }, emptyBinaryFun),
-    binaryOperation(CHAR, SHORT, "plus", { a, b -> a.plus(b) }, emptyBinaryFun),
-    binaryOperation(CHAR, BYTE, "times", { a, b -> a.times(b) }, emptyBinaryFun),
-    binaryOperation(CHAR, DOUBLE, "times", { a, b -> a.times(b) }, emptyBinaryFun),
-    binaryOperation(CHAR, FLOAT, "times", { a, b -> a.times(b) }, emptyBinaryFun),
-    binaryOperation(CHAR, INT, "times", { a, b -> a.times(b) }, emptyBinaryFun),
-    binaryOperation(CHAR, LONG, "times", { a, b -> a.times(b) }, emptyBinaryFun),
-    binaryOperation(CHAR, SHORT, "times", { a, b -> a.times(b) }, emptyBinaryFun),
     binaryOperation(CHAR, ANY, "equals", { a, b -> a.equals(b) }, emptyBinaryFun),
     binaryOperation(DOUBLE, BYTE, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
-    binaryOperation(DOUBLE, CHAR, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
     binaryOperation(DOUBLE, DOUBLE, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
     binaryOperation(DOUBLE, FLOAT, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
     binaryOperation(DOUBLE, INT, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
     binaryOperation(DOUBLE, LONG, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
     binaryOperation(DOUBLE, SHORT, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
     binaryOperation(DOUBLE, BYTE, "div", { a, b -> a.div(b) }, emptyBinaryFun),
-    binaryOperation(DOUBLE, CHAR, "div", { a, b -> a.div(b) }, emptyBinaryFun),
     binaryOperation(DOUBLE, DOUBLE, "div", { a, b -> a.div(b) }, emptyBinaryFun),
     binaryOperation(DOUBLE, FLOAT, "div", { a, b -> a.div(b) }, emptyBinaryFun),
     binaryOperation(DOUBLE, INT, "div", { a, b -> a.div(b) }, emptyBinaryFun),
     binaryOperation(DOUBLE, LONG, "div", { a, b -> a.div(b) }, emptyBinaryFun),
     binaryOperation(DOUBLE, SHORT, "div", { a, b -> a.div(b) }, emptyBinaryFun),
     binaryOperation(DOUBLE, BYTE, "minus", { a, b -> a.minus(b) }, emptyBinaryFun),
-    binaryOperation(DOUBLE, CHAR, "minus", { a, b -> a.minus(b) }, emptyBinaryFun),
     binaryOperation(DOUBLE, DOUBLE, "minus", { a, b -> a.minus(b) }, emptyBinaryFun),
     binaryOperation(DOUBLE, FLOAT, "minus", { a, b -> a.minus(b) }, emptyBinaryFun),
     binaryOperation(DOUBLE, INT, "minus", { a, b -> a.minus(b) }, emptyBinaryFun),
     binaryOperation(DOUBLE, LONG, "minus", { a, b -> a.minus(b) }, emptyBinaryFun),
     binaryOperation(DOUBLE, SHORT, "minus", { a, b -> a.minus(b) }, emptyBinaryFun),
     binaryOperation(DOUBLE, BYTE, "mod", { a, b -> a.mod(b) }, emptyBinaryFun),
-    binaryOperation(DOUBLE, CHAR, "mod", { a, b -> a.mod(b) }, emptyBinaryFun),
     binaryOperation(DOUBLE, DOUBLE, "mod", { a, b -> a.mod(b) }, emptyBinaryFun),
     binaryOperation(DOUBLE, FLOAT, "mod", { a, b -> a.mod(b) }, emptyBinaryFun),
     binaryOperation(DOUBLE, INT, "mod", { a, b -> a.mod(b) }, emptyBinaryFun),
     binaryOperation(DOUBLE, LONG, "mod", { a, b -> a.mod(b) }, emptyBinaryFun),
     binaryOperation(DOUBLE, SHORT, "mod", { a, b -> a.mod(b) }, emptyBinaryFun),
     binaryOperation(DOUBLE, BYTE, "plus", { a, b -> a.plus(b) }, emptyBinaryFun),
-    binaryOperation(DOUBLE, CHAR, "plus", { a, b -> a.plus(b) }, emptyBinaryFun),
     binaryOperation(DOUBLE, DOUBLE, "plus", { a, b -> a.plus(b) }, emptyBinaryFun),
     binaryOperation(DOUBLE, FLOAT, "plus", { a, b -> a.plus(b) }, emptyBinaryFun),
     binaryOperation(DOUBLE, INT, "plus", { a, b -> a.plus(b) }, emptyBinaryFun),
     binaryOperation(DOUBLE, LONG, "plus", { a, b -> a.plus(b) }, emptyBinaryFun),
     binaryOperation(DOUBLE, SHORT, "plus", { a, b -> a.plus(b) }, emptyBinaryFun),
     binaryOperation(DOUBLE, BYTE, "times", { a, b -> a.times(b) }, emptyBinaryFun),
-    binaryOperation(DOUBLE, CHAR, "times", { a, b -> a.times(b) }, emptyBinaryFun),
     binaryOperation(DOUBLE, DOUBLE, "times", { a, b -> a.times(b) }, emptyBinaryFun),
     binaryOperation(DOUBLE, FLOAT, "times", { a, b -> a.times(b) }, emptyBinaryFun),
     binaryOperation(DOUBLE, INT, "times", { a, b -> a.times(b) }, emptyBinaryFun),
@@ -237,42 +189,36 @@ private val binaryOperations: HashMap<BinaryOperationKey<*, *>, Pair<Function2<A
     binaryOperation(DOUBLE, SHORT, "times", { a, b -> a.times(b) }, emptyBinaryFun),
     binaryOperation(DOUBLE, ANY, "equals", { a, b -> a.equals(b) }, emptyBinaryFun),
     binaryOperation(FLOAT, BYTE, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
-    binaryOperation(FLOAT, CHAR, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
     binaryOperation(FLOAT, DOUBLE, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
     binaryOperation(FLOAT, FLOAT, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
     binaryOperation(FLOAT, INT, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
     binaryOperation(FLOAT, LONG, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
     binaryOperation(FLOAT, SHORT, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
     binaryOperation(FLOAT, BYTE, "div", { a, b -> a.div(b) }, emptyBinaryFun),
-    binaryOperation(FLOAT, CHAR, "div", { a, b -> a.div(b) }, emptyBinaryFun),
     binaryOperation(FLOAT, DOUBLE, "div", { a, b -> a.div(b) }, emptyBinaryFun),
     binaryOperation(FLOAT, FLOAT, "div", { a, b -> a.div(b) }, emptyBinaryFun),
     binaryOperation(FLOAT, INT, "div", { a, b -> a.div(b) }, emptyBinaryFun),
     binaryOperation(FLOAT, LONG, "div", { a, b -> a.div(b) }, emptyBinaryFun),
     binaryOperation(FLOAT, SHORT, "div", { a, b -> a.div(b) }, emptyBinaryFun),
     binaryOperation(FLOAT, BYTE, "minus", { a, b -> a.minus(b) }, emptyBinaryFun),
-    binaryOperation(FLOAT, CHAR, "minus", { a, b -> a.minus(b) }, emptyBinaryFun),
     binaryOperation(FLOAT, DOUBLE, "minus", { a, b -> a.minus(b) }, emptyBinaryFun),
     binaryOperation(FLOAT, FLOAT, "minus", { a, b -> a.minus(b) }, emptyBinaryFun),
     binaryOperation(FLOAT, INT, "minus", { a, b -> a.minus(b) }, emptyBinaryFun),
     binaryOperation(FLOAT, LONG, "minus", { a, b -> a.minus(b) }, emptyBinaryFun),
     binaryOperation(FLOAT, SHORT, "minus", { a, b -> a.minus(b) }, emptyBinaryFun),
     binaryOperation(FLOAT, BYTE, "mod", { a, b -> a.mod(b) }, emptyBinaryFun),
-    binaryOperation(FLOAT, CHAR, "mod", { a, b -> a.mod(b) }, emptyBinaryFun),
     binaryOperation(FLOAT, DOUBLE, "mod", { a, b -> a.mod(b) }, emptyBinaryFun),
     binaryOperation(FLOAT, FLOAT, "mod", { a, b -> a.mod(b) }, emptyBinaryFun),
     binaryOperation(FLOAT, INT, "mod", { a, b -> a.mod(b) }, emptyBinaryFun),
     binaryOperation(FLOAT, LONG, "mod", { a, b -> a.mod(b) }, emptyBinaryFun),
     binaryOperation(FLOAT, SHORT, "mod", { a, b -> a.mod(b) }, emptyBinaryFun),
     binaryOperation(FLOAT, BYTE, "plus", { a, b -> a.plus(b) }, emptyBinaryFun),
-    binaryOperation(FLOAT, CHAR, "plus", { a, b -> a.plus(b) }, emptyBinaryFun),
     binaryOperation(FLOAT, DOUBLE, "plus", { a, b -> a.plus(b) }, emptyBinaryFun),
     binaryOperation(FLOAT, FLOAT, "plus", { a, b -> a.plus(b) }, emptyBinaryFun),
     binaryOperation(FLOAT, INT, "plus", { a, b -> a.plus(b) }, emptyBinaryFun),
     binaryOperation(FLOAT, LONG, "plus", { a, b -> a.plus(b) }, emptyBinaryFun),
     binaryOperation(FLOAT, SHORT, "plus", { a, b -> a.plus(b) }, emptyBinaryFun),
     binaryOperation(FLOAT, BYTE, "times", { a, b -> a.times(b) }, emptyBinaryFun),
-    binaryOperation(FLOAT, CHAR, "times", { a, b -> a.times(b) }, emptyBinaryFun),
     binaryOperation(FLOAT, DOUBLE, "times", { a, b -> a.times(b) }, emptyBinaryFun),
     binaryOperation(FLOAT, FLOAT, "times", { a, b -> a.times(b) }, emptyBinaryFun),
     binaryOperation(FLOAT, INT, "times", { a, b -> a.times(b) }, emptyBinaryFun),
@@ -281,28 +227,24 @@ private val binaryOperations: HashMap<BinaryOperationKey<*, *>, Pair<Function2<A
     binaryOperation(FLOAT, ANY, "equals", { a, b -> a.equals(b) }, emptyBinaryFun),
     binaryOperation(INT, INT, "and", { a, b -> a.and(b) }, { a, b -> a.and(b) }),
     binaryOperation(INT, BYTE, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
-    binaryOperation(INT, CHAR, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
     binaryOperation(INT, DOUBLE, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
     binaryOperation(INT, FLOAT, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
     binaryOperation(INT, INT, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
     binaryOperation(INT, LONG, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
     binaryOperation(INT, SHORT, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
     binaryOperation(INT, BYTE, "div", { a, b -> a.div(b) }, { a, b -> a.divide(b) }),
-    binaryOperation(INT, CHAR, "div", { a, b -> a.div(b) }, emptyBinaryFun),
     binaryOperation(INT, DOUBLE, "div", { a, b -> a.div(b) }, emptyBinaryFun),
     binaryOperation(INT, FLOAT, "div", { a, b -> a.div(b) }, emptyBinaryFun),
     binaryOperation(INT, INT, "div", { a, b -> a.div(b) }, { a, b -> a.divide(b) }),
     binaryOperation(INT, LONG, "div", { a, b -> a.div(b) }, { a, b -> a.divide(b) }),
     binaryOperation(INT, SHORT, "div", { a, b -> a.div(b) }, { a, b -> a.divide(b) }),
     binaryOperation(INT, BYTE, "minus", { a, b -> a.minus(b) }, { a, b -> a.subtract(b) }),
-    binaryOperation(INT, CHAR, "minus", { a, b -> a.minus(b) }, emptyBinaryFun),
     binaryOperation(INT, DOUBLE, "minus", { a, b -> a.minus(b) }, emptyBinaryFun),
     binaryOperation(INT, FLOAT, "minus", { a, b -> a.minus(b) }, emptyBinaryFun),
     binaryOperation(INT, INT, "minus", { a, b -> a.minus(b) }, { a, b -> a.subtract(b) }),
     binaryOperation(INT, LONG, "minus", { a, b -> a.minus(b) }, { a, b -> a.subtract(b) }),
     binaryOperation(INT, SHORT, "minus", { a, b -> a.minus(b) }, { a, b -> a.subtract(b) }),
     binaryOperation(INT, BYTE, "mod", { a, b -> a.mod(b) }, { a, b -> a.mod(b) }),
-    binaryOperation(INT, CHAR, "mod", { a, b -> a.mod(b) }, emptyBinaryFun),
     binaryOperation(INT, DOUBLE, "mod", { a, b -> a.mod(b) }, emptyBinaryFun),
     binaryOperation(INT, FLOAT, "mod", { a, b -> a.mod(b) }, emptyBinaryFun),
     binaryOperation(INT, INT, "mod", { a, b -> a.mod(b) }, { a, b -> a.mod(b) }),
@@ -310,7 +252,6 @@ private val binaryOperations: HashMap<BinaryOperationKey<*, *>, Pair<Function2<A
     binaryOperation(INT, SHORT, "mod", { a, b -> a.mod(b) }, { a, b -> a.mod(b) }),
     binaryOperation(INT, INT, "or", { a, b -> a.or(b) }, { a, b -> a.or(b) }),
     binaryOperation(INT, BYTE, "plus", { a, b -> a.plus(b) }, { a, b -> a.add(b) }),
-    binaryOperation(INT, CHAR, "plus", { a, b -> a.plus(b) }, emptyBinaryFun),
     binaryOperation(INT, DOUBLE, "plus", { a, b -> a.plus(b) }, emptyBinaryFun),
     binaryOperation(INT, FLOAT, "plus", { a, b -> a.plus(b) }, emptyBinaryFun),
     binaryOperation(INT, INT, "plus", { a, b -> a.plus(b) }, { a, b -> a.add(b) }),
@@ -319,7 +260,6 @@ private val binaryOperations: HashMap<BinaryOperationKey<*, *>, Pair<Function2<A
     binaryOperation(INT, INT, "shl", { a, b -> a.shl(b) }, emptyBinaryFun),
     binaryOperation(INT, INT, "shr", { a, b -> a.shr(b) }, emptyBinaryFun),
     binaryOperation(INT, BYTE, "times", { a, b -> a.times(b) }, { a, b -> a.multiply(b) }),
-    binaryOperation(INT, CHAR, "times", { a, b -> a.times(b) }, emptyBinaryFun),
     binaryOperation(INT, DOUBLE, "times", { a, b -> a.times(b) }, emptyBinaryFun),
     binaryOperation(INT, FLOAT, "times", { a, b -> a.times(b) }, emptyBinaryFun),
     binaryOperation(INT, INT, "times", { a, b -> a.times(b) }, { a, b -> a.multiply(b) }),
@@ -330,28 +270,24 @@ private val binaryOperations: HashMap<BinaryOperationKey<*, *>, Pair<Function2<A
     binaryOperation(INT, ANY, "equals", { a, b -> a.equals(b) }, emptyBinaryFun),
     binaryOperation(LONG, LONG, "and", { a, b -> a.and(b) }, { a, b -> a.and(b) }),
     binaryOperation(LONG, BYTE, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
-    binaryOperation(LONG, CHAR, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
     binaryOperation(LONG, DOUBLE, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
     binaryOperation(LONG, FLOAT, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
     binaryOperation(LONG, INT, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
     binaryOperation(LONG, LONG, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
     binaryOperation(LONG, SHORT, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
     binaryOperation(LONG, BYTE, "div", { a, b -> a.div(b) }, { a, b -> a.divide(b) }),
-    binaryOperation(LONG, CHAR, "div", { a, b -> a.div(b) }, emptyBinaryFun),
     binaryOperation(LONG, DOUBLE, "div", { a, b -> a.div(b) }, emptyBinaryFun),
     binaryOperation(LONG, FLOAT, "div", { a, b -> a.div(b) }, emptyBinaryFun),
     binaryOperation(LONG, INT, "div", { a, b -> a.div(b) }, { a, b -> a.divide(b) }),
     binaryOperation(LONG, LONG, "div", { a, b -> a.div(b) }, { a, b -> a.divide(b) }),
     binaryOperation(LONG, SHORT, "div", { a, b -> a.div(b) }, { a, b -> a.divide(b) }),
     binaryOperation(LONG, BYTE, "minus", { a, b -> a.minus(b) }, { a, b -> a.subtract(b) }),
-    binaryOperation(LONG, CHAR, "minus", { a, b -> a.minus(b) }, emptyBinaryFun),
     binaryOperation(LONG, DOUBLE, "minus", { a, b -> a.minus(b) }, emptyBinaryFun),
     binaryOperation(LONG, FLOAT, "minus", { a, b -> a.minus(b) }, emptyBinaryFun),
     binaryOperation(LONG, INT, "minus", { a, b -> a.minus(b) }, { a, b -> a.subtract(b) }),
     binaryOperation(LONG, LONG, "minus", { a, b -> a.minus(b) }, { a, b -> a.subtract(b) }),
     binaryOperation(LONG, SHORT, "minus", { a, b -> a.minus(b) }, { a, b -> a.subtract(b) }),
     binaryOperation(LONG, BYTE, "mod", { a, b -> a.mod(b) }, { a, b -> a.mod(b) }),
-    binaryOperation(LONG, CHAR, "mod", { a, b -> a.mod(b) }, emptyBinaryFun),
     binaryOperation(LONG, DOUBLE, "mod", { a, b -> a.mod(b) }, emptyBinaryFun),
     binaryOperation(LONG, FLOAT, "mod", { a, b -> a.mod(b) }, emptyBinaryFun),
     binaryOperation(LONG, INT, "mod", { a, b -> a.mod(b) }, { a, b -> a.mod(b) }),
@@ -359,7 +295,6 @@ private val binaryOperations: HashMap<BinaryOperationKey<*, *>, Pair<Function2<A
     binaryOperation(LONG, SHORT, "mod", { a, b -> a.mod(b) }, { a, b -> a.mod(b) }),
     binaryOperation(LONG, LONG, "or", { a, b -> a.or(b) }, { a, b -> a.or(b) }),
     binaryOperation(LONG, BYTE, "plus", { a, b -> a.plus(b) }, { a, b -> a.add(b) }),
-    binaryOperation(LONG, CHAR, "plus", { a, b -> a.plus(b) }, emptyBinaryFun),
     binaryOperation(LONG, DOUBLE, "plus", { a, b -> a.plus(b) }, emptyBinaryFun),
     binaryOperation(LONG, FLOAT, "plus", { a, b -> a.plus(b) }, emptyBinaryFun),
     binaryOperation(LONG, INT, "plus", { a, b -> a.plus(b) }, { a, b -> a.add(b) }),
@@ -368,7 +303,6 @@ private val binaryOperations: HashMap<BinaryOperationKey<*, *>, Pair<Function2<A
     binaryOperation(LONG, INT, "shl", { a, b -> a.shl(b) }, emptyBinaryFun),
     binaryOperation(LONG, INT, "shr", { a, b -> a.shr(b) }, emptyBinaryFun),
     binaryOperation(LONG, BYTE, "times", { a, b -> a.times(b) }, { a, b -> a.multiply(b) }),
-    binaryOperation(LONG, CHAR, "times", { a, b -> a.times(b) }, emptyBinaryFun),
     binaryOperation(LONG, DOUBLE, "times", { a, b -> a.times(b) }, emptyBinaryFun),
     binaryOperation(LONG, FLOAT, "times", { a, b -> a.times(b) }, emptyBinaryFun),
     binaryOperation(LONG, INT, "times", { a, b -> a.times(b) }, { a, b -> a.multiply(b) }),
@@ -378,42 +312,36 @@ private val binaryOperations: HashMap<BinaryOperationKey<*, *>, Pair<Function2<A
     binaryOperation(LONG, LONG, "xor", { a, b -> a.xor(b) }, { a, b -> a.xor(b) }),
     binaryOperation(LONG, ANY, "equals", { a, b -> a.equals(b) }, emptyBinaryFun),
     binaryOperation(SHORT, BYTE, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
-    binaryOperation(SHORT, CHAR, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
     binaryOperation(SHORT, DOUBLE, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
     binaryOperation(SHORT, FLOAT, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
     binaryOperation(SHORT, INT, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
     binaryOperation(SHORT, LONG, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
     binaryOperation(SHORT, SHORT, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
     binaryOperation(SHORT, BYTE, "div", { a, b -> a.div(b) }, { a, b -> a.divide(b) }),
-    binaryOperation(SHORT, CHAR, "div", { a, b -> a.div(b) }, emptyBinaryFun),
     binaryOperation(SHORT, DOUBLE, "div", { a, b -> a.div(b) }, emptyBinaryFun),
     binaryOperation(SHORT, FLOAT, "div", { a, b -> a.div(b) }, emptyBinaryFun),
     binaryOperation(SHORT, INT, "div", { a, b -> a.div(b) }, { a, b -> a.divide(b) }),
     binaryOperation(SHORT, LONG, "div", { a, b -> a.div(b) }, { a, b -> a.divide(b) }),
     binaryOperation(SHORT, SHORT, "div", { a, b -> a.div(b) }, { a, b -> a.divide(b) }),
     binaryOperation(SHORT, BYTE, "minus", { a, b -> a.minus(b) }, { a, b -> a.subtract(b) }),
-    binaryOperation(SHORT, CHAR, "minus", { a, b -> a.minus(b) }, emptyBinaryFun),
     binaryOperation(SHORT, DOUBLE, "minus", { a, b -> a.minus(b) }, emptyBinaryFun),
     binaryOperation(SHORT, FLOAT, "minus", { a, b -> a.minus(b) }, emptyBinaryFun),
     binaryOperation(SHORT, INT, "minus", { a, b -> a.minus(b) }, { a, b -> a.subtract(b) }),
     binaryOperation(SHORT, LONG, "minus", { a, b -> a.minus(b) }, { a, b -> a.subtract(b) }),
     binaryOperation(SHORT, SHORT, "minus", { a, b -> a.minus(b) }, { a, b -> a.subtract(b) }),
     binaryOperation(SHORT, BYTE, "mod", { a, b -> a.mod(b) }, { a, b -> a.mod(b) }),
-    binaryOperation(SHORT, CHAR, "mod", { a, b -> a.mod(b) }, emptyBinaryFun),
     binaryOperation(SHORT, DOUBLE, "mod", { a, b -> a.mod(b) }, emptyBinaryFun),
     binaryOperation(SHORT, FLOAT, "mod", { a, b -> a.mod(b) }, emptyBinaryFun),
     binaryOperation(SHORT, INT, "mod", { a, b -> a.mod(b) }, { a, b -> a.mod(b) }),
     binaryOperation(SHORT, LONG, "mod", { a, b -> a.mod(b) }, { a, b -> a.mod(b) }),
     binaryOperation(SHORT, SHORT, "mod", { a, b -> a.mod(b) }, { a, b -> a.mod(b) }),
     binaryOperation(SHORT, BYTE, "plus", { a, b -> a.plus(b) }, { a, b -> a.add(b) }),
-    binaryOperation(SHORT, CHAR, "plus", { a, b -> a.plus(b) }, emptyBinaryFun),
     binaryOperation(SHORT, DOUBLE, "plus", { a, b -> a.plus(b) }, emptyBinaryFun),
     binaryOperation(SHORT, FLOAT, "plus", { a, b -> a.plus(b) }, emptyBinaryFun),
     binaryOperation(SHORT, INT, "plus", { a, b -> a.plus(b) }, { a, b -> a.add(b) }),
     binaryOperation(SHORT, LONG, "plus", { a, b -> a.plus(b) }, { a, b -> a.add(b) }),
     binaryOperation(SHORT, SHORT, "plus", { a, b -> a.plus(b) }, { a, b -> a.add(b) }),
     binaryOperation(SHORT, BYTE, "times", { a, b -> a.times(b) }, { a, b -> a.multiply(b) }),
-    binaryOperation(SHORT, CHAR, "times", { a, b -> a.times(b) }, emptyBinaryFun),
     binaryOperation(SHORT, DOUBLE, "times", { a, b -> a.times(b) }, emptyBinaryFun),
     binaryOperation(SHORT, FLOAT, "times", { a, b -> a.times(b) }, emptyBinaryFun),
     binaryOperation(SHORT, INT, "times", { a, b -> a.times(b) }, { a, b -> a.multiply(b) }),
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/diagnostics/DiagnosticsWithSuppression.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/diagnostics/DiagnosticsWithSuppression.java
index 85a01b8899d..7482867dd13 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/diagnostics/DiagnosticsWithSuppression.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/diagnostics/DiagnosticsWithSuppression.java
@@ -35,7 +35,7 @@ import org.jetbrains.kotlin.diagnostics.Severity;
 import org.jetbrains.kotlin.psi.*;
 import org.jetbrains.kotlin.resolve.BindingContext;
 import org.jetbrains.kotlin.resolve.constants.ArrayValue;
-import org.jetbrains.kotlin.resolve.constants.CompileTimeConstant;
+import org.jetbrains.kotlin.resolve.constants.ConstantValue;
 import org.jetbrains.kotlin.resolve.constants.StringValue;
 import org.jetbrains.kotlin.util.ExtensionProvider;
 
@@ -214,9 +214,9 @@ public class DiagnosticsWithSuppression implements Diagnostics {
             if (!KotlinBuiltIns.isSuppressAnnotation(annotationDescriptor)) continue;
 
             // We only add strings and skip other values to facilitate recovery in presence of erroneous code
-            for (CompileTimeConstant<?> arrayValue : annotationDescriptor.getAllValueArguments().values()) {
+            for (ConstantValue<?> arrayValue : annotationDescriptor.getAllValueArguments().values()) {
                 if ((arrayValue instanceof ArrayValue)) {
-                    for (CompileTimeConstant<?> value : ((ArrayValue) arrayValue).getValue()) {
+                    for (ConstantValue<?> value : ((ArrayValue) arrayValue).getValue()) {
                         if (value instanceof StringValue) {
                             builder.add(String.valueOf(((StringValue) value).getValue()).toLowerCase());
                         }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/inline/InlineUtil.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/inline/InlineUtil.java
index 983deaf5047..afcd4037800 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/inline/InlineUtil.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/inline/InlineUtil.java
@@ -32,7 +32,7 @@ import org.jetbrains.kotlin.resolve.calls.model.ArgumentMapping;
 import org.jetbrains.kotlin.resolve.calls.model.ArgumentMatch;
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall;
 import org.jetbrains.kotlin.resolve.constants.ArrayValue;
-import org.jetbrains.kotlin.resolve.constants.CompileTimeConstant;
+import org.jetbrains.kotlin.resolve.constants.ConstantValue;
 import org.jetbrains.kotlin.resolve.constants.EnumValue;
 
 import static kotlin.KotlinPackage.firstOrNull;
@@ -53,7 +53,7 @@ public class InlineUtil {
         if (annotation == null) {
             return InlineStrategy.NOT_INLINE;
         }
-        CompileTimeConstant<?> argument = firstOrNull(annotation.getAllValueArguments().values());
+        ConstantValue<?> argument = firstOrNull(annotation.getAllValueArguments().values());
         if (argument == null) {
             return InlineStrategy.AS_FUNCTION;
         }
@@ -72,9 +72,9 @@ public class InlineUtil {
     private static boolean hasInlineOption(@NotNull ValueParameterDescriptor descriptor, @NotNull InlineOption option) {
         AnnotationDescriptor annotation = descriptor.getAnnotations().findAnnotation(KotlinBuiltIns.FQ_NAMES.inlineOptions);
         if (annotation != null) {
-            CompileTimeConstant<?> argument = firstOrNull(annotation.getAllValueArguments().values());
+            ConstantValue<?> argument = firstOrNull(annotation.getAllValueArguments().values());
             if (argument instanceof ArrayValue) {
-                for (CompileTimeConstant<?> value : ((ArrayValue) argument).getValue()) {
+                for (ConstantValue<?> value : ((ArrayValue) argument).getValue()) {
                     if (value instanceof EnumValue && ((EnumValue) value).getValue().getName().asString().equals(option.name())) {
                         return true;
                     }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/FileScopeProvider.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/FileScopeProvider.kt
index 03e916e2f31..29854c8b2dc 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/FileScopeProvider.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/FileScopeProvider.kt
@@ -28,10 +28,8 @@ public interface FileScopeProvider {
         }
     }
 
-    public open class AdditionalScopes {
-        public open fun scopes(file: JetFile): List<JetScope> {
-            return emptyList()
-        }
+    public interface AdditionalScopes {
+        public fun scopes(file: JetFile): List<JetScope>
     }
 }
 
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/FileScopeProviderImpl.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/FileScopeProviderImpl.kt
index 55931fda2d0..7e48e22b22e 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/FileScopeProviderImpl.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/FileScopeProviderImpl.kt
@@ -16,29 +16,75 @@
 
 package org.jetbrains.kotlin.resolve.lazy
 
+import org.jetbrains.kotlin.descriptors.ModuleDescriptor
+import org.jetbrains.kotlin.descriptors.impl.SubpackagesScope
+import org.jetbrains.kotlin.name.FqName
+import org.jetbrains.kotlin.psi.JetCodeFragment
 import org.jetbrains.kotlin.psi.JetFile
+import org.jetbrains.kotlin.psi.JetImportsFactory
+import org.jetbrains.kotlin.resolve.BindingTrace
+import org.jetbrains.kotlin.resolve.NoSubpackagesInPackageScope
+import org.jetbrains.kotlin.resolve.QualifiedExpressionResolver
 import org.jetbrains.kotlin.resolve.TemporaryBindingTrace
+import org.jetbrains.kotlin.resolve.scopes.JetScope
+import org.jetbrains.kotlin.storage.StorageManager
 import org.jetbrains.kotlin.storage.get
+import org.jetbrains.kotlin.utils.sure
+import java.util.*
 
 public class FileScopeProviderImpl(
-        private val resolveSession: ResolveSession,
-        private val additionalScopes: FileScopeProvider.AdditionalScopes
+        private val topLevelDescriptorProvider: TopLevelDescriptorProvider,
+        private val storageManager: StorageManager,
+        private val moduleDescriptor: ModuleDescriptor,
+        private val qualifiedExpressionResolver: QualifiedExpressionResolver,
+        private val bindingTrace: BindingTrace,
+        private val jetImportsFactory: JetImportsFactory,
+        private val additionalScopes: Iterable<FileScopeProvider.AdditionalScopes>
 ) : FileScopeProvider {
 
-    private val defaultImports by resolveSession.getStorageManager().createLazyValue {
-        val defaultImports = resolveSession.getModuleDescriptor().defaultImports
-        resolveSession.getJetImportsFactory().createImportDirectives(defaultImports)
+    private val defaultImports by storageManager.createLazyValue {
+        jetImportsFactory.createImportDirectives(moduleDescriptor.defaultImports)
     }
 
-    private val fileScopes = resolveSession.getStorageManager().createMemoizedFunction { file: JetFile -> createFileScope(file) }
+    private val fileScopes = storageManager.createMemoizedFunction { file: JetFile -> createFileScope(file) }
 
     override fun getFileScope(file: JetFile) = fileScopes(file)
 
     private fun createFileScope(file: JetFile): LazyFileScope {
-        val tempTrace = TemporaryBindingTrace.create(resolveSession.getTrace(), "Transient trace for default imports lazy resolve")
-        return LazyFileScope.create(
-                resolveSession, file, defaultImports, additionalScopes.scopes(file),
-                resolveSession.getTrace(), tempTrace, "LazyFileScope for file " + file.getName()
-        )
+        val debugName = "LazyFileScope for file " + file.getName()
+        val tempTrace = TemporaryBindingTrace.create(bindingTrace, "Transient trace for default imports lazy resolve")
+
+        val imports = if (file is JetCodeFragment)
+            file.importsAsImportList()?.getImports() ?: listOf()
+        else
+            file.getImportDirectives()
+
+        val packageView = moduleDescriptor.getPackage(file.getPackageFqName())
+        val packageFragment = topLevelDescriptorProvider.getPackageFragment(file.getPackageFqName())
+                .sure { "Could not find fragment ${file.getPackageFqName()} for file ${file.getName()}" }
+
+        val aliasImportResolver = LazyImportResolver(storageManager, qualifiedExpressionResolver, this, moduleDescriptor, AliasImportsIndexed(imports), bindingTrace)
+        val allUnderImportResolver = LazyImportResolver(storageManager, qualifiedExpressionResolver, this, moduleDescriptor, AllUnderImportsIndexed(imports), bindingTrace)
+        val defaultAliasImportResolver = LazyImportResolver(storageManager, qualifiedExpressionResolver, this, moduleDescriptor, AliasImportsIndexed(defaultImports), tempTrace)
+        val defaultAllUnderImportResolver = LazyImportResolver(storageManager, qualifiedExpressionResolver, this, moduleDescriptor, AllUnderImportsIndexed(defaultImports), tempTrace)
+
+        val scopeChain = ArrayList<JetScope>()
+
+        scopeChain.add(LazyImportScope(packageFragment, aliasImportResolver, LazyImportScope.FilteringKind.ALL, "Alias imports in $debugName"))
+
+        scopeChain.add(NoSubpackagesInPackageScope(packageView)) //TODO: problems with visibility too
+        scopeChain.add(SubpackagesScope(moduleDescriptor, FqName.ROOT))
+
+        scopeChain.add(LazyImportScope(packageFragment, defaultAliasImportResolver, LazyImportScope.FilteringKind.ALL, "Default alias imports in $debugName"))
+
+        scopeChain.add(LazyImportScope(packageFragment, defaultAllUnderImportResolver, LazyImportScope.FilteringKind.VISIBLE_CLASSES, "Default all under imports in $debugName (visible classes)"))
+        scopeChain.add(LazyImportScope(packageFragment, allUnderImportResolver, LazyImportScope.FilteringKind.VISIBLE_CLASSES, "All under imports in $debugName (visible classes)"))
+
+        scopeChain.addAll(additionalScopes.flatMap { it.scopes(file) })
+
+        scopeChain.add(LazyImportScope(packageFragment, defaultAllUnderImportResolver, LazyImportScope.FilteringKind.INVISIBLE_CLASSES, "Default all under imports in $debugName (invisible classes only)"))
+        scopeChain.add(LazyImportScope(packageFragment, allUnderImportResolver, LazyImportScope.FilteringKind.INVISIBLE_CLASSES, "All under imports in $debugName (invisible classes only)"))
+
+        return LazyFileScope(scopeChain, aliasImportResolver, allUnderImportResolver, packageFragment, debugName)
     }
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/LazyDeclarationResolver.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/LazyDeclarationResolver.java
index 02ed9232825..cbe952096cb 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/LazyDeclarationResolver.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/LazyDeclarationResolver.java
@@ -38,26 +38,24 @@ import java.util.List;
 
 public class LazyDeclarationResolver {
 
-    private final BindingTrace trace;
+    @NotNull private final TopLevelDescriptorProvider topLevelDescriptorProvider;
+    @NotNull private final BindingTrace trace;
 
     protected DeclarationScopeProvider scopeProvider;
-    private TopLevelDescriptorProvider topLevelDescriptorProvider;
 
+    // component dependency cycle
     @Inject
     public void setDeclarationScopeProvider(@NotNull DeclarationScopeProviderImpl scopeProvider) {
         this.scopeProvider = scopeProvider;
     }
 
-    @Inject
-    public void setTopLevelDescriptorProvider(@NotNull TopLevelDescriptorProvider topLevelDescriptorProvider) {
-        this.topLevelDescriptorProvider = topLevelDescriptorProvider;
-    }
-
     @Deprecated
     public LazyDeclarationResolver(
             @NotNull GlobalContext globalContext,
-            @NotNull BindingTrace delegationTrace
+            @NotNull BindingTrace delegationTrace,
+            @NotNull TopLevelDescriptorProvider topLevelDescriptorProvider
     ) {
+        this.topLevelDescriptorProvider = topLevelDescriptorProvider;
         LockBasedLazyResolveStorageManager lockBasedLazyResolveStorageManager =
                 new LockBasedLazyResolveStorageManager(globalContext.getStorageManager());
 
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/LazyFileScope.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/LazyFileScope.kt
index 080087ed088..74bf6bd9ac6 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/LazyFileScope.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/LazyFileScope.kt
@@ -16,6 +16,7 @@
 
 package org.jetbrains.kotlin.resolve.lazy
 
+import org.jetbrains.kotlin.descriptors.ModuleDescriptor
 import org.jetbrains.kotlin.descriptors.PackageFragmentDescriptor
 import org.jetbrains.kotlin.descriptors.impl.SubpackagesScope
 import org.jetbrains.kotlin.name.FqName
@@ -24,12 +25,14 @@ import org.jetbrains.kotlin.psi.JetFile
 import org.jetbrains.kotlin.psi.JetImportDirective
 import org.jetbrains.kotlin.resolve.BindingTrace
 import org.jetbrains.kotlin.resolve.NoSubpackagesInPackageScope
+import org.jetbrains.kotlin.resolve.QualifiedExpressionResolver
 import org.jetbrains.kotlin.resolve.scopes.ChainedScope
 import org.jetbrains.kotlin.resolve.scopes.JetScope
+import org.jetbrains.kotlin.storage.StorageManager
 import org.jetbrains.kotlin.utils.sure
 import java.util.ArrayList
 
-class LazyFileScope private constructor(
+class LazyFileScope(
         scopeChain: List<JetScope>,
         private val aliasImportResolver: LazyImportResolver,
         private val allUnderImportResolver: LazyImportResolver,
@@ -50,50 +53,4 @@ class LazyFileScope private constructor(
             aliasImportResolver.forceResolveImportDirective(importDirective)
         }
     }
-
-    companion object Factory {
-        public fun create(
-                resolveSession: ResolveSession,
-                file: JetFile,
-                defaultImports: Collection<JetImportDirective>,
-                additionalScopes: List<JetScope>,
-                traceForImportResolve: BindingTrace,
-                traceForDefaultImportResolve: BindingTrace,
-                debugName: String
-        ): LazyFileScope {
-            val imports = if (file is JetCodeFragment)
-                file.importsAsImportList()?.getImports() ?: listOf()
-            else
-                file.getImportDirectives()
-
-            val moduleDescriptor = resolveSession.getModuleDescriptor()
-            val packageView = moduleDescriptor.getPackage(file.getPackageFqName())
-            val packageFragment = resolveSession.getPackageFragment(file.getPackageFqName())
-                    .sure { "Could not find fragment ${file.getPackageFqName()} for file ${file.getName()}" }
-
-            val aliasImportResolver = LazyImportResolver(resolveSession, moduleDescriptor, AliasImportsIndexed(imports), traceForImportResolve)
-            val allUnderImportResolver = LazyImportResolver(resolveSession, moduleDescriptor, AllUnderImportsIndexed(imports), traceForImportResolve)
-            val defaultAliasImportResolver = LazyImportResolver(resolveSession, moduleDescriptor, AliasImportsIndexed(defaultImports), traceForDefaultImportResolve)
-            val defaultAllUnderImportResolver = LazyImportResolver(resolveSession, moduleDescriptor, AllUnderImportsIndexed(defaultImports), traceForDefaultImportResolve)
-
-            val scopeChain = ArrayList<JetScope>()
-
-            scopeChain.add(LazyImportScope(packageFragment, aliasImportResolver, LazyImportScope.FilteringKind.ALL, "Alias imports in $debugName"))
-
-            scopeChain.add(NoSubpackagesInPackageScope(packageView)) //TODO: problems with visibility too
-            scopeChain.add(SubpackagesScope(moduleDescriptor, FqName.ROOT))
-
-            scopeChain.add(LazyImportScope(packageFragment, defaultAliasImportResolver, LazyImportScope.FilteringKind.ALL, "Default alias imports in $debugName"))
-
-            scopeChain.add(LazyImportScope(packageFragment, defaultAllUnderImportResolver, LazyImportScope.FilteringKind.VISIBLE_CLASSES, "Default all under imports in $debugName (visible classes)"))
-            scopeChain.add(LazyImportScope(packageFragment, allUnderImportResolver, LazyImportScope.FilteringKind.VISIBLE_CLASSES, "All under imports in $debugName (visible classes)"))
-
-            scopeChain.addAll(additionalScopes)
-
-            scopeChain.add(LazyImportScope(packageFragment, defaultAllUnderImportResolver, LazyImportScope.FilteringKind.INVISIBLE_CLASSES, "Default all under imports in $debugName (invisible classes only)"))
-            scopeChain.add(LazyImportScope(packageFragment, allUnderImportResolver, LazyImportScope.FilteringKind.INVISIBLE_CLASSES, "All under imports in $debugName (invisible classes only)"))
-
-            return LazyFileScope(scopeChain, aliasImportResolver, allUnderImportResolver, packageFragment, debugName)
-        }
-    }
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/LazyImportScope.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/LazyImportScope.kt
index e63d88e8f73..8b2d59de4f0 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/LazyImportScope.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/LazyImportScope.kt
@@ -25,10 +25,13 @@ import org.jetbrains.kotlin.psi.JetImportDirective
 import org.jetbrains.kotlin.psi.JetPsiUtil
 import org.jetbrains.kotlin.resolve.BindingTrace
 import org.jetbrains.kotlin.resolve.PlatformTypesMappedToKotlinChecker
+import org.jetbrains.kotlin.resolve.QualifiedExpressionResolver
 import org.jetbrains.kotlin.resolve.QualifiedExpressionResolver.LookupMode
 import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter
 import org.jetbrains.kotlin.resolve.scopes.JetScope
 import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue
+import org.jetbrains.kotlin.storage.StorageManager
+import org.jetbrains.kotlin.types.JetType
 import org.jetbrains.kotlin.util.collectionUtils.concat
 import org.jetbrains.kotlin.utils.Printer
 import java.util.LinkedHashSet
@@ -63,12 +66,14 @@ class AliasImportsIndexed(allImports: Collection<JetImportDirective>) : IndexedI
 }
 
 class LazyImportResolver(
-        val resolveSession: ResolveSession,
+        val storageManager: StorageManager,
+        val qualifiedExpressionResolver: QualifiedExpressionResolver,
+        val fileScopeProvider: FileScopeProvider,
         val moduleDescriptor: ModuleDescriptor,
         val indexedImports: IndexedImports,
         private val traceForImportResolve: BindingTrace
 ) {
-    private val importedScopesProvider = resolveSession.getStorageManager().createMemoizedFunction {
+    private val importedScopesProvider = storageManager.createMemoizedFunction {
         directive: JetImportDirective -> ImportDirectiveResolveCache(directive)
     }
 
@@ -86,7 +91,7 @@ class LazyImportResolver(
                 return status.scope
             }
 
-            return resolveSession.getStorageManager().compute {
+            return storageManager.compute {
                 val cachedStatus = importResolveStatus
                 if (cachedStatus != null && (cachedStatus.lookupMode == mode || cachedStatus.lookupMode == LookupMode.EVERYTHING)) {
                     cachedStatus.scope
@@ -95,8 +100,7 @@ class LazyImportResolver(
                     directiveUnderResolve = directive
 
                     try {
-                        val resolver = resolveSession.getQualifiedExpressionResolver()
-                        val directiveImportScope = resolver.processImportReference(
+                        val directiveImportScope = qualifiedExpressionResolver.processImportReference(
                                 directive, moduleDescriptor, traceForImportResolve, mode)
                         val descriptors = if (directive.isAllUnder()) emptyList() else directiveImportScope.getAllDescriptors()
 
@@ -126,7 +130,7 @@ class LazyImportResolver(
 
         val status = importedScopesProvider(importDirective).importResolveStatus
         if (status != null && !status.descriptors.isEmpty()) {
-            val fileScope = resolveSession.getFileScopeProvider().getFileScope(importDirective.getContainingJetFile())
+            val fileScope = fileScopeProvider.getFileScope(importDirective.getContainingJetFile())
             reportConflictingImport(importDirective, fileScope, status.descriptors, traceForImportResolve)
         }
     }
@@ -180,7 +184,7 @@ class LazyImportResolver(
             }
             return target
         }
-        return resolveSession.getStorageManager().compute(::compute)
+        return storageManager.compute(::compute)
     }
 
     public fun <D : DeclarationDescriptor> collectFromImports(
@@ -188,7 +192,7 @@ class LazyImportResolver(
             lookupMode: LookupMode,
             descriptorsSelector: (JetScope, Name) -> Collection<D>
     ): Collection<D> {
-        return resolveSession.getStorageManager().compute {
+        return storageManager.compute {
             var descriptors: Collection<D>? = null
             for (directive in indexedImports.importsForName(name)) {
                 if (directive == directiveUnderResolve) {
@@ -254,13 +258,29 @@ class LazyImportScope(
         return importResolver.collectFromImports(name, LookupMode.EVERYTHING) { scope, name -> scope.getFunctions(name) }
     }
 
+    override fun getSyntheticExtensionProperties(receiverTypes: Collection<JetType>, name: Name): Collection<PropertyDescriptor> {
+        if (filteringKind == FilteringKind.INVISIBLE_CLASSES) return listOf()
+        return importResolver.collectFromImports(name, LookupMode.EVERYTHING) { scope, name -> scope.getSyntheticExtensionProperties(receiverTypes, name) }
+    }
+
+    override fun getSyntheticExtensionProperties(receiverTypes: Collection<JetType>): Collection<PropertyDescriptor> {
+        // we do not perform any filtering by visibility here because all descriptors from both visible/invisible filter scopes are to be added anyway
+        if (filteringKind == FilteringKind.INVISIBLE_CLASSES) return listOf()
+
+        return importResolver.storageManager.compute {
+            importResolver.indexedImports.imports.flatMapTo(LinkedHashSet<PropertyDescriptor>()) { import ->
+                importResolver.getImportScope(import, LookupMode.EVERYTHING).getSyntheticExtensionProperties(receiverTypes)
+            }
+        }
+    }
+
     override fun getDeclarationsByLabel(labelName: Name): Collection<DeclarationDescriptor> = listOf()
 
     override fun getDescriptors(kindFilter: DescriptorKindFilter, nameFilter: (Name) -> Boolean): Collection<DeclarationDescriptor> {
         // we do not perform any filtering by visibility here because all descriptors from both visible/invisible filter scopes are to be added anyway
         if (filteringKind == FilteringKind.INVISIBLE_CLASSES) return listOf()
 
-        return importResolver.resolveSession.getStorageManager().compute {
+        return importResolver.storageManager.compute {
             val descriptors = LinkedHashSet<DeclarationDescriptor>()
             for (directive in importResolver.indexedImports.imports) {
                 val importPath = directive.getImportPath() ?: continue
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/ResolveSession.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/ResolveSession.java
index bfe286bb530..eac97c6719c 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/ResolveSession.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/ResolveSession.java
@@ -168,7 +168,7 @@ public class ResolveSession implements KotlinCodeAnalyzer, LazyClassContext {
                 if (packageDescriptor == null) {
                     return Collections.emptyList();
                 }
-                return packageDescriptor.getDeclarationProvider().getAllDeclaredSubPackages();
+                return packageDescriptor.getDeclarationProvider().getAllDeclaredSubPackages(nameFilter);
             }
         };
 
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/data/JetClassInfo.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/data/JetClassInfo.java
index 2e5d0a5898d..5c8e8ff6215 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/data/JetClassInfo.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/data/JetClassInfo.java
@@ -19,9 +19,9 @@ package org.jetbrains.kotlin.resolve.lazy.data;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.descriptors.ClassKind;
-import org.jetbrains.kotlin.psi.*;
-
-import java.util.List;
+import org.jetbrains.kotlin.psi.JetClass;
+import org.jetbrains.kotlin.psi.JetEnumEntry;
+import org.jetbrains.kotlin.psi.JetTypeParameterList;
 
 public class JetClassInfo extends JetClassOrObjectInfo<JetClass> {
     private final ClassKind kind;
@@ -34,12 +34,12 @@ public class JetClassInfo extends JetClassOrObjectInfo<JetClass> {
         else if (element.isInterface()) {
             this.kind = ClassKind.INTERFACE;
         }
-        else if (element.isAnnotation()) {
-            this.kind = ClassKind.ANNOTATION_CLASS;
-        }
         else if (element.isEnum()) {
             this.kind = ClassKind.ENUM_CLASS;
         }
+        else if (element.isAnnotation()) {
+            this.kind = ClassKind.ANNOTATION_CLASS;
+        }
         else {
             this.kind = ClassKind.CLASS;
         }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/declarations/CombinedPackageMemberDeclarationProvider.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/declarations/CombinedPackageMemberDeclarationProvider.kt
index 8b56cd67db2..a70311559be 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/declarations/CombinedPackageMemberDeclarationProvider.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/declarations/CombinedPackageMemberDeclarationProvider.kt
@@ -20,7 +20,7 @@ import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter
 
 public class CombinedPackageMemberDeclarationProvider(val providers: Collection<PackageMemberDeclarationProvider>) : PackageMemberDeclarationProvider {
-    override fun getAllDeclaredSubPackages() = providers.flatMap { it.getAllDeclaredSubPackages() }
+    override fun getAllDeclaredSubPackages(nameFilter: (Name) -> Boolean) = providers.flatMap { it.getAllDeclaredSubPackages(nameFilter) }
 
     override fun getPackageFiles() = providers.flatMap { it.getPackageFiles() }
 
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/declarations/FileBasedPackageMemberDeclarationProvider.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/declarations/FileBasedPackageMemberDeclarationProvider.kt
index e2b899946bf..c9d9eb272f7 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/declarations/FileBasedPackageMemberDeclarationProvider.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/declarations/FileBasedPackageMemberDeclarationProvider.kt
@@ -18,6 +18,7 @@ package org.jetbrains.kotlin.resolve.lazy.declarations
 
 import org.jetbrains.kotlin.psi.JetFile
 import org.jetbrains.kotlin.name.FqName
+import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.storage.StorageManager
 
 public class FileBasedPackageMemberDeclarationProvider internal constructor(
@@ -40,7 +41,7 @@ public class FileBasedPackageMemberDeclarationProvider internal constructor(
         }
     }
 
-    override fun getAllDeclaredSubPackages(): Collection<FqName> = allDeclaredSubPackages()
+    override fun getAllDeclaredSubPackages(nameFilter: (Name) -> Boolean): Collection<FqName> = allDeclaredSubPackages()
 
     override fun getPackageFiles() = packageFiles
 
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/declarations/PackageMemberDeclarationProvider.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/declarations/PackageMemberDeclarationProvider.kt
index fdd4170e82a..7f200b7b119 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/declarations/PackageMemberDeclarationProvider.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/declarations/PackageMemberDeclarationProvider.kt
@@ -19,9 +19,10 @@ package org.jetbrains.kotlin.resolve.lazy.declarations
 import org.jetbrains.annotations.ReadOnly
 import org.jetbrains.kotlin.psi.JetFile
 import org.jetbrains.kotlin.name.FqName
+import org.jetbrains.kotlin.name.Name
 
 public trait PackageMemberDeclarationProvider : DeclarationProvider {
-    public fun getAllDeclaredSubPackages(): Collection<FqName>
+    public fun getAllDeclaredSubPackages(nameFilter: (Name) -> Boolean): Collection<FqName>
 
     public fun getPackageFiles(): Collection<JetFile>
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/AbstractLazyMemberScope.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/AbstractLazyMemberScope.kt
index 0346754dba1..d6fe4b51cbf 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/AbstractLazyMemberScope.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/AbstractLazyMemberScope.kt
@@ -28,8 +28,10 @@ import org.jetbrains.kotlin.resolve.lazy.data.JetScriptInfo
 import org.jetbrains.kotlin.resolve.lazy.declarations.DeclarationProvider
 import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter
 import org.jetbrains.kotlin.resolve.scopes.JetScope
+import org.jetbrains.kotlin.resolve.scopes.JetScopeImpl
 import org.jetbrains.kotlin.storage.MemoizedFunctionToNotNull
 import org.jetbrains.kotlin.storage.StorageManager
+import org.jetbrains.kotlin.types.JetType
 import org.jetbrains.kotlin.utils.Printer
 import org.jetbrains.kotlin.utils.toReadOnlyList
 import java.util.LinkedHashSet
@@ -40,7 +42,7 @@ protected constructor(
         protected val declarationProvider: DP,
         protected val thisDescriptor: D,
         protected val trace: BindingTrace
-) : JetScope {
+) : JetScopeImpl() {
 
     protected val storageManager: StorageManager = c.storageManager
     private val classDescriptors: MemoizedFunctionToNotNull<Name, List<ClassDescriptor>> = storageManager.createMemoizedFunction { resolveClassDescriptor(it) }
@@ -110,10 +112,6 @@ protected constructor(
 
     protected abstract fun getNonDeclaredProperties(name: Name, result: MutableSet<VariableDescriptor>)
 
-    override fun getLocalVariable(name: Name): VariableDescriptor? = null
-
-    override fun getDeclarationsByLabel(labelName: Name) = setOf<DeclarationDescriptor>()
-
     protected fun computeDescriptorsFromDeclaredElements(kindFilter: DescriptorKindFilter,
                                                          nameFilter: (Name) -> Boolean): List<DeclarationDescriptor> {
         val declarations = declarationProvider.getDeclarations(kindFilter, nameFilter)
@@ -160,8 +158,6 @@ protected constructor(
         return result.toReadOnlyList()
     }
 
-    override fun getImplicitReceiversHierarchy() = listOf<ReceiverParameterDescriptor>()
-
     // Do not change this, override in concrete subclasses:
     // it is very easy to compromise laziness of this class, and fail all the debugging
     // a generic implementation can't do this properly
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/ClassResolutionScopesSupport.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/ClassResolutionScopesSupport.kt
new file mode 100644
index 00000000000..6a0ea715837
--- /dev/null
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/ClassResolutionScopesSupport.kt
@@ -0,0 +1,68 @@
+/*
+ * Copyright 2010-2015 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.kotlin.resolve.lazy.descriptors
+
+import org.jetbrains.kotlin.descriptors.ClassDescriptor
+import org.jetbrains.kotlin.resolve.scopes.*
+import org.jetbrains.kotlin.storage.StorageManager
+
+class ClassResolutionScopesSupport(
+        private val classDescriptor: ClassDescriptor,
+        storageManager: StorageManager,
+        private val getOuterScope: () -> JetScope
+) {
+    private val staticScope = StaticScopeForKotlinClass(classDescriptor)
+
+    private val scopeForClassHeaderResolution = storageManager.createLazyValue { computeScopeForClassHeaderResolution() }
+    private val scopeForMemberDeclarationResolution = storageManager.createLazyValue { computeScopeForMemberDeclarationResolution() }
+
+    fun getStaticScope(): JetScope = staticScope
+
+    fun getScopeForClassHeaderResolution(): JetScope = scopeForClassHeaderResolution()
+
+    fun getScopeForMemberDeclarationResolution(): JetScope = scopeForMemberDeclarationResolution()
+
+    private fun computeScopeForClassHeaderResolution(): JetScope {
+        val scope = WritableScopeImpl(JetScope.Empty, classDescriptor, RedeclarationHandler.DO_NOTHING, "Scope with type parameters for " + classDescriptor.getName())
+        for (typeParameterDescriptor in classDescriptor.getTypeConstructor().getParameters()) {
+            scope.addClassifierDescriptor(typeParameterDescriptor)
+        }
+        scope.changeLockLevel(WritableScope.LockLevel.READING)
+
+        return ChainedScope(classDescriptor, "ScopeForClassHeaderResolution: " + classDescriptor.getName(), scope, getOuterScope())
+    }
+
+    private fun computeScopeForMemberDeclarationResolution(): JetScope {
+        val thisScope = WritableScopeImpl(JetScope.Empty, classDescriptor, RedeclarationHandler.DO_NOTHING,
+                                          "Scope with 'this' for " + classDescriptor.getName(), classDescriptor.getThisAsReceiverParameter(), classDescriptor)
+        thisScope.changeLockLevel(WritableScope.LockLevel.READING)
+
+        return ChainedScope(
+                classDescriptor,
+                "ScopeForMemberDeclarationResolution: " + classDescriptor.getName(),
+                thisScope,
+                classDescriptor.getUnsubstitutedMemberScope(),
+                getScopeForClassHeaderResolution(),
+                getCompanionObjectScope(),
+                classDescriptor.getStaticScope())
+    }
+
+    private fun getCompanionObjectScope(): JetScope {
+        val companionObjectDescriptor = classDescriptor.getCompanionObjectDescriptor()
+        return if ((companionObjectDescriptor != null)) CompanionObjectMixinScope(companionObjectDescriptor) else JetScope.Empty
+    }
+}
\ No newline at end of file
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyAnnotations.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyAnnotations.kt
index 3cb342e5418..68fbd9bd134 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyAnnotations.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyAnnotations.kt
@@ -21,11 +21,8 @@ import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptor
 import org.jetbrains.kotlin.descriptors.annotations.Annotations
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.psi.JetAnnotationEntry
-import org.jetbrains.kotlin.resolve.AnnotationResolver
-import org.jetbrains.kotlin.resolve.BindingContext
-import org.jetbrains.kotlin.resolve.BindingTrace
-import org.jetbrains.kotlin.resolve.DescriptorUtils
-import org.jetbrains.kotlin.resolve.constants.CompileTimeConstant
+import org.jetbrains.kotlin.resolve.*
+import org.jetbrains.kotlin.resolve.constants.ConstantValue
 import org.jetbrains.kotlin.resolve.lazy.ForceResolveUtil
 import org.jetbrains.kotlin.resolve.lazy.LazyEntity
 import org.jetbrains.kotlin.resolve.scopes.JetScope
@@ -109,7 +106,7 @@ public class LazyAnnotationDescriptor(
 
     override fun getAllValueArguments() = valueArguments()
 
-    private fun computeValueArguments(): Map<ValueParameterDescriptor, CompileTimeConstant<*>> {
+    private fun computeValueArguments(): Map<ValueParameterDescriptor, ConstantValue<*>> {
         val resolutionResults = c.annotationResolver.resolveAnnotationCall(annotationEntry, c.scope, c.trace)
         AnnotationResolver.checkAnnotationType(annotationEntry, c.trace, resolutionResults)
 
@@ -119,9 +116,9 @@ public class LazyAnnotationDescriptor(
         return resolutionResults.getResultingCall().getValueArguments()
                 .mapValues { val (valueParameter, resolvedArgument) = it;
                     if (resolvedArgument == null) null
-                    else AnnotationResolver.getAnnotationArgumentValue(c.trace, valueParameter, resolvedArgument)
+                    else c.annotationResolver.getAnnotationArgumentValue(c.trace, valueParameter, resolvedArgument)
                 }
-                .filterValues { it != null } as Map<ValueParameterDescriptor, CompileTimeConstant<*>>
+                .filterValues { it != null } as Map<ValueParameterDescriptor, ConstantValue<*>>
     }
 
     override fun forceResolveAllContents() {
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyClassDescriptor.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyClassDescriptor.java
index c6d1f72fd60..7426c82f89a 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyClassDescriptor.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyClassDescriptor.java
@@ -87,15 +87,14 @@ public class LazyClassDescriptor extends ClassDescriptorBase implements ClassDes
     private final MemoizedFunctionToNotNull<JetObjectDeclaration, ClassDescriptor> extraCompanionObjectDescriptors;
 
     private final LazyClassMemberScope unsubstitutedMemberScope;
-    private final JetScope staticScope = new StaticScopeForKotlinClass(this);
 
-    private final NotNullLazyValue<JetScope> scopeForClassHeaderResolution;
-    private final NotNullLazyValue<JetScope> scopeForMemberDeclarationResolution;
     private final NotNullLazyValue<JetScope> scopeForPropertyInitializerResolution;
 
     private final NullableLazyValue<Void> forceResolveAllContents;
     private final boolean isCompanionObject;
 
+    private final ClassResolutionScopesSupport resolutionScopesSupport;
+
     public LazyClassDescriptor(
             @NotNull LazyClassContext c,
             @NotNull DeclarationDescriptor containingDeclaration,
@@ -193,18 +192,6 @@ public class LazyClassDescriptor extends ClassDescriptorBase implements ClassDes
                 return computeCompanionObjectDescriptor(companionObject);
             }
         });
-        this.scopeForClassHeaderResolution = storageManager.createLazyValue(new Function0<JetScope>() {
-            @Override
-            public JetScope invoke() {
-                return computeScopeForClassHeaderResolution();
-            }
-        });
-        this.scopeForMemberDeclarationResolution = storageManager.createLazyValue(new Function0<JetScope>() {
-            @Override
-            public JetScope invoke() {
-                return computeScopeForMemberDeclarationResolution();
-            }
-        });
         this.scopeForPropertyInitializerResolution = storageManager.createLazyValue(new Function0<JetScope>() {
             @Override
             public JetScope invoke() {
@@ -218,6 +205,13 @@ public class LazyClassDescriptor extends ClassDescriptorBase implements ClassDes
                 return null;
             }
         }, null);
+
+        this.resolutionScopesSupport = new ClassResolutionScopesSupport(this, storageManager, new Function0<JetScope>() {
+            @Override
+            public JetScope invoke() {
+                return getOuterScope();
+            }
+        });
     }
 
     // NOTE: Called from constructor!
@@ -231,25 +225,14 @@ public class LazyClassDescriptor extends ClassDescriptorBase implements ClassDes
 
     @NotNull
     @Override
-    public JetScope getScopeForMemberLookup() {
+    public JetScope getUnsubstitutedMemberScope() {
         return unsubstitutedMemberScope;
     }
 
     @Override
     @NotNull
     public JetScope getScopeForClassHeaderResolution() {
-        return scopeForClassHeaderResolution.invoke();
-    }
-
-    @NotNull
-    private JetScope computeScopeForClassHeaderResolution() {
-        WritableScopeImpl scope = new WritableScopeImpl(JetScope.Empty.INSTANCE$, this, RedeclarationHandler.DO_NOTHING, "Scope with type parameters for " + getName());
-        for (TypeParameterDescriptor typeParameterDescriptor : getTypeConstructor().getParameters()) {
-            scope.addClassifierDescriptor(typeParameterDescriptor);
-        }
-        scope.changeLockLevel(WritableScope.LockLevel.READING);
-
-        return new ChainedScope(this, "ScopeForClassHeaderResolution: " + getName(), scope, getOuterScope());
+        return resolutionScopesSupport.getScopeForClassHeaderResolution();
     }
 
     @NotNull
@@ -260,29 +243,7 @@ public class LazyClassDescriptor extends ClassDescriptorBase implements ClassDes
     @Override
     @NotNull
     public JetScope getScopeForMemberDeclarationResolution() {
-        return scopeForMemberDeclarationResolution.invoke();
-    }
-
-    @NotNull
-    private JetScope computeScopeForMemberDeclarationResolution() {
-        WritableScopeImpl thisScope = new WritableScopeImpl(JetScope.Empty.INSTANCE$, this, RedeclarationHandler.DO_NOTHING,
-                                                            "Scope with 'this' for " + getName(), this.getThisAsReceiverParameter(), this);
-        thisScope.changeLockLevel(WritableScope.LockLevel.READING);
-
-        return new ChainedScope(
-                this,
-                "ScopeForMemberDeclarationResolution: " + getName(),
-                thisScope,
-                getScopeForMemberLookup(),
-                getScopeForClassHeaderResolution(),
-                getCompanionObjectScope(),
-                getStaticScope()
-        );
-    }
-
-    private JetScope getCompanionObjectScope() {
-        ClassDescriptor companionObjectDescriptor = getCompanionObjectDescriptor();
-        return (companionObjectDescriptor != null) ? new CompanionObjectMixinScope(companionObjectDescriptor) : JetScope.Empty.INSTANCE$;
+        return resolutionScopesSupport.getScopeForMemberDeclarationResolution();
     }
 
     @Override
@@ -331,7 +292,7 @@ public class LazyClassDescriptor extends ClassDescriptorBase implements ClassDes
     @NotNull
     @Override
     public JetScope getStaticScope() {
-        return staticScope;
+        return resolutionScopesSupport.getStaticScope();
     }
 
     @NotNull
@@ -388,7 +349,7 @@ public class LazyClassDescriptor extends ClassDescriptorBase implements ClassDes
         }
         Name name = ((JetClassOrObjectInfo) companionObjectInfo).getName();
         assert name != null;
-        getScopeForMemberLookup().getClassifier(name);
+        getUnsubstitutedMemberScope().getClassifier(name);
         ClassDescriptor companionObjectDescriptor = c.getTrace().get(BindingContext.CLASS, companionObject);
         if (companionObjectDescriptor instanceof LazyClassDescriptor) {
             assert DescriptorUtils.isCompanionObject(companionObjectDescriptor) : "Not a companion object: " + companionObjectDescriptor;
@@ -481,7 +442,7 @@ public class LazyClassDescriptor extends ClassDescriptorBase implements ClassDes
 
         ForceResolveUtil.forceResolveAllContents(getConstructors());
         ForceResolveUtil.forceResolveAllContents(getDescriptorsForExtraCompanionObjects());
-        ForceResolveUtil.forceResolveAllContents(getScopeForMemberLookup());
+        ForceResolveUtil.forceResolveAllContents(getUnsubstitutedMemberScope());
         ForceResolveUtil.forceResolveAllContents(getTypeConstructor());
     }
 
@@ -503,7 +464,7 @@ public class LazyClassDescriptor extends ClassDescriptorBase implements ClassDes
         getOriginal();
         getScopeForClassHeaderResolution();
         getScopeForMemberDeclarationResolution();
-        getScopeForMemberLookup().getAllDescriptors();
+        getUnsubstitutedMemberScope().getAllDescriptors();
         getScopeForInitializerResolution();
         getUnsubstitutedInnerClassesScope();
         getTypeConstructor().getSupertypes();
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyClassMemberScope.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyClassMemberScope.kt
index 9d9c9ffa469..281951e026c 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyClassMemberScope.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyClassMemberScope.kt
@@ -99,7 +99,7 @@ public open class LazyClassMemberScope(
 
     private fun <D : CallableMemberDescriptor> generateFakeOverrides(name: Name, fromSupertypes: Collection<D>, result: MutableCollection<D>, exactDescriptorClass: Class<out D>) {
         OverridingUtil.generateOverridesInFunctionGroup(name, fromSupertypes, ArrayList(result), thisDescriptor, object : OverridingUtil.DescriptorSink {
-            override fun addToScope(fakeOverride: CallableMemberDescriptor) {
+            override fun addFakeOverride(fakeOverride: CallableMemberDescriptor) {
                 assert(exactDescriptorClass.isInstance(fakeOverride)) { "Wrong descriptor type in an override: " + fakeOverride + " while expecting " + exactDescriptorClass.getSimpleName() }
                 @suppress("UNCHECKED_CAST")
                 result.add(fakeOverride as D)
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyScriptClassDescriptor.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyScriptClassDescriptor.java
index 1a81b679724..996e919fd50 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyScriptClassDescriptor.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyScriptClassDescriptor.java
@@ -54,8 +54,8 @@ public class LazyScriptClassDescriptor extends LazyClassDescriptor {
 
     @NotNull
     @Override
-    public LazyScriptClassMemberScope getScopeForMemberLookup() {
-        return (LazyScriptClassMemberScope) super.getScopeForMemberLookup();
+    public LazyScriptClassMemberScope getUnsubstitutedMemberScope() {
+        return (LazyScriptClassMemberScope) super.getUnsubstitutedMemberScope();
     }
 
     @NotNull
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyScriptClassMemberScope.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyScriptClassMemberScope.kt
index 00eb512b7f3..bbe826048b0 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyScriptClassMemberScope.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyScriptClassMemberScope.kt
@@ -97,6 +97,7 @@ public class LazyScriptClassMemberScope protected constructor(
 
         val returnType = scriptDescriptor.getScriptCodeDescriptor().getReturnType()
         assert(returnType != null) { "Return type not initialized for " + scriptDescriptor }
+        returnType!!
 
         propertyDescriptor.setType(
                 returnType,
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyScriptDescriptor.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyScriptDescriptor.kt
index 4fd8535d455..fb05f3d224f 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyScriptDescriptor.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyScriptDescriptor.kt
@@ -16,18 +16,19 @@
 
 package org.jetbrains.kotlin.resolve.lazy.descriptors
 
-import org.jetbrains.kotlin.builtins.KotlinBuiltIns
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptorVisitor
 import org.jetbrains.kotlin.descriptors.PropertyDescriptor
 import org.jetbrains.kotlin.descriptors.ScriptDescriptor
+import org.jetbrains.kotlin.descriptors.SourceElement
 import org.jetbrains.kotlin.descriptors.annotations.Annotations
 import org.jetbrains.kotlin.descriptors.impl.DeclarationDescriptorNonRootImpl
 import org.jetbrains.kotlin.descriptors.impl.ReceiverParameterDescriptorImpl
 import org.jetbrains.kotlin.descriptors.impl.ScriptCodeDescriptor
+import org.jetbrains.kotlin.descriptors.impl.ValueParameterDescriptorImpl
+import org.jetbrains.kotlin.parsing.JetScriptDefinitionProvider
 import org.jetbrains.kotlin.psi.JetScript
 import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.ScriptBodyResolver
-import org.jetbrains.kotlin.resolve.ScriptParameterResolver
 import org.jetbrains.kotlin.resolve.lazy.ForceResolveUtil
 import org.jetbrains.kotlin.resolve.lazy.LazyEntity
 import org.jetbrains.kotlin.resolve.lazy.ResolveSession
@@ -56,7 +57,7 @@ public class LazyScriptDescriptor(
         resolveSession.getTrace().record(BindingContext.SCRIPT, jetScript, this)
     }
 
-    private val implicitReceiver = ReceiverParameterDescriptorImpl(this, KotlinBuiltIns.getInstance().getAnyType(), ScriptReceiver(this))
+    private val implicitReceiver = ReceiverParameterDescriptorImpl(this, ScriptReceiver(this))
 
     override fun getThisAsReceiverParameter() = implicitReceiver
 
@@ -64,13 +65,22 @@ public class LazyScriptDescriptor(
 
     override fun getClassDescriptor() = resolveSession.getClassDescriptorForScript(jetScript) as LazyScriptClassDescriptor
 
-    override fun getScriptResultProperty(): PropertyDescriptor = getClassDescriptor().getScopeForMemberLookup().getScriptResultProperty()
+    override fun getScriptResultProperty(): PropertyDescriptor = getClassDescriptor().getUnsubstitutedMemberScope().getScriptResultProperty()
 
     private val scriptCodeDescriptor = resolveSession.getStorageManager().createLazyValue {
         val result = ScriptCodeDescriptor(this)
+
+        val file = jetScript.getContainingJetFile()
+        val scriptDefinition = JetScriptDefinitionProvider.getInstance(file.getProject()).findScriptDefinition(file)
+
         result.initialize(
                 implicitReceiver,
-                ScriptParameterResolver.resolveScriptParameters(jetScript, this),
+                scriptDefinition.getScriptParameters().mapIndexed { index, scriptParameter ->
+                    ValueParameterDescriptorImpl(
+                            result, null, index, Annotations.EMPTY, scriptParameter.getName(), scriptParameter.getType(),
+                            false, null, SourceElement.NO_SOURCE
+                    )
+                },
                 DeferredType.create(resolveSession.getStorageManager(), resolveSession.getTrace()) {
                     scriptBodyResolver.resolveScriptReturnType(jetScript, this, resolveSession.getTrace())
                 }
@@ -81,7 +91,7 @@ public class LazyScriptDescriptor(
     override fun getScriptCodeDescriptor() = scriptCodeDescriptor()
 
     override fun getScopeForBodyResolution(): JetScope {
-        val parametersScope = WritableScopeImpl(JetScope.Empty, this, RedeclarationHandler.DO_NOTHING, "Parameters of " + this, implicitReceiver)
+        val parametersScope = WritableScopeImpl(JetScope.Empty, this, RedeclarationHandler.DO_NOTHING, "Parameters of $this", implicitReceiver)
         for (valueParameterDescriptor in getScriptCodeDescriptor().getValueParameters()) {
             parametersScope.addVariableDescriptor(valueParameterDescriptor)
         }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/validation/DeprecatedSymbolValidator.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/validation/DeprecatedSymbolValidator.kt
index 11cc047dfe3..b9f7a41ec3a 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/validation/DeprecatedSymbolValidator.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/validation/DeprecatedSymbolValidator.kt
@@ -47,7 +47,7 @@ public class DeprecatedSymbolValidator : SymbolUsageValidator {
     override fun validateTypeUsage(targetDescriptor: ClassifierDescriptor, trace: BindingTrace, element: PsiElement) {
         // Do not check types in annotation entries to prevent cycles in resolve, rely on call message
         val annotationEntry = JetStubbedPsiUtil.getPsiOrStubParent(element, javaClass<JetAnnotationEntry>(), true)
-        if (annotationEntry != null && annotationEntry.getCalleeExpression().getConstructorReferenceExpression() == element)
+        if (annotationEntry != null && annotationEntry.getCalleeExpression()!!.getConstructorReferenceExpression() == element)
             return
 
         // Do not check types in calls to super constructor in extends list, rely on call message
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/storage/LockBasedLazyResolveStorageManager.kt b/compiler/frontend/src/org/jetbrains/kotlin/storage/LockBasedLazyResolveStorageManager.kt
index fb5612e3bf0..4255d781a34 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/storage/LockBasedLazyResolveStorageManager.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/storage/LockBasedLazyResolveStorageManager.kt
@@ -74,7 +74,7 @@ public class LockBasedLazyResolveStorageManager(private val storageManager: Stor
             storageManager.compute { trace.record<K>(slice, key) }
         }
 
-        override fun <K, V> get(slice: ReadOnlySlice<K, V>, key: K): V = storageManager.compute { trace.get<K, V>(slice, key) }
+        override fun <K, V> get(slice: ReadOnlySlice<K, V>, key: K): V? = storageManager.compute { trace.get<K, V>(slice, key) }
 
         override fun <K, V> getKeys(slice: WritableSlice<K, V>): Collection<K> = storageManager.compute { trace.getKeys<K, V>(slice) }
 
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/BasicExpressionTypingVisitor.java b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/BasicExpressionTypingVisitor.java
index e177156ba62..32cd8428878 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/BasicExpressionTypingVisitor.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/BasicExpressionTypingVisitor.java
@@ -55,9 +55,7 @@ import org.jetbrains.kotlin.resolve.calls.tasks.ExplicitReceiverKind;
 import org.jetbrains.kotlin.resolve.calls.tasks.ResolutionCandidate;
 import org.jetbrains.kotlin.resolve.calls.tasks.TracingStrategy;
 import org.jetbrains.kotlin.resolve.calls.util.CallMaker;
-import org.jetbrains.kotlin.resolve.constants.CompileTimeConstant;
-import org.jetbrains.kotlin.resolve.constants.CompileTimeConstantChecker;
-import org.jetbrains.kotlin.resolve.constants.IntegerValueTypeConstant;
+import org.jetbrains.kotlin.resolve.constants.*;
 import org.jetbrains.kotlin.resolve.constants.evaluate.ConstantExpressionEvaluator;
 import org.jetbrains.kotlin.resolve.scopes.JetScope;
 import org.jetbrains.kotlin.resolve.scopes.WritableScopeImpl;
@@ -121,19 +119,20 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
 
     @Override
     public JetTypeInfo visitConstantExpression(@NotNull JetConstantExpression expression, ExpressionTypingContext context) {
-        CompileTimeConstant<?> value = ConstantExpressionEvaluator.evaluate(expression, context.trace, context.expectedType);
+        CompileTimeConstant<?> compileTimeConstant = ConstantExpressionEvaluator.evaluate(expression, context.trace, context.expectedType);
 
-        if (!(value instanceof IntegerValueTypeConstant)) {
+        if (!(compileTimeConstant instanceof IntegerValueTypeConstant)) {
             CompileTimeConstantChecker compileTimeConstantChecker = context.getCompileTimeConstantChecker();
-            boolean hasError = compileTimeConstantChecker.checkConstantExpressionType(value, expression, context.expectedType);
+            ConstantValue constantValue = compileTimeConstant != null ? ((TypedCompileTimeConstant) compileTimeConstant).getConstantValue() : null;
+            boolean hasError = compileTimeConstantChecker.checkConstantExpressionType(constantValue, expression, context.expectedType);
             if (hasError) {
                 IElementType elementType = expression.getNode().getElementType();
                 return TypeInfoFactoryPackage.createTypeInfo(getDefaultType(elementType), context);
             }
         }
 
-        assert value != null : "CompileTimeConstant should be evaluated for constant expression or an error should be recorded " + expression.getText();
-        return createCompileTimeConstantTypeInfo(value, expression, context, components.builtIns);
+        assert compileTimeConstant != null : "CompileTimeConstant should be evaluated for constant expression or an error should be recorded " + expression.getText();
+        return createCompileTimeConstantTypeInfo(compileTimeConstant, expression, context);
     }
 
     @NotNull
@@ -517,7 +516,9 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
     public JetTypeInfo visitClassLiteralExpression(@NotNull JetClassLiteralExpression expression, ExpressionTypingContext c) {
         JetType type = resolveClassLiteral(expression, c);
         if (type != null && !type.isError()) {
-            return TypeInfoFactoryPackage.createTypeInfo(components.reflectionTypes.getKClassType(Annotations.EMPTY, type), c);
+            return TypeInfoFactoryPackage.createCheckedTypeInfo(
+                    components.reflectionTypes.getKClassType(Annotations.EMPTY, type), c, expression
+            );
         }
 
         return TypeInfoFactoryPackage.createTypeInfo(ErrorUtils.createErrorType("Unresolved class"), c);
@@ -641,13 +642,10 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
         };
         ObservableBindingTrace traceAdapter = new ObservableBindingTrace(temporaryTrace);
         traceAdapter.addHandler(CLASS, handler);
-        components.localClassifierAnalyzer.processClassOrObject(components.globalContext,
-                                                                null, // don't need to add classifier of object literal to any scope
+        components.localClassifierAnalyzer.processClassOrObject(null, // don't need to add classifier of object literal to any scope
                                                                 context.replaceBindingTrace(traceAdapter).replaceContextDependency(INDEPENDENT),
                                                                 context.scope.getContainingDeclaration(),
-                                                                expression.getObjectDeclaration(),
-                                                                components.additionalCheckerProvider,
-                                                                components.dynamicTypesSettings);
+                                                                expression.getObjectDeclaration());
         temporaryTrace.commit();
         DataFlowInfo resultFlowInfo = context.dataFlowInfo;
         for (JetDelegationSpecifier specifier: expression.getObjectDeclaration().getDelegationSpecifiers()) {
@@ -694,20 +692,15 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
             return null;
         }
 
-        JetType receiverType = null;
-        if (extensionReceiver != null) {
-            receiverType = extensionReceiver.getType();
-        }
-        else if (dispatchReceiver != null) {
-            receiverType = dispatchReceiver.getType();
-        }
-        boolean isExtension = extensionReceiver != null;
+        JetType receiverType = extensionReceiver != null ? extensionReceiver.getType() :
+                               dispatchReceiver != null ? dispatchReceiver.getType() :
+                               null;
 
         if (descriptor instanceof FunctionDescriptor) {
-            return createFunctionReferenceType(expression, context, (FunctionDescriptor) descriptor, receiverType, isExtension);
+            return createFunctionReferenceType(expression, context, (FunctionDescriptor) descriptor, receiverType);
         }
         else if (descriptor instanceof PropertyDescriptor) {
-            return createPropertyReferenceType(expression, context, (PropertyDescriptor) descriptor, receiverType, isExtension);
+            return createPropertyReferenceType(expression, context, (PropertyDescriptor) descriptor, receiverType);
         }
         else if (descriptor instanceof VariableDescriptor) {
             context.trace.report(UNSUPPORTED.on(reference, "References to variables aren't supported yet"));
@@ -722,16 +715,14 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
             @NotNull JetCallableReferenceExpression expression,
             @NotNull ExpressionTypingContext context,
             @NotNull FunctionDescriptor descriptor,
-            @Nullable JetType receiverType,
-            boolean isExtension
+            @Nullable JetType receiverType
     ) {
         //noinspection ConstantConditions
         JetType type = components.reflectionTypes.getKFunctionType(
                 Annotations.EMPTY,
                 receiverType,
                 getValueParametersTypes(descriptor.getValueParameters()),
-                descriptor.getReturnType(),
-                isExtension
+                descriptor.getReturnType()
         );
 
         AnonymousFunctionDescriptor functionDescriptor = new AnonymousFunctionDescriptor(
@@ -753,11 +744,11 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
             @NotNull JetCallableReferenceExpression expression,
             @NotNull ExpressionTypingContext context,
             @NotNull PropertyDescriptor descriptor,
-            @Nullable JetType receiverType,
-            boolean isExtension
+            @Nullable JetType receiverType
     ) {
-        JetType type = components.reflectionTypes.getKPropertyType(Annotations.EMPTY, receiverType, descriptor.getType(), isExtension,
-                                                                   descriptor.isVar());
+        JetType type = components.reflectionTypes.getKPropertyType(
+                Annotations.EMPTY, receiverType, descriptor.getType(), descriptor.isVar()
+        );
 
         LocalVariableDescriptor localVariable =
                 new LocalVariableDescriptor(context.scope.getContainingDeclaration(), Annotations.EMPTY, Name.special("<anonymous>"),
@@ -947,7 +938,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
         CompileTimeConstant<?> value = ConstantExpressionEvaluator.evaluate(expression, contextWithExpectedType.trace,
                                                                                     contextWithExpectedType.expectedType);
         if (value != null) {
-            return createCompileTimeConstantTypeInfo(value, expression, contextWithExpectedType, components.builtIns);
+            return createCompileTimeConstantTypeInfo(value, expression, contextWithExpectedType);
         }
 
         return DataFlowUtils.checkType(typeInfo.replaceType(result),
@@ -1143,7 +1134,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
                 expression, contextWithExpectedType.trace, contextWithExpectedType.expectedType
         );
         if (value != null) {
-            return createCompileTimeConstantTypeInfo(value, expression, contextWithExpectedType, components.builtIns);
+            return createCompileTimeConstantTypeInfo(value, expression, contextWithExpectedType);
         }
         return DataFlowUtils.checkType(result, expression, contextWithExpectedType);
     }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ControlStructureTypingUtils.java b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ControlStructureTypingUtils.java
index ea78d9cf643..24c4ac42f9f 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ControlStructureTypingUtils.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ControlStructureTypingUtils.java
@@ -375,7 +375,7 @@ public class ControlStructureTypingUtils {
                     return;
                 }
                 JetExpression expression = (JetExpression) call.getCallElement();
-                if (status.hasOnlyErrorsFromPosition(EXPECTED_TYPE_POSITION.position()) || status.hasConflictingConstraints()) {
+                if (status.hasOnlyErrorsDerivedFrom(EXPECTED_TYPE_POSITION) || status.hasConflictingConstraints()) {
                     expression.accept(checkTypeVisitor, new CheckTypeContext(trace, data.expectedType));
                     return;
                 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/DataFlowUtils.java b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/DataFlowUtils.java
index f297b7e2d6d..c189ca513b3 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/DataFlowUtils.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/DataFlowUtils.java
@@ -31,11 +31,9 @@ import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo;
 import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowValue;
 import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowValueFactory;
 import org.jetbrains.kotlin.resolve.calls.smartcasts.SmartCastUtils;
-import org.jetbrains.kotlin.resolve.constants.CompileTimeConstant;
 import org.jetbrains.kotlin.resolve.constants.CompileTimeConstantChecker;
-import org.jetbrains.kotlin.resolve.constants.IntegerValueTypeConstant;
+import org.jetbrains.kotlin.resolve.constants.ConstantValue;
 import org.jetbrains.kotlin.resolve.constants.evaluate.ConstantExpressionEvaluator;
-import org.jetbrains.kotlin.resolve.constants.evaluate.EvaluatePackage;
 import org.jetbrains.kotlin.types.JetType;
 import org.jetbrains.kotlin.types.TypeUtils;
 import org.jetbrains.kotlin.types.TypesPackage;
@@ -176,12 +174,9 @@ public class DataFlowUtils {
         }
 
         if (expression instanceof JetConstantExpression) {
-            CompileTimeConstant<?> value = ConstantExpressionEvaluator.evaluate(expression, c.trace, c.expectedType);
-            if (value instanceof IntegerValueTypeConstant) {
-                value = EvaluatePackage.createCompileTimeConstantWithType((IntegerValueTypeConstant) value, c.expectedType);
-            }
+            ConstantValue<?> constantValue = ConstantExpressionEvaluator.evaluateToConstantValue(expression, c.trace, c.expectedType);
             boolean error = new CompileTimeConstantChecker(c.trace, true)
-                    .checkConstantExpressionType(value, (JetConstantExpression) expression, c.expectedType);
+                    .checkConstantExpressionType(constantValue, (JetConstantExpression) expression, c.expectedType);
             if (hasError != null) hasError.set(error);
             return expressionType;
         }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingServices.java b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingServices.java
index a9126f6a790..9867e0b7776 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingServices.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingServices.java
@@ -37,7 +37,6 @@ import org.jetbrains.kotlin.types.ErrorUtils;
 import org.jetbrains.kotlin.types.JetType;
 import org.jetbrains.kotlin.types.expressions.typeInfoFactory.TypeInfoFactoryPackage;
 
-import javax.inject.Inject;
 import java.util.Iterator;
 import java.util.List;
 
@@ -50,19 +49,15 @@ public class ExpressionTypingServices {
     private final ExpressionTypingFacade expressionTypingFacade;
     private final ExpressionTypingComponents expressionTypingComponents;
 
-    private StatementFilter statementFilter;
+    @NotNull private final StatementFilter statementFilter;
 
-    @Inject
-    public void setStatementFilter(@NotNull StatementFilter statementFilter) {
-        this.statementFilter = statementFilter;
-    }
-
-    public ExpressionTypingServices(@NotNull ExpressionTypingComponents components) {
+    public ExpressionTypingServices(@NotNull ExpressionTypingComponents components, @NotNull StatementFilter statementFilter) {
         this.expressionTypingComponents = components;
+        this.statementFilter = statementFilter;
         this.expressionTypingFacade = ExpressionTypingVisitorDispatcher.create(components);
     }
 
-    public StatementFilter getStatementFilter() {
+    @NotNull public StatementFilter getStatementFilter() {
         return statementFilter;
     }
 
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingUtils.java b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingUtils.java
index d4ec9b5440b..92932bd142e 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingUtils.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingUtils.java
@@ -22,7 +22,6 @@ import com.intellij.psi.tree.IElementType;
 import com.intellij.psi.util.PsiTreeUtil;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
 import org.jetbrains.kotlin.descriptors.*;
 import org.jetbrains.kotlin.diagnostics.Diagnostic;
 import org.jetbrains.kotlin.diagnostics.DiagnosticFactory;
@@ -33,6 +32,7 @@ import org.jetbrains.kotlin.resolve.*;
 import org.jetbrains.kotlin.resolve.calls.ArgumentTypeResolver;
 import org.jetbrains.kotlin.resolve.constants.CompileTimeConstant;
 import org.jetbrains.kotlin.resolve.constants.IntegerValueTypeConstant;
+import org.jetbrains.kotlin.resolve.constants.TypedCompileTimeConstant;
 import org.jetbrains.kotlin.resolve.scopes.WritableScope;
 import org.jetbrains.kotlin.resolve.scopes.WritableScopeImpl;
 import org.jetbrains.kotlin.resolve.scopes.receivers.ClassReceiver;
@@ -246,13 +246,21 @@ public class ExpressionTypingUtils {
     public static JetTypeInfo createCompileTimeConstantTypeInfo(
             @NotNull CompileTimeConstant<?> value,
             @NotNull JetExpression expression,
-            @NotNull ExpressionTypingContext context,
-            @NotNull KotlinBuiltIns kotlinBuiltIns
+            @NotNull ExpressionTypingContext context
     ) {
-        JetType expressionType = value.getType(kotlinBuiltIns);
-        if (value instanceof IntegerValueTypeConstant && context.contextDependency == INDEPENDENT) {
-            expressionType = ((IntegerValueTypeConstant) value).getType(context.expectedType);
-            ArgumentTypeResolver.updateNumberType(expressionType, expression, context);
+        JetType expressionType;
+        if (value instanceof IntegerValueTypeConstant) {
+            IntegerValueTypeConstant integerValueTypeConstant = (IntegerValueTypeConstant) value;
+            if (context.contextDependency == INDEPENDENT) {
+                expressionType = integerValueTypeConstant.getType(context.expectedType);
+                ArgumentTypeResolver.updateNumberType(expressionType, expression, context.statementFilter, context.trace);
+            }
+            else {
+                expressionType = integerValueTypeConstant.getUnknownIntegerType();
+            }
+        }
+        else {
+            expressionType = ((TypedCompileTimeConstant<?>) value).getType();
         }
 
         return TypeInfoFactoryPackage.createCheckedTypeInfo(expressionType, context, expression);
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingVisitorDispatcher.java b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingVisitorDispatcher.java
index 2230f498232..586ec8986e4 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingVisitorDispatcher.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingVisitorDispatcher.java
@@ -18,11 +18,13 @@ package org.jetbrains.kotlin.types.expressions;
 
 import com.intellij.openapi.diagnostic.Logger;
 import com.intellij.openapi.progress.ProcessCanceledException;
+import kotlin.jvm.functions.Function0;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.diagnostics.DiagnosticUtils;
 import org.jetbrains.kotlin.diagnostics.Errors;
 import org.jetbrains.kotlin.psi.*;
+import org.jetbrains.kotlin.resolve.AnnotationTargetChecker;
 import org.jetbrains.kotlin.resolve.BindingContext;
 import org.jetbrains.kotlin.resolve.BindingContextUtils;
 import org.jetbrains.kotlin.resolve.scopes.WritableScope;
@@ -30,6 +32,7 @@ import org.jetbrains.kotlin.types.DeferredType;
 import org.jetbrains.kotlin.types.ErrorUtils;
 import org.jetbrains.kotlin.types.JetType;
 import org.jetbrains.kotlin.types.expressions.typeInfoFactory.TypeInfoFactoryPackage;
+import org.jetbrains.kotlin.util.PerformanceCounter;
 import org.jetbrains.kotlin.util.ReenteringLazyValueComputationException;
 import org.jetbrains.kotlin.utils.KotlinFrontEndException;
 
@@ -38,6 +41,8 @@ import static org.jetbrains.kotlin.resolve.bindingContextUtil.BindingContextUtil
 
 public class ExpressionTypingVisitorDispatcher extends JetVisitor<JetTypeInfo, ExpressionTypingContext> implements ExpressionTypingInternals {
 
+    public static final PerformanceCounter typeInfoPerfCounter = PerformanceCounter.Companion.create("Type info", true);
+
     public interface StatementVisitorProvider {
         ExpressionTypingVisitorForStatements get(@NotNull ExpressionTypingContext context);
     }
@@ -139,7 +144,9 @@ public class ExpressionTypingVisitorDispatcher extends JetVisitor<JetTypeInfo, E
     @Override
     @NotNull
     public final JetTypeInfo getTypeInfo(@NotNull JetExpression expression, ExpressionTypingContext context) {
-        return getTypeInfo(expression, context, this);
+        JetTypeInfo result = getTypeInfo(expression, context, this);
+        AnnotationTargetChecker.INSTANCE$.checkExpression(expression, context.trace);
+        return result;
     }
 
     @Override
@@ -161,50 +168,55 @@ public class ExpressionTypingVisitorDispatcher extends JetVisitor<JetTypeInfo, E
     }
 
     @NotNull
-    private static JetTypeInfo getTypeInfo(@NotNull JetExpression expression, ExpressionTypingContext context, JetVisitor<JetTypeInfo, ExpressionTypingContext> visitor) {
-        try {
-            JetTypeInfo recordedTypeInfo = BindingContextUtils.getRecordedTypeInfo(expression, context.trace.getBindingContext());
-            if (recordedTypeInfo != null) {
-                return recordedTypeInfo;
-            }
-            JetTypeInfo result;
-            try {
-                result = expression.accept(visitor, context);
-                // Some recursive definitions (object expressions) must put their types in the cache manually:
-                //noinspection ConstantConditions
-                if (context.trace.get(BindingContext.PROCESSED, expression)) {
-                    JetType type = context.trace.getBindingContext().getType(expression);
-                    return result.replaceType(type);
-                }
+    private static JetTypeInfo getTypeInfo(@NotNull final JetExpression expression, final ExpressionTypingContext context, final JetVisitor<JetTypeInfo, ExpressionTypingContext> visitor) {
+        return typeInfoPerfCounter.time(new Function0<JetTypeInfo>() {
+            @Override
+            public JetTypeInfo invoke() {
+                try {
+                    JetTypeInfo recordedTypeInfo = BindingContextUtils.getRecordedTypeInfo(expression, context.trace.getBindingContext());
+                    if (recordedTypeInfo != null) {
+                        return recordedTypeInfo;
+                    }
+                    JetTypeInfo result;
+                    try {
+                        result = expression.accept(visitor, context);
+                        // Some recursive definitions (object expressions) must put their types in the cache manually:
+                        //noinspection ConstantConditions
+                        if (context.trace.get(BindingContext.PROCESSED, expression)) {
+                            JetType type = context.trace.getBindingContext().getType(expression);
+                            return result.replaceType(type);
+                        }
 
-                if (result.getType() instanceof DeferredType) {
-                    result = result.replaceType(((DeferredType) result.getType()).getDelegate());
-                }
-                context.trace.record(BindingContext.EXPRESSION_TYPE_INFO, expression, result);
-            }
-            catch (ReenteringLazyValueComputationException e) {
-                context.trace.report(TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM.on(expression));
-                result = TypeInfoFactoryPackage.noTypeInfo(context);
-            }
+                        if (result.getType() instanceof DeferredType) {
+                            result = result.replaceType(((DeferredType) result.getType()).getDelegate());
+                        }
+                        context.trace.record(BindingContext.EXPRESSION_TYPE_INFO, expression, result);
+                    }
+                    catch (ReenteringLazyValueComputationException e) {
+                        context.trace.report(TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM.on(expression));
+                        result = TypeInfoFactoryPackage.noTypeInfo(context);
+                    }
 
-            context.trace.record(BindingContext.PROCESSED, expression);
-            recordScopeAndDataFlowInfo(context.replaceDataFlowInfo(result.getDataFlowInfo()), expression);
-            return result;
-        }
-        catch (ProcessCanceledException e) {
-            throw e;
-        }
-        catch (KotlinFrontEndException e) {
-            throw e;
-        }
-        catch (Throwable e) {
-            context.trace.report(Errors.EXCEPTION_FROM_ANALYZER.on(expression, e));
-            logOrThrowException(expression, e);
-            return TypeInfoFactoryPackage.createTypeInfo(
-                    ErrorUtils.createErrorType(e.getClass().getSimpleName() + " from analyzer"), 
-                    context
-            );        
-        }
+                    context.trace.record(BindingContext.PROCESSED, expression);
+                    recordScopeAndDataFlowInfo(context.replaceDataFlowInfo(result.getDataFlowInfo()), expression);
+                    return result;
+                }
+                catch (ProcessCanceledException e) {
+                    throw e;
+                }
+                catch (KotlinFrontEndException e) {
+                    throw e;
+                }
+                catch (Throwable e) {
+                    context.trace.report(Errors.EXCEPTION_FROM_ANALYZER.on(expression, e));
+                    logOrThrowException(expression, e);
+                    return TypeInfoFactoryPackage.createTypeInfo(
+                            ErrorUtils.createErrorType(e.getClass().getSimpleName() + " from analyzer"),
+                            context
+                    );
+                }
+            }
+        });
     }
 
     private static void logOrThrowException(@NotNull JetExpression expression, Throwable e) {
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingVisitorForStatements.java b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingVisitorForStatements.java
index 6dece3bb9b1..30e12e7e517 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingVisitorForStatements.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingVisitorForStatements.java
@@ -29,10 +29,7 @@ import org.jetbrains.kotlin.diagnostics.Errors;
 import org.jetbrains.kotlin.lexer.JetTokens;
 import org.jetbrains.kotlin.name.Name;
 import org.jetbrains.kotlin.psi.*;
-import org.jetbrains.kotlin.resolve.AnnotationResolver;
-import org.jetbrains.kotlin.resolve.DescriptorUtils;
-import org.jetbrains.kotlin.resolve.ModifiersChecker;
-import org.jetbrains.kotlin.resolve.TemporaryBindingTrace;
+import org.jetbrains.kotlin.resolve.*;
 import org.jetbrains.kotlin.resolve.calls.context.TemporaryTraceAndCache;
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall;
 import org.jetbrains.kotlin.resolve.calls.results.OverloadResolutionResults;
@@ -99,10 +96,9 @@ public class ExpressionTypingVisitorForStatements extends ExpressionTypingVisito
     @Override
     public JetTypeInfo visitObjectDeclaration(@NotNull JetObjectDeclaration declaration, ExpressionTypingContext context) {
         components.localClassifierAnalyzer.processClassOrObject(
-                components.globalContext,
-                scope, context.replaceScope(scope).replaceContextDependency(INDEPENDENT), scope.getContainingDeclaration(), declaration,
-                components.additionalCheckerProvider,
-                components.dynamicTypesSettings);
+                scope, context.replaceScope(scope).replaceContextDependency(INDEPENDENT),
+                scope.getContainingDeclaration(),
+                declaration);
         return TypeInfoFactoryPackage.createTypeInfo(DataFlowUtils.checkStatementType(declaration, context), context);
     }
 
@@ -198,10 +194,9 @@ public class ExpressionTypingVisitorForStatements extends ExpressionTypingVisito
     @Override
     public JetTypeInfo visitClass(@NotNull JetClass klass, ExpressionTypingContext context) {
         components.localClassifierAnalyzer.processClassOrObject(
-                components.globalContext,
-                scope, context.replaceScope(scope).replaceContextDependency(INDEPENDENT), scope.getContainingDeclaration(), klass,
-                components.additionalCheckerProvider,
-                components.dynamicTypesSettings);
+                scope, context.replaceScope(scope).replaceContextDependency(INDEPENDENT),
+                scope.getContainingDeclaration(),
+                klass);
         return TypeInfoFactoryPackage.createTypeInfo(DataFlowUtils.checkStatementType(klass, context), context);
     }
 
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ForLoopConventionsChecker.java b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ForLoopConventionsChecker.java
index d3e70365fda..b82965c9874 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ForLoopConventionsChecker.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ForLoopConventionsChecker.java
@@ -33,7 +33,6 @@ import org.jetbrains.kotlin.resolve.validation.SymbolUsageValidator;
 import org.jetbrains.kotlin.types.JetType;
 import org.jetbrains.kotlin.util.slicedMap.WritableSlice;
 
-import javax.inject.Inject;
 import java.util.Collections;
 
 import static org.jetbrains.kotlin.diagnostics.Errors.*;
@@ -41,22 +40,17 @@ import static org.jetbrains.kotlin.resolve.BindingContext.*;
 
 public class ForLoopConventionsChecker {
 
-    private KotlinBuiltIns builtIns;
-    private SymbolUsageValidator symbolUsageValidator;
-    private FakeCallResolver fakeCallResolver;
+    @NotNull private final KotlinBuiltIns builtIns;
+    @NotNull private final SymbolUsageValidator symbolUsageValidator;
+    @NotNull private final FakeCallResolver fakeCallResolver;
 
-    @Inject
-    public void setBuiltIns(@NotNull KotlinBuiltIns builtIns) {
+    public ForLoopConventionsChecker(
+            @NotNull KotlinBuiltIns builtIns,
+            @NotNull FakeCallResolver fakeCallResolver,
+            @NotNull SymbolUsageValidator symbolUsageValidator
+    ) {
         this.builtIns = builtIns;
-    }
-
-    @Inject
-    public void setFakeCallResolver(@NotNull FakeCallResolver fakeCallResolver) {
         this.fakeCallResolver = fakeCallResolver;
-    }
-
-    @Inject
-    public void setSymbolUsageValidator(SymbolUsageValidator symbolUsageValidator) {
         this.symbolUsageValidator = symbolUsageValidator;
     }
 
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/FunctionsTypingVisitor.kt b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/FunctionsTypingVisitor.kt
index fbc931ea56b..dfa6f649dd9 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/FunctionsTypingVisitor.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/FunctionsTypingVisitor.kt
@@ -214,7 +214,7 @@ public class FunctionsTypingVisitor(facade: ExpressionTypingInternals) : Express
         // This is needed for ControlStructureTypingVisitor#visitReturnExpression() to properly type-check returned expressions
         context.trace.record(EXPECTED_RETURN_TYPE, functionLiteral, expectedType)
         val typeOfBodyExpression = // Type-check the body
-                components.expressionTypingServices.getBlockReturnedType(functionLiteral.getBodyExpression(), COERCION_TO_UNIT, newContext).type
+                components.expressionTypingServices.getBlockReturnedType(functionLiteral.getBodyExpression()!!, COERCION_TO_UNIT, newContext).type
 
         return declaredReturnType ?: computeReturnTypeBasedOnReturnExpressions(functionLiteral, context, typeOfBodyExpression)
     }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/LocalClassifierAnalyzer.kt b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/LocalClassifierAnalyzer.kt
index 242c0f514e3..7ec7c4cf7e2 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/LocalClassifierAnalyzer.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/LocalClassifierAnalyzer.kt
@@ -18,6 +18,7 @@ package org.jetbrains.kotlin.types.expressions
 
 import com.intellij.psi.PsiElement
 import com.intellij.psi.util.PsiTreeUtil
+import org.jetbrains.annotations.NotNull
 import org.jetbrains.kotlin.container.get
 import org.jetbrains.kotlin.context.GlobalContext
 import org.jetbrains.kotlin.context.withModule
@@ -45,19 +46,20 @@ import org.jetbrains.kotlin.storage.StorageManager
 import org.jetbrains.kotlin.types.DynamicTypesSettings
 
 public class LocalClassifierAnalyzer(
-        val descriptorResolver: DescriptorResolver,
-        val funcionDescriptorResolver: FunctionDescriptorResolver,
-        val typeResolver: TypeResolver,
-        val annotationResolver: AnnotationResolver
+        private val globalContext: GlobalContext,
+        private val storageManager: StorageManager,
+        private val descriptorResolver: DescriptorResolver,
+        private val funcionDescriptorResolver: FunctionDescriptorResolver,
+        private val typeResolver: TypeResolver,
+        private val annotationResolver: AnnotationResolver,
+        private val additionalCheckerProvider: AdditionalCheckerProvider,
+        private val dynamicTypesSettings: DynamicTypesSettings
 ) {
     fun processClassOrObject(
-            globalContext: GlobalContext,
             scope: WritableScope?,
             context: ExpressionTypingContext,
             containingDeclaration: DeclarationDescriptor,
-            classOrObject: JetClassOrObject,
-            additionalCheckerProvider: AdditionalCheckerProvider,
-            dynamicTypesSettings: DynamicTypesSettings
+            classOrObject: JetClassOrObject
     ) {
         val module = DescriptorUtils.getContainingModule(containingDeclaration)
         val moduleContext = globalContext.withProject(classOrObject.getProject()).withModule(module)
@@ -70,7 +72,7 @@ public class LocalClassifierAnalyzer(
                         scope,
                         classOrObject,
                         containingDeclaration,
-                        globalContext.storageManager,
+                        storageManager,
                         context,
                         module,
                         descriptorResolver,
@@ -150,8 +152,9 @@ class LocalClassDescriptorHolder(
 class LocalLazyDeclarationResolver(
         globalContext: GlobalContext,
         trace: BindingTrace,
-        val localClassDescriptorManager: LocalClassDescriptorHolder
-) : LazyDeclarationResolver(globalContext, trace) {
+        private val localClassDescriptorManager: LocalClassDescriptorHolder,
+        topLevelDescriptorProvider : TopLevelDescriptorProvider
+) : LazyDeclarationResolver(globalContext, trace, topLevelDescriptorProvider) {
 
     override fun getClassDescriptor(classOrObject: JetClassOrObject): ClassDescriptor {
         if (localClassDescriptorManager.isMyClass(classOrObject)) {
@@ -165,7 +168,7 @@ class LocalLazyDeclarationResolver(
 class DeclarationScopeProviderForLocalClassifierAnalyzer(
         lazyDeclarationResolver: LazyDeclarationResolver,
         fileScopeProvider: FileScopeProvider,
-        val localClassDescriptorManager: LocalClassDescriptorHolder
+        private val localClassDescriptorManager: LocalClassDescriptorHolder
 ) : DeclarationScopeProviderImpl(lazyDeclarationResolver, fileScopeProvider) {
     override fun getResolutionScopeForDeclaration(elementOfDeclaration: PsiElement): JetScope {
         if (localClassDescriptorManager.isMyClass(elementOfDeclaration)) {
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ValueParameterResolver.kt b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ValueParameterResolver.kt
index 43706b62fb4..d71dd0935df 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ValueParameterResolver.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ValueParameterResolver.kt
@@ -19,17 +19,20 @@ package org.jetbrains.kotlin.types.expressions
 import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor
 import org.jetbrains.kotlin.diagnostics.Errors
 import org.jetbrains.kotlin.psi.JetParameter
-import org.jetbrains.kotlin.resolve.*
+import org.jetbrains.kotlin.resolve.AdditionalCheckerProvider
+import org.jetbrains.kotlin.resolve.BindingTrace
+import org.jetbrains.kotlin.resolve.DescriptorResolver
+import org.jetbrains.kotlin.resolve.DescriptorUtils
 import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo
 import org.jetbrains.kotlin.resolve.constants.evaluate.ConstantExpressionEvaluator
 import org.jetbrains.kotlin.resolve.lazy.ForceResolveUtil
 import org.jetbrains.kotlin.resolve.scopes.JetScope
-import org.jetbrains.kotlin.resolve.validation.SymbolUsageValidator
 import org.jetbrains.kotlin.types.TypeUtils
 
 public class ValueParameterResolver(
         private val additionalCheckerProvider: AdditionalCheckerProvider,
-        private val expressionTypingServices: ExpressionTypingServices
+        private val expressionTypingServices: ExpressionTypingServices,
+        private val constantExpressionEvaluator: ConstantExpressionEvaluator
 ) {
     public fun resolveValueParameters(
             valueParameters: List<JetParameter>,
@@ -66,7 +69,7 @@ public class ValueParameterResolver(
         val defaultValue = jetParameter.getDefaultValue() ?: return
         expressionTypingServices.getTypeInfo(defaultValue, context.replaceExpectedType(valueParameterDescriptor.getType()))
         if (DescriptorUtils.isAnnotationClass(DescriptorResolver.getContainingClass(context.scope))) {
-            ConstantExpressionEvaluator.evaluate(defaultValue, context.trace, valueParameterDescriptor.getType())
+            constantExpressionEvaluator.evaluateExpression(defaultValue, context.trace, valueParameterDescriptor.getType())
             ?: context.trace.report(Errors.ANNOTATION_PARAMETER_DEFAULT_VALUE_MUST_BE_CONSTANT.on(defaultValue))
         }
     }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/util/PerformanceCounter.kt b/compiler/frontend/src/org/jetbrains/kotlin/util/PerformanceCounter.kt
index a48fd1b7627..a0aa4e08b75 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/util/PerformanceCounter.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/util/PerformanceCounter.kt
@@ -17,34 +17,22 @@
 package org.jetbrains.kotlin.util
 
 import java.lang.management.ManagementFactory
+import java.util.*
 import java.util.concurrent.TimeUnit
+import java.util.concurrent.atomic.AtomicInteger
+import java.util.concurrent.atomic.AtomicLong
 
-public class PerformanceCounter jvmOverloads constructor (val name: String, val reenterable: Boolean = false) {
+/**
+ * This counter is thread-safe for initialization and usage.
+ * But it may calculate time and number of runs not precisely.
+ */
+public abstract class PerformanceCounter protected constructor(val name: String) {
     companion object {
-        private val threadMxBean = ManagementFactory.getThreadMXBean()
         private val allCounters = arrayListOf<PerformanceCounter>()
 
-        private val enteredCounters = ThreadLocal<MutableSet<PerformanceCounter>>()
+        private var enabled = false
 
-        init {
-            threadMxBean.setThreadCpuTimeEnabled(true)
-        }
-
-        private fun enterCounter(counter: PerformanceCounter): Boolean {
-            var enteredCountersInThread = enteredCounters.get()
-            if (enteredCountersInThread == null) {
-                enteredCountersInThread = hashSetOf(counter)
-                enteredCounters.set(enteredCountersInThread)
-                return true
-            }
-            return enteredCountersInThread.add(counter)
-        }
-
-        private fun leaveCounter(counter: PerformanceCounter) {
-            enteredCounters.get()?.remove(counter)
-        }
-
-        public fun currentThreadCpuTime(): Long = threadMxBean.getCurrentThreadUserTime()
+        public fun currentTime(): Long = System.nanoTime()
 
         public fun report(consumer: (String) -> Unit) {
             val countersCopy = synchronized(allCounters) {
@@ -52,8 +40,40 @@ public class PerformanceCounter jvmOverloads constructor (val name: String, val
             }
             countersCopy.forEach { it.report(consumer) }
         }
+
+        public fun setTimeCounterEnabled(enable: Boolean) {
+            enabled = enable
+        }
+
+        public fun resetAllCounters() {
+            synchronized(allCounters) {
+                allCounters.forEach {
+                    it.reset()
+                }
+            }
+        }
+
+        public jvmOverloads fun create(name: String, reenterable: Boolean = false): PerformanceCounter {
+            return if (reenterable)
+                ReenterableCounter(name)
+            else
+                SimpleCounter(name)
+        }
+
+        public fun create(name: String, vararg excluded: PerformanceCounter): PerformanceCounter = CounterWithExclude(name, *excluded)
+
+        protected inline fun <T> getOrPut(threadLocal: ThreadLocal<T>, default: () -> T) : T {
+            var value = threadLocal.get()
+            if (value == null) {
+                value = default()
+                threadLocal.set(value)
+            }
+            return value
+        }
     }
 
+    protected val excludedFrom: MutableList<CounterWithExclude> = ArrayList()
+
     private var count: Int = 0
     private var totalTimeNanos: Long = 0
 
@@ -63,25 +83,34 @@ public class PerformanceCounter jvmOverloads constructor (val name: String, val
         }
     }
 
-    public fun increment() {
+    public final fun increment() {
         count++
     }
 
-    public fun time<T>(block: () -> T): T {
+    public final fun time<T>(block: () -> T): T {
         count++
-        val needTime = !reenterable || enterCounter(this)
-        val startTime = currentThreadCpuTime()
+        if (!enabled) return block()
+
+        excludedFrom.forEach { it.enterExcludedMethod() }
         try {
-            return block()
+            return countTime(block)
         }
         finally {
-            if (needTime) {
-                totalTimeNanos += currentThreadCpuTime() - startTime
-                if (reenterable) leaveCounter(this)
-            }
+            excludedFrom.forEach { it.exitExcludedMethod() }
         }
     }
 
+    public fun reset() {
+        count = 0
+        totalTimeNanos = 0
+    }
+
+    protected final fun incrementTime(delta: Long) {
+        totalTimeNanos += delta
+    }
+
+    protected abstract fun countTime<T>(block: () -> T): T
+
     public fun report(consumer: (String) -> Unit) {
         if (totalTimeNanos == 0L) {
             consumer("$name performed $count times")
@@ -91,4 +120,112 @@ public class PerformanceCounter jvmOverloads constructor (val name: String, val
             consumer("$name performed $count times, total time $millis ms")
         }
     }
-}
\ No newline at end of file
+}
+
+private class SimpleCounter(name: String): PerformanceCounter(name) {
+    override fun <T> countTime(block: () -> T): T {
+        val startTime = PerformanceCounter.currentTime()
+        try {
+            return block()
+        }
+        finally {
+            incrementTime(PerformanceCounter.currentTime() - startTime)
+        }
+    }
+}
+
+private class ReenterableCounter(name: String): PerformanceCounter(name) {
+    companion object {
+        private val enteredCounters = ThreadLocal<MutableSet<ReenterableCounter>>()
+
+        private fun enterCounter(counter: ReenterableCounter) = PerformanceCounter.getOrPut(enteredCounters) { HashSet() }.add(counter)
+
+        private fun leaveCounter(counter: ReenterableCounter) {
+            enteredCounters.get()?.remove(counter)
+        }
+    }
+
+    override fun <T> countTime(block: () -> T): T {
+        val startTime = PerformanceCounter.currentTime()
+        val needTime = enterCounter(this)
+        try {
+            return block()
+        }
+        finally {
+            if (needTime) {
+                incrementTime(PerformanceCounter.currentTime() - startTime)
+                leaveCounter(this)
+            }
+        }
+    }
+}
+
+/**
+ *  This class allows to calculate pure time for some method excluding some other methods.
+ *  For example, we can calculate total time for CallResolver excluding time for getTypeInfo().
+ *
+ *  Main and excluded methods may be reenterable.
+ */
+private class CounterWithExclude(name: String, vararg excludedCounters: PerformanceCounter): PerformanceCounter(name) {
+    companion object {
+        private val counterToCallStackMapThreadLocal = ThreadLocal<MutableMap<CounterWithExclude, CallStackWithTime>>()
+
+        private fun getCallStack(counter: CounterWithExclude)
+                = PerformanceCounter.getOrPut(counterToCallStackMapThreadLocal) { HashMap() }.getOrPut(counter) { CallStackWithTime() }
+    }
+
+    init {
+        excludedCounters.forEach { it.excludedFrom.add(this) }
+    }
+
+    private val callStack: CallStackWithTime
+        get() = getCallStack(this)
+
+    override fun <T> countTime(block: () -> T): T {
+        incrementTime(callStack.push(true))
+        try {
+            return block()
+        }
+        finally {
+            incrementTime(callStack.pop(true))
+        }
+    }
+
+    fun enterExcludedMethod() {
+        incrementTime(callStack.push(false))
+    }
+
+    fun exitExcludedMethod() {
+        incrementTime(callStack.pop(false))
+    }
+
+    private class CallStackWithTime {
+        private val callStack = Stack<Boolean>()
+        private var intervalStartTime: Long = 0
+
+        fun Stack<Boolean>.peekOrFalse() = if (isEmpty()) false else peek()
+
+        private fun intervalUsefulTime(callStackUpdate: Stack<Boolean>.() -> Unit): Long {
+            val delta = if (callStack.peekOrFalse()) PerformanceCounter.currentTime() - intervalStartTime else 0
+            callStack.callStackUpdate()
+
+            intervalStartTime = PerformanceCounter.currentTime()
+            return delta
+        }
+
+        fun push(usefulCall: Boolean): Long {
+            if (!isEnteredCounter() && !usefulCall) return 0
+
+            return intervalUsefulTime { push(usefulCall) }
+        }
+
+        fun pop(usefulCall: Boolean): Long {
+            if (!isEnteredCounter()) return 0
+
+            assert(callStack.peek() == usefulCall)
+            return intervalUsefulTime { pop() }
+        }
+
+        fun isEnteredCounter(): Boolean = !callStack.isEmpty()
+    }
+}
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/util/capitalizeDecapitalize.kt b/compiler/frontend/src/org/jetbrains/kotlin/util/capitalizeDecapitalize.kt
new file mode 100644
index 00000000000..76aafb5ba58
--- /dev/null
+++ b/compiler/frontend/src/org/jetbrains/kotlin/util/capitalizeDecapitalize.kt
@@ -0,0 +1,46 @@
+/*
+ * Copyright 2010-2015 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.kotlin.util.capitalizeDecapitalize
+
+/**
+ * "FooBar" -> "fooBar"
+ * "FOOBar" -> "fooBar"
+ * "FOO" -> "foo"
+ */
+public fun String.decapitalizeSmart(): String {
+    if (isEmpty() || !charAt(0).isUpperCase()) return this
+
+    if (length() == 1 || !charAt(1).isUpperCase()) {
+        return decapitalize()
+    }
+
+    val secondWordStart = (indices.firstOrNull { !charAt(it).isUpperCase() }
+                           ?: return toLowerCase()) - 1
+    return substring(0, secondWordStart).toLowerCase() + substring(secondWordStart)
+}
+
+/**
+ * "fooBar" -> "FOOBar"
+ * "FooBar" -> "FOOBar"
+ * "foo" -> "FOO"
+ */
+public fun String.capitalizeFirstWord(): String {
+    val secondWordStart = indices.drop(1).firstOrNull { !charAt(it).isLowerCase() }
+                          ?: return toUpperCase()
+    return substring(0, secondWordStart).toUpperCase() + substring(secondWordStart)
+}
+
diff --git a/compiler/light-classes/src/org/jetbrains/kotlin/asJava/KotlinLightMethodForTraitFakeOverride.kt b/compiler/light-classes/src/org/jetbrains/kotlin/asJava/KotlinLightMethodForTraitFakeOverride.kt
index b48223d3724..3328415221b 100644
--- a/compiler/light-classes/src/org/jetbrains/kotlin/asJava/KotlinLightMethodForTraitFakeOverride.kt
+++ b/compiler/light-classes/src/org/jetbrains/kotlin/asJava/KotlinLightMethodForTraitFakeOverride.kt
@@ -33,6 +33,6 @@ public class KotlinLightMethodForTraitFakeOverride(
     override fun getOrigin(): JetDeclaration = origin
 
     override fun copy(): PsiElement {
-        return KotlinLightMethodForTraitFakeOverride(getManager(), delegate, origin.copy() as JetDeclaration, getContainingClass())
+        return KotlinLightMethodForTraitFakeOverride(getManager(), delegate, origin.copy() as JetDeclaration, getContainingClass()!!)
     }
 }
diff --git a/compiler/light-classes/src/org/jetbrains/kotlin/asJava/LightClassUtil.java b/compiler/light-classes/src/org/jetbrains/kotlin/asJava/LightClassUtil.java
index 305e9aadb16..a20d1b07061 100644
--- a/compiler/light-classes/src/org/jetbrains/kotlin/asJava/LightClassUtil.java
+++ b/compiler/light-classes/src/org/jetbrains/kotlin/asJava/LightClassUtil.java
@@ -154,9 +154,8 @@ public class LightClassUtil {
         PsiClass outerPsiClass = getWrappingClass(companionObject);
         if (outerPsiClass != null) {
             for (PsiField fieldOfParent : outerPsiClass.getFields()) {
-                if (!(fieldOfParent instanceof KotlinLightElement)) continue;
-                if (((KotlinLightElement<?, ?>) fieldOfParent).getOrigin() == companionObject &&
-                    fieldOfParent.getName().equals(companionObject.getName())) { // TODO this check is relevant while light class has deprecated OBJECT$ field
+                if ((fieldOfParent instanceof KotlinLightElement) &&
+                    ((KotlinLightElement<?, ?>) fieldOfParent).getOrigin() == companionObject) {
                     return fieldOfParent;
                 }
             }
@@ -291,7 +290,8 @@ public class LightClassUtil {
                     new Function1<PsiMethod, Boolean>() {
                         @Override
                         public Boolean invoke(PsiMethod method) {
-                            return JvmAbi.isAccessorName(method.getName());
+                            String name = method.getName();
+                            return name.startsWith(JvmAbi.GETTER_PREFIX) || name.startsWith(JvmAbi.SETTER_PREFIX);
                         }
                     }
             );
diff --git a/compiler/serialization/src/org/jetbrains/kotlin/serialization/AnnotationSerializer.kt b/compiler/serialization/src/org/jetbrains/kotlin/serialization/AnnotationSerializer.kt
index 0f10bd149d4..fb56b522f35 100644
--- a/compiler/serialization/src/org/jetbrains/kotlin/serialization/AnnotationSerializer.kt
+++ b/compiler/serialization/src/org/jetbrains/kotlin/serialization/AnnotationSerializer.kt
@@ -16,7 +16,6 @@
 
 package org.jetbrains.kotlin.serialization
 
-import org.jetbrains.kotlin.builtins.KotlinBuiltIns
 import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.descriptors.annotations.AnnotationArgumentVisitor
 import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptor
@@ -26,7 +25,8 @@ import org.jetbrains.kotlin.serialization.ProtoBuf.Annotation.Argument.Value.Typ
 import org.jetbrains.kotlin.types.ErrorUtils
 import org.jetbrains.kotlin.types.JetType
 
-public object AnnotationSerializer {
+public class AnnotationSerializer() {
+
     public fun serializeAnnotation(annotation: AnnotationDescriptor, stringTable: StringTable): ProtoBuf.Annotation {
         return with(ProtoBuf.Annotation.newBuilder()) {
             val annotationClass = annotation.getType().getConstructor().getDeclarationDescriptor() as? ClassDescriptor
@@ -48,43 +48,43 @@ public object AnnotationSerializer {
         }
     }
 
-    fun valueProto(constant: CompileTimeConstant<*>, type: JetType, nameTable: StringTable): Value.Builder = with(Value.newBuilder()) {
+    fun valueProto(constant: ConstantValue<*>, type: JetType, nameTable: StringTable): Value.Builder = with(Value.newBuilder()) {
         constant.accept(object : AnnotationArgumentVisitor<Unit, Unit> {
             override fun visitAnnotationValue(value: AnnotationValue, data: Unit) {
                 setType(Type.ANNOTATION)
-                setAnnotation(serializeAnnotation(value.getValue(), nameTable))
+                setAnnotation(serializeAnnotation(value.value, nameTable))
             }
 
             override fun visitArrayValue(value: ArrayValue, data: Unit) {
                 setType(Type.ARRAY)
-                for (element in value.getValue()) {
-                    addArrayElement(valueProto(element, KotlinBuiltIns.getInstance().getArrayElementType(type), nameTable).build())
+                for (element in value.value) {
+                    addArrayElement(valueProto(element, value.elementType, nameTable).build())
                 }
             }
 
             override fun visitBooleanValue(value: BooleanValue, data: Unit) {
                 setType(Type.BOOLEAN)
-                setIntValue(if (value.getValue()) 1 else 0)
+                setIntValue(if (value.value) 1 else 0)
             }
 
             override fun visitByteValue(value: ByteValue, data: Unit) {
                 setType(Type.BYTE)
-                setIntValue(value.getValue().toLong())
+                setIntValue(value.value.toLong())
             }
 
             override fun visitCharValue(value: CharValue, data: Unit) {
                 setType(Type.CHAR)
-                setIntValue(value.getValue().toLong())
+                setIntValue(value.value.toLong())
             }
 
             override fun visitDoubleValue(value: DoubleValue, data: Unit) {
                 setType(Type.DOUBLE)
-                setDoubleValue(value.getValue())
+                setDoubleValue(value.value)
             }
 
             override fun visitEnumValue(value: EnumValue, data: Unit) {
                 setType(Type.ENUM)
-                val enumEntry = value.getValue()
+                val enumEntry = value.value
                 setClassId(nameTable.getFqNameIndex(enumEntry.getContainingDeclaration() as ClassDescriptor))
                 setEnumValueId(nameTable.getSimpleNameIndex(enumEntry.getName()))
             }
@@ -95,12 +95,12 @@ public object AnnotationSerializer {
 
             override fun visitFloatValue(value: FloatValue, data: Unit) {
                 setType(Type.FLOAT)
-                setFloatValue(value.getValue())
+                setFloatValue(value.value)
             }
 
             override fun visitIntValue(value: IntValue, data: Unit) {
                 setType(Type.INT)
-                setIntValue(value.getValue().toLong())
+                setIntValue(value.value.toLong())
             }
 
             override fun visitKClassValue(value: KClassValue?, data: Unit?) {
@@ -110,37 +110,21 @@ public object AnnotationSerializer {
 
             override fun visitLongValue(value: LongValue, data: Unit) {
                 setType(Type.LONG)
-                setIntValue(value.getValue())
+                setIntValue(value.value)
             }
 
             override fun visitNullValue(value: NullValue, data: Unit) {
                 throw UnsupportedOperationException("Null should not appear in annotation arguments")
             }
 
-            override fun visitNumberTypeValue(constant: IntegerValueTypeConstant, data: Unit) {
-                // TODO: IntegerValueTypeConstant should not occur in annotation arguments
-                val number = constant.getValue(type)
-                val specificConstant = with(KotlinBuiltIns.getInstance()) {
-                    when (type) {
-                        getLongType() -> LongValue(number.toLong(), true, true, true)
-                        getIntType() -> IntValue(number.toInt(), true, true, true)
-                        getShortType() -> ShortValue(number.toShort(), true, true, true)
-                        getByteType() -> ByteValue(number.toByte(), true, true, true)
-                        else -> throw IllegalStateException("Integer constant $constant has non-integer type $type")
-                    }
-                }
-
-                specificConstant.accept(this, data)
-            }
-
             override fun visitShortValue(value: ShortValue, data: Unit) {
                 setType(Type.SHORT)
-                setIntValue(value.getValue().toLong())
+                setIntValue(value.value.toLong())
             }
 
             override fun visitStringValue(value: StringValue, data: Unit) {
                 setType(Type.STRING)
-                setStringValue(nameTable.getStringIndex(value.getValue()))
+                setStringValue(nameTable.getStringIndex(value.value))
             }
         }, Unit)
 
diff --git a/compiler/serialization/src/org/jetbrains/kotlin/serialization/DescriptorSerializer.java b/compiler/serialization/src/org/jetbrains/kotlin/serialization/DescriptorSerializer.java
index c48b5449257..d1d0cdede90 100644
--- a/compiler/serialization/src/org/jetbrains/kotlin/serialization/DescriptorSerializer.java
+++ b/compiler/serialization/src/org/jetbrains/kotlin/serialization/DescriptorSerializer.java
@@ -24,7 +24,7 @@ import org.jetbrains.kotlin.descriptors.*;
 import org.jetbrains.kotlin.descriptors.annotations.Annotated;
 import org.jetbrains.kotlin.resolve.DescriptorFactory;
 import org.jetbrains.kotlin.resolve.MemberComparator;
-import org.jetbrains.kotlin.resolve.constants.CompileTimeConstant;
+import org.jetbrains.kotlin.resolve.constants.ConstantValue;
 import org.jetbrains.kotlin.resolve.constants.NullValue;
 import org.jetbrains.kotlin.types.*;
 
@@ -188,7 +188,7 @@ public class DescriptorSerializer {
                 }
             }
 
-            CompileTimeConstant<?> compileTimeConstant = propertyDescriptor.getCompileTimeInitializer();
+            ConstantValue<?> compileTimeConstant = propertyDescriptor.getCompileTimeInitializer();
             hasConstant = !(compileTimeConstant == null || compileTimeConstant instanceof NullValue);
         }
 
diff --git a/compiler/serialization/src/org/jetbrains/kotlin/serialization/builtins/BuiltInsSerializerExtension.kt b/compiler/serialization/src/org/jetbrains/kotlin/serialization/builtins/BuiltInsSerializerExtension.kt
index b5b4de0c193..623a46d10ed 100644
--- a/compiler/serialization/src/org/jetbrains/kotlin/serialization/builtins/BuiltInsSerializerExtension.kt
+++ b/compiler/serialization/src/org/jetbrains/kotlin/serialization/builtins/BuiltInsSerializerExtension.kt
@@ -16,25 +16,18 @@
 
 package org.jetbrains.kotlin.serialization.builtins
 
-import org.jetbrains.kotlin.builtins.KotlinBuiltIns
-import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor
-import org.jetbrains.kotlin.descriptors.ClassDescriptor
-import org.jetbrains.kotlin.descriptors.PackageFragmentDescriptor
-import org.jetbrains.kotlin.descriptors.PropertyDescriptor
-import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor
+import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.resolve.constants.NullValue
-import org.jetbrains.kotlin.resolve.descriptorUtil.builtIns
 import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter
-import org.jetbrains.kotlin.serialization.AnnotationSerializer
-import org.jetbrains.kotlin.serialization.DescriptorSerializer
-import org.jetbrains.kotlin.serialization.ProtoBuf
-import org.jetbrains.kotlin.serialization.SerializerExtension
-import org.jetbrains.kotlin.serialization.StringTable
+import org.jetbrains.kotlin.serialization.*
+
+public class BuiltInsSerializerExtension() : SerializerExtension() {
+
+    private val annotationSerializer = AnnotationSerializer()
 
-public object BuiltInsSerializerExtension : SerializerExtension() {
     override fun serializeClass(descriptor: ClassDescriptor, proto: ProtoBuf.Class.Builder, stringTable: StringTable) {
         for (annotation in descriptor.getAnnotations()) {
-            proto.addExtension(BuiltInsProtoBuf.classAnnotation, AnnotationSerializer.serializeAnnotation(annotation, stringTable))
+            proto.addExtension(BuiltInsProtoBuf.classAnnotation, annotationSerializer.serializeAnnotation(annotation, stringTable))
         }
     }
 
@@ -58,13 +51,13 @@ public object BuiltInsSerializerExtension : SerializerExtension() {
             stringTable: StringTable
     ) {
         for (annotation in callable.getAnnotations()) {
-            proto.addExtension(BuiltInsProtoBuf.callableAnnotation, AnnotationSerializer.serializeAnnotation(annotation, stringTable))
+            proto.addExtension(BuiltInsProtoBuf.callableAnnotation, annotationSerializer.serializeAnnotation(annotation, stringTable))
         }
         val propertyDescriptor = callable as? PropertyDescriptor ?: return
         val compileTimeConstant = propertyDescriptor.getCompileTimeInitializer()
         if (compileTimeConstant != null && compileTimeConstant !is NullValue) {
-            val type = compileTimeConstant.getType(propertyDescriptor.builtIns)
-            proto.setExtension(BuiltInsProtoBuf.compileTimeValue, AnnotationSerializer.valueProto(compileTimeConstant, type, stringTable).build())
+            val valueProto = annotationSerializer.valueProto(compileTimeConstant, compileTimeConstant.type, stringTable)
+            proto.setExtension(BuiltInsProtoBuf.compileTimeValue, valueProto.build())
         }
     }
 
@@ -74,7 +67,7 @@ public object BuiltInsSerializerExtension : SerializerExtension() {
             stringTable: StringTable
     ) {
         for (annotation in descriptor.getAnnotations()) {
-            proto.addExtension(BuiltInsProtoBuf.parameterAnnotation, AnnotationSerializer.serializeAnnotation(annotation, stringTable))
+            proto.addExtension(BuiltInsProtoBuf.parameterAnnotation, annotationSerializer.serializeAnnotation(annotation, stringTable))
         }
     }
 }
\ No newline at end of file
diff --git a/compiler/testData/asJava/lightClasses/nullabilityAnnotations/ClassObjectField.java b/compiler/testData/asJava/lightClasses/nullabilityAnnotations/ClassObjectField.java
index 216eca84c56..74373b189c7 100644
--- a/compiler/testData/asJava/lightClasses/nullabilityAnnotations/ClassObjectField.java
+++ b/compiler/testData/asJava/lightClasses/nullabilityAnnotations/ClassObjectField.java
@@ -3,11 +3,6 @@ public final class ClassObjectField {
     public static final java.lang.String x = "";
     private static final java.lang.String y = "";
     public static final ClassObjectField.Companion Companion;
-    /**
-     * @deprecated
-     */
-    @java.lang.Deprecated
-    public static final ClassObjectField.Companion OBJECT$;
 
     public ClassObjectField() { /* compiled code */ }
 
diff --git a/compiler/testData/asJava/lightClasses/nullabilityAnnotations/TraitClassObjectField.java b/compiler/testData/asJava/lightClasses/nullabilityAnnotations/TraitClassObjectField.java
index 27b9d09742c..6a1577a11e3 100644
--- a/compiler/testData/asJava/lightClasses/nullabilityAnnotations/TraitClassObjectField.java
+++ b/compiler/testData/asJava/lightClasses/nullabilityAnnotations/TraitClassObjectField.java
@@ -1,10 +1,5 @@
 public interface TraitClassObjectField {
     TraitClassObjectField.Companion Companion;
-    /**
-     * @deprecated
-     */
-    @java.lang.Deprecated
-    TraitClassObjectField.Companion OBJECT$;
     @org.jetbrains.annotations.Nullable
     java.lang.String x = "";
 
diff --git a/compiler/testData/asJava/lightClasses/publicField/CompanionObject.java b/compiler/testData/asJava/lightClasses/publicField/CompanionObject.java
new file mode 100644
index 00000000000..dcd3d456f9c
--- /dev/null
+++ b/compiler/testData/asJava/lightClasses/publicField/CompanionObject.java
@@ -0,0 +1,13 @@
+public final class C {
+    @kotlin.jvm.publicField
+    public static final java.lang.String foo = "A";
+    public static final C.Companion Companion;
+
+    public C() { /* compiled code */ }
+
+    public static final class Companion {
+        private final java.lang.String getFoo() { /* compiled code */ }
+
+        private Companion() { /* compiled code */ }
+    }
+}
\ No newline at end of file
diff --git a/compiler/testData/asJava/lightClasses/publicField/CompanionObject.kt b/compiler/testData/asJava/lightClasses/publicField/CompanionObject.kt
new file mode 100644
index 00000000000..d51b5963d95
--- /dev/null
+++ b/compiler/testData/asJava/lightClasses/publicField/CompanionObject.kt
@@ -0,0 +1,7 @@
+// C
+
+class C {
+    companion object {
+        @[publicField] private val foo: String = "A"
+    }
+}
diff --git a/compiler/testData/asJava/lightClasses/publicField/Simple.java b/compiler/testData/asJava/lightClasses/publicField/Simple.java
new file mode 100644
index 00000000000..96daa4f378a
--- /dev/null
+++ b/compiler/testData/asJava/lightClasses/publicField/Simple.java
@@ -0,0 +1,6 @@
+public final class C {
+    @kotlin.jvm.publicField
+    public final java.lang.String foo = "A";
+
+    public C() { /* compiled code */ }
+}
\ No newline at end of file
diff --git a/compiler/testData/asJava/lightClasses/publicField/Simple.kt b/compiler/testData/asJava/lightClasses/publicField/Simple.kt
new file mode 100644
index 00000000000..d6225c5a956
--- /dev/null
+++ b/compiler/testData/asJava/lightClasses/publicField/Simple.kt
@@ -0,0 +1,5 @@
+// C
+
+class C {
+    @[kotlin.jvm.publicField] private val foo: String = "A"
+}
diff --git a/compiler/testData/builtin-classes.txt b/compiler/testData/builtin-classes.txt
index f17d20445cd..18247418e80 100644
--- a/compiler/testData/builtin-classes.txt
+++ b/compiler/testData/builtin-classes.txt
@@ -49,7 +49,6 @@ public abstract class BooleanIterator : kotlin.Iterator<kotlin.Boolean> {
 public final class Byte : kotlin.Number, kotlin.Comparable<kotlin.Byte> {
     /*primary*/ private constructor Byte()
     public open override /*1*/ fun compareTo(/*0*/ other: kotlin.Byte): kotlin.Int
-    kotlin.deprecated(value = "This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.") public final fun compareTo(/*0*/ other: kotlin.Char): kotlin.Int
     public final fun compareTo(/*0*/ other: kotlin.Double): kotlin.Int
     public final fun compareTo(/*0*/ other: kotlin.Float): kotlin.Int
     public final fun compareTo(/*0*/ other: kotlin.Int): kotlin.Int
@@ -57,7 +56,6 @@ public final class Byte : kotlin.Number, kotlin.Comparable<kotlin.Byte> {
     public final fun compareTo(/*0*/ other: kotlin.Short): kotlin.Int
     public final fun dec(): kotlin.Byte
     public final fun div(/*0*/ other: kotlin.Byte): kotlin.Int
-    kotlin.deprecated(value = "This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.") public final fun div(/*0*/ other: kotlin.Char): kotlin.Int
     public final fun div(/*0*/ other: kotlin.Double): kotlin.Double
     public final fun div(/*0*/ other: kotlin.Float): kotlin.Float
     public final fun div(/*0*/ other: kotlin.Int): kotlin.Int
@@ -66,14 +64,12 @@ public final class Byte : kotlin.Number, kotlin.Comparable<kotlin.Byte> {
     public final fun inc(): kotlin.Byte
     public final fun minus(): kotlin.Int
     public final fun minus(/*0*/ other: kotlin.Byte): kotlin.Int
-    kotlin.deprecated(value = "This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.") public final fun minus(/*0*/ other: kotlin.Char): kotlin.Int
     public final fun minus(/*0*/ other: kotlin.Double): kotlin.Double
     public final fun minus(/*0*/ other: kotlin.Float): kotlin.Float
     public final fun minus(/*0*/ other: kotlin.Int): kotlin.Int
     public final fun minus(/*0*/ other: kotlin.Long): kotlin.Long
     public final fun minus(/*0*/ other: kotlin.Short): kotlin.Int
     public final fun mod(/*0*/ other: kotlin.Byte): kotlin.Int
-    kotlin.deprecated(value = "This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.") public final fun mod(/*0*/ other: kotlin.Char): kotlin.Int
     public final fun mod(/*0*/ other: kotlin.Double): kotlin.Double
     public final fun mod(/*0*/ other: kotlin.Float): kotlin.Float
     public final fun mod(/*0*/ other: kotlin.Int): kotlin.Int
@@ -81,21 +77,18 @@ public final class Byte : kotlin.Number, kotlin.Comparable<kotlin.Byte> {
     public final fun mod(/*0*/ other: kotlin.Short): kotlin.Int
     public final fun plus(): kotlin.Int
     public final fun plus(/*0*/ other: kotlin.Byte): kotlin.Int
-    kotlin.deprecated(value = "This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.") public final fun plus(/*0*/ other: kotlin.Char): kotlin.Int
     public final fun plus(/*0*/ other: kotlin.Double): kotlin.Double
     public final fun plus(/*0*/ other: kotlin.Float): kotlin.Float
     public final fun plus(/*0*/ other: kotlin.Int): kotlin.Int
     public final fun plus(/*0*/ other: kotlin.Long): kotlin.Long
     public final fun plus(/*0*/ other: kotlin.Short): kotlin.Int
     public final fun rangeTo(/*0*/ other: kotlin.Byte): kotlin.ByteRange
-    kotlin.deprecated(value = "This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.") public final fun rangeTo(/*0*/ other: kotlin.Char): kotlin.CharRange
     public final fun rangeTo(/*0*/ other: kotlin.Double): kotlin.DoubleRange
     public final fun rangeTo(/*0*/ other: kotlin.Float): kotlin.FloatRange
     public final fun rangeTo(/*0*/ other: kotlin.Int): kotlin.IntRange
     public final fun rangeTo(/*0*/ other: kotlin.Long): kotlin.LongRange
     public final fun rangeTo(/*0*/ other: kotlin.Short): kotlin.ShortRange
     public final fun times(/*0*/ other: kotlin.Byte): kotlin.Int
-    kotlin.deprecated(value = "This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.") public final fun times(/*0*/ other: kotlin.Char): kotlin.Int
     public final fun times(/*0*/ other: kotlin.Double): kotlin.Double
     public final fun times(/*0*/ other: kotlin.Float): kotlin.Float
     public final fun times(/*0*/ other: kotlin.Int): kotlin.Int
@@ -184,49 +177,13 @@ public final class ByteRange : kotlin.Range<kotlin.Byte>, kotlin.Progression<kot
 
 public final class Char : kotlin.Comparable<kotlin.Char> {
     /*primary*/ private constructor Char()
-    kotlin.deprecated(value = "This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int or other operand to Char.") public final fun compareTo(/*0*/ other: kotlin.Byte): kotlin.Int
     public open override /*1*/ fun compareTo(/*0*/ other: kotlin.Char): kotlin.Int
-    kotlin.deprecated(value = "This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.") public final fun compareTo(/*0*/ other: kotlin.Double): kotlin.Int
-    kotlin.deprecated(value = "This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.") public final fun compareTo(/*0*/ other: kotlin.Float): kotlin.Int
-    kotlin.deprecated(value = "This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int or other operand to Char.") public final fun compareTo(/*0*/ other: kotlin.Int): kotlin.Int
-    kotlin.deprecated(value = "This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int or other operand to Char.") public final fun compareTo(/*0*/ other: kotlin.Long): kotlin.Int
-    kotlin.deprecated(value = "This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int or other operand to Char.") public final fun compareTo(/*0*/ other: kotlin.Short): kotlin.Int
     public final fun dec(): kotlin.Char
-    kotlin.deprecated(value = "This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.") public final fun div(/*0*/ other: kotlin.Byte): kotlin.Int
-    kotlin.deprecated(value = "This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.") public final fun div(/*0*/ other: kotlin.Double): kotlin.Double
-    kotlin.deprecated(value = "This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.") public final fun div(/*0*/ other: kotlin.Float): kotlin.Float
-    kotlin.deprecated(value = "This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.") public final fun div(/*0*/ other: kotlin.Int): kotlin.Int
-    kotlin.deprecated(value = "This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.") public final fun div(/*0*/ other: kotlin.Long): kotlin.Long
-    kotlin.deprecated(value = "This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.") public final fun div(/*0*/ other: kotlin.Short): kotlin.Int
     public final fun inc(): kotlin.Char
-    kotlin.deprecated(value = "This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.") public final fun minus(): kotlin.Int
-    kotlin.deprecated(value = "This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.") public final fun minus(/*0*/ other: kotlin.Byte): kotlin.Int
     public final fun minus(/*0*/ other: kotlin.Char): kotlin.Int
-    kotlin.deprecated(value = "This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.") public final fun minus(/*0*/ other: kotlin.Double): kotlin.Double
-    kotlin.deprecated(value = "This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.") public final fun minus(/*0*/ other: kotlin.Float): kotlin.Float
-    kotlin.deprecated(value = "This operation will change return type to Char in M13. Either call toInt or toChar on return value or convert Char operand to Int.") public final fun minus(/*0*/ other: kotlin.Int): kotlin.Int
-    kotlin.deprecated(value = "This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.") public final fun minus(/*0*/ other: kotlin.Long): kotlin.Long
-    kotlin.deprecated(value = "This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.") public final fun minus(/*0*/ other: kotlin.Short): kotlin.Int
-    kotlin.deprecated(value = "This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.") public final fun mod(/*0*/ other: kotlin.Byte): kotlin.Int
-    kotlin.deprecated(value = "This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.") public final fun mod(/*0*/ other: kotlin.Double): kotlin.Double
-    kotlin.deprecated(value = "This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.") public final fun mod(/*0*/ other: kotlin.Float): kotlin.Float
-    kotlin.deprecated(value = "This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.") public final fun mod(/*0*/ other: kotlin.Int): kotlin.Int
-    kotlin.deprecated(value = "This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.") public final fun mod(/*0*/ other: kotlin.Long): kotlin.Long
-    kotlin.deprecated(value = "This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.") public final fun mod(/*0*/ other: kotlin.Short): kotlin.Int
-    kotlin.deprecated(value = "This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.") public final fun plus(): kotlin.Int
-    kotlin.deprecated(value = "This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.") public final fun plus(/*0*/ other: kotlin.Byte): kotlin.Int
-    kotlin.deprecated(value = "This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.") public final fun plus(/*0*/ other: kotlin.Double): kotlin.Double
-    kotlin.deprecated(value = "This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.") public final fun plus(/*0*/ other: kotlin.Float): kotlin.Float
-    kotlin.deprecated(value = "This operation will change return type to Char in M13. Either call toInt or toChar on return value or convert Char operand to Int.") public final fun plus(/*0*/ other: kotlin.Int): kotlin.Int
-    kotlin.deprecated(value = "This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.") public final fun plus(/*0*/ other: kotlin.Long): kotlin.Long
-    kotlin.deprecated(value = "This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.") public final fun plus(/*0*/ other: kotlin.Short): kotlin.Int
+    public final fun minus(/*0*/ other: kotlin.Int): kotlin.Char
+    public final fun plus(/*0*/ other: kotlin.Int): kotlin.Char
     public final fun rangeTo(/*0*/ other: kotlin.Char): kotlin.CharRange
-    kotlin.deprecated(value = "This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.") public final fun times(/*0*/ other: kotlin.Byte): kotlin.Int
-    kotlin.deprecated(value = "This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.") public final fun times(/*0*/ other: kotlin.Double): kotlin.Double
-    kotlin.deprecated(value = "This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.") public final fun times(/*0*/ other: kotlin.Float): kotlin.Float
-    kotlin.deprecated(value = "This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.") public final fun times(/*0*/ other: kotlin.Int): kotlin.Int
-    kotlin.deprecated(value = "This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.") public final fun times(/*0*/ other: kotlin.Long): kotlin.Long
-    kotlin.deprecated(value = "This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.") public final fun times(/*0*/ other: kotlin.Short): kotlin.Int
     public open fun toByte(): kotlin.Byte
     public open fun toChar(): kotlin.Char
     public open fun toDouble(): kotlin.Double
@@ -329,7 +286,6 @@ public interface Comparable</*0*/ in T> {
 public final class Double : kotlin.Number, kotlin.Comparable<kotlin.Double> {
     /*primary*/ private constructor Double()
     public final fun compareTo(/*0*/ other: kotlin.Byte): kotlin.Int
-    kotlin.deprecated(value = "This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.") public final fun compareTo(/*0*/ other: kotlin.Char): kotlin.Int
     public open override /*1*/ fun compareTo(/*0*/ other: kotlin.Double): kotlin.Int
     public final fun compareTo(/*0*/ other: kotlin.Float): kotlin.Int
     public final fun compareTo(/*0*/ other: kotlin.Int): kotlin.Int
@@ -337,7 +293,6 @@ public final class Double : kotlin.Number, kotlin.Comparable<kotlin.Double> {
     public final fun compareTo(/*0*/ other: kotlin.Short): kotlin.Int
     public final fun dec(): kotlin.Double
     public final fun div(/*0*/ other: kotlin.Byte): kotlin.Double
-    kotlin.deprecated(value = "This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.") public final fun div(/*0*/ other: kotlin.Char): kotlin.Double
     public final fun div(/*0*/ other: kotlin.Double): kotlin.Double
     public final fun div(/*0*/ other: kotlin.Float): kotlin.Double
     public final fun div(/*0*/ other: kotlin.Int): kotlin.Double
@@ -346,14 +301,12 @@ public final class Double : kotlin.Number, kotlin.Comparable<kotlin.Double> {
     public final fun inc(): kotlin.Double
     public final fun minus(): kotlin.Double
     public final fun minus(/*0*/ other: kotlin.Byte): kotlin.Double
-    kotlin.deprecated(value = "This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.") public final fun minus(/*0*/ other: kotlin.Char): kotlin.Double
     public final fun minus(/*0*/ other: kotlin.Double): kotlin.Double
     public final fun minus(/*0*/ other: kotlin.Float): kotlin.Double
     public final fun minus(/*0*/ other: kotlin.Int): kotlin.Double
     public final fun minus(/*0*/ other: kotlin.Long): kotlin.Double
     public final fun minus(/*0*/ other: kotlin.Short): kotlin.Double
     public final fun mod(/*0*/ other: kotlin.Byte): kotlin.Double
-    kotlin.deprecated(value = "This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.") public final fun mod(/*0*/ other: kotlin.Char): kotlin.Double
     public final fun mod(/*0*/ other: kotlin.Double): kotlin.Double
     public final fun mod(/*0*/ other: kotlin.Float): kotlin.Double
     public final fun mod(/*0*/ other: kotlin.Int): kotlin.Double
@@ -361,21 +314,18 @@ public final class Double : kotlin.Number, kotlin.Comparable<kotlin.Double> {
     public final fun mod(/*0*/ other: kotlin.Short): kotlin.Double
     public final fun plus(): kotlin.Double
     public final fun plus(/*0*/ other: kotlin.Byte): kotlin.Double
-    kotlin.deprecated(value = "This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.") public final fun plus(/*0*/ other: kotlin.Char): kotlin.Double
     public final fun plus(/*0*/ other: kotlin.Double): kotlin.Double
     public final fun plus(/*0*/ other: kotlin.Float): kotlin.Double
     public final fun plus(/*0*/ other: kotlin.Int): kotlin.Double
     public final fun plus(/*0*/ other: kotlin.Long): kotlin.Double
     public final fun plus(/*0*/ other: kotlin.Short): kotlin.Double
     public final fun rangeTo(/*0*/ other: kotlin.Byte): kotlin.DoubleRange
-    kotlin.deprecated(value = "This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.") public final fun rangeTo(/*0*/ other: kotlin.Char): kotlin.DoubleRange
     public final fun rangeTo(/*0*/ other: kotlin.Double): kotlin.DoubleRange
     public final fun rangeTo(/*0*/ other: kotlin.Float): kotlin.DoubleRange
     public final fun rangeTo(/*0*/ other: kotlin.Int): kotlin.DoubleRange
     public final fun rangeTo(/*0*/ other: kotlin.Long): kotlin.DoubleRange
     public final fun rangeTo(/*0*/ other: kotlin.Short): kotlin.DoubleRange
     public final fun times(/*0*/ other: kotlin.Byte): kotlin.Double
-    kotlin.deprecated(value = "This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.") public final fun times(/*0*/ other: kotlin.Char): kotlin.Double
     public final fun times(/*0*/ other: kotlin.Double): kotlin.Double
     public final fun times(/*0*/ other: kotlin.Float): kotlin.Double
     public final fun times(/*0*/ other: kotlin.Int): kotlin.Double
@@ -479,7 +429,6 @@ public abstract class Enum</*0*/ E : kotlin.Enum<E>> : kotlin.Comparable<E> {
 public final class Float : kotlin.Number, kotlin.Comparable<kotlin.Float> {
     /*primary*/ private constructor Float()
     public final fun compareTo(/*0*/ other: kotlin.Byte): kotlin.Int
-    kotlin.deprecated(value = "This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.") public final fun compareTo(/*0*/ other: kotlin.Char): kotlin.Int
     public final fun compareTo(/*0*/ other: kotlin.Double): kotlin.Int
     public open override /*1*/ fun compareTo(/*0*/ other: kotlin.Float): kotlin.Int
     public final fun compareTo(/*0*/ other: kotlin.Int): kotlin.Int
@@ -487,7 +436,6 @@ public final class Float : kotlin.Number, kotlin.Comparable<kotlin.Float> {
     public final fun compareTo(/*0*/ other: kotlin.Short): kotlin.Int
     public final fun dec(): kotlin.Float
     public final fun div(/*0*/ other: kotlin.Byte): kotlin.Float
-    kotlin.deprecated(value = "This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.") public final fun div(/*0*/ other: kotlin.Char): kotlin.Float
     public final fun div(/*0*/ other: kotlin.Double): kotlin.Double
     public final fun div(/*0*/ other: kotlin.Float): kotlin.Float
     public final fun div(/*0*/ other: kotlin.Int): kotlin.Float
@@ -496,14 +444,12 @@ public final class Float : kotlin.Number, kotlin.Comparable<kotlin.Float> {
     public final fun inc(): kotlin.Float
     public final fun minus(): kotlin.Float
     public final fun minus(/*0*/ other: kotlin.Byte): kotlin.Float
-    kotlin.deprecated(value = "This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.") public final fun minus(/*0*/ other: kotlin.Char): kotlin.Float
     public final fun minus(/*0*/ other: kotlin.Double): kotlin.Double
     public final fun minus(/*0*/ other: kotlin.Float): kotlin.Float
     public final fun minus(/*0*/ other: kotlin.Int): kotlin.Float
     public final fun minus(/*0*/ other: kotlin.Long): kotlin.Float
     public final fun minus(/*0*/ other: kotlin.Short): kotlin.Float
     public final fun mod(/*0*/ other: kotlin.Byte): kotlin.Float
-    kotlin.deprecated(value = "This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.") public final fun mod(/*0*/ other: kotlin.Char): kotlin.Float
     public final fun mod(/*0*/ other: kotlin.Double): kotlin.Double
     public final fun mod(/*0*/ other: kotlin.Float): kotlin.Float
     public final fun mod(/*0*/ other: kotlin.Int): kotlin.Float
@@ -511,21 +457,18 @@ public final class Float : kotlin.Number, kotlin.Comparable<kotlin.Float> {
     public final fun mod(/*0*/ other: kotlin.Short): kotlin.Float
     public final fun plus(): kotlin.Float
     public final fun plus(/*0*/ other: kotlin.Byte): kotlin.Float
-    kotlin.deprecated(value = "This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.") public final fun plus(/*0*/ other: kotlin.Char): kotlin.Float
     public final fun plus(/*0*/ other: kotlin.Double): kotlin.Double
     public final fun plus(/*0*/ other: kotlin.Float): kotlin.Float
     public final fun plus(/*0*/ other: kotlin.Int): kotlin.Float
     public final fun plus(/*0*/ other: kotlin.Long): kotlin.Float
     public final fun plus(/*0*/ other: kotlin.Short): kotlin.Float
     public final fun rangeTo(/*0*/ other: kotlin.Byte): kotlin.FloatRange
-    kotlin.deprecated(value = "This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.") public final fun rangeTo(/*0*/ other: kotlin.Char): kotlin.FloatRange
     public final fun rangeTo(/*0*/ other: kotlin.Double): kotlin.DoubleRange
     public final fun rangeTo(/*0*/ other: kotlin.Float): kotlin.FloatRange
     public final fun rangeTo(/*0*/ other: kotlin.Int): kotlin.FloatRange
     public final fun rangeTo(/*0*/ other: kotlin.Long): kotlin.FloatRange
     public final fun rangeTo(/*0*/ other: kotlin.Short): kotlin.FloatRange
     public final fun times(/*0*/ other: kotlin.Byte): kotlin.Float
-    kotlin.deprecated(value = "This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.") public final fun times(/*0*/ other: kotlin.Char): kotlin.Float
     public final fun times(/*0*/ other: kotlin.Double): kotlin.Double
     public final fun times(/*0*/ other: kotlin.Float): kotlin.Float
     public final fun times(/*0*/ other: kotlin.Int): kotlin.Float
@@ -685,7 +628,6 @@ public final class Int : kotlin.Number, kotlin.Comparable<kotlin.Int> {
     /*primary*/ private constructor Int()
     public final fun and(/*0*/ other: kotlin.Int): kotlin.Int
     public final fun compareTo(/*0*/ other: kotlin.Byte): kotlin.Int
-    kotlin.deprecated(value = "This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.") public final fun compareTo(/*0*/ other: kotlin.Char): kotlin.Int
     public final fun compareTo(/*0*/ other: kotlin.Double): kotlin.Int
     public final fun compareTo(/*0*/ other: kotlin.Float): kotlin.Int
     public open override /*1*/ fun compareTo(/*0*/ other: kotlin.Int): kotlin.Int
@@ -693,7 +635,6 @@ public final class Int : kotlin.Number, kotlin.Comparable<kotlin.Int> {
     public final fun compareTo(/*0*/ other: kotlin.Short): kotlin.Int
     public final fun dec(): kotlin.Int
     public final fun div(/*0*/ other: kotlin.Byte): kotlin.Int
-    kotlin.deprecated(value = "This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.") public final fun div(/*0*/ other: kotlin.Char): kotlin.Int
     public final fun div(/*0*/ other: kotlin.Double): kotlin.Double
     public final fun div(/*0*/ other: kotlin.Float): kotlin.Float
     public final fun div(/*0*/ other: kotlin.Int): kotlin.Int
@@ -703,14 +644,12 @@ public final class Int : kotlin.Number, kotlin.Comparable<kotlin.Int> {
     public final fun inv(): kotlin.Int
     public final fun minus(): kotlin.Int
     public final fun minus(/*0*/ other: kotlin.Byte): kotlin.Int
-    kotlin.deprecated(value = "This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.") public final fun minus(/*0*/ other: kotlin.Char): kotlin.Int
     public final fun minus(/*0*/ other: kotlin.Double): kotlin.Double
     public final fun minus(/*0*/ other: kotlin.Float): kotlin.Float
     public final fun minus(/*0*/ other: kotlin.Int): kotlin.Int
     public final fun minus(/*0*/ other: kotlin.Long): kotlin.Long
     public final fun minus(/*0*/ other: kotlin.Short): kotlin.Int
     public final fun mod(/*0*/ other: kotlin.Byte): kotlin.Int
-    kotlin.deprecated(value = "This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.") public final fun mod(/*0*/ other: kotlin.Char): kotlin.Int
     public final fun mod(/*0*/ other: kotlin.Double): kotlin.Double
     public final fun mod(/*0*/ other: kotlin.Float): kotlin.Float
     public final fun mod(/*0*/ other: kotlin.Int): kotlin.Int
@@ -719,14 +658,12 @@ public final class Int : kotlin.Number, kotlin.Comparable<kotlin.Int> {
     public final fun or(/*0*/ other: kotlin.Int): kotlin.Int
     public final fun plus(): kotlin.Int
     public final fun plus(/*0*/ other: kotlin.Byte): kotlin.Int
-    kotlin.deprecated(value = "This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.") public final fun plus(/*0*/ other: kotlin.Char): kotlin.Int
     public final fun plus(/*0*/ other: kotlin.Double): kotlin.Double
     public final fun plus(/*0*/ other: kotlin.Float): kotlin.Float
     public final fun plus(/*0*/ other: kotlin.Int): kotlin.Int
     public final fun plus(/*0*/ other: kotlin.Long): kotlin.Long
     public final fun plus(/*0*/ other: kotlin.Short): kotlin.Int
     public final fun rangeTo(/*0*/ other: kotlin.Byte): kotlin.IntRange
-    kotlin.deprecated(value = "This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.") public final fun rangeTo(/*0*/ other: kotlin.Char): kotlin.IntRange
     public final fun rangeTo(/*0*/ other: kotlin.Double): kotlin.DoubleRange
     public final fun rangeTo(/*0*/ other: kotlin.Float): kotlin.FloatRange
     public final fun rangeTo(/*0*/ other: kotlin.Int): kotlin.IntRange
@@ -735,7 +672,6 @@ public final class Int : kotlin.Number, kotlin.Comparable<kotlin.Int> {
     public final fun shl(/*0*/ bits: kotlin.Int): kotlin.Int
     public final fun shr(/*0*/ bits: kotlin.Int): kotlin.Int
     public final fun times(/*0*/ other: kotlin.Byte): kotlin.Int
-    kotlin.deprecated(value = "This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.") public final fun times(/*0*/ other: kotlin.Char): kotlin.Int
     public final fun times(/*0*/ other: kotlin.Double): kotlin.Double
     public final fun times(/*0*/ other: kotlin.Float): kotlin.Float
     public final fun times(/*0*/ other: kotlin.Int): kotlin.Int
@@ -867,7 +803,6 @@ public final class Long : kotlin.Number, kotlin.Comparable<kotlin.Long> {
     /*primary*/ private constructor Long()
     public final fun and(/*0*/ other: kotlin.Long): kotlin.Long
     public final fun compareTo(/*0*/ other: kotlin.Byte): kotlin.Int
-    kotlin.deprecated(value = "This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.") public final fun compareTo(/*0*/ other: kotlin.Char): kotlin.Int
     public final fun compareTo(/*0*/ other: kotlin.Double): kotlin.Int
     public final fun compareTo(/*0*/ other: kotlin.Float): kotlin.Int
     public final fun compareTo(/*0*/ other: kotlin.Int): kotlin.Int
@@ -875,7 +810,6 @@ public final class Long : kotlin.Number, kotlin.Comparable<kotlin.Long> {
     public final fun compareTo(/*0*/ other: kotlin.Short): kotlin.Int
     public final fun dec(): kotlin.Long
     public final fun div(/*0*/ other: kotlin.Byte): kotlin.Long
-    kotlin.deprecated(value = "This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.") public final fun div(/*0*/ other: kotlin.Char): kotlin.Long
     public final fun div(/*0*/ other: kotlin.Double): kotlin.Double
     public final fun div(/*0*/ other: kotlin.Float): kotlin.Float
     public final fun div(/*0*/ other: kotlin.Int): kotlin.Long
@@ -885,14 +819,12 @@ public final class Long : kotlin.Number, kotlin.Comparable<kotlin.Long> {
     public final fun inv(): kotlin.Long
     public final fun minus(): kotlin.Long
     public final fun minus(/*0*/ other: kotlin.Byte): kotlin.Long
-    kotlin.deprecated(value = "This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.") public final fun minus(/*0*/ other: kotlin.Char): kotlin.Long
     public final fun minus(/*0*/ other: kotlin.Double): kotlin.Double
     public final fun minus(/*0*/ other: kotlin.Float): kotlin.Float
     public final fun minus(/*0*/ other: kotlin.Int): kotlin.Long
     public final fun minus(/*0*/ other: kotlin.Long): kotlin.Long
     public final fun minus(/*0*/ other: kotlin.Short): kotlin.Long
     public final fun mod(/*0*/ other: kotlin.Byte): kotlin.Long
-    kotlin.deprecated(value = "This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.") public final fun mod(/*0*/ other: kotlin.Char): kotlin.Long
     public final fun mod(/*0*/ other: kotlin.Double): kotlin.Double
     public final fun mod(/*0*/ other: kotlin.Float): kotlin.Float
     public final fun mod(/*0*/ other: kotlin.Int): kotlin.Long
@@ -901,14 +833,12 @@ public final class Long : kotlin.Number, kotlin.Comparable<kotlin.Long> {
     public final fun or(/*0*/ other: kotlin.Long): kotlin.Long
     public final fun plus(): kotlin.Long
     public final fun plus(/*0*/ other: kotlin.Byte): kotlin.Long
-    kotlin.deprecated(value = "This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.") public final fun plus(/*0*/ other: kotlin.Char): kotlin.Long
     public final fun plus(/*0*/ other: kotlin.Double): kotlin.Double
     public final fun plus(/*0*/ other: kotlin.Float): kotlin.Float
     public final fun plus(/*0*/ other: kotlin.Int): kotlin.Long
     public final fun plus(/*0*/ other: kotlin.Long): kotlin.Long
     public final fun plus(/*0*/ other: kotlin.Short): kotlin.Long
     public final fun rangeTo(/*0*/ other: kotlin.Byte): kotlin.LongRange
-    kotlin.deprecated(value = "This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.") public final fun rangeTo(/*0*/ other: kotlin.Char): kotlin.LongRange
     public final fun rangeTo(/*0*/ other: kotlin.Double): kotlin.DoubleRange
     public final fun rangeTo(/*0*/ other: kotlin.Float): kotlin.FloatRange
     public final fun rangeTo(/*0*/ other: kotlin.Int): kotlin.LongRange
@@ -917,7 +847,6 @@ public final class Long : kotlin.Number, kotlin.Comparable<kotlin.Long> {
     public final fun shl(/*0*/ bits: kotlin.Int): kotlin.Long
     public final fun shr(/*0*/ bits: kotlin.Int): kotlin.Long
     public final fun times(/*0*/ other: kotlin.Byte): kotlin.Long
-    kotlin.deprecated(value = "This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.") public final fun times(/*0*/ other: kotlin.Char): kotlin.Long
     public final fun times(/*0*/ other: kotlin.Double): kotlin.Double
     public final fun times(/*0*/ other: kotlin.Float): kotlin.Float
     public final fun times(/*0*/ other: kotlin.Int): kotlin.Long
@@ -1162,7 +1091,7 @@ public interface Range</*0*/ T : kotlin.Comparable<T>> {
     public open fun isEmpty(): kotlin.Boolean
 }
 
-public final annotation class ReplaceWith : kotlin.Annotation {
+kotlin.annotation.annotation() public final class ReplaceWith : kotlin.Annotation {
     /*primary*/ public constructor ReplaceWith(/*0*/ expression: kotlin.String, /*1*/ vararg imports: kotlin.String /*kotlin.Array<out kotlin.String>*/)
     internal final val expression: kotlin.String
         internal final fun <get-expression>(): kotlin.String
@@ -1181,7 +1110,6 @@ public interface Set</*0*/ out E> : kotlin.Collection<E> {
 public final class Short : kotlin.Number, kotlin.Comparable<kotlin.Short> {
     /*primary*/ private constructor Short()
     public final fun compareTo(/*0*/ other: kotlin.Byte): kotlin.Int
-    kotlin.deprecated(value = "This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.") public final fun compareTo(/*0*/ other: kotlin.Char): kotlin.Int
     public final fun compareTo(/*0*/ other: kotlin.Double): kotlin.Int
     public final fun compareTo(/*0*/ other: kotlin.Float): kotlin.Int
     public final fun compareTo(/*0*/ other: kotlin.Int): kotlin.Int
@@ -1189,7 +1117,6 @@ public final class Short : kotlin.Number, kotlin.Comparable<kotlin.Short> {
     public open override /*1*/ fun compareTo(/*0*/ other: kotlin.Short): kotlin.Int
     public final fun dec(): kotlin.Short
     public final fun div(/*0*/ other: kotlin.Byte): kotlin.Int
-    kotlin.deprecated(value = "This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.") public final fun div(/*0*/ other: kotlin.Char): kotlin.Int
     public final fun div(/*0*/ other: kotlin.Double): kotlin.Double
     public final fun div(/*0*/ other: kotlin.Float): kotlin.Float
     public final fun div(/*0*/ other: kotlin.Int): kotlin.Int
@@ -1198,14 +1125,12 @@ public final class Short : kotlin.Number, kotlin.Comparable<kotlin.Short> {
     public final fun inc(): kotlin.Short
     public final fun minus(): kotlin.Int
     public final fun minus(/*0*/ other: kotlin.Byte): kotlin.Int
-    kotlin.deprecated(value = "This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.") public final fun minus(/*0*/ other: kotlin.Char): kotlin.Int
     public final fun minus(/*0*/ other: kotlin.Double): kotlin.Double
     public final fun minus(/*0*/ other: kotlin.Float): kotlin.Float
     public final fun minus(/*0*/ other: kotlin.Int): kotlin.Int
     public final fun minus(/*0*/ other: kotlin.Long): kotlin.Long
     public final fun minus(/*0*/ other: kotlin.Short): kotlin.Int
     public final fun mod(/*0*/ other: kotlin.Byte): kotlin.Int
-    kotlin.deprecated(value = "This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.") public final fun mod(/*0*/ other: kotlin.Char): kotlin.Int
     public final fun mod(/*0*/ other: kotlin.Double): kotlin.Double
     public final fun mod(/*0*/ other: kotlin.Float): kotlin.Float
     public final fun mod(/*0*/ other: kotlin.Int): kotlin.Int
@@ -1213,21 +1138,18 @@ public final class Short : kotlin.Number, kotlin.Comparable<kotlin.Short> {
     public final fun mod(/*0*/ other: kotlin.Short): kotlin.Int
     public final fun plus(): kotlin.Int
     public final fun plus(/*0*/ other: kotlin.Byte): kotlin.Int
-    kotlin.deprecated(value = "This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.") public final fun plus(/*0*/ other: kotlin.Char): kotlin.Int
     public final fun plus(/*0*/ other: kotlin.Double): kotlin.Double
     public final fun plus(/*0*/ other: kotlin.Float): kotlin.Float
     public final fun plus(/*0*/ other: kotlin.Int): kotlin.Int
     public final fun plus(/*0*/ other: kotlin.Long): kotlin.Long
     public final fun plus(/*0*/ other: kotlin.Short): kotlin.Int
     public final fun rangeTo(/*0*/ other: kotlin.Byte): kotlin.ShortRange
-    kotlin.deprecated(value = "This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.") public final fun rangeTo(/*0*/ other: kotlin.Char): kotlin.ShortRange
     public final fun rangeTo(/*0*/ other: kotlin.Double): kotlin.DoubleRange
     public final fun rangeTo(/*0*/ other: kotlin.Float): kotlin.FloatRange
     public final fun rangeTo(/*0*/ other: kotlin.Int): kotlin.IntRange
     public final fun rangeTo(/*0*/ other: kotlin.Long): kotlin.LongRange
     public final fun rangeTo(/*0*/ other: kotlin.Short): kotlin.ShortRange
     public final fun times(/*0*/ other: kotlin.Byte): kotlin.Int
-    kotlin.deprecated(value = "This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.") public final fun times(/*0*/ other: kotlin.Char): kotlin.Int
     public final fun times(/*0*/ other: kotlin.Double): kotlin.Double
     public final fun times(/*0*/ other: kotlin.Float): kotlin.Float
     public final fun times(/*0*/ other: kotlin.Int): kotlin.Int
@@ -1339,11 +1261,11 @@ public object Unit {
     /*primary*/ private constructor Unit()
 }
 
-public final annotation class data : kotlin.Annotation {
+kotlin.annotation.target(allowedTargets = {AnnotationTarget.CLASSIFIER}) kotlin.annotation.annotation() public final class data : kotlin.Annotation {
     /*primary*/ public constructor data()
 }
 
-public final annotation class deprecated : kotlin.Annotation {
+kotlin.annotation.target(allowedTargets = {AnnotationTarget.CLASSIFIER, AnnotationTarget.FUNCTION, AnnotationTarget.PROPERTY, AnnotationTarget.ANNOTATION_CLASS, AnnotationTarget.CONSTRUCTOR, AnnotationTarget.PROPERTY_SETTER, AnnotationTarget.PROPERTY_GETTER, AnnotationTarget.LOCAL_VARIABLE, AnnotationTarget.FIELD, AnnotationTarget.VALUE_PARAMETER}) kotlin.annotation.annotation() public final class deprecated : kotlin.Annotation {
     /*primary*/ public constructor deprecated(/*0*/ value: kotlin.String, /*1*/ replaceWith: kotlin.ReplaceWith = ...)
     internal final val replaceWith: kotlin.ReplaceWith
         internal final fun <get-replaceWith>(): kotlin.ReplaceWith
@@ -1351,32 +1273,32 @@ public final annotation class deprecated : kotlin.Annotation {
         internal final fun <get-value>(): kotlin.String
 }
 
-public final annotation class extension : kotlin.Annotation {
+kotlin.annotation.target(allowedTargets = {AnnotationTarget.TYPE}) kotlin.annotation.annotation() public final class extension : kotlin.Annotation {
     /*primary*/ public constructor extension()
 }
 
-public final annotation class inline : kotlin.Annotation {
+kotlin.annotation.annotation() public final class inline : kotlin.Annotation {
     /*primary*/ public constructor inline(/*0*/ strategy: kotlin.InlineStrategy = ...)
     public final val strategy: kotlin.InlineStrategy
         public final fun <get-strategy>(): kotlin.InlineStrategy
 }
 
-public final annotation class inlineOptions : kotlin.Annotation {
+kotlin.annotation.annotation() public final class inlineOptions : kotlin.Annotation {
     /*primary*/ public constructor inlineOptions(/*0*/ vararg value: kotlin.InlineOption /*kotlin.Array<out kotlin.InlineOption>*/)
     internal final val value: kotlin.Array<out kotlin.InlineOption>
         internal final fun <get-value>(): kotlin.Array<out kotlin.InlineOption>
 }
 
-public final annotation class noinline : kotlin.Annotation {
+kotlin.annotation.annotation() public final class noinline : kotlin.Annotation {
     /*primary*/ public constructor noinline()
 }
 
-public final annotation class suppress : kotlin.Annotation {
+kotlin.annotation.target(allowedTargets = {AnnotationTarget.CLASSIFIER, AnnotationTarget.ANNOTATION_CLASS, AnnotationTarget.PROPERTY, AnnotationTarget.FIELD, AnnotationTarget.LOCAL_VARIABLE, AnnotationTarget.VALUE_PARAMETER, AnnotationTarget.CONSTRUCTOR, AnnotationTarget.FUNCTION, AnnotationTarget.PROPERTY_GETTER, AnnotationTarget.PROPERTY_SETTER, AnnotationTarget.TYPE, AnnotationTarget.EXPRESSION, AnnotationTarget.FILE}) kotlin.annotation.annotation() public final class suppress : kotlin.Annotation {
     /*primary*/ public constructor suppress(/*0*/ vararg names: kotlin.String /*kotlin.Array<out kotlin.String>*/)
     internal final val names: kotlin.Array<out kotlin.String>
         internal final fun <get-names>(): kotlin.Array<out kotlin.String>
 }
 
-public final annotation class tailRecursive : kotlin.Annotation {
+kotlin.annotation.target(allowedTargets = {AnnotationTarget.FUNCTION}) kotlin.annotation.annotation() public final class tailRecursive : kotlin.Annotation {
     /*primary*/ public constructor tailRecursive()
 }
diff --git a/compiler/testData/cfg/expressions/assignmentToThis.instructions b/compiler/testData/cfg/expressions/assignmentToThis.instructions
index 1252b97f023..c060be35c16 100644
--- a/compiler/testData/cfg/expressions/assignmentToThis.instructions
+++ b/compiler/testData/cfg/expressions/assignmentToThis.instructions
@@ -9,12 +9,14 @@ L0:
     magic[FAKE_INITIALIZER](c: C) -> <v0>
     w(c|<v0>)
   2 mark({ this = c })
-    r(c) -> <v1>
-    magic[UNSUPPORTED_ELEMENT](this = c|<v1>) -> <v2>
+    r(this, <this>) -> <v1>
+    magic[VALUE_CONSUMER](this|<v1>) -> <v2>
+    r(c) -> <v3>
+    w(this|<v3>)
 L1:
-  1 <END>                                                NEXT:[<SINK>]
+  1 <END>                                       NEXT:[<SINK>]
 error:
-    <ERROR>                                              PREV:[]
+    <ERROR>                                     PREV:[]
 sink:
-    <SINK>                                               PREV:[<ERROR>, <END>]
-=====================
\ No newline at end of file
+    <SINK>                                      PREV:[<ERROR>, <END>]
+=====================
diff --git a/compiler/testData/cfg/expressions/assignmentToThis.values b/compiler/testData/cfg/expressions/assignmentToThis.values
index 3121c81908d..491d3789f6e 100644
--- a/compiler/testData/cfg/expressions/assignmentToThis.values
+++ b/compiler/testData/cfg/expressions/assignmentToThis.values
@@ -4,7 +4,10 @@ fun Int.bar(c: C) {
 }
 ---------------------
                <v0>: {<: [ERROR : C]}   NEW: magic[FAKE_INITIALIZER](c: C) -> <v0>
-c              <v1>: *                  NEW: r(c) -> <v1>
-this = c       <v2>: *                  NEW: magic[UNSUPPORTED_ELEMENT](this = c|<v1>) -> <v2>
-{ this = c }   <v2>: *                  COPY
+               <v2>: *                  NEW: magic[VALUE_CONSUMER](this|<v1>) -> <v2>
+this           <v1>: *                  COPY
+this           <v1>: *                  NEW: r(this, <this>) -> <v1>
+c              <v3>: *                  NEW: r(c) -> <v3>
+this = c       !<v4>: *
+{ this = c }   !<v4>: *                 COPY
 =====================
diff --git a/compiler/testData/cfg/expressions/unresolvedWriteLHS.instructions b/compiler/testData/cfg/expressions/unresolvedWriteLHS.instructions
index 7a929be8f3f..c5b37f7f1ff 100644
--- a/compiler/testData/cfg/expressions/unresolvedWriteLHS.instructions
+++ b/compiler/testData/cfg/expressions/unresolvedWriteLHS.instructions
@@ -6,13 +6,15 @@ fun foo() {
 L0:
   1 <START>
   2 mark({ x = "" })
+    magic[UNRESOLVED_CALL](x) -> <v0>
+    magic[VALUE_CONSUMER](x|<v0>) -> <v1>
     mark("")
-    r("") -> <v0>
-    magic[UNSUPPORTED_ELEMENT](x = ""|<v0>) -> <v1>
+    r("") -> <v2>
+    w(x|<v2>)
 L1:
-  1 <END>                                              NEXT:[<SINK>]
+  1 <END>                                    NEXT:[<SINK>]
 error:
-    <ERROR>                                            PREV:[]
+    <ERROR>                                  PREV:[]
 sink:
-    <SINK>                                             PREV:[<ERROR>, <END>]
-=====================
\ No newline at end of file
+    <SINK>                                   PREV:[<ERROR>, <END>]
+=====================
diff --git a/compiler/testData/cfg/expressions/unresolvedWriteLHS.values b/compiler/testData/cfg/expressions/unresolvedWriteLHS.values
index 70ca650ecb8..a2c04e03388 100644
--- a/compiler/testData/cfg/expressions/unresolvedWriteLHS.values
+++ b/compiler/testData/cfg/expressions/unresolvedWriteLHS.values
@@ -3,7 +3,9 @@ fun foo() {
     x = ""
 }
 ---------------------
-""           <v0>: *   NEW: r("") -> <v0>
-x = ""       <v1>: *   NEW: magic[UNSUPPORTED_ELEMENT](x = ""|<v0>) -> <v1>
-{ x = "" }   <v1>: *   COPY
+             <v1>: *    NEW: magic[VALUE_CONSUMER](x|<v0>) -> <v1>
+x            <v0>: *    NEW: magic[UNRESOLVED_CALL](x) -> <v0>
+""           <v2>: *    NEW: r("") -> <v2>
+x = ""       !<v3>: *
+{ x = "" }   !<v3>: *   COPY
 =====================
diff --git a/compiler/testData/cli/js/diagnosticForUnhandledElements.kt b/compiler/testData/cli/js/diagnosticForUnhandledElements.kt
index 5a7883465d0..63a097901ec 100644
--- a/compiler/testData/cli/js/diagnosticForUnhandledElements.kt
+++ b/compiler/testData/cli/js/diagnosticForUnhandledElements.kt
@@ -1,5 +1,6 @@
 package foo
 
+target(AnnotationTarget.CLASSIFIER, AnnotationTarget.FUNCTION, AnnotationTarget.VALUE_PARAMETER, AnnotationTarget.EXPRESSION)
 annotation class fancy
 
 @fancy
diff --git a/compiler/testData/cli/js/diagnosticForUnhandledElements.out b/compiler/testData/cli/js/diagnosticForUnhandledElements.out
index 5abe071dcd4..808d4aef92a 100644
--- a/compiler/testData/cli/js/diagnosticForUnhandledElements.out
+++ b/compiler/testData/cli/js/diagnosticForUnhandledElements.out
@@ -1,4 +1,4 @@
-compiler/testData/cli/js/diagnosticForUnhandledElements.kt:9:17: error: cannot translate (not supported yet): '@fancy 1'
+compiler/testData/cli/js/diagnosticForUnhandledElements.kt:10:17: error: cannot translate (not supported yet): '@fancy 1'
         return (@fancy 1)
                 ^
 COMPILATION_ERROR
diff --git a/compiler/testData/cli/jvm/noReflectionInClasspath.args b/compiler/testData/cli/jvm/noReflectionInClasspath.args
deleted file mode 100644
index 6c45450a152..00000000000
--- a/compiler/testData/cli/jvm/noReflectionInClasspath.args
+++ /dev/null
@@ -1,3 +0,0 @@
-$TESTDATA_DIR$/noReflectionInClasspath.kt
--d
-$TEMP_DIR$
diff --git a/compiler/testData/cli/jvm/noReflectionInClasspath.kt b/compiler/testData/cli/jvm/noReflectionInClasspath.kt
deleted file mode 100644
index aea00a248ca..00000000000
--- a/compiler/testData/cli/jvm/noReflectionInClasspath.kt
+++ /dev/null
@@ -1,4 +0,0 @@
-class Foo(val prop: Any)
-
-fun t1() = Foo::prop
-fun t2() = Foo::class
diff --git a/compiler/testData/cli/jvm/noReflectionInClasspath.out b/compiler/testData/cli/jvm/noReflectionInClasspath.out
deleted file mode 100644
index 77b22ce279d..00000000000
--- a/compiler/testData/cli/jvm/noReflectionInClasspath.out
+++ /dev/null
@@ -1,7 +0,0 @@
-compiler/testData/cli/jvm/noReflectionInClasspath.kt:3:12: error: expression 'Foo::prop' uses reflection which is not found in compilation classpath. Make sure you have kotlin-reflect.jar in the classpath
-fun t1() = Foo::prop
-           ^
-compiler/testData/cli/jvm/noReflectionInClasspath.kt:4:12: error: expression 'Foo::class' uses reflection which is not found in compilation classpath. Make sure you have kotlin-reflect.jar in the classpath
-fun t2() = Foo::class
-           ^
-COMPILATION_ERROR
diff --git a/compiler/testData/codegen/box/binaryOp/call.kt b/compiler/testData/codegen/box/binaryOp/call.kt
index c7a2752f4bb..0f3d0139001 100644
--- a/compiler/testData/codegen/box/binaryOp/call.kt
+++ b/compiler/testData/codegen/box/binaryOp/call.kt
@@ -5,6 +5,8 @@ fun box(): String {
     val a4: Long = 1.plus(1)
     val a5: Double = 1.0.plus(1)
     val a6: Float = 1f.plus(1)
+    val a7: Char = 'A'.plus(1)
+    val a8: Int = 'B'.minus('A')
 
     if (a1 != 2.toByte()) return "fail 1"
     if (a2 != 2.toShort()) return "fail 2"
@@ -12,6 +14,8 @@ fun box(): String {
     if (a4 != 2L) return "fail 4"
     if (a5 != 2.0) return "fail 5"
     if (a6 != 2f) return "fail 6"
+    if (a7 != 'B') return "fail 7"
+    if (a8 != 1) return "fail 8"
 
     return "OK"
 }
\ No newline at end of file
diff --git a/compiler/testData/codegen/box/binaryOp/callAny.kt b/compiler/testData/codegen/box/binaryOp/callAny.kt
new file mode 100644
index 00000000000..7969cb5ec79
--- /dev/null
+++ b/compiler/testData/codegen/box/binaryOp/callAny.kt
@@ -0,0 +1,21 @@
+fun box(): String {
+    val a1: Any = 1.toByte().plus(1)
+    val a2: Any = 1.toShort().plus(1)
+    val a3: Any = 1.plus(1)
+    val a4: Any = 1L.plus(1)
+    val a5: Any = 1.0.plus(1)
+    val a6: Any = 1f.plus(1)
+    val a7: Any = 'A'.plus(1)
+    val a8: Any = 'B'.minus('A')
+
+    if (a1 !is Int || a1 != 2) return "fail 1"
+    if (a2 !is Int || a2 != 2) return "fail 2"
+    if (a3 !is Int || a3 != 2) return "fail 3"
+    if (a4 !is Long || a4 != 2L) return "fail 4"
+    if (a5 !is Double || a5 != 2.0) return "fail 5"
+    if (a6 !is Float || a6 != 2f) return "fail 6"
+    if (a7 !is Char || a7 != 'B') return "fail 7"
+    if (a8 !is Int || a8 != 1) return "fail 8"
+
+    return "OK"
+}
\ No newline at end of file
diff --git a/compiler/testData/codegen/box/binaryOp/callNullable.kt b/compiler/testData/codegen/box/binaryOp/callNullable.kt
index 802bef63e31..0167a38ed04 100644
--- a/compiler/testData/codegen/box/binaryOp/callNullable.kt
+++ b/compiler/testData/codegen/box/binaryOp/callNullable.kt
@@ -5,6 +5,8 @@ fun box(): String {
     val a4: Long? = 1.plus(1)
     val a5: Double? = 1.0.plus(1)
     val a6: Float? = 1f.plus(1)
+    val a7: Char? = 'A'.plus(1)
+    val a8: Int? = 'B'.minus('A')
 
     if (a1!! != 2.toByte()) return "fail 1"
     if (a2!! != 2.toShort()) return "fail 2"
@@ -12,6 +14,8 @@ fun box(): String {
     if (a4!! != 2L) return "fail 4"
     if (a5!! != 2.0) return "fail 5"
     if (a6!! != 2f) return "fail 6"
+    if (a7!! != 'B') return "fail 7"
+    if (a8!! != 1) return "fail 8"
 
     return "OK"
 }
diff --git a/compiler/testData/codegen/box/binaryOp/infixCall.kt b/compiler/testData/codegen/box/binaryOp/infixCall.kt
index f8f688298c4..76c0d070d01 100644
--- a/compiler/testData/codegen/box/binaryOp/infixCall.kt
+++ b/compiler/testData/codegen/box/binaryOp/infixCall.kt
@@ -5,6 +5,8 @@ fun box(): String {
     val a4: Long = 1 plus 1
     val a5: Double = 1.0 plus 1
     val a6: Float = 1f plus 1
+    val a7: Char = 'A' plus 1
+    val a8: Int = 'B' minus 'A'
 
     if (a1 != 2.toByte()) return "fail 1"
     if (a2 != 2.toShort()) return "fail 2"
@@ -12,6 +14,8 @@ fun box(): String {
     if (a4 != 2L) return "fail 4"
     if (a5 != 2.0) return "fail 5"
     if (a6 != 2f) return "fail 6"
+    if (a7 != 'B') return "fail 7"
+    if (a8 != 1) return "fail 8"
 
     return "OK"
 }
\ No newline at end of file
diff --git a/compiler/testData/codegen/box/binaryOp/infixCallAny.kt b/compiler/testData/codegen/box/binaryOp/infixCallAny.kt
new file mode 100644
index 00000000000..6056e74e00e
--- /dev/null
+++ b/compiler/testData/codegen/box/binaryOp/infixCallAny.kt
@@ -0,0 +1,21 @@
+fun box(): String {
+    val a1: Any = 1.toByte() plus 1
+    val a2: Any = 1.toShort() plus 1
+    val a3: Any = 1 plus 1
+    val a4: Any = 1L plus 1
+    val a5: Any = 1.0 plus 1
+    val a6: Any = 1f plus 1
+    val a7: Any = 'A' plus 1
+    val a8: Any = 'B' minus 'A'
+
+    if (a1 !is Int || a1 != 2) return "fail 1"
+    if (a2 !is Int || a2 != 2) return "fail 2"
+    if (a3 !is Int || a3 != 2) return "fail 3"
+    if (a4 !is Long || a4 != 2L) return "fail 4"
+    if (a5 !is Double || a5 != 2.0) return "fail 5"
+    if (a6 !is Float || a6 != 2f) return "fail 6"
+    if (a7 !is Char || a7 != 'B') return "fail 7"
+    if (a8 !is Int || a8 != 1) return "fail 8"
+
+    return "OK"
+}
\ No newline at end of file
diff --git a/compiler/testData/codegen/box/binaryOp/infixCallNullable.kt b/compiler/testData/codegen/box/binaryOp/infixCallNullable.kt
index 4a8ed98d307..9fbd75a5c27 100644
--- a/compiler/testData/codegen/box/binaryOp/infixCallNullable.kt
+++ b/compiler/testData/codegen/box/binaryOp/infixCallNullable.kt
@@ -5,6 +5,8 @@ fun box(): String {
     val a4: Long? = 1 plus 1
     val a5: Double? = 1.0 plus 1
     val a6: Float? = 1f plus 1
+    val a7: Char? = 'A' plus 1
+    val a8: Int? = 'B' minus 'A'
 
     if (a1!! != 2.toByte()) return "fail 1"
     if (a2!! != 2.toShort()) return "fail 2"
@@ -12,6 +14,8 @@ fun box(): String {
     if (a4!! != 2L) return "fail 4"
     if (a5!! != 2.0) return "fail 5"
     if (a6!! != 2f) return "fail 6"
+    if (a7!! != 'B') return "fail 7"
+    if (a8!! != 1) return "fail 8"
 
     return "OK"
 }
diff --git a/compiler/testData/codegen/box/binaryOp/intrinsic.kt b/compiler/testData/codegen/box/binaryOp/intrinsic.kt
index cd39565e450..7434a7848e5 100644
--- a/compiler/testData/codegen/box/binaryOp/intrinsic.kt
+++ b/compiler/testData/codegen/box/binaryOp/intrinsic.kt
@@ -5,6 +5,8 @@ fun box(): String {
     val a4: Long = 1 + 1
     val a5: Double = 1.0 + 1
     val a6: Float = 1f + 1
+    val a7: Char = 'A' + 1
+    val a8: Int = 'B' - 'A'
 
     if (a1 != 2.toByte()) return "fail 1"
     if (a2 != 2.toShort()) return "fail 2"
@@ -12,6 +14,8 @@ fun box(): String {
     if (a4 != 2L) return "fail 4"
     if (a5 != 2.0) return "fail 5"
     if (a6 != 2f) return "fail 6"
+    if (a7 != 'B') return "fail 7"
+    if (a8 != 1) return "fail 8"
 
     return "OK"
 }
\ No newline at end of file
diff --git a/compiler/testData/codegen/box/binaryOp/intrinsicAny.kt b/compiler/testData/codegen/box/binaryOp/intrinsicAny.kt
new file mode 100644
index 00000000000..fd240b08a58
--- /dev/null
+++ b/compiler/testData/codegen/box/binaryOp/intrinsicAny.kt
@@ -0,0 +1,21 @@
+fun box(): String {
+    val a1: Any = 1.toByte() + 1
+    val a2: Any = 1.toShort() + 1
+    val a3: Any = 1 + 1
+    val a4: Any = 1L + 1
+    val a5: Any = 1.0 + 1
+    val a6: Any = 1f + 1
+    val a7: Any = 'A' + 1
+    val a8: Any = 'B' - 'A'
+
+    if (a1 !is Int || a1 != 2) return "fail 1"
+    if (a2 !is Int || a2 != 2) return "fail 2"
+    if (a3 !is Int || a3 != 2) return "fail 3"
+    if (a4 !is Long || a4 != 2L) return "fail 4"
+    if (a5 !is Double || a5 != 2.0) return "fail 5"
+    if (a6 !is Float || a6 != 2f) return "fail 6"
+    if (a7 !is Char || a7 != 'B') return "fail 7"
+    if (a8 !is Int || a8 != 1) return "fail 8"
+
+    return "OK"
+}
\ No newline at end of file
diff --git a/compiler/testData/codegen/box/binaryOp/intrinsicNullable.kt b/compiler/testData/codegen/box/binaryOp/intrinsicNullable.kt
index 75288bc5be8..fdfc98f3bb4 100644
--- a/compiler/testData/codegen/box/binaryOp/intrinsicNullable.kt
+++ b/compiler/testData/codegen/box/binaryOp/intrinsicNullable.kt
@@ -5,6 +5,8 @@ fun box(): String {
     val a4: Long? = 1 + 1
     val a5: Double? = 1.0 + 1
     val a6: Float? = 1f + 1
+    val a7: Char? = 'A' + 1
+    val a8: Int? = 'B' - 'A'
 
     if (a1!! != 2.toByte()) return "fail 1"
     if (a2!! != 2.toShort()) return "fail 2"
@@ -12,6 +14,8 @@ fun box(): String {
     if (a4!! != 2L) return "fail 4"
     if (a5!! != 2.0) return "fail 5"
     if (a6!! != 2f) return "fail 6"
+    if (a7!! != 'B') return "fail 7"
+    if (a8!! != 1) return "fail 8"
 
     return "OK"
 }
diff --git a/compiler/testData/codegen/box/binaryOp/longOverflow.kt b/compiler/testData/codegen/box/binaryOp/longOverflow.kt
deleted file mode 100644
index 9f7a9f6bd4d..00000000000
--- a/compiler/testData/codegen/box/binaryOp/longOverflow.kt
+++ /dev/null
@@ -1,5 +0,0 @@
-fun box(): String {
-    val a: Long = 2147483647 + 1
-    if (a != -2147483648L) return "fail: in this case we should add to ints and than cast the result to long - overflow expected"
-    return "OK"
-}
\ No newline at end of file
diff --git a/compiler/testData/codegen/box/binaryOp/overflowChar.kt b/compiler/testData/codegen/box/binaryOp/overflowChar.kt
new file mode 100644
index 00000000000..0f06f4969fd
--- /dev/null
+++ b/compiler/testData/codegen/box/binaryOp/overflowChar.kt
@@ -0,0 +1,10 @@
+fun box(): String {
+    val c1: Char = 0.toChar()
+    val c2 = c1 - 1
+    if (c2 < c1) return "fail: 0.toChar() - 1 should overflow to positive."
+
+    val c3 = c2 + 1
+    if (c3 > c2) return "fail: FFFF.toChar() + 1 should overflow to zero."
+
+    return "OK"
+}
\ No newline at end of file
diff --git a/compiler/testData/codegen/box/binaryOp/overflowInt.kt b/compiler/testData/codegen/box/binaryOp/overflowInt.kt
new file mode 100644
index 00000000000..4d5b899987f
--- /dev/null
+++ b/compiler/testData/codegen/box/binaryOp/overflowInt.kt
@@ -0,0 +1,11 @@
+fun box(): String {
+    val i1: Int = Int.MAX_VALUE
+    val i2 = i1 + 1
+    if (i2 > i1) return "fail: Int.MAX_VALUE + 1 should overflow to negative."
+
+    val i3: Int = Int.MIN_VALUE
+    val i4 = i3 - 1
+    if (i4 < i3) return "fail: Int.MIN_VALUE - 1 should overflow to positive."
+
+    return "OK"
+}
\ No newline at end of file
diff --git a/compiler/testData/codegen/box/binaryOp/overflowLong.kt b/compiler/testData/codegen/box/binaryOp/overflowLong.kt
new file mode 100644
index 00000000000..28d37ab1c12
--- /dev/null
+++ b/compiler/testData/codegen/box/binaryOp/overflowLong.kt
@@ -0,0 +1,14 @@
+fun box(): String {
+    val a: Long = 2147483647 + 1
+    if (a != -2147483648L) return "fail: in this case we should add to ints and than cast the result to long - overflow expected"
+
+    val l1 = Long.MAX_VALUE
+    val l2 = l1 + 1
+    if (l2 > l1) return "fail: Long.MAX_VALUE + 1 should overflow to negative."
+
+    val l3 = Long.MIN_VALUE
+    val l4 = l3 - 1
+    if (l4 < l3) return "fail: Long.MIN_VALUE - 1 should overflow to positive."
+
+    return "OK"
+}
\ No newline at end of file
diff --git a/compiler/testData/codegen/box/builtinStubMethods/extendJavaCollections/abstractMap.kt b/compiler/testData/codegen/box/builtinStubMethods/extendJavaCollections/abstractMap.kt
index 59f2d50e8ad..1a7f0ae1eb2 100644
--- a/compiler/testData/codegen/box/builtinStubMethods/extendJavaCollections/abstractMap.kt
+++ b/compiler/testData/codegen/box/builtinStubMethods/extendJavaCollections/abstractMap.kt
@@ -2,7 +2,7 @@ import java.util.AbstractMap
 import java.util.Collections
 
 class A : AbstractMap<Int, String>() {
-    override fun entrySet(): Set<Map.Entry<Int, String>> = Collections.emptySet()
+    override fun entrySet(): MutableSet<MutableMap.MutableEntry<Int, String>> = Collections.emptySet()
 }
 
 fun box(): String {
diff --git a/compiler/testData/codegen/box/casts/asAny.kt b/compiler/testData/codegen/box/casts/asAny.kt
deleted file mode 100644
index 5c277379d48..00000000000
--- a/compiler/testData/codegen/box/casts/asAny.kt
+++ /dev/null
@@ -1,7 +0,0 @@
-fun println(s: String) {
-}
-
-fun box(): String {
-    println(":Hi!") as Any
-    return "OK"
-}
diff --git a/compiler/testData/codegen/box/casts/unitAsAny.kt b/compiler/testData/codegen/box/casts/unitAsAny.kt
new file mode 100644
index 00000000000..74326356cba
--- /dev/null
+++ b/compiler/testData/codegen/box/casts/unitAsAny.kt
@@ -0,0 +1,8 @@
+fun println(s: String) {
+}
+
+fun box(): String {
+    val x = println(":Hi!") as Any
+    if (x != Unit) return "Fail: $x"
+    return "OK"
+}
diff --git a/compiler/testData/codegen/box/casts/unitAsSafeAny.kt b/compiler/testData/codegen/box/casts/unitAsSafeAny.kt
new file mode 100644
index 00000000000..81d5a495425
--- /dev/null
+++ b/compiler/testData/codegen/box/casts/unitAsSafeAny.kt
@@ -0,0 +1,8 @@
+fun println(s: String) {
+}
+
+fun box(): String {
+    val x = println(":Hi!") as? Any
+    if (x != Unit) return "Fail: $x"
+    return "OK"
+}
diff --git a/compiler/testData/codegen/box/controlStructures/tryCatchInExpressions/catch.kt b/compiler/testData/codegen/box/controlStructures/tryCatchInExpressions/catch.kt
new file mode 100644
index 00000000000..cb00faf1fe3
--- /dev/null
+++ b/compiler/testData/codegen/box/controlStructures/tryCatchInExpressions/catch.kt
@@ -0,0 +1,2 @@
+fun box(): String =
+        "O" + try { throw Exception("oops!") } catch (e: Exception) { "K" }
\ No newline at end of file
diff --git a/compiler/testData/codegen/box/controlStructures/tryCatchInExpressions/complexChain.kt b/compiler/testData/codegen/box/controlStructures/tryCatchInExpressions/complexChain.kt
new file mode 100644
index 00000000000..36f2e84f29f
--- /dev/null
+++ b/compiler/testData/codegen/box/controlStructures/tryCatchInExpressions/complexChain.kt
@@ -0,0 +1,52 @@
+fun cleanup() {}
+
+inline fun concat(x: String, y: String): String = x + y
+
+inline fun throws() {
+    try {
+        throw Exception()
+    }
+    finally {
+        cleanup()
+    }
+}
+
+inline fun first(x: String, y: String): String = x
+
+fun box(): String =
+    "" + concat(
+            try { "" } finally { "0" },
+            "" + concat(
+                    first(
+                            try { 
+                                try { 
+                                    "O" 
+                                } 
+                                finally { 
+                                    "1"
+                                } 
+                            } 
+                            catch (e: Exception) { 
+                                throw e 
+                            }
+                            finally {
+                                cleanup()
+                            }, 
+                            "2"
+                    ),
+                    first(
+                        try { 
+                            throws()
+                            throw Exception()
+                            "3"
+                        } 
+                        catch (e: Exception) { 
+                            "K" 
+                        } 
+                        finally {
+                            cleanup()
+                        },
+                        "4"
+                    )
+            )
+    )
diff --git a/compiler/testData/codegen/box/controlStructures/tryCatchInExpressions/differentTypes.kt b/compiler/testData/codegen/box/controlStructures/tryCatchInExpressions/differentTypes.kt
new file mode 100644
index 00000000000..44fa018cce5
--- /dev/null
+++ b/compiler/testData/codegen/box/controlStructures/tryCatchInExpressions/differentTypes.kt
@@ -0,0 +1,8 @@
+fun foo(b: Byte, s: String, i: Int, d: Double, li: Long): String = "$b $s $i $d $li"
+
+fun box(): String {
+    val test = foo(1, "abc", 1, 1.0, try { 1L } catch (e: Exception) { 10L })
+    if (test != "1 abc 1 1.0 1") return "Failed, test==$test"
+
+    return "OK"
+}
\ No newline at end of file
diff --git a/compiler/testData/codegen/box/controlStructures/tryCatchInExpressions/expectException.kt b/compiler/testData/codegen/box/controlStructures/tryCatchInExpressions/expectException.kt
new file mode 100644
index 00000000000..63bd4900c12
--- /dev/null
+++ b/compiler/testData/codegen/box/controlStructures/tryCatchInExpressions/expectException.kt
@@ -0,0 +1,35 @@
+public inline fun fails(block: () -> Unit): Throwable? {
+    var thrown: Throwable? = null
+    try {
+        block()
+    } catch (e: Throwable) {
+        thrown = e
+    }
+    if (thrown == null)
+        throw Exception("Expected an exception to be thrown")
+    return thrown
+}
+
+public inline fun throwIt(msg: String) {
+    throw Exception(msg)
+}
+
+fun box(): String {
+    fails {
+        throwIt("oops!")
+    }
+
+    var x = 0
+    try {
+        fails {
+            x = 1
+        }
+    }
+    catch (e: Exception) {
+        x = 2
+    }
+
+    if (x != 2) return "Failed: x==$x"
+
+    return "OK"
+}
\ No newline at end of file
diff --git a/compiler/testData/codegen/box/controlStructures/tryCatchInExpressions/finally.kt b/compiler/testData/codegen/box/controlStructures/tryCatchInExpressions/finally.kt
new file mode 100644
index 00000000000..2d4b9f825a7
--- /dev/null
+++ b/compiler/testData/codegen/box/controlStructures/tryCatchInExpressions/finally.kt
@@ -0,0 +1,2 @@
+fun box(): String =
+        "O" + try { "K" } finally { "hmmm" }
\ No newline at end of file
diff --git a/compiler/testData/codegen/box/controlStructures/tryCatchInExpressions/inlineTryCatch.kt b/compiler/testData/codegen/box/controlStructures/tryCatchInExpressions/inlineTryCatch.kt
new file mode 100644
index 00000000000..dd3a181348a
--- /dev/null
+++ b/compiler/testData/codegen/box/controlStructures/tryCatchInExpressions/inlineTryCatch.kt
@@ -0,0 +1,17 @@
+inline fun <T> tryOrElse(f1: () -> T, f2: () -> T): T {
+    try {
+        return f1()
+    }
+    catch (e: Exception) {
+        return f2()
+    }
+}
+
+fun testIt() = "abc" + tryOrElse({ "def" }, { "oops" }) + "ghi"
+
+fun box(): String {
+    val test = testIt()
+    if (test != "abcdefghi") return "Failed, test==$test"
+
+    return "OK"
+}
diff --git a/compiler/testData/codegen/box/controlStructures/tryCatchInExpressions/inlineTryExpr.kt b/compiler/testData/codegen/box/controlStructures/tryCatchInExpressions/inlineTryExpr.kt
new file mode 100644
index 00000000000..8205200452a
--- /dev/null
+++ b/compiler/testData/codegen/box/controlStructures/tryCatchInExpressions/inlineTryExpr.kt
@@ -0,0 +1,14 @@
+inline fun <T> tryOrElse(f1: () -> T, f2: () -> T): T =
+        try { f1() } catch (e: Exception) { f2() }
+
+fun testIt() =
+        "abc" +
+        tryOrElse({ try { "def" } catch(e: Exception) { "oops!" } }, { "hmmm..." }) +
+        "ghi"
+
+fun box(): String {
+    val test = testIt()
+    if (test != "abcdefghi") return "Failed, test==$test"
+
+    return "OK"
+}
diff --git a/compiler/testData/codegen/box/controlStructures/tryCatchInExpressions/inlineTryFinally.kt b/compiler/testData/codegen/box/controlStructures/tryCatchInExpressions/inlineTryFinally.kt
new file mode 100644
index 00000000000..eb488beb689
--- /dev/null
+++ b/compiler/testData/codegen/box/controlStructures/tryCatchInExpressions/inlineTryFinally.kt
@@ -0,0 +1,22 @@
+inline fun <T> tryAndThen(f1: () -> Unit, f2: () -> Unit, f3: () -> T): T {
+    try {
+        f1()
+    }
+    catch (e: Exception) {
+        f2()
+    }
+    finally {
+        return f3()
+    }
+}
+
+fun testIt() = "abc" +
+               tryAndThen({}, {}, { "def" }) +
+               "ghi"
+
+fun box(): String {
+    val test = testIt()
+    if (test != "abcdefghi") return "Failed, test==$test"
+
+    return "OK"
+}
diff --git a/compiler/testData/codegen/box/controlStructures/tryCatchInExpressions/multipleCatchBlocks.kt b/compiler/testData/codegen/box/controlStructures/tryCatchInExpressions/multipleCatchBlocks.kt
new file mode 100644
index 00000000000..45dd6ead838
--- /dev/null
+++ b/compiler/testData/codegen/box/controlStructures/tryCatchInExpressions/multipleCatchBlocks.kt
@@ -0,0 +1,20 @@
+class Exception1(msg: String): Exception(msg)
+class Exception2(msg: String): Exception(msg)
+class Exception3(msg: String): Exception(msg)
+
+fun box(): String =
+        "O" + try {
+            throw Exception3("K")
+        }
+        catch (e1: Exception1) {
+            "e1"
+        }
+        catch (e2: Exception2) {
+            "e2"
+        }
+        catch (e3: Exception3) {
+            e3.getMessage()
+        }
+        catch (e: Exception) {
+            "e"
+        }
diff --git a/compiler/testData/codegen/box/controlStructures/tryCatchInExpressions/splitTry.kt b/compiler/testData/codegen/box/controlStructures/tryCatchInExpressions/splitTry.kt
new file mode 100644
index 00000000000..c60bde586a1
--- /dev/null
+++ b/compiler/testData/codegen/box/controlStructures/tryCatchInExpressions/splitTry.kt
@@ -0,0 +1,25 @@
+inline fun test(s: () -> Int): Int =
+        try {
+            val i = s()
+            i + 10
+        }
+        finally {
+            0
+        }
+
+fun box() : String {
+    test {
+        try {
+            val p = 1
+            return "OK"
+        }
+        catch(e: Exception) {
+            -2
+        }
+        finally {
+            -3
+        }
+    }
+
+    return "Failed"
+}
diff --git a/compiler/testData/codegen/box/controlStructures/tryCatchInExpressions/splitTryCorner1.kt b/compiler/testData/codegen/box/controlStructures/tryCatchInExpressions/splitTryCorner1.kt
new file mode 100644
index 00000000000..bbf5ad07064
--- /dev/null
+++ b/compiler/testData/codegen/box/controlStructures/tryCatchInExpressions/splitTryCorner1.kt
@@ -0,0 +1,11 @@
+fun shouldReturnFalse() : Boolean {
+    try {
+        return true
+    } finally {
+        if (true)
+            return false
+    }
+}
+
+fun box(): String =
+        if (shouldReturnFalse()) "Failed" else "OK"
\ No newline at end of file
diff --git a/compiler/testData/codegen/box/controlStructures/tryCatchInExpressions/splitTryCorner2.kt b/compiler/testData/codegen/box/controlStructures/tryCatchInExpressions/splitTryCorner2.kt
new file mode 100644
index 00000000000..7c0c3e81c55
--- /dev/null
+++ b/compiler/testData/codegen/box/controlStructures/tryCatchInExpressions/splitTryCorner2.kt
@@ -0,0 +1,22 @@
+fun shouldReturn11() : Int {
+    var x = 0
+    while (true) {
+        try {
+            if(x < 10)
+                x++
+            else
+                break
+        }
+        finally {
+            x++
+        }
+    }
+    return x
+}
+
+fun box(): String {
+    val test = shouldReturn11()
+    if (test != 11) return "Failed, test=$test"
+
+    return "OK"
+}
diff --git a/compiler/testData/codegen/box/controlStructures/tryCatchInExpressions/try.kt b/compiler/testData/codegen/box/controlStructures/tryCatchInExpressions/try.kt
new file mode 100644
index 00000000000..695e324988e
--- /dev/null
+++ b/compiler/testData/codegen/box/controlStructures/tryCatchInExpressions/try.kt
@@ -0,0 +1,2 @@
+fun box(): String =
+        "O" + try { "K" } catch (e: Exception) { "oops!" }
\ No newline at end of file
diff --git a/compiler/testData/codegen/box/controlStructures/tryCatchInExpressions/tryAfterTry.kt b/compiler/testData/codegen/box/controlStructures/tryCatchInExpressions/tryAfterTry.kt
new file mode 100644
index 00000000000..7d6dcc3d2a3
--- /dev/null
+++ b/compiler/testData/codegen/box/controlStructures/tryCatchInExpressions/tryAfterTry.kt
@@ -0,0 +1,4 @@
+fun box(): String =
+        "" +
+        try { "O" } catch (e: Exception) { "1" } +
+        try { throw Exception("oops!") } catch (e: Exception) { "K" }
\ No newline at end of file
diff --git a/compiler/testData/codegen/box/controlStructures/tryCatchInExpressions/tryAndBreak.kt b/compiler/testData/codegen/box/controlStructures/tryCatchInExpressions/tryAndBreak.kt
new file mode 100644
index 00000000000..a1f867b1c3d
--- /dev/null
+++ b/compiler/testData/codegen/box/controlStructures/tryCatchInExpressions/tryAndBreak.kt
@@ -0,0 +1,19 @@
+fun idiv(a: Int, b: Int): Int =
+        if (b == 0) throw Exception("Division by zero") else a / b
+
+fun foo(): Int {
+    var sum = 0
+    var i = 2
+    while (i > -10) {
+        sum += try { idiv(100, i) } catch (e: Exception) { break }
+        i--
+    }
+    return sum
+}
+
+fun box(): String {
+    val test = foo()
+    if (test != 150) return "Failed, test=$test"
+
+    return "OK"
+}
\ No newline at end of file
diff --git a/compiler/testData/codegen/box/controlStructures/tryCatchInExpressions/tryAndContinue.kt b/compiler/testData/codegen/box/controlStructures/tryCatchInExpressions/tryAndContinue.kt
new file mode 100644
index 00000000000..120d463b00c
--- /dev/null
+++ b/compiler/testData/codegen/box/controlStructures/tryCatchInExpressions/tryAndContinue.kt
@@ -0,0 +1,17 @@
+fun idiv(a: Int, b: Int): Int =
+        if (b == 0) throw Exception("Division by zero") else a / b
+
+fun foo(): Int {
+    var sum = 0
+    for (i in -10 .. 10) {
+        sum += try { idiv(100, i) } catch (e: Exception) { continue }
+    }
+    return sum
+}
+
+fun box(): String {
+    val test = foo()
+    if (test != 0) return "Failed, test=$test"
+
+    return "OK"
+}
\ No newline at end of file
diff --git a/compiler/testData/codegen/box/controlStructures/tryCatchInExpressions/tryInsideCatch.kt b/compiler/testData/codegen/box/controlStructures/tryCatchInExpressions/tryInsideCatch.kt
new file mode 100644
index 00000000000..09f9857b57c
--- /dev/null
+++ b/compiler/testData/codegen/box/controlStructures/tryCatchInExpressions/tryInsideCatch.kt
@@ -0,0 +1,8 @@
+fun box(): String =
+        "O" +
+        try {
+            throw Exception("oops!")
+        }
+        catch (e: Exception) {
+            try { "K" } catch (e: Exception) { "2" }
+        }
\ No newline at end of file
diff --git a/compiler/testData/codegen/box/controlStructures/tryCatchInExpressions/tryInsideTry.kt b/compiler/testData/codegen/box/controlStructures/tryCatchInExpressions/tryInsideTry.kt
new file mode 100644
index 00000000000..3d1ccd9e7ae
--- /dev/null
+++ b/compiler/testData/codegen/box/controlStructures/tryCatchInExpressions/tryInsideTry.kt
@@ -0,0 +1,10 @@
+class MyException(message: String): Exception(message)
+
+fun box(): String =
+        "O" +
+        try {
+            try { throw Exception("oops!") } catch (mye: MyException) { "1" }
+        }
+        catch (e: Exception) {
+            "K"
+        }
\ No newline at end of file
diff --git a/compiler/testData/codegen/box/controlStructures/tryCatchInExpressions/unmatchedInlineMarkers.kt b/compiler/testData/codegen/box/controlStructures/tryCatchInExpressions/unmatchedInlineMarkers.kt
new file mode 100644
index 00000000000..015b4137f65
--- /dev/null
+++ b/compiler/testData/codegen/box/controlStructures/tryCatchInExpressions/unmatchedInlineMarkers.kt
@@ -0,0 +1,17 @@
+inline fun catchAll(x: String, block: () -> Unit): String {
+    try {
+        block()
+    } catch (e: Throwable) {
+    }
+    return x
+}
+
+inline fun throwIt(msg: String) {
+    throw Exception(msg)
+}
+
+inline fun bar(x: String): String =
+        x + catchAll("") { throwIt("oops!") }
+
+fun box(): String =
+        bar("OK")
diff --git a/compiler/testData/codegen/box/enum/publicConstructorWithDefault.kt b/compiler/testData/codegen/box/enum/publicConstructorWithDefault.kt
new file mode 100644
index 00000000000..be8a43b12b5
--- /dev/null
+++ b/compiler/testData/codegen/box/enum/publicConstructorWithDefault.kt
@@ -0,0 +1,9 @@
+// KT-8438 org.jetbrains.org.objectweb.asm.tree.analysis.AnalyzerException: Error at instruction 4: Cannot pop operand off an empty stack
+
+enum class E public constructor(x: String = "OK") {
+    ENTRY();
+
+    val result = x
+}
+
+fun box(): String = E.ENTRY.result
diff --git a/compiler/testData/codegen/box/platformTypes/primitives/identityEquals.kt b/compiler/testData/codegen/box/platformTypes/primitives/identityEquals.kt
index ae9aefb1c64..a4ee0641f67 100644
--- a/compiler/testData/codegen/box/platformTypes/primitives/identityEquals.kt
+++ b/compiler/testData/codegen/box/platformTypes/primitives/identityEquals.kt
@@ -3,7 +3,7 @@ fun box(): String {
     l.add(1000)
 
     val x = l[0] === 1000
-    if (x) return "Fail: $x"
+    if (!x) return "Fail: $x"
     val x1 = l[0] === 1
     if (x1) return "Fail 1: $x"
     val x2 = l[0] === l[0]
diff --git a/compiler/testData/codegen/box/primitiveTypes/rangeTo.kt b/compiler/testData/codegen/box/primitiveTypes/rangeTo.kt
index 089d33c836c..798246e70d3 100644
--- a/compiler/testData/codegen/box/primitiveTypes/rangeTo.kt
+++ b/compiler/testData/codegen/box/primitiveTypes/rangeTo.kt
@@ -10,9 +10,6 @@ fun box(): String {
     b.rangeTo(b)
     b rangeTo b
     b..b
-    b.rangeTo(c)
-    b rangeTo c
-    b..c
     b.rangeTo(s)
     b rangeTo s
     b..s
@@ -36,9 +33,6 @@ fun box(): String {
     s.rangeTo(b)
     s rangeTo b
     s..b
-    s.rangeTo(c)
-    s rangeTo c
-    s..c
     s.rangeTo(s)
     s rangeTo s
     s..s
@@ -58,9 +52,6 @@ fun box(): String {
     i.rangeTo(b)
     i rangeTo b
     i..b
-    i.rangeTo(c)
-    i rangeTo c
-    i..c
     i.rangeTo(s)
     i rangeTo s
     i..s
@@ -80,9 +71,6 @@ fun box(): String {
     j.rangeTo(b)
     j rangeTo b
     j..b
-    j.rangeTo(c)
-    j rangeTo c
-    j..c
     j.rangeTo(s)
     j rangeTo s
     j..s
@@ -102,9 +90,6 @@ fun box(): String {
     f.rangeTo(b)
     f rangeTo b
     f..b
-    f.rangeTo(c)
-    f rangeTo c
-    f..c
     f.rangeTo(s)
     f rangeTo s
     f..s
@@ -124,9 +109,6 @@ fun box(): String {
     d.rangeTo(b)
     d rangeTo b
     d..b
-    d.rangeTo(c)
-    d rangeTo c
-    d..c
     d.rangeTo(s)
     d rangeTo s
     d..s
@@ -151,7 +133,7 @@ fun main(args: Array<String>) {
     val s = "bcsijfd"
     for (i in s) {
         for (j in s) {
-            if (i == 'c' && j != 'c') continue
+            if ((i == 'c') != (j == 'c')) continue
             println("    $i.rangeTo($j)")
             println("    $i rangeTo $j")
             println("    $i..$j")
diff --git a/compiler/testData/codegen/boxAgainstJava/annotations/javaNegativePropertyAsAnnotationParameter.kt b/compiler/testData/codegen/boxAgainstJava/annotations/javaNegativePropertyAsAnnotationParameter.kt
index b3cf2d96acf..0146526a3a7 100644
--- a/compiler/testData/codegen/boxAgainstJava/annotations/javaNegativePropertyAsAnnotationParameter.kt
+++ b/compiler/testData/codegen/boxAgainstJava/annotations/javaNegativePropertyAsAnnotationParameter.kt
@@ -1,6 +1,3 @@
-import java.lang.annotation.Retention
-import java.lang.annotation.RetentionPolicy
-
 Ann(Foo.i, Foo.s, Foo.f, Foo.d, Foo.l, Foo.b) class MyClass
 
 fun box(): String {
@@ -15,8 +12,7 @@ fun box(): String {
     return "OK"
 }
 
-Retention(RetentionPolicy.RUNTIME)
-annotation class Ann(
+annotation(retention = AnnotationRetention.RUNTIME) class Ann(
         val i: Int,
         val s: Short,
         val f: Float,
diff --git a/compiler/testData/codegen/boxAgainstJava/annotations/javaPropertyAsAnnotationParameter.java b/compiler/testData/codegen/boxAgainstJava/annotations/javaPropertyAsAnnotationParameter.java
index 9e0b81576c2..2c5840ad27f 100644
--- a/compiler/testData/codegen/boxAgainstJava/annotations/javaPropertyAsAnnotationParameter.java
+++ b/compiler/testData/codegen/boxAgainstJava/annotations/javaPropertyAsAnnotationParameter.java
@@ -8,4 +8,6 @@ class Foo {
     public static final boolean bool = true;
     public static final char c = 'c';
     public static final String str = "str";
+    public static final int charAsInt = '3';
+    public static final char intAsChar = 3;
 }
\ No newline at end of file
diff --git a/compiler/testData/codegen/boxAgainstJava/annotations/javaPropertyAsAnnotationParameter.kt b/compiler/testData/codegen/boxAgainstJava/annotations/javaPropertyAsAnnotationParameter.kt
index 60170c36cba..cb542bcd213 100644
--- a/compiler/testData/codegen/boxAgainstJava/annotations/javaPropertyAsAnnotationParameter.kt
+++ b/compiler/testData/codegen/boxAgainstJava/annotations/javaPropertyAsAnnotationParameter.kt
@@ -1,7 +1,4 @@
-import java.lang.annotation.Retention
-import java.lang.annotation.RetentionPolicy
-
-Ann(Foo.i, Foo.s, Foo.f, Foo.d, Foo.l, Foo.b, Foo.bool, Foo.c, Foo.str) class MyClass
+Ann(Foo.i, Foo.s, Foo.f, Foo.d, Foo.l, Foo.b, Foo.bool, Foo.c, Foo.str, Foo.charAsInt, Foo.intAsChar) class MyClass
 
 fun box(): String {
     val ann = javaClass<MyClass>().getAnnotation(javaClass<Ann>())
@@ -15,11 +12,12 @@ fun box(): String {
     if (!ann.bool) return "fail: annotation parameter i should be true, but was ${ann.i}"
     if (ann.c != 'c') return "fail: annotation parameter i should be c, but was ${ann.i}"
     if (ann.str != "str") return "fail: annotation parameter i should be str, but was ${ann.i}"
+    if (ann.i2 != '3'.toInt()) return "fail: annotation parameter i2 should be ${'3'.toInt()}, but was ${ann.i}"
+    if (ann.c2 != 3.toChar()) return "fail: annotation parameter c2 should be 3, but was ${ann.i}"
     return "OK"
 }
 
-Retention(RetentionPolicy.RUNTIME)
-annotation class Ann(
+annotation(retention = AnnotationRetention.RUNTIME) class Ann(
         val i: Int,
         val s: Short,
         val f: Float,
@@ -28,5 +26,7 @@ annotation class Ann(
         val b: Byte,
         val bool: Boolean,
         val c: Char,
-        val str: String
+        val str: String,
+        val i2: Int,
+        val c2: Char
 )
\ No newline at end of file
diff --git a/compiler/testData/codegen/boxAgainstJava/annotations/javaPropertyWithIntInitializer.kt b/compiler/testData/codegen/boxAgainstJava/annotations/javaPropertyWithIntInitializer.kt
index 67875adf7f6..4e621be9447 100644
--- a/compiler/testData/codegen/boxAgainstJava/annotations/javaPropertyWithIntInitializer.kt
+++ b/compiler/testData/codegen/boxAgainstJava/annotations/javaPropertyWithIntInitializer.kt
@@ -1,6 +1,3 @@
-import java.lang.annotation.Retention
-import java.lang.annotation.RetentionPolicy
-
 Ann(Foo.i, Foo.s, Foo.f, Foo.d, Foo.l, Foo.b, Foo.c) class MyClass
 
 fun box(): String {
@@ -16,8 +13,7 @@ fun box(): String {
     return "OK"
 }
 
-Retention(RetentionPolicy.RUNTIME)
-annotation class Ann(
+annotation(retention = AnnotationRetention.RUNTIME) class Ann(
         val i: Int,
         val s: Short,
         val f: Float,
diff --git a/compiler/testData/codegen/boxAgainstJava/reflection/mapping/javaFields.kt b/compiler/testData/codegen/boxAgainstJava/reflection/mapping/javaFields.kt
index bb2102216e9..bd5f9a4fc71 100644
--- a/compiler/testData/codegen/boxAgainstJava/reflection/mapping/javaFields.kt
+++ b/compiler/testData/codegen/boxAgainstJava/reflection/mapping/javaFields.kt
@@ -10,8 +10,8 @@ fun box(): String {
     val s = J::s
 
     // Check that correct reflection objects are created
-    assert(i.javaClass.getSimpleName() == "KMemberPropertyImpl", "Fail i class")
-    assert(s.javaClass.getSimpleName() == "KMutableMemberPropertyImpl", "Fail s class")
+    assert(i !is KMutableProperty<*>, "Fail i class: ${i.javaClass}")
+    assert(s is KMutableProperty<*>, "Fail s class: ${s.javaClass}")
 
     // Check that no Method objects are created for such properties
     assert(i.javaGetter == null, "Fail i getter")
@@ -33,8 +33,8 @@ fun box(): String {
     assert(a.s == "def", "Fail js access")
 
     // Check that valid Kotlin reflection objects are created by those Field objects
-    val ki = ji.kotlin as KMemberProperty<J, Int>
-    val ks = js.kotlin as KMutableMemberProperty<J, String>
+    val ki = ji.kotlin as KProperty1<J, Int>
+    val ks = js.kotlin as KMutableProperty1<J, String>
     assert(ki.get(a) == 42, "Fail ki get")
     assert(ks.get(a) == "def", "Fail ks get")
     ks.set(a, "ghi")
diff --git a/compiler/testData/codegen/boxAgainstJava/sam/adapters/doubleLongParameters.java b/compiler/testData/codegen/boxAgainstJava/sam/adapters/doubleLongParameters.java
new file mode 100644
index 00000000000..66fd53063de
--- /dev/null
+++ b/compiler/testData/codegen/boxAgainstJava/sam/adapters/doubleLongParameters.java
@@ -0,0 +1,3 @@
+interface GenericInterface<T> {
+    public T foo(double d, int i, long j, short s);
+}
diff --git a/compiler/testData/codegen/boxAgainstJava/sam/adapters/doubleLongParameters.kt b/compiler/testData/codegen/boxAgainstJava/sam/adapters/doubleLongParameters.kt
new file mode 100644
index 00000000000..2f350b4dbad
--- /dev/null
+++ b/compiler/testData/codegen/boxAgainstJava/sam/adapters/doubleLongParameters.kt
@@ -0,0 +1,9 @@
+fun getInterface(): GenericInterface<String> {
+    return GenericInterface { d, i, j, s ->
+        "OK"
+    }
+}
+
+fun box(): String {
+    return getInterface().foo(0.0, 0, 0, 0)
+}
diff --git a/compiler/testData/codegen/boxAgainstJava/syntheticExtensions/fromTwoBases.java b/compiler/testData/codegen/boxAgainstJava/syntheticExtensions/fromTwoBases.java
new file mode 100644
index 00000000000..43794724a9c
--- /dev/null
+++ b/compiler/testData/codegen/boxAgainstJava/syntheticExtensions/fromTwoBases.java
@@ -0,0 +1,14 @@
+interface A {
+    String getOk();
+}
+
+interface B {
+    String getOk();
+}
+
+interface C extends A, B {
+}
+
+class JavaClass implements C {
+    public String getOk() { return "OK"; }
+}
diff --git a/compiler/testData/codegen/boxAgainstJava/syntheticExtensions/fromTwoBases.kt b/compiler/testData/codegen/boxAgainstJava/syntheticExtensions/fromTwoBases.kt
new file mode 100644
index 00000000000..ca57a4e6155
--- /dev/null
+++ b/compiler/testData/codegen/boxAgainstJava/syntheticExtensions/fromTwoBases.kt
@@ -0,0 +1,5 @@
+fun box(): String {
+    return f(JavaClass())
+}
+
+fun f(c: C) = c.ok
diff --git a/compiler/testData/codegen/boxAgainstJava/syntheticExtensions/getter.java b/compiler/testData/codegen/boxAgainstJava/syntheticExtensions/getter.java
new file mode 100644
index 00000000000..a28f5ff490d
--- /dev/null
+++ b/compiler/testData/codegen/boxAgainstJava/syntheticExtensions/getter.java
@@ -0,0 +1,3 @@
+class JavaClass {
+    public String getOk() { return "OK"; }
+}
\ No newline at end of file
diff --git a/compiler/testData/codegen/boxAgainstJava/syntheticExtensions/getter.kt b/compiler/testData/codegen/boxAgainstJava/syntheticExtensions/getter.kt
new file mode 100644
index 00000000000..de99f3e9890
--- /dev/null
+++ b/compiler/testData/codegen/boxAgainstJava/syntheticExtensions/getter.kt
@@ -0,0 +1,3 @@
+fun box(): String {
+    return JavaClass().ok
+}
diff --git a/compiler/testData/codegen/boxAgainstJava/syntheticExtensions/implicitReceiver.java b/compiler/testData/codegen/boxAgainstJava/syntheticExtensions/implicitReceiver.java
new file mode 100644
index 00000000000..48b5ecade7b
--- /dev/null
+++ b/compiler/testData/codegen/boxAgainstJava/syntheticExtensions/implicitReceiver.java
@@ -0,0 +1,11 @@
+class JavaClass {
+    private String myX;
+
+    public String getX() {
+        return myX;
+    }
+
+    public void setX(String x) {
+        myX = x;
+    }
+}
\ No newline at end of file
diff --git a/compiler/testData/codegen/boxAgainstJava/syntheticExtensions/implicitReceiver.kt b/compiler/testData/codegen/boxAgainstJava/syntheticExtensions/implicitReceiver.kt
new file mode 100644
index 00000000000..b815079a31d
--- /dev/null
+++ b/compiler/testData/codegen/boxAgainstJava/syntheticExtensions/implicitReceiver.kt
@@ -0,0 +1,8 @@
+fun box(): String {
+    return JavaClass().doIt()
+}
+
+fun JavaClass.doIt(): String {
+    x = "OK"
+    return x
+}
diff --git a/compiler/testData/codegen/boxAgainstJava/syntheticExtensions/overrideOnlyGetter.java b/compiler/testData/codegen/boxAgainstJava/syntheticExtensions/overrideOnlyGetter.java
new file mode 100644
index 00000000000..4a7ab421bc5
--- /dev/null
+++ b/compiler/testData/codegen/boxAgainstJava/syntheticExtensions/overrideOnlyGetter.java
@@ -0,0 +1,10 @@
+class JavaClass1 {
+    protected Object value = null;
+
+    public Object getSomething() { return null; }
+    public void setSomething(Object value) {  this.value = value; }
+}
+
+class JavaClass2 extends JavaClass1 {
+    public String getSomething() { return (String)value; }
+}
diff --git a/compiler/testData/codegen/boxAgainstJava/syntheticExtensions/overrideOnlyGetter.kt b/compiler/testData/codegen/boxAgainstJava/syntheticExtensions/overrideOnlyGetter.kt
new file mode 100644
index 00000000000..cd8d6552080
--- /dev/null
+++ b/compiler/testData/codegen/boxAgainstJava/syntheticExtensions/overrideOnlyGetter.kt
@@ -0,0 +1,5 @@
+fun box(): String {
+    val javaClass = JavaClass2()
+    javaClass.something = "OK"
+    return javaClass.something
+}
diff --git a/compiler/testData/codegen/boxAgainstJava/syntheticExtensions/plusPlus.java b/compiler/testData/codegen/boxAgainstJava/syntheticExtensions/plusPlus.java
new file mode 100644
index 00000000000..0b0e9b587ca
--- /dev/null
+++ b/compiler/testData/codegen/boxAgainstJava/syntheticExtensions/plusPlus.java
@@ -0,0 +1,11 @@
+class JavaClass {
+    private int myX = 0;
+
+    public int getX() {
+        return myX;
+    }
+
+    public void setX(int x) {
+        myX = x;
+    }
+}
\ No newline at end of file
diff --git a/compiler/testData/codegen/boxAgainstJava/syntheticExtensions/plusPlus.kt b/compiler/testData/codegen/boxAgainstJava/syntheticExtensions/plusPlus.kt
new file mode 100644
index 00000000000..4f9f39e43d2
--- /dev/null
+++ b/compiler/testData/codegen/boxAgainstJava/syntheticExtensions/plusPlus.kt
@@ -0,0 +1,5 @@
+fun box(): String {
+    val javaClass = JavaClass()
+    javaClass.x++
+    return if (javaClass.x == 1) "OK" else "ERROR"
+}
diff --git a/compiler/testData/codegen/boxAgainstJava/syntheticExtensions/setter.java b/compiler/testData/codegen/boxAgainstJava/syntheticExtensions/setter.java
new file mode 100644
index 00000000000..48b5ecade7b
--- /dev/null
+++ b/compiler/testData/codegen/boxAgainstJava/syntheticExtensions/setter.java
@@ -0,0 +1,11 @@
+class JavaClass {
+    private String myX;
+
+    public String getX() {
+        return myX;
+    }
+
+    public void setX(String x) {
+        myX = x;
+    }
+}
\ No newline at end of file
diff --git a/compiler/testData/codegen/boxAgainstJava/syntheticExtensions/setter.kt b/compiler/testData/codegen/boxAgainstJava/syntheticExtensions/setter.kt
new file mode 100644
index 00000000000..1be9b657a1b
--- /dev/null
+++ b/compiler/testData/codegen/boxAgainstJava/syntheticExtensions/setter.kt
@@ -0,0 +1,5 @@
+fun box(): String {
+    val javaClass = JavaClass()
+    javaClass.x = "OK"
+    return javaClass.x
+}
diff --git a/compiler/testData/codegen/boxWithJava/annotatedSamFunExpression/annotatedSamFunExpression.kt b/compiler/testData/codegen/boxWithJava/annotatedSamFunExpression/annotatedSamFunExpression.kt
index 798e6a86839..582e297caa7 100644
--- a/compiler/testData/codegen/boxWithJava/annotatedSamFunExpression/annotatedSamFunExpression.kt
+++ b/compiler/testData/codegen/boxWithJava/annotatedSamFunExpression/annotatedSamFunExpression.kt
@@ -1,10 +1,8 @@
-import java.lang.annotation.*
 import java.lang.reflect.Method
 import kotlin.reflect.jvm.java
 import kotlin.test.assertEquals
 
-Retention(RetentionPolicy.RUNTIME)
-annotation class Ann(val x: String)
+annotation(retention = AnnotationRetention.RUNTIME) class Ann(val x: String)
 
 fun testMethod(method: Method, name: String) {
     assertEquals("OK", method.getAnnotation(javaClass<Ann>()).x, "On method of test named `$name`")
diff --git a/compiler/testData/codegen/boxWithJava/annotatedSamLambda/annotatedSamLambda.kt b/compiler/testData/codegen/boxWithJava/annotatedSamLambda/annotatedSamLambda.kt
index 1b43fadddd4..b6f53f39310 100644
--- a/compiler/testData/codegen/boxWithJava/annotatedSamLambda/annotatedSamLambda.kt
+++ b/compiler/testData/codegen/boxWithJava/annotatedSamLambda/annotatedSamLambda.kt
@@ -1,10 +1,9 @@
-import java.lang.annotation.*
 import java.lang.reflect.Method
 import kotlin.reflect.jvm.java
 import kotlin.test.assertEquals
 
-Retention(RetentionPolicy.RUNTIME)
-annotation class Ann(val x: String)
+target(AnnotationTarget.EXPRESSION)
+annotation(retention = AnnotationRetention.RUNTIME) class Ann(val x: String)
 
 fun testMethod(method: Method, name: String) {
     assertEquals("OK", method.getAnnotation(javaClass<Ann>()).x, "On method of test named `$name`")
diff --git a/compiler/testData/codegen/boxWithJava/annotationsWithKClass/array/array.kt b/compiler/testData/codegen/boxWithJava/annotationsWithKClass/array/array.kt
index 0f8718e1bc0..f4f88aa7c14 100644
--- a/compiler/testData/codegen/boxWithJava/annotationsWithKClass/array/array.kt
+++ b/compiler/testData/codegen/boxWithJava/annotationsWithKClass/array/array.kt
@@ -1,8 +1,6 @@
 import kotlin.reflect.KClass
-import java.lang.annotation.*
 
-Retention(RetentionPolicy.RUNTIME)
-annotation
+annotation(retention = AnnotationRetention.RUNTIME)
 class Ann(val args: Array<KClass<*>>)
 
 fun box(): String {
diff --git a/compiler/testData/codegen/boxWithJava/annotationsWithKClass/basic/basic.kt b/compiler/testData/codegen/boxWithJava/annotationsWithKClass/basic/basic.kt
index b0c937dff79..c346d5ec59c 100644
--- a/compiler/testData/codegen/boxWithJava/annotationsWithKClass/basic/basic.kt
+++ b/compiler/testData/codegen/boxWithJava/annotationsWithKClass/basic/basic.kt
@@ -1,8 +1,6 @@
 import kotlin.reflect.KClass
-import java.lang.annotation.*
 
-Retention(RetentionPolicy.RUNTIME)
-annotation
+annotation(retention = AnnotationRetention.RUNTIME)
 class Ann(val arg: KClass<*>)
 
 fun box(): String {
diff --git a/compiler/testData/codegen/boxWithJava/annotationsWithKClass/vararg/vararg.kt b/compiler/testData/codegen/boxWithJava/annotationsWithKClass/vararg/vararg.kt
index d22a733d399..cf39dfd67ca 100644
--- a/compiler/testData/codegen/boxWithJava/annotationsWithKClass/vararg/vararg.kt
+++ b/compiler/testData/codegen/boxWithJava/annotationsWithKClass/vararg/vararg.kt
@@ -1,8 +1,6 @@
 import kotlin.reflect.KClass
-import java.lang.annotation.*
 
-Retention(RetentionPolicy.RUNTIME)
-annotation
+annotation(retention = AnnotationRetention.RUNTIME)
 class Ann(vararg val args: KClass<*>)
 
 fun box(): String {
diff --git a/compiler/testData/codegen/boxWithJava/classObjectAccessor/J.java b/compiler/testData/codegen/boxWithJava/classObjectAccessor/J.java
index 308c328b2b8..1464f02b7bc 100644
--- a/compiler/testData/codegen/boxWithJava/classObjectAccessor/J.java
+++ b/compiler/testData/codegen/boxWithJava/classObjectAccessor/J.java
@@ -1,5 +1,5 @@
 public class J {
     public static int f() {
-       return A.Companion.getI1() + A.OBJECT$.getI2() + B.Named.getI1() + B.OBJECT$.getI2();
+       return A.Companion.getI1() + A.Companion.getI2() + B.Named.getI1() + B.Named.getI2();
     }
 }
diff --git a/compiler/testData/codegen/boxWithJava/platformStatic/annotations/simpleClassObject.kt b/compiler/testData/codegen/boxWithJava/platformStatic/annotations/simpleClassObject.kt
index a57849fb795..296cd8224cb 100644
--- a/compiler/testData/codegen/boxWithJava/platformStatic/annotations/simpleClassObject.kt
+++ b/compiler/testData/codegen/boxWithJava/platformStatic/annotations/simpleClassObject.kt
@@ -1,9 +1,6 @@
-import java.lang.annotation.Retention
-import java.lang.annotation.RetentionPolicy
 import kotlin.platform.platformStatic
 
-Retention(RetentionPolicy.RUNTIME)
-annotation class testAnnotation
+annotation(retention = AnnotationRetention.RUNTIME) class testAnnotation
 
 class A {
 
diff --git a/compiler/testData/codegen/boxWithJava/publicField/simple/Test.java b/compiler/testData/codegen/boxWithJava/publicField/simple/Test.java
new file mode 100644
index 00000000000..846c2246310
--- /dev/null
+++ b/compiler/testData/codegen/boxWithJava/publicField/simple/Test.java
@@ -0,0 +1,6 @@
+public class Test {
+    public static String invokeMethodWithPublicField() {
+        C c = new C();
+        return c.foo;
+    }
+}
\ No newline at end of file
diff --git a/compiler/testData/codegen/boxWithJava/publicField/simple/simple.kt b/compiler/testData/codegen/boxWithJava/publicField/simple/simple.kt
new file mode 100644
index 00000000000..798704c4d84
--- /dev/null
+++ b/compiler/testData/codegen/boxWithJava/publicField/simple/simple.kt
@@ -0,0 +1,7 @@
+class C {
+    @publicField private val foo: String = "OK"
+}
+
+fun box(): String {
+    return Test.invokeMethodWithPublicField()
+}
diff --git a/compiler/testData/codegen/boxWithJava/reflection/functionReferenceErasedToKFunction/J.java b/compiler/testData/codegen/boxWithJava/reflection/functionReferenceErasedToKFunction/J.java
index 6536c732dea..100310e99de 100644
--- a/compiler/testData/codegen/boxWithJava/reflection/functionReferenceErasedToKFunction/J.java
+++ b/compiler/testData/codegen/boxWithJava/reflection/functionReferenceErasedToKFunction/J.java
@@ -1,9 +1,9 @@
 import kotlin.jvm.functions.Function2;
-import kotlin.reflect.KMemberFunction;
+import kotlin.reflect.KFunction;
 
 public class J {
     public static String go() {
-        KMemberFunction<K, String> fun = K.Companion.getRef();
+        KFunction<String> fun = K.Companion.getRef();
         Object result = ((Function2) fun).invoke(new K(), "KO");
         return (String) result;
     }
diff --git a/compiler/testData/codegen/boxWithJava/reflection/javaStaticField/J.java b/compiler/testData/codegen/boxWithJava/reflection/javaStaticField/J.java
new file mode 100644
index 00000000000..00317c601f4
--- /dev/null
+++ b/compiler/testData/codegen/boxWithJava/reflection/javaStaticField/J.java
@@ -0,0 +1,3 @@
+public class J {
+    static String x;
+}
diff --git a/compiler/testData/codegen/boxWithJava/reflection/javaStaticField/K.kt b/compiler/testData/codegen/boxWithJava/reflection/javaStaticField/K.kt
new file mode 100644
index 00000000000..869e71619f0
--- /dev/null
+++ b/compiler/testData/codegen/boxWithJava/reflection/javaStaticField/K.kt
@@ -0,0 +1,12 @@
+import kotlin.test.assertEquals
+
+fun box(): String {
+    val f = J::x
+    assertEquals("x", f.name)
+
+    f.set("OK")
+    assertEquals("OK", J.x)
+    assertEquals("OK", f.getter())
+
+    return f.get()
+}
diff --git a/compiler/testData/codegen/boxWithJava/reflection/kotlinPropertyInheritedInJava/K.kt b/compiler/testData/codegen/boxWithJava/reflection/kotlinPropertyInheritedInJava/K.kt
index 7cb9078f898..71c941f1bca 100644
--- a/compiler/testData/codegen/boxWithJava/reflection/kotlinPropertyInheritedInJava/K.kt
+++ b/compiler/testData/codegen/boxWithJava/reflection/kotlinPropertyInheritedInJava/K.kt
@@ -11,7 +11,7 @@ fun box(): String {
     val j = J()
 
     val prop = J::prop
-    if (prop !is KMutableMemberProperty<*, *>) return "Fail instanceof"
+    if (prop !is KMutableProperty1<*, *>) return "Fail instanceof"
     if (prop.name != "prop") return "Fail name: ${prop.name}"
     if (prop.get(j) != ":(") return "Fail get before: ${prop[j]}"
     prop[j] = ":)"
@@ -27,13 +27,13 @@ fun box(): String {
 
     val prop2 = klass.properties.firstOrNull { it.name == "prop" } ?: "Fail: no 'prop' property in properties"
     if (prop != prop2) return "Fail: property references from :: and from properties differ: $prop != $prop2"
-    if (prop2 !is KMutableMemberProperty<*, *>) return "Fail instanceof 2"
-    (prop2 as KMutableMemberProperty<J, String>).set(j, "::)")
+    if (prop2 !is KMutableProperty1<*, *>) return "Fail instanceof 2"
+    (prop2 as KMutableProperty1<J, String>).set(j, "::)")
     if (prop.get(j) != "::)") return "Fail get after 2: ${prop[j]}"
 
 
     val ext = klass.extensionProperties.firstOrNull { it.name == "ext" } ?: "Fail: no 'ext' property in extensionProperties"
-    ext as KMemberExtensionProperty<J, Int, Int>
+    ext as KProperty2<J, Int, Int>
     val fortyTwo = ext.get(j, 42)
     if (fortyTwo != 42) return "Fail ext get: $fortyTwo"
 
diff --git a/compiler/testData/codegen/boxWithJava/reflection/noConflictOnKotlinGetterAndJavaField/J.java b/compiler/testData/codegen/boxWithJava/reflection/noConflictOnKotlinGetterAndJavaField/J.java
new file mode 100644
index 00000000000..c081e6d25cf
--- /dev/null
+++ b/compiler/testData/codegen/boxWithJava/reflection/noConflictOnKotlinGetterAndJavaField/J.java
@@ -0,0 +1,3 @@
+public class J {
+    public String foo = "";
+}
diff --git a/compiler/testData/codegen/boxWithJava/reflection/noConflictOnKotlinGetterAndJavaField/K.kt b/compiler/testData/codegen/boxWithJava/reflection/noConflictOnKotlinGetterAndJavaField/K.kt
new file mode 100644
index 00000000000..d78c60c8661
--- /dev/null
+++ b/compiler/testData/codegen/boxWithJava/reflection/noConflictOnKotlinGetterAndJavaField/K.kt
@@ -0,0 +1,23 @@
+import kotlin.test.*
+
+class K : J() {
+    fun getFoo(): String = "K"
+}
+
+fun box(): String {
+    val j = J()
+    val x = J::foo
+    x.set(j, "J")
+    assertEquals("J", x.get(j))
+
+    val k = K()
+    val y = K::foo
+    y.set(k, "K")
+    assertEquals("K", y.get(k))
+    assertEquals("K", x.get(k))
+
+    val z = K::getFoo
+    assertEquals("K", z.invoke(k))
+
+    return "OK"
+}
diff --git a/compiler/testData/codegen/boxWithStdlib/annotations/annotatedEnumEntry.kt b/compiler/testData/codegen/boxWithStdlib/annotations/annotatedEnumEntry.kt
index 95143c59e78..ead0b2e2156 100644
--- a/compiler/testData/codegen/boxWithStdlib/annotations/annotatedEnumEntry.kt
+++ b/compiler/testData/codegen/boxWithStdlib/annotations/annotatedEnumEntry.kt
@@ -1,12 +1,8 @@
 // KT-5665
 
-import java.lang.annotation.*
+annotation(retention = AnnotationRetention.RUNTIME) class First
 
-Retention(RetentionPolicy.RUNTIME)
-annotation class First
-
-Retention(RetentionPolicy.RUNTIME)
-annotation class Second(val value: String)
+annotation(retention = AnnotationRetention.RUNTIME) class Second(val value: String)
 
 enum class E {
     @First
diff --git a/compiler/testData/codegen/boxWithStdlib/annotations/annotatedLambda/funExpression.kt b/compiler/testData/codegen/boxWithStdlib/annotations/annotatedLambda/funExpression.kt
index e1a35abe22b..3bcc483afe4 100644
--- a/compiler/testData/codegen/boxWithStdlib/annotations/annotatedLambda/funExpression.kt
+++ b/compiler/testData/codegen/boxWithStdlib/annotations/annotatedLambda/funExpression.kt
@@ -1,10 +1,8 @@
-import java.lang.annotation.*
 import java.lang.reflect.Method
 import kotlin.reflect.jvm.java
 import kotlin.test.assertEquals
 
-Retention(RetentionPolicy.RUNTIME)
-annotation class Ann(val x: String)
+annotation(retention = AnnotationRetention.RUNTIME) class Ann(val x: String)
 
 fun foo0(block: () -> Unit) = block.javaClass
 fun foo1(block: (String) -> Unit) = block.javaClass
diff --git a/compiler/testData/codegen/boxWithStdlib/annotations/annotatedLambda/lambda.kt b/compiler/testData/codegen/boxWithStdlib/annotations/annotatedLambda/lambda.kt
index 81a259382c7..e5de02774ae 100644
--- a/compiler/testData/codegen/boxWithStdlib/annotations/annotatedLambda/lambda.kt
+++ b/compiler/testData/codegen/boxWithStdlib/annotations/annotatedLambda/lambda.kt
@@ -1,10 +1,9 @@
-import java.lang.annotation.*
 import java.lang.reflect.Method
 import kotlin.reflect.jvm.java
 import kotlin.test.assertEquals
 
-Retention(RetentionPolicy.RUNTIME)
-annotation class Ann(val x: String)
+target(AnnotationTarget.EXPRESSION)
+annotation(retention = AnnotationRetention.RUNTIME) class Ann(val x: String)
 
 fun foo0(block: () -> Unit) = block.javaClass
 
diff --git a/compiler/testData/codegen/boxWithStdlib/annotations/annotationsOnDefault.kt b/compiler/testData/codegen/boxWithStdlib/annotations/annotationsOnDefault.kt
index 3ae2dd93f86..6179a2439ea 100644
--- a/compiler/testData/codegen/boxWithStdlib/annotations/annotationsOnDefault.kt
+++ b/compiler/testData/codegen/boxWithStdlib/annotations/annotationsOnDefault.kt
@@ -1,8 +1,6 @@
-import java.lang.annotation.*
 import kotlin.test.assertEquals
 
-Retention(RetentionPolicy.RUNTIME)
-annotation class Ann(val x: Int)
+annotation(retention = AnnotationRetention.RUNTIME) class Ann(val x: Int)
 class A {
     Ann(1) fun foo(x: Int, y: Int = 2, z: Int) {}
 
diff --git a/compiler/testData/codegen/boxWithStdlib/annotations/defaultParameterValues.kt b/compiler/testData/codegen/boxWithStdlib/annotations/defaultParameterValues.kt
index 304e1fcce29..d99408f2f40 100644
--- a/compiler/testData/codegen/boxWithStdlib/annotations/defaultParameterValues.kt
+++ b/compiler/testData/codegen/boxWithStdlib/annotations/defaultParameterValues.kt
@@ -1,10 +1,7 @@
-import java.lang.annotation.Retention
-import java.lang.annotation.RetentionPolicy
 import kotlin.reflect.KClass
 import kotlin.reflect.jvm.java
 
-Retention(RetentionPolicy.RUNTIME)
-annotation class Ann(
+annotation(retention = AnnotationRetention.RUNTIME) class Ann(
         val i: Int = 1,
         val s: String = "a",
         val a: Ann2 = Ann2(),
diff --git a/compiler/testData/codegen/boxWithStdlib/annotations/delegatedPropertySetter.kt b/compiler/testData/codegen/boxWithStdlib/annotations/delegatedPropertySetter.kt
index 24e7376a8a3..34356bf7a12 100644
--- a/compiler/testData/codegen/boxWithStdlib/annotations/delegatedPropertySetter.kt
+++ b/compiler/testData/codegen/boxWithStdlib/annotations/delegatedPropertySetter.kt
@@ -1,7 +1,4 @@
-import java.lang.annotation.*
-
-Retention(RetentionPolicy.RUNTIME)
-annotation class First
+annotation(retention = AnnotationRetention.RUNTIME) class First
 
 class MyClass() {
     public var x: String by Delegate()
diff --git a/compiler/testData/codegen/boxWithStdlib/annotations/kotlinPropertyFromClassObjectAsParameter.kt b/compiler/testData/codegen/boxWithStdlib/annotations/kotlinPropertyFromClassObjectAsParameter.kt
index ec16c008089..835385e0b5e 100644
--- a/compiler/testData/codegen/boxWithStdlib/annotations/kotlinPropertyFromClassObjectAsParameter.kt
+++ b/compiler/testData/codegen/boxWithStdlib/annotations/kotlinPropertyFromClassObjectAsParameter.kt
@@ -1,6 +1,3 @@
-import java.lang.annotation.Retention
-import java.lang.annotation.RetentionPolicy
-
 Ann(Foo.i, Foo.s, Foo.f, Foo.d, Foo.l, Foo.b, Foo.bool, Foo.c, Foo.str) class MyClass
 
 fun box(): String {
@@ -18,8 +15,7 @@ fun box(): String {
     return "OK"
 }
 
-Retention(RetentionPolicy.RUNTIME)
-annotation class Ann(
+annotation(retention = AnnotationRetention.RUNTIME) class Ann(
         val i: Int,
         val s: Short,
         val f: Float,
diff --git a/compiler/testData/codegen/boxWithStdlib/annotations/kotlinTopLevelPropertyAsParameter.kt b/compiler/testData/codegen/boxWithStdlib/annotations/kotlinTopLevelPropertyAsParameter.kt
index 8356c404d74..eaaafbf3f6e 100644
--- a/compiler/testData/codegen/boxWithStdlib/annotations/kotlinTopLevelPropertyAsParameter.kt
+++ b/compiler/testData/codegen/boxWithStdlib/annotations/kotlinTopLevelPropertyAsParameter.kt
@@ -1,6 +1,3 @@
-import java.lang.annotation.Retention
-import java.lang.annotation.RetentionPolicy
-
 Ann(i, s, f, d, l, b, bool, c, str) class MyClass
 
 fun box(): String {
@@ -18,8 +15,7 @@ fun box(): String {
     return "OK"
 }
 
-Retention(RetentionPolicy.RUNTIME)
-annotation class Ann(
+annotation(retention = AnnotationRetention.RUNTIME) class Ann(
         val i: Int,
         val s: Short,
         val f: Float,
diff --git a/compiler/testData/codegen/boxWithStdlib/annotations/nestedClassPropertyAsParameter.kt b/compiler/testData/codegen/boxWithStdlib/annotations/nestedClassPropertyAsParameter.kt
index 48a935e5c2f..d7dd3805275 100644
--- a/compiler/testData/codegen/boxWithStdlib/annotations/nestedClassPropertyAsParameter.kt
+++ b/compiler/testData/codegen/boxWithStdlib/annotations/nestedClassPropertyAsParameter.kt
@@ -1,6 +1,3 @@
-import java.lang.annotation.Retention
-import java.lang.annotation.RetentionPolicy
-
 Ann(A.B.i) class MyClass
 
 fun box(): String {
@@ -10,8 +7,7 @@ fun box(): String {
     return "OK"
 }
 
-Retention(RetentionPolicy.RUNTIME)
-annotation class Ann(val i: Int)
+annotation(retention = AnnotationRetention.RUNTIME) class Ann(val i: Int)
 
 class A {
    class B {
diff --git a/compiler/testData/codegen/boxWithStdlib/annotations/parameterWithPrimitiveType.kt b/compiler/testData/codegen/boxWithStdlib/annotations/parameterWithPrimitiveType.kt
index 3b7914376da..6469958ea93 100644
--- a/compiler/testData/codegen/boxWithStdlib/annotations/parameterWithPrimitiveType.kt
+++ b/compiler/testData/codegen/boxWithStdlib/annotations/parameterWithPrimitiveType.kt
@@ -1,8 +1,4 @@
-import java.lang.annotation.Retention
-import java.lang.annotation.RetentionPolicy
-
-Retention(RetentionPolicy.RUNTIME)
-annotation class Ann(
+annotation(retention = AnnotationRetention.RUNTIME) class Ann(
         val b: Byte,
         val s: Short,
         val i: Int,
diff --git a/compiler/testData/codegen/boxWithStdlib/annotations/propertyWithPropertyInInitializerAsParameter.kt b/compiler/testData/codegen/boxWithStdlib/annotations/propertyWithPropertyInInitializerAsParameter.kt
index 97afafad53c..268155c7a59 100644
--- a/compiler/testData/codegen/boxWithStdlib/annotations/propertyWithPropertyInInitializerAsParameter.kt
+++ b/compiler/testData/codegen/boxWithStdlib/annotations/propertyWithPropertyInInitializerAsParameter.kt
@@ -1,6 +1,3 @@
-import java.lang.annotation.Retention
-import java.lang.annotation.RetentionPolicy
-
 Ann(i) class MyClass
 
 fun box(): String {
@@ -10,8 +7,7 @@ fun box(): String {
     return "OK"
 }
 
-Retention(RetentionPolicy.RUNTIME)
-annotation class Ann(val i: Int)
+annotation(retention = AnnotationRetention.RUNTIME) class Ann(val i: Int)
 
 val i2: Int = 1
 val i: Int = i2
diff --git a/compiler/testData/codegen/boxWithStdlib/annotations/varargInAnnotationParameter.kt b/compiler/testData/codegen/boxWithStdlib/annotations/varargInAnnotationParameter.kt
index bcb6d456c13..ed2fe14f038 100644
--- a/compiler/testData/codegen/boxWithStdlib/annotations/varargInAnnotationParameter.kt
+++ b/compiler/testData/codegen/boxWithStdlib/annotations/varargInAnnotationParameter.kt
@@ -1,8 +1,4 @@
-import java.lang.annotation.Retention
-import java.lang.annotation.RetentionPolicy
-
-Retention(RetentionPolicy.RUNTIME)
-annotation class Ann(vararg val p: Int)
+annotation(retention = AnnotationRetention.RUNTIME) class Ann(vararg val p: Int)
 
 Ann() class MyClass1
 Ann(1) class MyClass2
diff --git a/compiler/testData/codegen/boxWithStdlib/callableReference/function/abstractClassMember.kt b/compiler/testData/codegen/boxWithStdlib/callableReference/function/abstractClassMember.kt
index a5718485bec..515b25914d0 100644
--- a/compiler/testData/codegen/boxWithStdlib/callableReference/function/abstractClassMember.kt
+++ b/compiler/testData/codegen/boxWithStdlib/callableReference/function/abstractClassMember.kt
@@ -6,4 +6,4 @@ class B : A() {
     override fun foo() = "OK"
 }
 
-fun box(): String = B().(A::foo)()
+fun box(): String = (A::foo)(B())
diff --git a/compiler/testData/codegen/boxWithStdlib/callableReference/function/booleanNotIntrinsic.kt b/compiler/testData/codegen/boxWithStdlib/callableReference/function/booleanNotIntrinsic.kt
index 114e328afef..213c8d88996 100644
--- a/compiler/testData/codegen/boxWithStdlib/callableReference/function/booleanNotIntrinsic.kt
+++ b/compiler/testData/codegen/boxWithStdlib/callableReference/function/booleanNotIntrinsic.kt
@@ -1,5 +1,5 @@
 fun box(): String {
-    if (true.(Boolean::not)() != false) return "Fail 1"
-    if (false.(Boolean::not)() != true) return "Fail 2"
+    if ((Boolean::not)(true) != false) return "Fail 1"
+    if ((Boolean::not)(false) != true) return "Fail 2"
     return "OK"
 }
diff --git a/compiler/testData/codegen/boxWithStdlib/callableReference/function/classMemberFromClass.kt b/compiler/testData/codegen/boxWithStdlib/callableReference/function/classMemberFromClass.kt
index 1ef4255bbe1..7f5fd04017f 100644
--- a/compiler/testData/codegen/boxWithStdlib/callableReference/function/classMemberFromClass.kt
+++ b/compiler/testData/codegen/boxWithStdlib/callableReference/function/classMemberFromClass.kt
@@ -1,7 +1,7 @@
 class A {
     fun foo(k: Int) = k
 
-    fun result() = this.(::foo)(111)
+    fun result() = (::foo)(this, 111)
 }
 
 fun box(): String {
diff --git a/compiler/testData/codegen/boxWithStdlib/callableReference/function/classMemberFromExtension.kt b/compiler/testData/codegen/boxWithStdlib/callableReference/function/classMemberFromExtension.kt
index f19e87f864c..607fa3700f5 100644
--- a/compiler/testData/codegen/boxWithStdlib/callableReference/function/classMemberFromExtension.kt
+++ b/compiler/testData/codegen/boxWithStdlib/callableReference/function/classMemberFromExtension.kt
@@ -3,7 +3,7 @@ class A {
     fun k(k: Int) = k
 }
 
-fun A.foo() = this.(::o)() + this.(A::k)(222)
+fun A.foo() = (::o)(this) + (A::k)(this, 222)
 
 fun box(): String {
     val result = A().foo()
diff --git a/compiler/testData/codegen/boxWithStdlib/callableReference/function/classMemberFromTopLevelStringNoArgs.kt b/compiler/testData/codegen/boxWithStdlib/callableReference/function/classMemberFromTopLevelStringNoArgs.kt
index d7fe34551ef..4ea10740594 100644
--- a/compiler/testData/codegen/boxWithStdlib/callableReference/function/classMemberFromTopLevelStringNoArgs.kt
+++ b/compiler/testData/codegen/boxWithStdlib/callableReference/function/classMemberFromTopLevelStringNoArgs.kt
@@ -4,5 +4,5 @@ class A {
 
 fun box(): String {
     val x = A::foo
-    return A().x()
+    return x(A())
 }
diff --git a/compiler/testData/codegen/boxWithStdlib/callableReference/function/classMemberFromTopLevelStringOneStringArg.kt b/compiler/testData/codegen/boxWithStdlib/callableReference/function/classMemberFromTopLevelStringOneStringArg.kt
index 9e03ba90c63..acdf2f897d5 100644
--- a/compiler/testData/codegen/boxWithStdlib/callableReference/function/classMemberFromTopLevelStringOneStringArg.kt
+++ b/compiler/testData/codegen/boxWithStdlib/callableReference/function/classMemberFromTopLevelStringOneStringArg.kt
@@ -4,5 +4,5 @@ class A {
 
 fun box(): String {
     val x = A::foo
-    return A().x("OK")
+    return x(A(), "OK")
 }
diff --git a/compiler/testData/codegen/boxWithStdlib/callableReference/function/classMemberFromTopLevelUnitNoArgs.kt b/compiler/testData/codegen/boxWithStdlib/callableReference/function/classMemberFromTopLevelUnitNoArgs.kt
index 4fb93fc926f..37ebbdb72eb 100644
--- a/compiler/testData/codegen/boxWithStdlib/callableReference/function/classMemberFromTopLevelUnitNoArgs.kt
+++ b/compiler/testData/codegen/boxWithStdlib/callableReference/function/classMemberFromTopLevelUnitNoArgs.kt
@@ -9,6 +9,6 @@ class A {
 fun box(): String {
     val a = A()
     val x = A::foo
-    a.x()
+    x(a)
     return a.result
 }
diff --git a/compiler/testData/codegen/boxWithStdlib/callableReference/function/classMemberFromTopLevelUnitOneStringArg.kt b/compiler/testData/codegen/boxWithStdlib/callableReference/function/classMemberFromTopLevelUnitOneStringArg.kt
index c982e914210..3b280c28f34 100644
--- a/compiler/testData/codegen/boxWithStdlib/callableReference/function/classMemberFromTopLevelUnitOneStringArg.kt
+++ b/compiler/testData/codegen/boxWithStdlib/callableReference/function/classMemberFromTopLevelUnitOneStringArg.kt
@@ -9,6 +9,6 @@ class A {
 fun box(): String {
     val a = A()
     val x = A::foo
-    a.x("OK")
+    x(a, "OK")
     return a.result
 }
diff --git a/compiler/testData/codegen/boxWithStdlib/callableReference/function/enumNameMethod.kt b/compiler/testData/codegen/boxWithStdlib/callableReference/function/enumNameMethod.kt
index 1aa7fc633b2..b6a1bf51558 100644
--- a/compiler/testData/codegen/boxWithStdlib/callableReference/function/enumNameMethod.kt
+++ b/compiler/testData/codegen/boxWithStdlib/callableReference/function/enumNameMethod.kt
@@ -3,7 +3,7 @@ enum class E {
 }
 
 fun box(): String {
-    val i = E.I.(E::name)()
+    val i = (E::name)(E.I)
     if (i != "I") return "Fail $i"
     return "OK"
 }
diff --git a/compiler/testData/codegen/boxWithStdlib/callableReference/function/equalsIntrinsic.kt b/compiler/testData/codegen/boxWithStdlib/callableReference/function/equalsIntrinsic.kt
index be58579704b..c83a188802d 100644
--- a/compiler/testData/codegen/boxWithStdlib/callableReference/function/equalsIntrinsic.kt
+++ b/compiler/testData/codegen/boxWithStdlib/callableReference/function/equalsIntrinsic.kt
@@ -1,3 +1,3 @@
 class A
 
-fun box() = if (A().(A::equals)(A())) "Fail" else "OK"
+fun box() = if ((A::equals)(A(), A())) "Fail" else "OK"
diff --git a/compiler/testData/codegen/boxWithStdlib/callableReference/function/extensionFromClass.kt b/compiler/testData/codegen/boxWithStdlib/callableReference/function/extensionFromClass.kt
index 0bbfc45d383..f5dabed6746 100644
--- a/compiler/testData/codegen/boxWithStdlib/callableReference/function/extensionFromClass.kt
+++ b/compiler/testData/codegen/boxWithStdlib/callableReference/function/extensionFromClass.kt
@@ -1,5 +1,5 @@
 class A {
-    fun result() = this.(::foo)("OK")
+    fun result() = (::foo)(this, "OK")
 }
 
 fun A.foo(x: String) = x
diff --git a/compiler/testData/codegen/boxWithStdlib/callableReference/function/extensionFromExtension.kt b/compiler/testData/codegen/boxWithStdlib/callableReference/function/extensionFromExtension.kt
index 4f43bb608d8..103ceee5cbc 100644
--- a/compiler/testData/codegen/boxWithStdlib/callableReference/function/extensionFromExtension.kt
+++ b/compiler/testData/codegen/boxWithStdlib/callableReference/function/extensionFromExtension.kt
@@ -1,6 +1,6 @@
 class A
 
-fun A.foo() = this.(A::bar)("OK")
+fun A.foo() = (A::bar)(this, "OK")
 
 fun A.bar(x: String) = x
 
diff --git a/compiler/testData/codegen/boxWithStdlib/callableReference/function/extensionFromTopLevelStringNoArgs.kt b/compiler/testData/codegen/boxWithStdlib/callableReference/function/extensionFromTopLevelStringNoArgs.kt
index 46f1caa4528..b5fd42ad9c6 100644
--- a/compiler/testData/codegen/boxWithStdlib/callableReference/function/extensionFromTopLevelStringNoArgs.kt
+++ b/compiler/testData/codegen/boxWithStdlib/callableReference/function/extensionFromTopLevelStringNoArgs.kt
@@ -4,5 +4,5 @@ fun A.foo() = "OK"
 
 fun box(): String {
     val x = A::foo
-    return A().x()
+    return x(A())
 }
diff --git a/compiler/testData/codegen/boxWithStdlib/callableReference/function/extensionFromTopLevelStringOneStringArg.kt b/compiler/testData/codegen/boxWithStdlib/callableReference/function/extensionFromTopLevelStringOneStringArg.kt
index 9f371dbf329..69db0311a69 100644
--- a/compiler/testData/codegen/boxWithStdlib/callableReference/function/extensionFromTopLevelStringOneStringArg.kt
+++ b/compiler/testData/codegen/boxWithStdlib/callableReference/function/extensionFromTopLevelStringOneStringArg.kt
@@ -4,5 +4,5 @@ fun A.foo(result: String) = result
 
 fun box(): String {
     val x = A::foo
-    return A().x("OK")
+    return x(A(), "OK")
 }
diff --git a/compiler/testData/codegen/boxWithStdlib/callableReference/function/extensionFromTopLevelUnitNoArgs.kt b/compiler/testData/codegen/boxWithStdlib/callableReference/function/extensionFromTopLevelUnitNoArgs.kt
index d90c6c98d28..b590ad2ec91 100644
--- a/compiler/testData/codegen/boxWithStdlib/callableReference/function/extensionFromTopLevelUnitNoArgs.kt
+++ b/compiler/testData/codegen/boxWithStdlib/callableReference/function/extensionFromTopLevelUnitNoArgs.kt
@@ -9,6 +9,6 @@ fun A.foo() {
 fun box(): String {
     val a = A()
     val x = A::foo
-    a.x()
+    x(a)
     return a.result
 }
diff --git a/compiler/testData/codegen/boxWithStdlib/callableReference/function/extensionFromTopLevelUnitOneStringArg.kt b/compiler/testData/codegen/boxWithStdlib/callableReference/function/extensionFromTopLevelUnitOneStringArg.kt
index 68fdd0903e5..aa9d5505bbf 100644
--- a/compiler/testData/codegen/boxWithStdlib/callableReference/function/extensionFromTopLevelUnitOneStringArg.kt
+++ b/compiler/testData/codegen/boxWithStdlib/callableReference/function/extensionFromTopLevelUnitOneStringArg.kt
@@ -9,6 +9,6 @@ fun A.foo(newResult: String) {
 fun box(): String {
     val a = A()
     val x = A::foo
-    a.x("OK")
+    x(a, "OK")
     return a.result
 }
diff --git a/compiler/testData/codegen/boxWithStdlib/callableReference/function/genericMember.kt b/compiler/testData/codegen/boxWithStdlib/callableReference/function/genericMember.kt
index 8608c508dde..25dabc055f2 100644
--- a/compiler/testData/codegen/boxWithStdlib/callableReference/function/genericMember.kt
+++ b/compiler/testData/codegen/boxWithStdlib/callableReference/function/genericMember.kt
@@ -2,4 +2,4 @@ class A<T>(val t: T) {
     fun foo(): T = t
 }
 
-fun box() = A("OK").(A<String>::foo)()
+fun box() = (A<String>::foo)(A("OK"))
diff --git a/compiler/testData/codegen/boxWithStdlib/callableReference/function/innerConstructorFromClass.kt b/compiler/testData/codegen/boxWithStdlib/callableReference/function/innerConstructorFromClass.kt
index 8f19b83cb4f..53b31fa77d0 100644
--- a/compiler/testData/codegen/boxWithStdlib/callableReference/function/innerConstructorFromClass.kt
+++ b/compiler/testData/codegen/boxWithStdlib/callableReference/function/innerConstructorFromClass.kt
@@ -4,7 +4,7 @@ class A {
         val k = 222
     }
     
-    fun result() = this.(A::Inner)().o + this.(::Inner)().k
+    fun result() = (A::Inner)(this).o + (::Inner)(this).k
 }
 
 fun box(): String {
diff --git a/compiler/testData/codegen/boxWithStdlib/callableReference/function/innerConstructorFromExtension.kt b/compiler/testData/codegen/boxWithStdlib/callableReference/function/innerConstructorFromExtension.kt
index 6fa9653c833..aad8cb2a97a 100644
--- a/compiler/testData/codegen/boxWithStdlib/callableReference/function/innerConstructorFromExtension.kt
+++ b/compiler/testData/codegen/boxWithStdlib/callableReference/function/innerConstructorFromExtension.kt
@@ -5,7 +5,7 @@ class A {
     }
 }
 
-fun A.foo() = this.(A::Inner)().o + this.(::Inner)().k
+fun A.foo() = (A::Inner)(this).o + (::Inner)(this).k
 
 fun box(): String {
     val result = A().foo()
diff --git a/compiler/testData/codegen/boxWithStdlib/callableReference/function/innerConstructorFromTopLevelNoArgs.kt b/compiler/testData/codegen/boxWithStdlib/callableReference/function/innerConstructorFromTopLevelNoArgs.kt
index b974ba82993..577eb19e7af 100644
--- a/compiler/testData/codegen/boxWithStdlib/callableReference/function/innerConstructorFromTopLevelNoArgs.kt
+++ b/compiler/testData/codegen/boxWithStdlib/callableReference/function/innerConstructorFromTopLevelNoArgs.kt
@@ -6,7 +6,7 @@ class A {
 }
 
 fun box(): String {
-    val result = (::A)().(A::Inner)().o + A().(A::Inner)().k
+    val result = (A::Inner)((::A)()).o + (A::Inner)(A()).k
     if (result != 333) return "Fail $result"
     return "OK"
 }
diff --git a/compiler/testData/codegen/boxWithStdlib/callableReference/function/innerConstructorFromTopLevelOneStringArg.kt b/compiler/testData/codegen/boxWithStdlib/callableReference/function/innerConstructorFromTopLevelOneStringArg.kt
index e47bd741210..0eb2b831a2b 100644
--- a/compiler/testData/codegen/boxWithStdlib/callableReference/function/innerConstructorFromTopLevelOneStringArg.kt
+++ b/compiler/testData/codegen/boxWithStdlib/callableReference/function/innerConstructorFromTopLevelOneStringArg.kt
@@ -3,7 +3,7 @@ class A {
 }
 
 fun box(): String {
-    val result = (::A)().(A::Inner)(111).result + A().(A::Inner)(222).result
+    val result = (A::Inner)((::A)(), 111).result + (A::Inner)(A(), 222).result
     if (result != 333) return "Fail $result"
     return "OK"
 }
diff --git a/compiler/testData/codegen/boxWithStdlib/callableReference/function/local/captureOuter.kt b/compiler/testData/codegen/boxWithStdlib/callableReference/function/local/captureOuter.kt
index 46bec43ff91..e653f8f0574 100644
--- a/compiler/testData/codegen/boxWithStdlib/callableReference/function/local/captureOuter.kt
+++ b/compiler/testData/codegen/boxWithStdlib/callableReference/function/local/captureOuter.kt
@@ -8,5 +8,5 @@ class Outer {
 
 fun box(): String {
     val f = Outer.Inner::foo
-    return Outer().Inner().f()
+    return f(Outer().Inner())
 }
diff --git a/compiler/testData/codegen/boxWithStdlib/callableReference/function/local/classMember.kt b/compiler/testData/codegen/boxWithStdlib/callableReference/function/local/classMember.kt
index 343e9015c84..72bb8af6e81 100644
--- a/compiler/testData/codegen/boxWithStdlib/callableReference/function/local/classMember.kt
+++ b/compiler/testData/codegen/boxWithStdlib/callableReference/function/local/classMember.kt
@@ -4,5 +4,5 @@ fun box(): String {
     }
 
     val ref = Local::foo
-    return Local().ref()
+    return ref(Local())
 }
diff --git a/compiler/testData/codegen/boxWithStdlib/callableReference/function/local/enumExtendsTrait.kt b/compiler/testData/codegen/boxWithStdlib/callableReference/function/local/enumExtendsTrait.kt
index 5b28434e19c..f2bfced60f4 100644
--- a/compiler/testData/codegen/boxWithStdlib/callableReference/function/local/enumExtendsTrait.kt
+++ b/compiler/testData/codegen/boxWithStdlib/callableReference/function/local/enumExtendsTrait.kt
@@ -7,5 +7,5 @@ enum class E : Named {
 }
 
 fun box(): String {
-    return E.OK.(Named::name)()
+    return (Named::name)(E.OK)
 }
diff --git a/compiler/testData/codegen/boxWithStdlib/callableReference/function/local/extension.kt b/compiler/testData/codegen/boxWithStdlib/callableReference/function/local/extension.kt
index c0ce1217d94..3919a320e81 100644
--- a/compiler/testData/codegen/boxWithStdlib/callableReference/function/local/extension.kt
+++ b/compiler/testData/codegen/boxWithStdlib/callableReference/function/local/extension.kt
@@ -2,5 +2,5 @@ class A
 
 fun box(): String {
     fun A.foo() = "OK"
-    return A().(A::foo)()
+    return (A::foo)(A())
 }
diff --git a/compiler/testData/codegen/boxWithStdlib/callableReference/function/local/extensionToLocalClass.kt b/compiler/testData/codegen/boxWithStdlib/callableReference/function/local/extensionToLocalClass.kt
index 781d8096ea0..43537f177e9 100644
--- a/compiler/testData/codegen/boxWithStdlib/callableReference/function/local/extensionToLocalClass.kt
+++ b/compiler/testData/codegen/boxWithStdlib/callableReference/function/local/extensionToLocalClass.kt
@@ -1,5 +1,5 @@
 fun box(): String {
     class A
     fun A.foo() = "OK"
-    return (::A)().(A::foo)()
+    return (A::foo)((::A)())
 }
diff --git a/compiler/testData/codegen/boxWithStdlib/callableReference/function/local/extensionToPrimitive.kt b/compiler/testData/codegen/boxWithStdlib/callableReference/function/local/extensionToPrimitive.kt
index f8db384261a..9cb84f4df07 100644
--- a/compiler/testData/codegen/boxWithStdlib/callableReference/function/local/extensionToPrimitive.kt
+++ b/compiler/testData/codegen/boxWithStdlib/callableReference/function/local/extensionToPrimitive.kt
@@ -1,4 +1,4 @@
 fun box(): String {
     fun Int.is42With(that: Int) = this + 2 * that == 42
-    return if (16.(Int::is42With)(13)) "OK" else "Fail"
+    return if ((Int::is42With)(16, 13)) "OK" else "Fail"
 }
diff --git a/compiler/testData/codegen/boxWithStdlib/callableReference/function/local/extensionWithClosure.kt b/compiler/testData/codegen/boxWithStdlib/callableReference/function/local/extensionWithClosure.kt
index a3e02eef8de..cbbbcd219b1 100644
--- a/compiler/testData/codegen/boxWithStdlib/callableReference/function/local/extensionWithClosure.kt
+++ b/compiler/testData/codegen/boxWithStdlib/callableReference/function/local/extensionWithClosure.kt
@@ -6,6 +6,6 @@ fun box(): String {
     fun A.ext() { result = "OK" }
 
     val f = A::ext
-    A().f()
+    f(A())
     return result
 }
diff --git a/compiler/testData/codegen/boxWithStdlib/callableReference/function/local/genericMember.kt b/compiler/testData/codegen/boxWithStdlib/callableReference/function/local/genericMember.kt
index ad0db326cd9..12e60f50480 100644
--- a/compiler/testData/codegen/boxWithStdlib/callableReference/function/local/genericMember.kt
+++ b/compiler/testData/codegen/boxWithStdlib/callableReference/function/local/genericMember.kt
@@ -4,5 +4,5 @@ fun box(): String {
     }
 
     val ref = Id<String>::invoke
-    return Id<String>().ref("OK")
+    return ref(Id<String>(), "OK")
 }
diff --git a/compiler/testData/codegen/boxWithStdlib/callableReference/function/local/localClassMember.kt b/compiler/testData/codegen/boxWithStdlib/callableReference/function/local/localClassMember.kt
index abe1c70a0bd..98f62fb5b40 100644
--- a/compiler/testData/codegen/boxWithStdlib/callableReference/function/local/localClassMember.kt
+++ b/compiler/testData/codegen/boxWithStdlib/callableReference/function/local/localClassMember.kt
@@ -7,5 +7,5 @@ fun box(): String {
 
     val member = Local::foo
     val instance = Local()
-    return instance.member()
+    return member(instance)
 }
diff --git a/compiler/testData/codegen/boxWithStdlib/callableReference/function/objectMemberUnitNoArgs.kt b/compiler/testData/codegen/boxWithStdlib/callableReference/function/objectMemberUnitNoArgs.kt
index 35d45d87c65..15191f36579 100644
--- a/compiler/testData/codegen/boxWithStdlib/callableReference/function/objectMemberUnitNoArgs.kt
+++ b/compiler/testData/codegen/boxWithStdlib/callableReference/function/objectMemberUnitNoArgs.kt
@@ -8,6 +8,6 @@ object A {
 
 fun box(): String {
     val x = A::foo
-    A.x()
+    x(A)
     return A.result
 }
diff --git a/compiler/testData/codegen/boxWithStdlib/callableReference/function/objectMemberUnitOneStringArg.kt b/compiler/testData/codegen/boxWithStdlib/callableReference/function/objectMemberUnitOneStringArg.kt
index 1598361da6a..fe7f8a41b7f 100644
--- a/compiler/testData/codegen/boxWithStdlib/callableReference/function/objectMemberUnitOneStringArg.kt
+++ b/compiler/testData/codegen/boxWithStdlib/callableReference/function/objectMemberUnitOneStringArg.kt
@@ -8,6 +8,6 @@ object A {
 
 fun box(): String {
     val x = A::foo
-    A.x("OK")
+    x(A, "OK")
     return A.result
 }
diff --git a/compiler/testData/codegen/boxWithStdlib/callableReference/function/privateClassMember.kt b/compiler/testData/codegen/boxWithStdlib/callableReference/function/privateClassMember.kt
index 1b7ffe85906..c796995fc67 100644
--- a/compiler/testData/codegen/boxWithStdlib/callableReference/function/privateClassMember.kt
+++ b/compiler/testData/codegen/boxWithStdlib/callableReference/function/privateClassMember.kt
@@ -1,7 +1,7 @@
 class A {
     private fun foo() = "OK"
 
-    fun bar() = this.(::foo)()
+    fun bar() = (::foo)(this)
 }
 
 fun box() = A().bar()
diff --git a/compiler/testData/codegen/boxWithStdlib/callableReference/function/traitImplMethodWithClassReceiver.kt b/compiler/testData/codegen/boxWithStdlib/callableReference/function/traitImplMethodWithClassReceiver.kt
index b47561d9d03..51923a24746 100644
--- a/compiler/testData/codegen/boxWithStdlib/callableReference/function/traitImplMethodWithClassReceiver.kt
+++ b/compiler/testData/codegen/boxWithStdlib/callableReference/function/traitImplMethodWithClassReceiver.kt
@@ -4,7 +4,7 @@ interface T {
 
 class B : T {
     inner class C {
-        fun bar() = this@B.(::foo)()
+        fun bar() = (::foo)(this@B)
     }
 }
 
diff --git a/compiler/testData/codegen/boxWithStdlib/callableReference/function/traitMember.kt b/compiler/testData/codegen/boxWithStdlib/callableReference/function/traitMember.kt
index 619220ff65f..88cf738eaa7 100644
--- a/compiler/testData/codegen/boxWithStdlib/callableReference/function/traitMember.kt
+++ b/compiler/testData/codegen/boxWithStdlib/callableReference/function/traitMember.kt
@@ -6,4 +6,4 @@ class B : A {
     override fun foo() = "OK"
 }
 
-fun box() = B().(A::foo)()
+fun box() = (A::foo)(B())
diff --git a/compiler/testData/codegen/boxWithStdlib/callableReference/property/genericProperty.kt b/compiler/testData/codegen/boxWithStdlib/callableReference/property/genericProperty.kt
index d5e2dd8f1d2..fae016e0a82 100644
--- a/compiler/testData/codegen/boxWithStdlib/callableReference/property/genericProperty.kt
+++ b/compiler/testData/codegen/boxWithStdlib/callableReference/property/genericProperty.kt
@@ -1,6 +1,6 @@
 //For KT-6020
-import kotlin.reflect.KMemberProperty
-import kotlin.reflect.KMutableMemberProperty
+import kotlin.reflect.KProperty1
+import kotlin.reflect.KMutableProperty1
 
 class Value<T>(var value: T = null as T, var text: String? = null)
 
@@ -8,7 +8,7 @@ val <T> Value<T>.additionalText by DVal(Value<T>::text) //works
 
 val <T> Value<T>.additionalValue by DVal(Value<T>::value) //not work
 
-class DVal<T, R, P: KMemberProperty<T, R>>(val kmember: P) {
+class DVal<T, R, P: KProperty1<T, R>>(val kmember: P) {
     fun get(t: T, p: PropertyMetadata): R {
         return kmember.get(t)
     }
@@ -17,4 +17,4 @@ class DVal<T, R, P: KMemberProperty<T, R>>(val kmember: P) {
 fun box(): String {
     val p = Value("O", "K")
     return p.additionalValue + p.additionalText
-}
\ No newline at end of file
+}
diff --git a/compiler/testData/codegen/boxWithStdlib/callableReference/property/kClassInstanceIsInitializedFirst.kt b/compiler/testData/codegen/boxWithStdlib/callableReference/property/kClassInstanceIsInitializedFirst.kt
index db87afa64e7..5ce636926d5 100644
--- a/compiler/testData/codegen/boxWithStdlib/callableReference/property/kClassInstanceIsInitializedFirst.kt
+++ b/compiler/testData/codegen/boxWithStdlib/callableReference/property/kClassInstanceIsInitializedFirst.kt
@@ -1,8 +1,8 @@
-import kotlin.reflect.KMemberProperty
+import kotlin.reflect.KProperty1
 
 class A {
     companion object {
-        val ref: KMemberProperty<A, String> = A::foo
+        val ref: KProperty1<A, String> = A::foo
     }
 
     val foo: String = "OK"
diff --git a/compiler/testData/codegen/boxWithStdlib/callableReference/property/kt6870_privatePropertyReference.kt b/compiler/testData/codegen/boxWithStdlib/callableReference/property/kt6870_privatePropertyReference.kt
new file mode 100644
index 00000000000..3bfa39df049
--- /dev/null
+++ b/compiler/testData/codegen/boxWithStdlib/callableReference/property/kt6870_privatePropertyReference.kt
@@ -0,0 +1,22 @@
+class Test {
+    private var iv = 1
+
+    public fun exec() {
+        val t = object : Thread() {
+            override fun run() {
+                ::iv.get(this@Test)
+                ::iv.set(this@Test, 2)
+            }
+        }
+        t.start()
+        t.join(1000)
+    }
+
+    fun result() = if (iv == 2) "OK" else "Fail $iv"
+}
+
+fun box(): String {
+    val t = Test()
+    t.exec()
+    return t.result()
+}
diff --git a/compiler/testData/codegen/boxWithStdlib/casts/unitAsInt.kt b/compiler/testData/codegen/boxWithStdlib/casts/unitAsInt.kt
new file mode 100644
index 00000000000..39713cf804f
--- /dev/null
+++ b/compiler/testData/codegen/boxWithStdlib/casts/unitAsInt.kt
@@ -0,0 +1,15 @@
+fun foo() {}
+
+fun box(): String {
+    try {
+        foo() as Int?
+    }
+    catch (e: ClassCastException) {
+        return "OK"
+    }
+    catch (e: Throwable) {
+        return "Fail: ClassCastException should have been thrown, but was instead ${e.javaClass.getName()}: ${e.getMessage()}"
+    }
+
+    return "Fail: no exception was thrown"
+}
diff --git a/compiler/testData/codegen/boxWithStdlib/evaluate/char.kt b/compiler/testData/codegen/boxWithStdlib/evaluate/char.kt
index 22674ee4f60..6fe0644ffe4 100644
--- a/compiler/testData/codegen/boxWithStdlib/evaluate/char.kt
+++ b/compiler/testData/codegen/boxWithStdlib/evaluate/char.kt
@@ -1,10 +1,6 @@
 package test
 
-import java.lang.annotation.Retention
-import java.lang.annotation.RetentionPolicy
-
-Retention(RetentionPolicy.RUNTIME)
-annotation class Ann(val c1: Int)
+annotation(retention = AnnotationRetention.RUNTIME) class Ann(val c1: Int)
 
 Ann('a' - 'a') class MyClass
 
diff --git a/compiler/testData/codegen/boxWithStdlib/evaluate/divide.kt b/compiler/testData/codegen/boxWithStdlib/evaluate/divide.kt
index ca891eb6eac..1273569707b 100644
--- a/compiler/testData/codegen/boxWithStdlib/evaluate/divide.kt
+++ b/compiler/testData/codegen/boxWithStdlib/evaluate/divide.kt
@@ -1,8 +1,4 @@
-import java.lang.annotation.Retention
-import java.lang.annotation.RetentionPolicy
-
-Retention(RetentionPolicy.RUNTIME)
-annotation class Ann(
+annotation(retention = AnnotationRetention.RUNTIME) class Ann(
         val b: Byte,
         val s: Short,
         val i: Int,
diff --git a/compiler/testData/codegen/boxWithStdlib/evaluate/infixCallBinary.kt b/compiler/testData/codegen/boxWithStdlib/evaluate/infixCallBinary.kt
index 3ecdbb17b1f..52666d81d24 100644
--- a/compiler/testData/codegen/boxWithStdlib/evaluate/infixCallBinary.kt
+++ b/compiler/testData/codegen/boxWithStdlib/evaluate/infixCallBinary.kt
@@ -1,8 +1,4 @@
-import java.lang.annotation.Retention
-import java.lang.annotation.RetentionPolicy
-
-Retention(RetentionPolicy.RUNTIME)
-annotation class Ann(
+annotation(retention = AnnotationRetention.RUNTIME) class Ann(
         val p1: Int,
         val p2: Int,
         val p3: Int,
diff --git a/compiler/testData/codegen/boxWithStdlib/evaluate/intrincics.kt b/compiler/testData/codegen/boxWithStdlib/evaluate/intrincics.kt
index f63fdef4400..07cbc06acb8 100644
--- a/compiler/testData/codegen/boxWithStdlib/evaluate/intrincics.kt
+++ b/compiler/testData/codegen/boxWithStdlib/evaluate/intrincics.kt
@@ -1,8 +1,4 @@
-import java.lang.annotation.Retention
-import java.lang.annotation.RetentionPolicy
-
-Retention(RetentionPolicy.RUNTIME)
-annotation class Ann(
+annotation(retention = AnnotationRetention.RUNTIME) class Ann(
         val p1: Int,
         val p2: Short,
         val p3: Byte,
diff --git a/compiler/testData/codegen/boxWithStdlib/evaluate/maxValue.kt b/compiler/testData/codegen/boxWithStdlib/evaluate/maxValue.kt
index 1cb3dcb089c..7ec02fad346 100644
--- a/compiler/testData/codegen/boxWithStdlib/evaluate/maxValue.kt
+++ b/compiler/testData/codegen/boxWithStdlib/evaluate/maxValue.kt
@@ -1,8 +1,4 @@
-import java.lang.annotation.Retention
-import java.lang.annotation.RetentionPolicy
-
-Retention(RetentionPolicy.RUNTIME)
-annotation class Ann(
+annotation(retention = AnnotationRetention.RUNTIME) class Ann(
         val p1: Int,
         val p2: Int,
         val p3: Int,
diff --git a/compiler/testData/codegen/boxWithStdlib/evaluate/maxValueByte.kt b/compiler/testData/codegen/boxWithStdlib/evaluate/maxValueByte.kt
index c927a96f218..11e6517a39e 100644
--- a/compiler/testData/codegen/boxWithStdlib/evaluate/maxValueByte.kt
+++ b/compiler/testData/codegen/boxWithStdlib/evaluate/maxValueByte.kt
@@ -1,8 +1,4 @@
-import java.lang.annotation.Retention
-import java.lang.annotation.RetentionPolicy
-
-Retention(RetentionPolicy.RUNTIME)
-annotation class Ann(
+annotation(retention = AnnotationRetention.RUNTIME) class Ann(
         val p1: Int,
         val p2: Byte,
         val p4: Int,
diff --git a/compiler/testData/codegen/boxWithStdlib/evaluate/maxValueInt.kt b/compiler/testData/codegen/boxWithStdlib/evaluate/maxValueInt.kt
index 8317171ba77..2b81c8bac02 100644
--- a/compiler/testData/codegen/boxWithStdlib/evaluate/maxValueInt.kt
+++ b/compiler/testData/codegen/boxWithStdlib/evaluate/maxValueInt.kt
@@ -1,8 +1,4 @@
-import java.lang.annotation.Retention
-import java.lang.annotation.RetentionPolicy
-
-Retention(RetentionPolicy.RUNTIME)
-annotation class Ann(
+annotation(retention = AnnotationRetention.RUNTIME) class Ann(
         val p1: Int,
         val p2: Int,
         val p4: Long,
diff --git a/compiler/testData/codegen/boxWithStdlib/evaluate/miltiply.kt b/compiler/testData/codegen/boxWithStdlib/evaluate/miltiply.kt
index aca9bf3c2de..5125caa4557 100644
--- a/compiler/testData/codegen/boxWithStdlib/evaluate/miltiply.kt
+++ b/compiler/testData/codegen/boxWithStdlib/evaluate/miltiply.kt
@@ -1,8 +1,4 @@
-import java.lang.annotation.Retention
-import java.lang.annotation.RetentionPolicy
-
-Retention(RetentionPolicy.RUNTIME)
-annotation class Ann(
+annotation(retention = AnnotationRetention.RUNTIME) class Ann(
         val p1: Byte,
         val p2: Short,
         val p3: Int,
diff --git a/compiler/testData/codegen/boxWithStdlib/evaluate/minus.kt b/compiler/testData/codegen/boxWithStdlib/evaluate/minus.kt
index 626c85df9b7..baeeab6de9f 100644
--- a/compiler/testData/codegen/boxWithStdlib/evaluate/minus.kt
+++ b/compiler/testData/codegen/boxWithStdlib/evaluate/minus.kt
@@ -1,8 +1,4 @@
-import java.lang.annotation.Retention
-import java.lang.annotation.RetentionPolicy
-
-Retention(RetentionPolicy.RUNTIME)
-annotation class Ann(
+annotation(retention = AnnotationRetention.RUNTIME) class Ann(
         val p1: Byte,
         val p2: Short,
         val p3: Int,
diff --git a/compiler/testData/codegen/boxWithStdlib/evaluate/mod.kt b/compiler/testData/codegen/boxWithStdlib/evaluate/mod.kt
index 5042c163602..64ba6b944ea 100644
--- a/compiler/testData/codegen/boxWithStdlib/evaluate/mod.kt
+++ b/compiler/testData/codegen/boxWithStdlib/evaluate/mod.kt
@@ -1,8 +1,4 @@
-import java.lang.annotation.Retention
-import java.lang.annotation.RetentionPolicy
-
-Retention(RetentionPolicy.RUNTIME)
-annotation class Ann(
+annotation(retention = AnnotationRetention.RUNTIME) class Ann(
         val p1: Byte,
         val p2: Short,
         val p3: Int,
diff --git a/compiler/testData/codegen/boxWithStdlib/evaluate/paranthesized.kt b/compiler/testData/codegen/boxWithStdlib/evaluate/paranthesized.kt
index 62629fe5b1f..f9815c6940b 100644
--- a/compiler/testData/codegen/boxWithStdlib/evaluate/paranthesized.kt
+++ b/compiler/testData/codegen/boxWithStdlib/evaluate/paranthesized.kt
@@ -1,8 +1,4 @@
-import java.lang.annotation.Retention
-import java.lang.annotation.RetentionPolicy
-
-Retention(RetentionPolicy.RUNTIME)
-annotation class Ann(
+annotation(retention = AnnotationRetention.RUNTIME) class Ann(
         val p1: Byte,
         val p2: Short,
         val p3: Int,
diff --git a/compiler/testData/codegen/boxWithStdlib/evaluate/plus.kt b/compiler/testData/codegen/boxWithStdlib/evaluate/plus.kt
index c84910aa5cb..bfa000dfe76 100644
--- a/compiler/testData/codegen/boxWithStdlib/evaluate/plus.kt
+++ b/compiler/testData/codegen/boxWithStdlib/evaluate/plus.kt
@@ -1,8 +1,4 @@
-import java.lang.annotation.Retention
-import java.lang.annotation.RetentionPolicy
-
-Retention(RetentionPolicy.RUNTIME)
-annotation class Ann(
+annotation(retention = AnnotationRetention.RUNTIME) class Ann(
         val p1: Byte,
         val p2: Short,
         val p3: Int,
diff --git a/compiler/testData/codegen/boxWithStdlib/evaluate/simpleCallBinary.kt b/compiler/testData/codegen/boxWithStdlib/evaluate/simpleCallBinary.kt
index 84999de929f..2be9ecb8298 100644
--- a/compiler/testData/codegen/boxWithStdlib/evaluate/simpleCallBinary.kt
+++ b/compiler/testData/codegen/boxWithStdlib/evaluate/simpleCallBinary.kt
@@ -1,8 +1,4 @@
-import java.lang.annotation.Retention
-import java.lang.annotation.RetentionPolicy
-
-Retention(RetentionPolicy.RUNTIME)
-annotation class Ann(
+annotation(retention = AnnotationRetention.RUNTIME) class Ann(
         val p1: Int,
         val p2: Int,
         val p3: Int,
diff --git a/compiler/testData/codegen/boxWithStdlib/evaluate/unaryMinus.kt b/compiler/testData/codegen/boxWithStdlib/evaluate/unaryMinus.kt
index 68d4077cedc..a40663c2e87 100644
--- a/compiler/testData/codegen/boxWithStdlib/evaluate/unaryMinus.kt
+++ b/compiler/testData/codegen/boxWithStdlib/evaluate/unaryMinus.kt
@@ -1,8 +1,4 @@
-import java.lang.annotation.Retention
-import java.lang.annotation.RetentionPolicy
-
-Retention(RetentionPolicy.RUNTIME)
-annotation class Ann(
+annotation(retention = AnnotationRetention.RUNTIME) class Ann(
         val p1: Byte,
         val p2: Short,
         val p3: Int,
diff --git a/compiler/testData/codegen/boxWithStdlib/evaluate/unaryPlus.kt b/compiler/testData/codegen/boxWithStdlib/evaluate/unaryPlus.kt
index a75bc397886..b330439042e 100644
--- a/compiler/testData/codegen/boxWithStdlib/evaluate/unaryPlus.kt
+++ b/compiler/testData/codegen/boxWithStdlib/evaluate/unaryPlus.kt
@@ -1,8 +1,4 @@
-import java.lang.annotation.Retention
-import java.lang.annotation.RetentionPolicy
-
-Retention(RetentionPolicy.RUNTIME)
-annotation class Ann(
+annotation(retention = AnnotationRetention.RUNTIME) class Ann(
         val p1: Byte,
         val p2: Short,
         val p3: Int,
diff --git a/compiler/testData/codegen/boxWithStdlib/fullJdk/platformTypeAssertionStackTrace.kt b/compiler/testData/codegen/boxWithStdlib/fullJdk/platformTypeAssertionStackTrace.kt
index a459b553fe7..e2d11d5240c 100644
--- a/compiler/testData/codegen/boxWithStdlib/fullJdk/platformTypeAssertionStackTrace.kt
+++ b/compiler/testData/codegen/boxWithStdlib/fullJdk/platformTypeAssertionStackTrace.kt
@@ -1,8 +1,7 @@
-import java.util.Arrays
-import java.util.ArrayList
+import java.util.*
 
 fun box(): String {
-    val a = ArrayList<String>()
+    val a = ArrayList<String>() as AbstractList<String>
     a.add(null)
     try {
         val b: String = a[0]
diff --git a/compiler/testData/codegen/boxWithStdlib/platformStatic/callableRef.kt b/compiler/testData/codegen/boxWithStdlib/platformStatic/callableRef.kt
index a0f350cafc5..346de4cd500 100644
--- a/compiler/testData/codegen/boxWithStdlib/platformStatic/callableRef.kt
+++ b/compiler/testData/codegen/boxWithStdlib/platformStatic/callableRef.kt
@@ -4,7 +4,7 @@ object A {
 
     val b: String = "OK"
 
-    platformStatic val c: String = "OK"
+    platformStatic var c: String = "Fail"
 
     platformStatic fun test1() : String {
         return b
@@ -28,15 +28,17 @@ object A {
 }
 
 fun box(): String {
-    if (A.(A::test1)() != "OK") return "fail 1"
+    if ((A::test1)(A) != "OK") return "fail 1"
 
-    if (A.(A::test2)() != "OK") return "fail 2"
+    if ((A::test2)(A) != "OK") return "fail 2"
 
-    if (A.(A::test3)() != "1OK") return "fail 3"
+    if ((A::test3)(A) != "1OK") return "fail 3"
 
-    if (A.(A::test4)() != "1OK") return "fail 4"
+    if ((A::test4)(A) != "1OK") return "fail 4"
+
+    (A::c).set(A, "OK")
 
     if (((A::c).get(A)) != "OK") return "fail 5"
 
     return "OK"
-}
\ No newline at end of file
+}
diff --git a/compiler/testData/codegen/boxWithStdlib/ranges/expression/inexactDownToMinValue.kt b/compiler/testData/codegen/boxWithStdlib/ranges/expression/inexactDownToMinValue.kt
index 2339845995d..f4d26ce7d35 100644
--- a/compiler/testData/codegen/boxWithStdlib/ranges/expression/inexactDownToMinValue.kt
+++ b/compiler/testData/codegen/boxWithStdlib/ranges/expression/inexactDownToMinValue.kt
@@ -55,13 +55,13 @@ fun box(): String {
     }
 
     val list5 = ArrayList<Char>()
-    val range5 = (MinC + 5).toChar() downTo MinC step 3
+    val range5 = (MinC + 5) downTo MinC step 3
     for (i in range5) {
         list5.add(i)
         if (list5.size() > 23) break
     }
-    if (list5 != listOf<Char>((MinC + 5).toChar(), (MinC + 2).toChar())) {
-        return "Wrong elements for (MinC + 5).toChar() downTo MinC step 3: $list5"
+    if (list5 != listOf<Char>((MinC + 5), (MinC + 2))) {
+        return "Wrong elements for (MinC + 5) downTo MinC step 3: $list5"
     }
 
     return "OK"
diff --git a/compiler/testData/codegen/boxWithStdlib/ranges/expression/inexactToMaxValue.kt b/compiler/testData/codegen/boxWithStdlib/ranges/expression/inexactToMaxValue.kt
index 5ae8ded829d..d5befa8aa5a 100644
--- a/compiler/testData/codegen/boxWithStdlib/ranges/expression/inexactToMaxValue.kt
+++ b/compiler/testData/codegen/boxWithStdlib/ranges/expression/inexactToMaxValue.kt
@@ -55,13 +55,13 @@ fun box(): String {
     }
 
     val list5 = ArrayList<Char>()
-    val range5 = (MaxC - 5).toChar()..MaxC step 3
+    val range5 = (MaxC - 5)..MaxC step 3
     for (i in range5) {
         list5.add(i)
         if (list5.size() > 23) break
     }
-    if (list5 != listOf<Char>((MaxC - 5).toChar(), (MaxC - 2).toChar())) {
-        return "Wrong elements for (MaxC - 5).toChar()..MaxC step 3: $list5"
+    if (list5 != listOf<Char>((MaxC - 5), (MaxC - 2))) {
+        return "Wrong elements for (MaxC - 5)..MaxC step 3: $list5"
     }
 
     return "OK"
diff --git a/compiler/testData/codegen/boxWithStdlib/ranges/expression/maxValueMinusTwoToMaxValue.kt b/compiler/testData/codegen/boxWithStdlib/ranges/expression/maxValueMinusTwoToMaxValue.kt
index 13fbca1e1cb..3ee48b17dde 100644
--- a/compiler/testData/codegen/boxWithStdlib/ranges/expression/maxValueMinusTwoToMaxValue.kt
+++ b/compiler/testData/codegen/boxWithStdlib/ranges/expression/maxValueMinusTwoToMaxValue.kt
@@ -55,13 +55,13 @@ fun box(): String {
     }
 
     val list5 = ArrayList<Char>()
-    val range5 = (MaxC - 2).toChar()..MaxC
+    val range5 = (MaxC - 2)..MaxC
     for (i in range5) {
         list5.add(i)
         if (list5.size() > 23) break
     }
-    if (list5 != listOf<Char>((MaxC - 2).toChar(), (MaxC - 1).toChar(), MaxC)) {
-        return "Wrong elements for (MaxC - 2).toChar()..MaxC: $list5"
+    if (list5 != listOf<Char>((MaxC - 2), (MaxC - 1), MaxC)) {
+        return "Wrong elements for (MaxC - 2)..MaxC: $list5"
     }
 
     return "OK"
diff --git a/compiler/testData/codegen/boxWithStdlib/ranges/expression/progressionDownToMinValue.kt b/compiler/testData/codegen/boxWithStdlib/ranges/expression/progressionDownToMinValue.kt
index 3d45cda9ea5..1531e67511c 100644
--- a/compiler/testData/codegen/boxWithStdlib/ranges/expression/progressionDownToMinValue.kt
+++ b/compiler/testData/codegen/boxWithStdlib/ranges/expression/progressionDownToMinValue.kt
@@ -55,13 +55,13 @@ fun box(): String {
     }
 
     val list5 = ArrayList<Char>()
-    val range5 = (MinC + 2).toChar() downTo MinC step 1
+    val range5 = (MinC + 2) downTo MinC step 1
     for (i in range5) {
         list5.add(i)
         if (list5.size() > 23) break
     }
-    if (list5 != listOf<Char>((MinC + 2).toChar(), (MinC + 1).toChar(), MinC)) {
-        return "Wrong elements for (MinC + 2).toChar() downTo MinC step 1: $list5"
+    if (list5 != listOf<Char>((MinC + 2), (MinC + 1), MinC)) {
+        return "Wrong elements for (MinC + 2) downTo MinC step 1: $list5"
     }
 
     return "OK"
diff --git a/compiler/testData/codegen/boxWithStdlib/ranges/expression/progressionMaxValueMinusTwoToMaxValue.kt b/compiler/testData/codegen/boxWithStdlib/ranges/expression/progressionMaxValueMinusTwoToMaxValue.kt
index f65cb237f61..9d9f13d7349 100644
--- a/compiler/testData/codegen/boxWithStdlib/ranges/expression/progressionMaxValueMinusTwoToMaxValue.kt
+++ b/compiler/testData/codegen/boxWithStdlib/ranges/expression/progressionMaxValueMinusTwoToMaxValue.kt
@@ -55,13 +55,13 @@ fun box(): String {
     }
 
     val list5 = ArrayList<Char>()
-    val range5 = (MaxC - 2).toChar()..MaxC step 2
+    val range5 = (MaxC - 2)..MaxC step 2
     for (i in range5) {
         list5.add(i)
         if (list5.size() > 23) break
     }
-    if (list5 != listOf<Char>((MaxC - 2).toChar(), MaxC)) {
-        return "Wrong elements for (MaxC - 2).toChar()..MaxC step 2: $list5"
+    if (list5 != listOf<Char>((MaxC - 2), MaxC)) {
+        return "Wrong elements for (MaxC - 2)..MaxC step 2: $list5"
     }
 
     return "OK"
diff --git a/compiler/testData/codegen/boxWithStdlib/ranges/literal/inexactDownToMinValue.kt b/compiler/testData/codegen/boxWithStdlib/ranges/literal/inexactDownToMinValue.kt
index cb91d07024b..c8b9e14014d 100644
--- a/compiler/testData/codegen/boxWithStdlib/ranges/literal/inexactDownToMinValue.kt
+++ b/compiler/testData/codegen/boxWithStdlib/ranges/literal/inexactDownToMinValue.kt
@@ -51,12 +51,12 @@ fun box(): String {
     }
 
     val list5 = ArrayList<Char>()
-    for (i in (MinC + 5).toChar() downTo MinC step 3) {
+    for (i in (MinC + 5) downTo MinC step 3) {
         list5.add(i)
         if (list5.size() > 23) break
     }
-    if (list5 != listOf<Char>((MinC + 5).toChar(), (MinC + 2).toChar())) {
-        return "Wrong elements for (MinC + 5).toChar() downTo MinC step 3: $list5"
+    if (list5 != listOf<Char>((MinC + 5), (MinC + 2))) {
+        return "Wrong elements for (MinC + 5) downTo MinC step 3: $list5"
     }
 
     return "OK"
diff --git a/compiler/testData/codegen/boxWithStdlib/ranges/literal/inexactToMaxValue.kt b/compiler/testData/codegen/boxWithStdlib/ranges/literal/inexactToMaxValue.kt
index 453cc240062..fc4b412712b 100644
--- a/compiler/testData/codegen/boxWithStdlib/ranges/literal/inexactToMaxValue.kt
+++ b/compiler/testData/codegen/boxWithStdlib/ranges/literal/inexactToMaxValue.kt
@@ -51,12 +51,12 @@ fun box(): String {
     }
 
     val list5 = ArrayList<Char>()
-    for (i in (MaxC - 5).toChar()..MaxC step 3) {
+    for (i in (MaxC - 5)..MaxC step 3) {
         list5.add(i)
         if (list5.size() > 23) break
     }
-    if (list5 != listOf<Char>((MaxC - 5).toChar(), (MaxC - 2).toChar())) {
-        return "Wrong elements for (MaxC - 5).toChar()..MaxC step 3: $list5"
+    if (list5 != listOf<Char>((MaxC - 5), (MaxC - 2))) {
+        return "Wrong elements for (MaxC - 5)..MaxC step 3: $list5"
     }
 
     return "OK"
diff --git a/compiler/testData/codegen/boxWithStdlib/ranges/literal/maxValueMinusTwoToMaxValue.kt b/compiler/testData/codegen/boxWithStdlib/ranges/literal/maxValueMinusTwoToMaxValue.kt
index 15d32a278cc..716ea1cc300 100644
--- a/compiler/testData/codegen/boxWithStdlib/ranges/literal/maxValueMinusTwoToMaxValue.kt
+++ b/compiler/testData/codegen/boxWithStdlib/ranges/literal/maxValueMinusTwoToMaxValue.kt
@@ -51,12 +51,12 @@ fun box(): String {
     }
 
     val list5 = ArrayList<Char>()
-    for (i in (MaxC - 2).toChar()..MaxC) {
+    for (i in (MaxC - 2)..MaxC) {
         list5.add(i)
         if (list5.size() > 23) break
     }
-    if (list5 != listOf<Char>((MaxC - 2).toChar(), (MaxC - 1).toChar(), MaxC)) {
-        return "Wrong elements for (MaxC - 2).toChar()..MaxC: $list5"
+    if (list5 != listOf<Char>((MaxC - 2), (MaxC - 1), MaxC)) {
+        return "Wrong elements for (MaxC - 2)..MaxC: $list5"
     }
 
     return "OK"
diff --git a/compiler/testData/codegen/boxWithStdlib/ranges/literal/progressionDownToMinValue.kt b/compiler/testData/codegen/boxWithStdlib/ranges/literal/progressionDownToMinValue.kt
index 19f8e9f5078..89b997b8a0d 100644
--- a/compiler/testData/codegen/boxWithStdlib/ranges/literal/progressionDownToMinValue.kt
+++ b/compiler/testData/codegen/boxWithStdlib/ranges/literal/progressionDownToMinValue.kt
@@ -51,12 +51,12 @@ fun box(): String {
     }
 
     val list5 = ArrayList<Char>()
-    for (i in (MinC + 2).toChar() downTo MinC step 1) {
+    for (i in (MinC + 2) downTo MinC step 1) {
         list5.add(i)
         if (list5.size() > 23) break
     }
-    if (list5 != listOf<Char>((MinC + 2).toChar(), (MinC + 1).toChar(), MinC)) {
-        return "Wrong elements for (MinC + 2).toChar() downTo MinC step 1: $list5"
+    if (list5 != listOf<Char>((MinC + 2), (MinC + 1), MinC)) {
+        return "Wrong elements for (MinC + 2) downTo MinC step 1: $list5"
     }
 
     return "OK"
diff --git a/compiler/testData/codegen/boxWithStdlib/ranges/literal/progressionMaxValueMinusTwoToMaxValue.kt b/compiler/testData/codegen/boxWithStdlib/ranges/literal/progressionMaxValueMinusTwoToMaxValue.kt
index 408f69acf01..d4c93ce04ae 100644
--- a/compiler/testData/codegen/boxWithStdlib/ranges/literal/progressionMaxValueMinusTwoToMaxValue.kt
+++ b/compiler/testData/codegen/boxWithStdlib/ranges/literal/progressionMaxValueMinusTwoToMaxValue.kt
@@ -51,12 +51,12 @@ fun box(): String {
     }
 
     val list5 = ArrayList<Char>()
-    for (i in (MaxC - 2).toChar()..MaxC step 2) {
+    for (i in (MaxC - 2)..MaxC step 2) {
         list5.add(i)
         if (list5.size() > 23) break
     }
-    if (list5 != listOf<Char>((MaxC - 2).toChar(), MaxC)) {
-        return "Wrong elements for (MaxC - 2).toChar()..MaxC step 2: $list5"
+    if (list5 != listOf<Char>((MaxC - 2), MaxC)) {
+        return "Wrong elements for (MaxC - 2)..MaxC step 2: $list5"
     }
 
     return "OK"
diff --git a/compiler/testData/codegen/boxWithStdlib/reflection/classLiterals/annotationClassLiteral.kt b/compiler/testData/codegen/boxWithStdlib/reflection/classLiterals/annotationClassLiteral.kt
new file mode 100644
index 00000000000..a567b7f80af
--- /dev/null
+++ b/compiler/testData/codegen/boxWithStdlib/reflection/classLiterals/annotationClassLiteral.kt
@@ -0,0 +1,7 @@
+import kotlin.test.assertEquals
+
+fun box(): String {
+    assertEquals("deprecated", deprecated::class.simpleName)
+
+    return "OK"
+}
\ No newline at end of file
diff --git a/compiler/testData/codegen/boxWithStdlib/reflection/classLiterals/classSimpleName.kt b/compiler/testData/codegen/boxWithStdlib/reflection/classes/classSimpleName.kt
similarity index 100%
rename from compiler/testData/codegen/boxWithStdlib/reflection/classLiterals/classSimpleName.kt
rename to compiler/testData/codegen/boxWithStdlib/reflection/classes/classSimpleName.kt
diff --git a/compiler/testData/codegen/boxWithStdlib/reflection/classes/jvmName.kt b/compiler/testData/codegen/boxWithStdlib/reflection/classes/jvmName.kt
new file mode 100644
index 00000000000..919900c354e
--- /dev/null
+++ b/compiler/testData/codegen/boxWithStdlib/reflection/classes/jvmName.kt
@@ -0,0 +1,41 @@
+import kotlin.test.assertEquals
+import kotlin.test.assertTrue
+import kotlin.reflect.jvm.jvmName
+import kotlin.reflect.jvm.kotlin
+
+class Klass {
+    class Nested
+    companion object
+}
+
+fun box(): String {
+    assertEquals("Klass", Klass::class.jvmName)
+    assertEquals("Klass\$Nested", Klass.Nested::class.jvmName)
+    assertEquals("Klass\$Companion", Klass.Companion::class.jvmName)
+
+    assertEquals("java.lang.Object", Any::class.jvmName)
+    assertEquals("int", Int::class.jvmName)
+    assertEquals("[I", IntArray::class.jvmName)
+    assertEquals("java.util.List", List::class.jvmName)
+    assertEquals("java.util.List", MutableList::class.jvmName)
+    assertEquals("java.lang.String", String::class.jvmName)
+    assertEquals("java.lang.String", java.lang.String::class.jvmName)
+
+    assertEquals("[Ljava.lang.Object;", Array<Any>::class.jvmName)
+    assertEquals("[Ljava.lang.Integer;", Array<Int>::class.jvmName)
+    assertEquals("[[Ljava.lang.String;", Array<Array<String>>::class.jvmName)
+
+    assertEquals("java.util.Date", java.util.Date::class.jvmName)
+    assertEquals("kotlin.jvm.internal.KotlinSyntheticClass\$Kind", kotlin.jvm.internal.KotlinSyntheticClass.Kind::class.jvmName)
+    assertEquals("java.lang.Void", java.lang.Void::class.jvmName)
+
+    class Local
+    val l = Local::class.jvmName
+    assertTrue(l != null && l.startsWith("_DefaultPackage\$") && "\$box\$" in l && l.endsWith("\$Local"))
+
+    val obj = object {}
+    val o = obj.javaClass.kotlin.jvmName
+    assertTrue(o != null && o.startsWith("_DefaultPackage\$") && "\$box\$" in o && o.endsWith("\$1"))
+
+    return "OK"
+}
diff --git a/compiler/testData/codegen/boxWithStdlib/reflection/classLiterals/localClassSimpleName.kt b/compiler/testData/codegen/boxWithStdlib/reflection/classes/localClassSimpleName.kt
similarity index 100%
rename from compiler/testData/codegen/boxWithStdlib/reflection/classLiterals/localClassSimpleName.kt
rename to compiler/testData/codegen/boxWithStdlib/reflection/classes/localClassSimpleName.kt
diff --git a/compiler/testData/codegen/boxWithStdlib/reflection/classes/qualifiedName.kt b/compiler/testData/codegen/boxWithStdlib/reflection/classes/qualifiedName.kt
new file mode 100644
index 00000000000..66646bf5ce0
--- /dev/null
+++ b/compiler/testData/codegen/boxWithStdlib/reflection/classes/qualifiedName.kt
@@ -0,0 +1,37 @@
+import kotlin.test.assertEquals
+import kotlin.reflect.jvm.kotlin
+
+class Klass {
+    class Nested
+    companion object
+}
+
+fun box(): String {
+    assertEquals("Klass", Klass::class.qualifiedName)
+    assertEquals("Klass.Nested", Klass.Nested::class.qualifiedName)
+    assertEquals("Klass.Companion", Klass.Companion::class.qualifiedName)
+
+    assertEquals("kotlin.Any", Any::class.qualifiedName)
+    assertEquals("kotlin.Int", Int::class.qualifiedName)
+    assertEquals("kotlin.Int.Companion", Int.Companion::class.qualifiedName)
+    assertEquals("kotlin.IntArray", IntArray::class.qualifiedName)
+    assertEquals("kotlin.List", List::class.qualifiedName)
+    assertEquals("kotlin.String", String::class.qualifiedName)
+    assertEquals("kotlin.String", java.lang.String::class.qualifiedName)
+
+    assertEquals("kotlin.Array", Array<Any>::class.qualifiedName)
+    assertEquals("kotlin.Array", Array<Int>::class.qualifiedName)
+    assertEquals("kotlin.Array", Array<Array<String>>::class.qualifiedName)
+
+    assertEquals("java.util.Date", java.util.Date::class.qualifiedName)
+    assertEquals("kotlin.jvm.internal.KotlinSyntheticClass.Kind", kotlin.jvm.internal.KotlinSyntheticClass.Kind::class.qualifiedName)
+    assertEquals("java.lang.Void", java.lang.Void::class.qualifiedName)
+
+    class Local
+    assertEquals(null, Local::class.qualifiedName)
+
+    val o = object {}
+    assertEquals(null, o.javaClass.kotlin.qualifiedName)
+
+    return "OK"
+}
diff --git a/compiler/testData/codegen/boxWithStdlib/reflection/constructors/constructorName.kt b/compiler/testData/codegen/boxWithStdlib/reflection/constructors/constructorName.kt
new file mode 100644
index 00000000000..155efebed30
--- /dev/null
+++ b/compiler/testData/codegen/boxWithStdlib/reflection/constructors/constructorName.kt
@@ -0,0 +1,8 @@
+import kotlin.test.assertEquals
+
+class A
+
+fun box(): String {
+    assertEquals("<init>", ::A.name)
+    return "OK"
+}
diff --git a/compiler/testData/codegen/boxWithStdlib/reflection/enclosing/kt6368.kt b/compiler/testData/codegen/boxWithStdlib/reflection/enclosing/kt6368.kt
index 16d226f3c0d..8547b6a5178 100644
--- a/compiler/testData/codegen/boxWithStdlib/reflection/enclosing/kt6368.kt
+++ b/compiler/testData/codegen/boxWithStdlib/reflection/enclosing/kt6368.kt
@@ -15,7 +15,7 @@ val a by Delegates.lazy {
 }
 
 fun box(): String {
-    val r = a["result"]
+    val r = a["result"]!!
 
     // Check that reflection won't fail
     r.javaClass.getEnclosingMethod().toString()
diff --git a/compiler/testData/codegen/boxWithStdlib/reflection/functions/localFunctionName.kt b/compiler/testData/codegen/boxWithStdlib/reflection/functions/localFunctionName.kt
new file mode 100644
index 00000000000..361ba4c3ce3
--- /dev/null
+++ b/compiler/testData/codegen/boxWithStdlib/reflection/functions/localFunctionName.kt
@@ -0,0 +1,5 @@
+fun box(): String {
+    fun OK() {}
+
+    return ::OK.name
+}
diff --git a/compiler/testData/codegen/boxWithStdlib/reflection/functions/platformName.kt b/compiler/testData/codegen/boxWithStdlib/reflection/functions/platformName.kt
new file mode 100644
index 00000000000..26692f89c18
--- /dev/null
+++ b/compiler/testData/codegen/boxWithStdlib/reflection/functions/platformName.kt
@@ -0,0 +1,6 @@
+import kotlin.platform.platformName
+
+@platformName("Fail")
+fun OK() {}
+
+fun box() = ::OK.name
diff --git a/compiler/testData/codegen/boxWithStdlib/reflection/functions/simpleNames.kt b/compiler/testData/codegen/boxWithStdlib/reflection/functions/simpleNames.kt
new file mode 100644
index 00000000000..417d2391154
--- /dev/null
+++ b/compiler/testData/codegen/boxWithStdlib/reflection/functions/simpleNames.kt
@@ -0,0 +1,16 @@
+import kotlin.test.assertEquals
+
+fun foo() {}
+
+class A {
+    fun bar() = ""
+}
+
+fun Int.baz() = this
+
+fun box(): String {
+    assertEquals("foo", ::foo.name)
+    assertEquals("bar", A::bar.name)
+    assertEquals("baz", Int::baz.name)
+    return "OK"
+}
diff --git a/compiler/testData/codegen/boxWithStdlib/reflection/kClassInAnnotation/array.kt b/compiler/testData/codegen/boxWithStdlib/reflection/kClassInAnnotation/array.kt
index baf6024ecf4..05fc8d82bed 100644
--- a/compiler/testData/codegen/boxWithStdlib/reflection/kClassInAnnotation/array.kt
+++ b/compiler/testData/codegen/boxWithStdlib/reflection/kClassInAnnotation/array.kt
@@ -1,8 +1,6 @@
 import kotlin.reflect.KClass
-import java.lang.annotation.*
 
-Retention(RetentionPolicy.RUNTIME)
-annotation
+annotation(retention = AnnotationRetention.RUNTIME)
 class Ann(val args: Array<KClass<*>>)
 
 class O
diff --git a/compiler/testData/codegen/boxWithStdlib/reflection/kClassInAnnotation/basic.kt b/compiler/testData/codegen/boxWithStdlib/reflection/kClassInAnnotation/basic.kt
index eb42b6d11b8..16039ba0f60 100644
--- a/compiler/testData/codegen/boxWithStdlib/reflection/kClassInAnnotation/basic.kt
+++ b/compiler/testData/codegen/boxWithStdlib/reflection/kClassInAnnotation/basic.kt
@@ -1,8 +1,6 @@
 import kotlin.reflect.KClass
-import java.lang.annotation.*
 
-Retention(RetentionPolicy.RUNTIME)
-annotation
+annotation(retention = AnnotationRetention.RUNTIME)
 class Ann(val arg: KClass<*>)
 
 class OK
diff --git a/compiler/testData/codegen/boxWithStdlib/reflection/kClassInAnnotation/vararg.kt b/compiler/testData/codegen/boxWithStdlib/reflection/kClassInAnnotation/vararg.kt
index 5033ea07085..41d79e7c693 100644
--- a/compiler/testData/codegen/boxWithStdlib/reflection/kClassInAnnotation/vararg.kt
+++ b/compiler/testData/codegen/boxWithStdlib/reflection/kClassInAnnotation/vararg.kt
@@ -1,8 +1,6 @@
 import kotlin.reflect.KClass
-import java.lang.annotation.*
 
-Retention(RetentionPolicy.RUNTIME)
-annotation
+annotation(retention = AnnotationRetention.RUNTIME)
 class Ann(vararg val args: KClass<*>)
 
 class O
diff --git a/compiler/testData/codegen/boxWithStdlib/reflection/methodsFromAny/extensionPropertyReceiverToString.kt b/compiler/testData/codegen/boxWithStdlib/reflection/methodsFromAny/extensionPropertyReceiverToString.kt
index bb1915fb389..5f4f70ce558 100644
--- a/compiler/testData/codegen/boxWithStdlib/reflection/methodsFromAny/extensionPropertyReceiverToString.kt
+++ b/compiler/testData/codegen/boxWithStdlib/reflection/methodsFromAny/extensionPropertyReceiverToString.kt
@@ -1,7 +1,7 @@
-import kotlin.reflect.KExtensionProperty
+import kotlin.reflect.KProperty1
 import kotlin.test.assertEquals
 
-fun check(expected: String, p: KExtensionProperty<*, *>) {
+fun check(expected: String, p: KProperty1<*, *>) {
     var s = p.toString()
 
     // Strip "val" or "var"
diff --git a/compiler/testData/codegen/boxWithStdlib/reflection/methodsFromAny/functionEqualsHashCode.kt b/compiler/testData/codegen/boxWithStdlib/reflection/methodsFromAny/functionEqualsHashCode.kt
new file mode 100644
index 00000000000..bc313072f2e
--- /dev/null
+++ b/compiler/testData/codegen/boxWithStdlib/reflection/methodsFromAny/functionEqualsHashCode.kt
@@ -0,0 +1,31 @@
+import kotlin.test.*
+
+fun top() = 42
+
+fun Int.intExt(): Int = this
+
+class A {
+    fun mem() {}
+}
+
+class B {
+    fun mem() {}
+}
+
+
+fun checkEqual(x: Any, y: Any) {
+    assertEquals(x, y)
+    assertEquals(x.hashCode(), y.hashCode(), "Elements are equal but their hash codes are not: ${x.hashCode()} != ${y.hashCode()}")
+}
+
+fun box(): String {
+    checkEqual(::top, ::top)
+    checkEqual(Int::intExt, Int::intExt)
+    checkEqual(A::mem, A::mem)
+
+    assertFalse(::top == Int::intExt)
+    assertFalse(::top == A::mem)
+    assertFalse(A::mem == B::mem)
+
+    return "OK"
+}
diff --git a/compiler/testData/codegen/boxWithStdlib/reflection/methodsFromAny/functionToString.kt b/compiler/testData/codegen/boxWithStdlib/reflection/methodsFromAny/functionToString.kt
new file mode 100644
index 00000000000..c0d912c985b
--- /dev/null
+++ b/compiler/testData/codegen/boxWithStdlib/reflection/methodsFromAny/functionToString.kt
@@ -0,0 +1,24 @@
+package test
+
+import kotlin.test.assertEquals
+
+fun top() = 42
+
+fun String.ext(): Int = 0
+fun IntRange?.ext2(): Array<Int?> = arrayOfNulls(0)
+
+class A {
+    fun mem(): String = ""
+}
+
+fun assertToString(s: String, x: Any) {
+    assertEquals(s, x.toString())
+}
+
+fun box(): String {
+    assertToString("fun top(): kotlin.Int", ::top)
+    assertToString("fun kotlin.String.ext(): kotlin.Int", String::ext)
+    assertToString("fun kotlin.IntRange?.ext2(): kotlin.Array<kotlin.Int?>", IntRange::ext2)
+    assertToString("fun test.A.mem(): kotlin.String", A::mem)
+    return "OK"
+}
diff --git a/compiler/testData/codegen/boxWithStdlib/reflection/methodsFromAny/equalsHashCode.kt b/compiler/testData/codegen/boxWithStdlib/reflection/methodsFromAny/propertyEqualsHashCode.kt
similarity index 100%
rename from compiler/testData/codegen/boxWithStdlib/reflection/methodsFromAny/equalsHashCode.kt
rename to compiler/testData/codegen/boxWithStdlib/reflection/methodsFromAny/propertyEqualsHashCode.kt
diff --git a/compiler/testData/codegen/boxWithStdlib/reflection/properties/accessors/accessorNames.kt b/compiler/testData/codegen/boxWithStdlib/reflection/properties/accessors/accessorNames.kt
new file mode 100644
index 00000000000..fdb3103603b
--- /dev/null
+++ b/compiler/testData/codegen/boxWithStdlib/reflection/properties/accessors/accessorNames.kt
@@ -0,0 +1,30 @@
+import kotlin.reflect.*
+import kotlin.test.assertEquals
+
+var foo = ""
+var String.bar: String
+    get() = this
+    set(value) {}
+
+class A(var baz: Int) {
+    var String.quux: String
+        get() = this
+        set(value) {}
+}
+
+fun box(): String {
+    assertEquals("<get-foo>", ::foo.getter.name)
+    assertEquals("<set-foo>", ::foo.setter.name)
+
+    assertEquals("<get-bar>", String::bar.getter.name)
+    assertEquals("<set-bar>", String::bar.setter.name)
+
+    assertEquals("<get-baz>", A::baz.getter.name)
+    assertEquals("<set-baz>", A::baz.setter.name)
+
+    val me = A::class.extensionProperties.single() as KMutableProperty2<A, String, String>
+    assertEquals("<get-quux>", me.getter.name)
+    assertEquals("<set-quux>", me.setter.name)
+
+    return "OK"
+}
diff --git a/compiler/testData/codegen/boxWithStdlib/reflection/properties/accessors/extensionPropertyAccessors.kt b/compiler/testData/codegen/boxWithStdlib/reflection/properties/accessors/extensionPropertyAccessors.kt
new file mode 100644
index 00000000000..42cbcc74e80
--- /dev/null
+++ b/compiler/testData/codegen/boxWithStdlib/reflection/properties/accessors/extensionPropertyAccessors.kt
@@ -0,0 +1,18 @@
+import kotlin.test.assertEquals
+
+var state: String = ""
+
+var String.prop: String
+    get() = length().toString()
+    set(value) { state = this + value }
+
+fun box(): String {
+    val prop = String::prop
+
+    assertEquals("3", prop.getter.invoke("abc"))
+    assertEquals("5", prop.getter("defgh"))
+
+    prop.setter("O", "K")
+
+    return state
+}
diff --git a/compiler/testData/codegen/boxWithStdlib/reflection/properties/accessors/memberExtensions.kt b/compiler/testData/codegen/boxWithStdlib/reflection/properties/accessors/memberExtensions.kt
new file mode 100644
index 00000000000..fcd53d24ef5
--- /dev/null
+++ b/compiler/testData/codegen/boxWithStdlib/reflection/properties/accessors/memberExtensions.kt
@@ -0,0 +1,20 @@
+import kotlin.reflect.KMutableProperty2
+import kotlin.test.assertEquals
+
+class C(var state: String) {
+    var String.prop: String
+        get() = length().toString()
+        set(value) { state = this + value }
+}
+
+fun box(): String {
+    val prop = C::class.extensionProperties.single() as KMutableProperty2<C, String, String>
+
+    val c = C("")
+    assertEquals("3", prop.getter.invoke(c, "abc"))
+    assertEquals("1", prop.getter(c, "d"))
+
+    prop.setter(c, "O", "K")
+
+    return c.state
+}
diff --git a/compiler/testData/codegen/boxWithStdlib/reflection/properties/accessors/memberPropertyAccessors.kt b/compiler/testData/codegen/boxWithStdlib/reflection/properties/accessors/memberPropertyAccessors.kt
new file mode 100644
index 00000000000..dcf3c560b42
--- /dev/null
+++ b/compiler/testData/codegen/boxWithStdlib/reflection/properties/accessors/memberPropertyAccessors.kt
@@ -0,0 +1,15 @@
+import kotlin.test.assertEquals
+
+class C(var state: String)
+
+fun box(): String {
+    val prop = C::state
+
+    val c = C("1")
+    assertEquals("1", prop.getter.invoke(c))
+    assertEquals("1", prop.getter(c))
+
+    prop.setter(c, "OK")
+
+    return prop.get(c)
+}
diff --git a/compiler/testData/codegen/boxWithStdlib/reflection/properties/accessors/topLevelPropertyAccessors.kt b/compiler/testData/codegen/boxWithStdlib/reflection/properties/accessors/topLevelPropertyAccessors.kt
new file mode 100644
index 00000000000..49ab1f5ef8e
--- /dev/null
+++ b/compiler/testData/codegen/boxWithStdlib/reflection/properties/accessors/topLevelPropertyAccessors.kt
@@ -0,0 +1,14 @@
+import kotlin.test.assertEquals
+
+var state: String = ""
+
+fun box(): String {
+    val prop = ::state
+
+    assertEquals("", prop.getter.invoke())
+    assertEquals("", prop.getter())
+
+    prop.setter("OK")
+
+    return prop.get()
+}
diff --git a/compiler/testData/codegen/boxWithStdlib/reflection/properties/callPrivatePropertyFromGetProperties.kt b/compiler/testData/codegen/boxWithStdlib/reflection/properties/callPrivatePropertyFromGetProperties.kt
index 59589294b1c..b11fc5e5dd8 100644
--- a/compiler/testData/codegen/boxWithStdlib/reflection/properties/callPrivatePropertyFromGetProperties.kt
+++ b/compiler/testData/codegen/boxWithStdlib/reflection/properties/callPrivatePropertyFromGetProperties.kt
@@ -4,7 +4,7 @@ import kotlin.reflect.jvm.*
 class K(private val value: String)
 
 fun box(): String {
-    val p = javaClass<K>().kotlin.properties.single() as KMemberProperty<K, String>
+    val p = javaClass<K>().kotlin.properties.single() as KProperty1<K, String>
 
     try {
         return p.get(K("Fail: private property should not be accessible by default"))
diff --git a/compiler/testData/codegen/boxWithStdlib/reflection/properties/genericClassLiteralPropertyReceiverIsStar.kt b/compiler/testData/codegen/boxWithStdlib/reflection/properties/genericClassLiteralPropertyReceiverIsStar.kt
index c87de4331d0..e97248ae99b 100644
--- a/compiler/testData/codegen/boxWithStdlib/reflection/properties/genericClassLiteralPropertyReceiverIsStar.kt
+++ b/compiler/testData/codegen/boxWithStdlib/reflection/properties/genericClassLiteralPropertyReceiverIsStar.kt
@@ -1,11 +1,10 @@
-import kotlin.reflect.KMemberProperty
+import kotlin.reflect.KProperty1
 
 class A<T> {
     val result = "OK"
 }
 
 fun box(): String {
-    val k = A::class.properties.single()
-    k : KMemberProperty<A<*>, *>
+    val k : KProperty1<A<*>, *> = A::class.properties.single()
     return k.get(A<String>()) as String
 }
diff --git a/compiler/testData/codegen/boxWithStdlib/reflection/properties/getExtensionPropertiesMutableVsReadonly.kt b/compiler/testData/codegen/boxWithStdlib/reflection/properties/getExtensionPropertiesMutableVsReadonly.kt
index 76b17b83f51..2ebf098af3c 100644
--- a/compiler/testData/codegen/boxWithStdlib/reflection/properties/getExtensionPropertiesMutableVsReadonly.kt
+++ b/compiler/testData/codegen/boxWithStdlib/reflection/properties/getExtensionPropertiesMutableVsReadonly.kt
@@ -1,5 +1,5 @@
 import kotlin.reflect.jvm.kotlin
-import kotlin.reflect.KMutableMemberExtensionProperty
+import kotlin.reflect.KMutableProperty2
 
 var storage = "before"
 
@@ -15,12 +15,12 @@ class A {
 fun box(): String {
     val props = javaClass<A>().kotlin.extensionProperties
     val readonly = props.single { it.name == "readonly" }
-    assert(readonly !is KMutableMemberExtensionProperty<A, *, *>) { "Fail 1: $readonly" }
+    assert(readonly !is KMutableProperty2<A, *, *>) { "Fail 1: $readonly" }
     val mutable = props.single { it.name == "mutable" }
-    assert(mutable is KMutableMemberExtensionProperty<A, *, *>) { "Fail 2: $mutable" }
+    assert(mutable is KMutableProperty2<A, *, *>) { "Fail 2: $mutable" }
 
     val a = A()
-    mutable as KMutableMemberExtensionProperty<A, String, String>
+    mutable as KMutableProperty2<A, String, String>
     assert(mutable[a, ""] == "before") { "Fail 3: ${mutable.get(a, "")}" }
     mutable[a, ""] = "OK"
     return mutable.get(a, "")
diff --git a/compiler/testData/codegen/boxWithStdlib/reflection/properties/getPropertiesMutableVsReadonly.kt b/compiler/testData/codegen/boxWithStdlib/reflection/properties/getPropertiesMutableVsReadonly.kt
index 435243a6938..fb764361b30 100644
--- a/compiler/testData/codegen/boxWithStdlib/reflection/properties/getPropertiesMutableVsReadonly.kt
+++ b/compiler/testData/codegen/boxWithStdlib/reflection/properties/getPropertiesMutableVsReadonly.kt
@@ -1,5 +1,5 @@
 import kotlin.reflect.jvm.kotlin
-import kotlin.reflect.KMutableMemberProperty
+import kotlin.reflect.KMutableProperty1
 
 class A(val readonly: String) {
     var mutable: String = "before"
@@ -8,12 +8,12 @@ class A(val readonly: String) {
 fun box(): String {
     val props = javaClass<A>().kotlin.properties
     val readonly = props.single { it.name == "readonly" }
-    assert(readonly !is KMutableMemberProperty<A, *>) { "Fail 1: $readonly" }
+    assert(readonly !is KMutableProperty1<A, *>) { "Fail 1: $readonly" }
     val mutable = props.single { it.name == "mutable" }
-    assert(mutable is KMutableMemberProperty<A, *>) { "Fail 2: $mutable" }
+    assert(mutable is KMutableProperty1<A, *>) { "Fail 2: $mutable" }
 
     val a = A("")
-    mutable as KMutableMemberProperty<A, String>
+    mutable as KMutableProperty1<A, String>
     assert(mutable[a] == "before") { "Fail 3: ${mutable.get(a)}" }
     mutable[a] = "OK"
     return mutable.get(a)
diff --git a/compiler/testData/codegen/boxWithStdlib/reflection/properties/memberAndMemberExtensionWithSameName.kt b/compiler/testData/codegen/boxWithStdlib/reflection/properties/memberAndMemberExtensionWithSameName.kt
index b194d12e01c..a60072738bd 100644
--- a/compiler/testData/codegen/boxWithStdlib/reflection/properties/memberAndMemberExtensionWithSameName.kt
+++ b/compiler/testData/codegen/boxWithStdlib/reflection/properties/memberAndMemberExtensionWithSameName.kt
@@ -1,6 +1,6 @@
 import kotlin.reflect.jvm.kotlin
-import kotlin.reflect.KMemberProperty
-import kotlin.reflect.KMemberExtensionProperty
+import kotlin.reflect.KProperty1
+import kotlin.reflect.KProperty2
 
 class A {
     val foo: String = "member"
@@ -9,15 +9,15 @@ class A {
 
 fun box(): String {
     run {
-        val foo: KMemberProperty<A, *> = javaClass<A>().kotlin.properties.single()
+        val foo: KProperty1<A, *> = javaClass<A>().kotlin.properties.single()
         assert(foo.name == "foo") { "Fail name: $foo (${foo.name})" }
         assert(foo.get(A()) == "member") { "Fail value: ${foo[A()]}" }
     }
 
     run {
-        val foo: KMemberExtensionProperty<A, *, *> = javaClass<A>().kotlin.extensionProperties.single()
+        val foo: KProperty2<A, *, *> = javaClass<A>().kotlin.extensionProperties.single()
         assert(foo.name == "foo") { "Fail name: $foo (${foo.name})" }
-        foo as KMemberExtensionProperty<A, Unit, *>
+        foo as KProperty2<A, Unit, *>
         assert(foo.get(A(), Unit) == "extension") { "Fail value: ${foo[A(), Unit]}" }
     }
 
diff --git a/compiler/testData/codegen/boxWithStdlib/callableReference/property/privateClassVal.kt b/compiler/testData/codegen/boxWithStdlib/reflection/properties/privateClassVal.kt
similarity index 83%
rename from compiler/testData/codegen/boxWithStdlib/callableReference/property/privateClassVal.kt
rename to compiler/testData/codegen/boxWithStdlib/reflection/properties/privateClassVal.kt
index c6ed7d44c65..6a0d84da88d 100644
--- a/compiler/testData/codegen/boxWithStdlib/callableReference/property/privateClassVal.kt
+++ b/compiler/testData/codegen/boxWithStdlib/reflection/properties/privateClassVal.kt
@@ -1,11 +1,11 @@
 import kotlin.reflect.IllegalPropertyAccessException
-import kotlin.reflect.KMemberProperty
+import kotlin.reflect.KProperty1
 import kotlin.reflect.jvm.accessible
 
 class Result {
     private val value = "OK"
 
-    fun ref(): KMemberProperty<Result, String> = ::value
+    fun ref() = Result::class.properties.single() as KProperty1<Result, String>
 }
 
 fun box(): String {
diff --git a/compiler/testData/codegen/boxWithStdlib/callableReference/property/privateClassVar.kt b/compiler/testData/codegen/boxWithStdlib/reflection/properties/privateClassVar.kt
similarity index 83%
rename from compiler/testData/codegen/boxWithStdlib/callableReference/property/privateClassVar.kt
rename to compiler/testData/codegen/boxWithStdlib/reflection/properties/privateClassVar.kt
index f8f4d8226ca..81f336e698f 100644
--- a/compiler/testData/codegen/boxWithStdlib/callableReference/property/privateClassVar.kt
+++ b/compiler/testData/codegen/boxWithStdlib/reflection/properties/privateClassVar.kt
@@ -1,11 +1,11 @@
 import kotlin.reflect.IllegalPropertyAccessException
-import kotlin.reflect.KMutableMemberProperty
+import kotlin.reflect.KMutableProperty1
 import kotlin.reflect.jvm.accessible
 
 class A {
     private var value = 0
 
-    fun ref(): KMutableMemberProperty<A, Int> = ::value
+    fun ref() = A::class.properties.single() as KMutableProperty1<A, Int>
 }
 
 fun box(): String {
diff --git a/compiler/testData/codegen/boxWithStdlib/callableReference/property/protectedClassVar.kt b/compiler/testData/codegen/boxWithStdlib/reflection/properties/protectedClassVar.kt
similarity index 84%
rename from compiler/testData/codegen/boxWithStdlib/callableReference/property/protectedClassVar.kt
rename to compiler/testData/codegen/boxWithStdlib/reflection/properties/protectedClassVar.kt
index 9263a9b188f..578b45f3e2e 100644
--- a/compiler/testData/codegen/boxWithStdlib/callableReference/property/protectedClassVar.kt
+++ b/compiler/testData/codegen/boxWithStdlib/reflection/properties/protectedClassVar.kt
@@ -1,10 +1,11 @@
 import kotlin.reflect.IllegalPropertyAccessException
 import kotlin.reflect.jvm.accessible
+import kotlin.reflect.KMutableProperty1
 
 class A(param: String) {
     protected var v: String = param
 
-    fun ref() = ::v
+    fun ref() = A::class.properties.single() as KMutableProperty1<A, String>
 }
 
 fun box(): String {
diff --git a/compiler/testData/codegen/boxWithStdlib/regressions/kt1932.kt b/compiler/testData/codegen/boxWithStdlib/regressions/kt1932.kt
index b8040c69354..b5d58877650 100644
--- a/compiler/testData/codegen/boxWithStdlib/regressions/kt1932.kt
+++ b/compiler/testData/codegen/boxWithStdlib/regressions/kt1932.kt
@@ -1,8 +1,6 @@
-import java.lang.annotation.Retention
-import java.lang.annotation.RetentionPolicy
 import java.lang.annotation.Annotation
 
-Retention(RetentionPolicy.RUNTIME) annotation class foo(val name : String)
+annotation(retention = AnnotationRetention.RUNTIME) class foo(val name : String)
 
 class Test() {
     foo("OK") fun hello(input : String) {
diff --git a/compiler/testData/codegen/boxWithStdlib/regressions/kt3850.kt b/compiler/testData/codegen/boxWithStdlib/regressions/kt3850.kt
new file mode 100644
index 00000000000..ca5e250355d
--- /dev/null
+++ b/compiler/testData/codegen/boxWithStdlib/regressions/kt3850.kt
@@ -0,0 +1,6 @@
+class One {
+    val a1 = arrayOf(
+            object { val fy = "text"}
+    )}
+
+fun box() = if (One().a1[0].fy == "text") "OK" else "fail"
\ No newline at end of file
diff --git a/compiler/testData/codegen/boxWithStdlib/regressions/typeCastException.kt b/compiler/testData/codegen/boxWithStdlib/regressions/typeCastException.kt
index e67ff8472d5..5a25780bb51 100644
--- a/compiler/testData/codegen/boxWithStdlib/regressions/typeCastException.kt
+++ b/compiler/testData/codegen/boxWithStdlib/regressions/typeCastException.kt
@@ -1,4 +1,7 @@
+import java.util.ArrayList
+
 // KT-2823 TypeCastException has no message
+// KT-5121 Better error message in on casting null to non-null type
 
 fun box(): String {
     try {
@@ -6,9 +9,20 @@ fun box(): String {
         a as Array<String>
     }
     catch (e: TypeCastException) {
-        if (e.getMessage() == "kotlin.Any? cannot be cast to kotlin.Array<kotlin.String>") {
-            return "OK"
+        if (e.getMessage() != "null cannot be cast to non-null type kotlin.Array<kotlin.String>") {
+            return "Fail 1: $e"
         }
     }
-    return "fail"
+
+    try {
+        val x: String? = null
+        x as String
+    }
+    catch (e: TypeCastException) {
+        if (e.getMessage() != "null cannot be cast to non-null type kotlin.String") {
+            return "Fail 2: $e"
+        }
+    }
+
+    return "OK"
 }
diff --git a/compiler/testData/codegen/bytecodeText/annotationJavaRetentionPolicyRuntime.kt b/compiler/testData/codegen/bytecodeText/annotationJavaRetentionPolicyRuntime.kt
new file mode 100644
index 00000000000..649f4d30daf
--- /dev/null
+++ b/compiler/testData/codegen/bytecodeText/annotationJavaRetentionPolicyRuntime.kt
@@ -0,0 +1,9 @@
+import java.lang.annotation.Retention
+import java.lang.annotation.RetentionPolicy
+
+Ann class MyClass
+
+Retention(RetentionPolicy.RUNTIME)
+annotation class Ann
+
+// 1 @LAnn;()
\ No newline at end of file
diff --git a/compiler/testData/codegen/bytecodeText/annotationRetentionPolicyClass.kt b/compiler/testData/codegen/bytecodeText/annotationRetentionPolicyClass.kt
index aef672ab0de..6e2e89a7c8d 100644
--- a/compiler/testData/codegen/bytecodeText/annotationRetentionPolicyClass.kt
+++ b/compiler/testData/codegen/bytecodeText/annotationRetentionPolicyClass.kt
@@ -1,9 +1,7 @@
-import java.lang.annotation.Retention
-import java.lang.annotation.RetentionPolicy
-
 Ann class MyClass
 
-Retention(RetentionPolicy.CLASS)
-annotation class Ann
+annotation(retention = AnnotationRetention.BINARY) class Ann
+
+// 1 @LAnn;()
+// 1 invisible
 
-// 1 @LAnn;()
\ No newline at end of file
diff --git a/compiler/testData/codegen/bytecodeText/annotationRetentionPolicyRuntime.kt b/compiler/testData/codegen/bytecodeText/annotationRetentionPolicyRuntime.kt
index 649f4d30daf..08c29cd3766 100644
--- a/compiler/testData/codegen/bytecodeText/annotationRetentionPolicyRuntime.kt
+++ b/compiler/testData/codegen/bytecodeText/annotationRetentionPolicyRuntime.kt
@@ -1,9 +1,6 @@
-import java.lang.annotation.Retention
-import java.lang.annotation.RetentionPolicy
-
 Ann class MyClass
 
-Retention(RetentionPolicy.RUNTIME)
-annotation class Ann
+annotation(retention = AnnotationRetention.RUNTIME) class Ann
 
-// 1 @LAnn;()
\ No newline at end of file
+// 1 @LAnn;()
+// 0 invisible
diff --git a/compiler/testData/codegen/bytecodeText/annotationRetentionPolicySource.kt b/compiler/testData/codegen/bytecodeText/annotationRetentionPolicySource.kt
index a2248c7740b..7260c31a09b 100644
--- a/compiler/testData/codegen/bytecodeText/annotationRetentionPolicySource.kt
+++ b/compiler/testData/codegen/bytecodeText/annotationRetentionPolicySource.kt
@@ -1,9 +1,5 @@
-import java.lang.annotation.Retention
-import java.lang.annotation.RetentionPolicy
-
 Ann class MyClass
 
-Retention(RetentionPolicy.SOURCE)
-annotation class Ann
+annotation(retention = AnnotationRetention.SOURCE) class Ann
 
 // 0 @LAnn;()
\ No newline at end of file
diff --git a/compiler/testData/codegen/bytecodeText/directInvoke/callableReference.kt b/compiler/testData/codegen/bytecodeText/directInvoke/callableReference.kt
index 1a4f2bf1324..dd9fd0af1bd 100644
--- a/compiler/testData/codegen/bytecodeText/directInvoke/callableReference.kt
+++ b/compiler/testData/codegen/bytecodeText/directInvoke/callableReference.kt
@@ -3,8 +3,8 @@ class Z{
     fun a(s: Int) {}
 
     fun b() {
-        Z().(Z::a)(1)
+        (Z::a)(Z(), 1)
     }
 }
 
-// 1 invoke \(LZ;I\)V
\ No newline at end of file
+// 1 invoke \(LZ;I\)V
diff --git a/compiler/testData/codegen/bytecodeText/storeStackBeforeInline/unreachableMarker.kt b/compiler/testData/codegen/bytecodeText/storeStackBeforeInline/unreachableMarker.kt
index 0b68ac9f93b..255dbcccba6 100644
--- a/compiler/testData/codegen/bytecodeText/storeStackBeforeInline/unreachableMarker.kt
+++ b/compiler/testData/codegen/bytecodeText/storeStackBeforeInline/unreachableMarker.kt
@@ -16,6 +16,6 @@ fun foo() : String {
     )
 }
 
-// 12 ALOAD
-// 0 ASTORE
+// 14 ALOAD
+// 2 ASTORE
 // 0 InlineMarker
diff --git a/compiler/testData/codegen/properties/syntheticMethod/inClass.kt b/compiler/testData/codegen/properties/syntheticMethod/inClass.kt
index f17c4afc14c..c050fdabadc 100644
--- a/compiler/testData/codegen/properties/syntheticMethod/inClass.kt
+++ b/compiler/testData/codegen/properties/syntheticMethod/inClass.kt
@@ -1,6 +1,4 @@
-import java.lang.annotation.*
-
-Retention(RetentionPolicy.RUNTIME) annotation class SomeAnnotation(val value: String)
+annotation(retention = AnnotationRetention.RUNTIME) class SomeAnnotation(val value: String)
 
 class A {
     @SomeAnnotation("OK") val property: Int
diff --git a/compiler/testData/codegen/properties/syntheticMethod/inTrait.kt b/compiler/testData/codegen/properties/syntheticMethod/inTrait.kt
index fecb7aed395..20006213ee7 100644
--- a/compiler/testData/codegen/properties/syntheticMethod/inTrait.kt
+++ b/compiler/testData/codegen/properties/syntheticMethod/inTrait.kt
@@ -1,6 +1,4 @@
-import java.lang.annotation.*
-
-Retention(RetentionPolicy.RUNTIME) annotation class SomeAnnotation(val value: String)
+annotation(retention = AnnotationRetention.RUNTIME) class SomeAnnotation(val value: String)
 
 interface T {
     @SomeAnnotation("OK") val property: Int
diff --git a/compiler/testData/codegen/properties/syntheticMethod/topLevel.kt b/compiler/testData/codegen/properties/syntheticMethod/topLevel.kt
index 9bd6284ea32..c5948fc87dd 100644
--- a/compiler/testData/codegen/properties/syntheticMethod/topLevel.kt
+++ b/compiler/testData/codegen/properties/syntheticMethod/topLevel.kt
@@ -1,6 +1,4 @@
-import java.lang.annotation.*
-
-Retention(RetentionPolicy.RUNTIME) annotation class SomeAnnotation(val value: String)
+annotation(retention = AnnotationRetention.RUNTIME) class SomeAnnotation(val value: String)
 
 @SomeAnnotation("OK") val property: Int
     get() = 42
diff --git a/compiler/testData/compileJavaAgainstKotlin/class/ExtendsAbstractListT.txt b/compiler/testData/compileJavaAgainstKotlin/class/ExtendsAbstractListT.txt
index 3d18e1b2dff..0a34238bdb0 100644
--- a/compiler/testData/compileJavaAgainstKotlin/class/ExtendsAbstractListT.txt
+++ b/compiler/testData/compileJavaAgainstKotlin/class/ExtendsAbstractListT.txt
@@ -10,17 +10,17 @@ internal abstract class Mine</*0*/ T> : java.util.AbstractList<T> {
     public open /*fake_override*/ fun add(/*0*/ T!): kotlin.Boolean
     public open /*fake_override*/ fun add(/*0*/ kotlin.Int, /*1*/ T!): kotlin.Unit
     public open /*fake_override*/ fun addAll(/*0*/ kotlin.Collection<T!>): kotlin.Boolean
-    public open /*fake_override*/ fun addAll(/*0*/ kotlin.Int, /*1*/ (kotlin.MutableCollection<out T!>..kotlin.Collection<T!>?)): kotlin.Boolean
+    public open /*fake_override*/ fun addAll(/*0*/ kotlin.Int, /*1*/ kotlin.Collection<T!>): kotlin.Boolean
     public open /*fake_override*/ fun clear(): kotlin.Unit
     public open /*fake_override*/ fun contains(/*0*/ kotlin.Any?): kotlin.Boolean
     public open /*fake_override*/ fun containsAll(/*0*/ kotlin.Collection<kotlin.Any?>): kotlin.Boolean
     public abstract /*fake_override*/ fun get(/*0*/ kotlin.Int): T!
-    public open /*fake_override*/ fun indexOf(/*0*/ kotlin.Any!): kotlin.Int
+    public open /*fake_override*/ fun indexOf(/*0*/ kotlin.Any?): kotlin.Int
     public open /*fake_override*/ fun isEmpty(): kotlin.Boolean
-    public open /*fake_override*/ fun iterator(): kotlin.(Mutable)Iterator<T!>!
-    public open /*fake_override*/ fun lastIndexOf(/*0*/ kotlin.Any!): kotlin.Int
-    public open /*fake_override*/ fun listIterator(): kotlin.(Mutable)ListIterator<T!>!
-    public open /*fake_override*/ fun listIterator(/*0*/ kotlin.Int): kotlin.(Mutable)ListIterator<T!>!
+    public open /*fake_override*/ fun iterator(): kotlin.MutableIterator<T!>
+    public open /*fake_override*/ fun lastIndexOf(/*0*/ kotlin.Any?): kotlin.Int
+    public open /*fake_override*/ fun listIterator(): kotlin.MutableListIterator<T!>
+    public open /*fake_override*/ fun listIterator(/*0*/ kotlin.Int): kotlin.MutableListIterator<T!>
     invisible_fake open /*fake_override*/ fun outOfBoundsMsg(/*0*/ kotlin.Int): kotlin.String!
     invisible_fake open /*fake_override*/ fun rangeCheckForAdd(/*0*/ kotlin.Int): kotlin.Unit
     public open /*fake_override*/ fun remove(/*0*/ kotlin.Any?): kotlin.Boolean
@@ -30,7 +30,7 @@ internal abstract class Mine</*0*/ T> : java.util.AbstractList<T> {
     public open /*fake_override*/ fun retainAll(/*0*/ kotlin.Collection<kotlin.Any?>): kotlin.Boolean
     public open /*fake_override*/ fun set(/*0*/ kotlin.Int, /*1*/ T!): T!
     public abstract /*fake_override*/ fun size(): kotlin.Int
-    public open /*fake_override*/ fun subList(/*0*/ kotlin.Int, /*1*/ kotlin.Int): kotlin.(Mutable)List<T!>!
+    public open /*fake_override*/ fun subList(/*0*/ kotlin.Int, /*1*/ kotlin.Int): kotlin.MutableList<T!>
     public open /*fake_override*/ fun toArray(): kotlin.Array<(out) kotlin.Any!>!
     public open /*fake_override*/ fun </*0*/ T> toArray(/*0*/ kotlin.Array<(out) T!>!): kotlin.Array<(out) T!>!
 }
diff --git a/compiler/testData/compileJavaAgainstKotlin/class/ImplementsListString.txt b/compiler/testData/compileJavaAgainstKotlin/class/ImplementsListString.txt
index 4c097c488c3..c8e93e1d5fa 100644
--- a/compiler/testData/compileJavaAgainstKotlin/class/ImplementsListString.txt
+++ b/compiler/testData/compileJavaAgainstKotlin/class/ImplementsListString.txt
@@ -4,22 +4,22 @@ internal abstract class Mine : java.util.List<kotlin.String> {
     public constructor Mine()
     public abstract /*fake_override*/ fun add(/*0*/ kotlin.Int, /*1*/ kotlin.String!): kotlin.Unit
     public abstract /*fake_override*/ fun add(/*0*/ kotlin.String!): kotlin.Boolean
-    public abstract /*fake_override*/ fun addAll(/*0*/ (kotlin.MutableCollection<out kotlin.String!>..kotlin.Collection<kotlin.String!>?)): kotlin.Boolean
+    public abstract /*fake_override*/ fun addAll(/*0*/ kotlin.Collection<kotlin.String!>): kotlin.Boolean
     public abstract /*fake_override*/ fun addAll(/*0*/ kotlin.Int, /*1*/ (kotlin.MutableCollection<out kotlin.String!>..kotlin.Collection<kotlin.String!>?)): kotlin.Boolean
     public abstract /*fake_override*/ fun clear(): kotlin.Unit
-    public abstract /*fake_override*/ fun contains(/*0*/ kotlin.Any!): kotlin.Boolean
-    public abstract /*fake_override*/ fun containsAll(/*0*/ kotlin.(Mutable)Collection<*>!): kotlin.Boolean
+    public abstract /*fake_override*/ fun contains(/*0*/ kotlin.Any?): kotlin.Boolean
+    public abstract /*fake_override*/ fun containsAll(/*0*/ kotlin.Collection<*>): kotlin.Boolean
     public abstract /*fake_override*/ fun get(/*0*/ kotlin.Int): kotlin.String!
     public abstract /*fake_override*/ fun indexOf(/*0*/ kotlin.Any!): kotlin.Int
     public abstract /*fake_override*/ fun isEmpty(): kotlin.Boolean
-    public abstract /*fake_override*/ fun iterator(): kotlin.(Mutable)Iterator<kotlin.String!>!
+    public abstract /*fake_override*/ fun iterator(): kotlin.MutableIterator<kotlin.String!>
     public abstract /*fake_override*/ fun lastIndexOf(/*0*/ kotlin.Any!): kotlin.Int
     public abstract /*fake_override*/ fun listIterator(): kotlin.(Mutable)ListIterator<kotlin.String!>!
     public abstract /*fake_override*/ fun listIterator(/*0*/ kotlin.Int): kotlin.(Mutable)ListIterator<kotlin.String!>!
-    public abstract /*fake_override*/ fun remove(/*0*/ kotlin.Any!): kotlin.Boolean
+    public abstract /*fake_override*/ fun remove(/*0*/ kotlin.Any?): kotlin.Boolean
     public abstract /*fake_override*/ fun remove(/*0*/ kotlin.Int): kotlin.String!
-    public abstract /*fake_override*/ fun removeAll(/*0*/ kotlin.(Mutable)Collection<*>!): kotlin.Boolean
-    public abstract /*fake_override*/ fun retainAll(/*0*/ kotlin.(Mutable)Collection<*>!): kotlin.Boolean
+    public abstract /*fake_override*/ fun removeAll(/*0*/ kotlin.Collection<*>): kotlin.Boolean
+    public abstract /*fake_override*/ fun retainAll(/*0*/ kotlin.Collection<*>): kotlin.Boolean
     public abstract /*fake_override*/ fun set(/*0*/ kotlin.Int, /*1*/ kotlin.String!): kotlin.String!
     public abstract /*fake_override*/ fun size(): kotlin.Int
     public abstract /*fake_override*/ fun subList(/*0*/ kotlin.Int, /*1*/ kotlin.Int): kotlin.(Mutable)List<kotlin.String!>!
diff --git a/compiler/testData/compileJavaAgainstKotlin/method/primitiveOverride/ByteOverridesObject.txt b/compiler/testData/compileJavaAgainstKotlin/method/primitiveOverride/ByteOverridesObject.txt
index 001503d8b8d..2ceb1273a48 100644
--- a/compiler/testData/compileJavaAgainstKotlin/method/primitiveOverride/ByteOverridesObject.txt
+++ b/compiler/testData/compileJavaAgainstKotlin/method/primitiveOverride/ByteOverridesObject.txt
@@ -22,6 +22,6 @@ public/*package*/ open class ExtendsB : test.B {
 
 public/*package*/ open class ExtendsC : test.C {
     public/*package*/ constructor ExtendsC()
-    public open fun foo(): kotlin.Byte!
+    public open fun foo(): kotlin.Byte
     public/*package*/ open fun test(): kotlin.Unit
 }
diff --git a/compiler/testData/compileJavaAgainstKotlin/method/primitiveOverride/IntOverridesComparable.txt b/compiler/testData/compileJavaAgainstKotlin/method/primitiveOverride/IntOverridesComparable.txt
index 2b3b2080112..6328834735d 100644
--- a/compiler/testData/compileJavaAgainstKotlin/method/primitiveOverride/IntOverridesComparable.txt
+++ b/compiler/testData/compileJavaAgainstKotlin/method/primitiveOverride/IntOverridesComparable.txt
@@ -22,6 +22,6 @@ public/*package*/ open class ExtendsB : test.B {
 
 public/*package*/ open class ExtendsC : test.C {
     public/*package*/ constructor ExtendsC()
-    public open fun foo(): kotlin.Int!
+    public open fun foo(): kotlin.Int
     public/*package*/ open fun test(): kotlin.Unit
 }
diff --git a/compiler/testData/compileJavaAgainstKotlin/method/primitiveOverride/IntOverridesNumber.txt b/compiler/testData/compileJavaAgainstKotlin/method/primitiveOverride/IntOverridesNumber.txt
index c2628690147..e23a75459d8 100644
--- a/compiler/testData/compileJavaAgainstKotlin/method/primitiveOverride/IntOverridesNumber.txt
+++ b/compiler/testData/compileJavaAgainstKotlin/method/primitiveOverride/IntOverridesNumber.txt
@@ -22,6 +22,6 @@ public/*package*/ open class ExtendsB : test.B {
 
 public/*package*/ open class ExtendsC : test.C {
     public/*package*/ constructor ExtendsC()
-    public open fun foo(): kotlin.Int!
+    public open fun foo(): kotlin.Int
     public/*package*/ open fun test(): kotlin.Unit
 }
diff --git a/compiler/testData/compileJavaAgainstKotlin/method/primitiveOverride/IntOverridesObject.txt b/compiler/testData/compileJavaAgainstKotlin/method/primitiveOverride/IntOverridesObject.txt
index 961872949bb..d4f815b37c3 100644
--- a/compiler/testData/compileJavaAgainstKotlin/method/primitiveOverride/IntOverridesObject.txt
+++ b/compiler/testData/compileJavaAgainstKotlin/method/primitiveOverride/IntOverridesObject.txt
@@ -22,6 +22,6 @@ public/*package*/ open class ExtendsB : test.B {
 
 public/*package*/ open class ExtendsC : test.C {
     public/*package*/ constructor ExtendsC()
-    public open fun foo(): kotlin.Int!
+    public open fun foo(): kotlin.Int
     public/*package*/ open fun test(): kotlin.Unit
 }
diff --git a/compiler/testData/compileJavaAgainstKotlin/method/primitiveOverride/NullableIntOverridesObject.txt b/compiler/testData/compileJavaAgainstKotlin/method/primitiveOverride/NullableIntOverridesObject.txt
index 9411026f19b..172f848f148 100644
--- a/compiler/testData/compileJavaAgainstKotlin/method/primitiveOverride/NullableIntOverridesObject.txt
+++ b/compiler/testData/compileJavaAgainstKotlin/method/primitiveOverride/NullableIntOverridesObject.txt
@@ -22,6 +22,6 @@ public/*package*/ open class ExtendsB : test.B {
 
 public/*package*/ open class ExtendsC : test.C {
     public/*package*/ constructor ExtendsC()
-    public open fun foo(): kotlin.Int!
+    public open fun foo(): kotlin.Int?
     public/*package*/ open fun test(): kotlin.Unit
 }
diff --git a/compiler/testData/compileJavaAgainstKotlin/method/primitiveOverride/OverrideInJava.txt b/compiler/testData/compileJavaAgainstKotlin/method/primitiveOverride/OverrideInJava.txt
index 407ad2cb5e4..b337973dbde 100644
--- a/compiler/testData/compileJavaAgainstKotlin/method/primitiveOverride/OverrideInJava.txt
+++ b/compiler/testData/compileJavaAgainstKotlin/method/primitiveOverride/OverrideInJava.txt
@@ -11,6 +11,6 @@ internal abstract class B : test.A<kotlin.Int> {
 
 public/*package*/ open class ExtendsB : test.B {
     public/*package*/ constructor ExtendsB()
-    public open fun foo(): kotlin.Int!
+    public open fun foo(): kotlin.Int
     public/*package*/ open fun test(): kotlin.Unit
 }
diff --git a/compiler/testData/compileJavaAgainstKotlin/staticFields/AnnotationClass.txt b/compiler/testData/compileJavaAgainstKotlin/staticFields/AnnotationClass.txt
index 04893348d74..c1267305f6b 100644
--- a/compiler/testData/compileJavaAgainstKotlin/staticFields/AnnotationClass.txt
+++ b/compiler/testData/compileJavaAgainstKotlin/staticFields/AnnotationClass.txt
@@ -1,36 +1,36 @@
 package test
 
-internal final annotation class AByte : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class AByte : kotlin.Annotation {
     public constructor AByte(/*0*/ kotlin.Byte)
     internal final val value: kotlin.Byte
 }
 
-internal final annotation class AChar : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class AChar : kotlin.Annotation {
     public constructor AChar(/*0*/ kotlin.Char)
     internal final val value: kotlin.Char
 }
 
-internal final annotation class ADouble : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class ADouble : kotlin.Annotation {
     public constructor ADouble(/*0*/ kotlin.Double)
     internal final val value: kotlin.Double
 }
 
-internal final annotation class AFloat : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class AFloat : kotlin.Annotation {
     public constructor AFloat(/*0*/ kotlin.Float)
     internal final val value: kotlin.Float
 }
 
-internal final annotation class AInt : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class AInt : kotlin.Annotation {
     public constructor AInt(/*0*/ kotlin.Int)
     internal final val value: kotlin.Int
 }
 
-internal final annotation class ALong : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class ALong : kotlin.Annotation {
     public constructor ALong(/*0*/ kotlin.Long)
     internal final val value: kotlin.Long
 }
 
-internal final annotation class AString : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class AString : kotlin.Annotation {
     public constructor AString(/*0*/ kotlin.String)
     internal final val value: kotlin.String
 }
diff --git a/compiler/testData/compileJavaAgainstKotlin/staticFields/AnnotationTrait.txt b/compiler/testData/compileJavaAgainstKotlin/staticFields/AnnotationTrait.txt
index 98cd5456308..4f0b36ea32f 100644
--- a/compiler/testData/compileJavaAgainstKotlin/staticFields/AnnotationTrait.txt
+++ b/compiler/testData/compileJavaAgainstKotlin/staticFields/AnnotationTrait.txt
@@ -1,36 +1,36 @@
 package test
 
-internal final annotation class AByte : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class AByte : kotlin.Annotation {
     public constructor AByte(/*0*/ kotlin.Byte)
     internal final val value: kotlin.Byte
 }
 
-internal final annotation class AChar : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class AChar : kotlin.Annotation {
     public constructor AChar(/*0*/ kotlin.Char)
     internal final val value: kotlin.Char
 }
 
-internal final annotation class ADouble : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class ADouble : kotlin.Annotation {
     public constructor ADouble(/*0*/ kotlin.Double)
     internal final val value: kotlin.Double
 }
 
-internal final annotation class AFloat : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class AFloat : kotlin.Annotation {
     public constructor AFloat(/*0*/ kotlin.Float)
     internal final val value: kotlin.Float
 }
 
-internal final annotation class AInt : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class AInt : kotlin.Annotation {
     public constructor AInt(/*0*/ kotlin.Int)
     internal final val value: kotlin.Int
 }
 
-internal final annotation class ALong : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class ALong : kotlin.Annotation {
     public constructor ALong(/*0*/ kotlin.Long)
     internal final val value: kotlin.Long
 }
 
-internal final annotation class AString : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class AString : kotlin.Annotation {
     public constructor AString(/*0*/ kotlin.String)
     internal final val value: kotlin.String
 }
diff --git a/compiler/testData/compileJavaAgainstKotlin/staticFields/kt3698.txt b/compiler/testData/compileJavaAgainstKotlin/staticFields/kt3698.txt
index fe3d067c610..16f4f02d951 100644
--- a/compiler/testData/compileJavaAgainstKotlin/staticFields/kt3698.txt
+++ b/compiler/testData/compileJavaAgainstKotlin/staticFields/kt3698.txt
@@ -12,7 +12,7 @@ internal final class KotlinClass {
 public open class kt3698 {
     public constructor kt3698()
 
-    public/*package*/ final annotation class Foo : kotlin.Annotation {
+    public/*package*/ final class Foo : kotlin.Annotation {
         public/*package*/ constructor Foo(/*0*/ kotlin.Int)
         public final val value: kotlin.Int
         public abstract fun value(): kotlin.Int
diff --git a/compiler/testData/compileJavaAgainstKotlin/targets/annotation.java b/compiler/testData/compileJavaAgainstKotlin/targets/annotation.java
new file mode 100644
index 00000000000..af701eeac59
--- /dev/null
+++ b/compiler/testData/compileJavaAgainstKotlin/targets/annotation.java
@@ -0,0 +1,9 @@
+package test;
+
+@meta @interface MyAnn {
+
+}
+
+@meta class My {
+
+}
\ No newline at end of file
diff --git a/compiler/testData/compileJavaAgainstKotlin/targets/annotation.javaerr.txt b/compiler/testData/compileJavaAgainstKotlin/targets/annotation.javaerr.txt
new file mode 100644
index 00000000000..496546b7bf8
--- /dev/null
+++ b/compiler/testData/compileJavaAgainstKotlin/targets/annotation.javaerr.txt
@@ -0,0 +1,2 @@
+annotation.java:7:1:compiler.err.annotation.type.not.applicable
+
diff --git a/compiler/testData/compileJavaAgainstKotlin/targets/annotation.kt b/compiler/testData/compileJavaAgainstKotlin/targets/annotation.kt
new file mode 100644
index 00000000000..a560c088c9e
--- /dev/null
+++ b/compiler/testData/compileJavaAgainstKotlin/targets/annotation.kt
@@ -0,0 +1,4 @@
+package test
+
+target(AnnotationTarget.ANNOTATION_CLASS)
+annotation class meta
\ No newline at end of file
diff --git a/compiler/testData/compileJavaAgainstKotlin/targets/annotation.txt b/compiler/testData/compileJavaAgainstKotlin/targets/annotation.txt
new file mode 100644
index 00000000000..c67a9aad096
--- /dev/null
+++ b/compiler/testData/compileJavaAgainstKotlin/targets/annotation.txt
@@ -0,0 +1,9 @@
+package test
+
+test.meta() public/*package*/ final class MyAnn : kotlin.Annotation {
+    public/*package*/ constructor MyAnn()
+}
+
+kotlin.annotation.target(allowedTargets = {AnnotationTarget.ANNOTATION_CLASS}) kotlin.annotation.annotation() java.lang.annotation.Target(value = {ElementType.ANNOTATION_TYPE}) internal final class meta : kotlin.Annotation {
+    public constructor meta()
+}
diff --git a/compiler/testData/compileJavaAgainstKotlin/targets/base.java b/compiler/testData/compileJavaAgainstKotlin/targets/base.java
new file mode 100644
index 00000000000..afa45c0c6ab
--- /dev/null
+++ b/compiler/testData/compileJavaAgainstKotlin/targets/base.java
@@ -0,0 +1,8 @@
+package test;
+
+@base class My {
+
+    @base int foo(@base int i) {
+        return i + 1;
+    }
+}
\ No newline at end of file
diff --git a/compiler/testData/compileJavaAgainstKotlin/targets/base.kt b/compiler/testData/compileJavaAgainstKotlin/targets/base.kt
new file mode 100644
index 00000000000..b0691602b5e
--- /dev/null
+++ b/compiler/testData/compileJavaAgainstKotlin/targets/base.kt
@@ -0,0 +1,3 @@
+package test
+
+annotation class base
\ No newline at end of file
diff --git a/compiler/testData/compileJavaAgainstKotlin/targets/base.txt b/compiler/testData/compileJavaAgainstKotlin/targets/base.txt
new file mode 100644
index 00000000000..13302e3e361
--- /dev/null
+++ b/compiler/testData/compileJavaAgainstKotlin/targets/base.txt
@@ -0,0 +1,10 @@
+package test
+
+test.base() public/*package*/ open class My {
+    public/*package*/ constructor My()
+    test.base() public/*package*/ open fun foo(/*0*/ test.base() kotlin.Int): kotlin.Int
+}
+
+kotlin.annotation.annotation() internal final class base : kotlin.Annotation {
+    public constructor base()
+}
diff --git a/compiler/testData/compileJavaAgainstKotlin/targets/classifier.java b/compiler/testData/compileJavaAgainstKotlin/targets/classifier.java
new file mode 100644
index 00000000000..786a75cace4
--- /dev/null
+++ b/compiler/testData/compileJavaAgainstKotlin/targets/classifier.java
@@ -0,0 +1,8 @@
+package test;
+
+@classifier class My {
+
+    @classifier int foo() {
+        return 1;
+    }
+}
\ No newline at end of file
diff --git a/compiler/testData/compileJavaAgainstKotlin/targets/classifier.javaerr.txt b/compiler/testData/compileJavaAgainstKotlin/targets/classifier.javaerr.txt
new file mode 100644
index 00000000000..f935f54bbca
--- /dev/null
+++ b/compiler/testData/compileJavaAgainstKotlin/targets/classifier.javaerr.txt
@@ -0,0 +1 @@
+classifier.java:5:5:compiler.err.annotation.type.not.applicable
diff --git a/compiler/testData/compileJavaAgainstKotlin/targets/classifier.kt b/compiler/testData/compileJavaAgainstKotlin/targets/classifier.kt
new file mode 100644
index 00000000000..42ed393d490
--- /dev/null
+++ b/compiler/testData/compileJavaAgainstKotlin/targets/classifier.kt
@@ -0,0 +1,4 @@
+package test
+
+target(AnnotationTarget.CLASSIFIER)
+annotation class classifier
\ No newline at end of file
diff --git a/compiler/testData/compileJavaAgainstKotlin/targets/classifier.txt b/compiler/testData/compileJavaAgainstKotlin/targets/classifier.txt
new file mode 100644
index 00000000000..e78c36e3bfa
--- /dev/null
+++ b/compiler/testData/compileJavaAgainstKotlin/targets/classifier.txt
@@ -0,0 +1,5 @@
+package test
+
+kotlin.annotation.target(allowedTargets = {AnnotationTarget.CLASSIFIER}) kotlin.annotation.annotation() java.lang.annotation.Target(value = {ElementType.TYPE}) internal final class classifier : kotlin.Annotation {
+    public constructor classifier()
+}
diff --git a/compiler/testData/compileJavaAgainstKotlin/targets/constructor.java b/compiler/testData/compileJavaAgainstKotlin/targets/constructor.java
new file mode 100644
index 00000000000..5e7c693be7f
--- /dev/null
+++ b/compiler/testData/compileJavaAgainstKotlin/targets/constructor.java
@@ -0,0 +1,10 @@
+package test;
+
+class My {
+
+    @constructor My() {}
+
+    @constructor int foo() {
+        return 1;
+    }
+}
\ No newline at end of file
diff --git a/compiler/testData/compileJavaAgainstKotlin/targets/constructor.javaerr.txt b/compiler/testData/compileJavaAgainstKotlin/targets/constructor.javaerr.txt
new file mode 100644
index 00000000000..7a80dcd0a10
--- /dev/null
+++ b/compiler/testData/compileJavaAgainstKotlin/targets/constructor.javaerr.txt
@@ -0,0 +1,3 @@
+constructor.java:7:5:compiler.err.annotation.type.not.applicable
+
+
diff --git a/compiler/testData/compileJavaAgainstKotlin/targets/constructor.kt b/compiler/testData/compileJavaAgainstKotlin/targets/constructor.kt
new file mode 100644
index 00000000000..f30855bce29
--- /dev/null
+++ b/compiler/testData/compileJavaAgainstKotlin/targets/constructor.kt
@@ -0,0 +1,4 @@
+package test
+
+target(AnnotationTarget.CONSTRUCTOR)
+annotation class constructor
\ No newline at end of file
diff --git a/compiler/testData/compileJavaAgainstKotlin/targets/constructor.txt b/compiler/testData/compileJavaAgainstKotlin/targets/constructor.txt
new file mode 100644
index 00000000000..ce1e8b0164d
--- /dev/null
+++ b/compiler/testData/compileJavaAgainstKotlin/targets/constructor.txt
@@ -0,0 +1,5 @@
+package test
+
+kotlin.annotation.target(allowedTargets = {AnnotationTarget.CONSTRUCTOR}) kotlin.annotation.annotation() java.lang.annotation.Target(value = {ElementType.CONSTRUCTOR}) internal final class constructor : kotlin.Annotation {
+    public constructor constructor()
+}
diff --git a/compiler/testData/compileJavaAgainstKotlin/targets/empty.java b/compiler/testData/compileJavaAgainstKotlin/targets/empty.java
new file mode 100644
index 00000000000..3ba7c8f7e80
--- /dev/null
+++ b/compiler/testData/compileJavaAgainstKotlin/targets/empty.java
@@ -0,0 +1,8 @@
+package test;
+
+@empty class My {
+
+    @empty int foo(@empty int i) {
+        return i + 1;
+    }
+}
\ No newline at end of file
diff --git a/compiler/testData/compileJavaAgainstKotlin/targets/empty.javaerr.txt b/compiler/testData/compileJavaAgainstKotlin/targets/empty.javaerr.txt
new file mode 100644
index 00000000000..b48349025fb
--- /dev/null
+++ b/compiler/testData/compileJavaAgainstKotlin/targets/empty.javaerr.txt
@@ -0,0 +1,4 @@
+empty.java:3:1:compiler.err.annotation.type.not.applicable
+empty.java:5:20:compiler.err.annotation.type.not.applicable
+empty.java:5:5:compiler.err.annotation.type.not.applicable
+
diff --git a/compiler/testData/compileJavaAgainstKotlin/targets/empty.kt b/compiler/testData/compileJavaAgainstKotlin/targets/empty.kt
new file mode 100644
index 00000000000..baf723a676d
--- /dev/null
+++ b/compiler/testData/compileJavaAgainstKotlin/targets/empty.kt
@@ -0,0 +1,4 @@
+package test
+
+target()
+annotation class empty
diff --git a/compiler/testData/compileJavaAgainstKotlin/targets/empty.txt b/compiler/testData/compileJavaAgainstKotlin/targets/empty.txt
new file mode 100644
index 00000000000..0dd05225d23
--- /dev/null
+++ b/compiler/testData/compileJavaAgainstKotlin/targets/empty.txt
@@ -0,0 +1,5 @@
+package test
+
+kotlin.annotation.target(allowedTargets = {}) kotlin.annotation.annotation() java.lang.annotation.Target(value = {}) internal final class empty : kotlin.Annotation {
+    public constructor empty()
+}
diff --git a/compiler/testData/compileJavaAgainstKotlin/targets/field.java b/compiler/testData/compileJavaAgainstKotlin/targets/field.java
new file mode 100644
index 00000000000..cca6d2eb004
--- /dev/null
+++ b/compiler/testData/compileJavaAgainstKotlin/targets/field.java
@@ -0,0 +1,7 @@
+package test;
+
+class My {
+    @field int prop;
+
+    @field int get() { return prop; }
+}
\ No newline at end of file
diff --git a/compiler/testData/compileJavaAgainstKotlin/targets/field.javaerr.txt b/compiler/testData/compileJavaAgainstKotlin/targets/field.javaerr.txt
new file mode 100644
index 00000000000..75d28283491
--- /dev/null
+++ b/compiler/testData/compileJavaAgainstKotlin/targets/field.javaerr.txt
@@ -0,0 +1,4 @@
+field.java:6:5:compiler.err.annotation.type.not.applicable
+
+
+
diff --git a/compiler/testData/compileJavaAgainstKotlin/targets/field.kt b/compiler/testData/compileJavaAgainstKotlin/targets/field.kt
new file mode 100644
index 00000000000..121f11551c2
--- /dev/null
+++ b/compiler/testData/compileJavaAgainstKotlin/targets/field.kt
@@ -0,0 +1,4 @@
+package test
+
+target(AnnotationTarget.FIELD)
+annotation class field
diff --git a/compiler/testData/compileJavaAgainstKotlin/targets/field.txt b/compiler/testData/compileJavaAgainstKotlin/targets/field.txt
new file mode 100644
index 00000000000..65c95f1a64a
--- /dev/null
+++ b/compiler/testData/compileJavaAgainstKotlin/targets/field.txt
@@ -0,0 +1,5 @@
+package test
+
+kotlin.annotation.target(allowedTargets = {AnnotationTarget.FIELD}) kotlin.annotation.annotation() java.lang.annotation.Target(value = {ElementType.FIELD}) internal final class field : kotlin.Annotation {
+    public constructor field()
+}
diff --git a/compiler/testData/compileJavaAgainstKotlin/targets/function.java b/compiler/testData/compileJavaAgainstKotlin/targets/function.java
new file mode 100644
index 00000000000..e7c96c8b5db
--- /dev/null
+++ b/compiler/testData/compileJavaAgainstKotlin/targets/function.java
@@ -0,0 +1,8 @@
+package test;
+
+@function class My {
+
+    @function int foo() {
+        return 1;
+    }
+}
\ No newline at end of file
diff --git a/compiler/testData/compileJavaAgainstKotlin/targets/function.javaerr.txt b/compiler/testData/compileJavaAgainstKotlin/targets/function.javaerr.txt
new file mode 100644
index 00000000000..68ddefc0953
--- /dev/null
+++ b/compiler/testData/compileJavaAgainstKotlin/targets/function.javaerr.txt
@@ -0,0 +1,2 @@
+function.java:3:1:compiler.err.annotation.type.not.applicable
+
diff --git a/compiler/testData/compileJavaAgainstKotlin/targets/function.kt b/compiler/testData/compileJavaAgainstKotlin/targets/function.kt
new file mode 100644
index 00000000000..149d5a6feb5
--- /dev/null
+++ b/compiler/testData/compileJavaAgainstKotlin/targets/function.kt
@@ -0,0 +1,4 @@
+package test
+
+target(AnnotationTarget.FUNCTION)
+annotation class function
\ No newline at end of file
diff --git a/compiler/testData/compileJavaAgainstKotlin/targets/function.txt b/compiler/testData/compileJavaAgainstKotlin/targets/function.txt
new file mode 100644
index 00000000000..89291920462
--- /dev/null
+++ b/compiler/testData/compileJavaAgainstKotlin/targets/function.txt
@@ -0,0 +1,5 @@
+package test
+
+kotlin.annotation.target(allowedTargets = {AnnotationTarget.FUNCTION}) kotlin.annotation.annotation() java.lang.annotation.Target(value = {ElementType.METHOD}) internal final class function : kotlin.Annotation {
+    public constructor function()
+}
diff --git a/compiler/testData/compileJavaAgainstKotlin/targets/getter.java b/compiler/testData/compileJavaAgainstKotlin/targets/getter.java
new file mode 100644
index 00000000000..2e1ad2d6d59
--- /dev/null
+++ b/compiler/testData/compileJavaAgainstKotlin/targets/getter.java
@@ -0,0 +1,8 @@
+package test;
+
+@getter class My {
+
+    @getter int foo() {
+        return 1;
+    }
+}
\ No newline at end of file
diff --git a/compiler/testData/compileJavaAgainstKotlin/targets/getter.javaerr.txt b/compiler/testData/compileJavaAgainstKotlin/targets/getter.javaerr.txt
new file mode 100644
index 00000000000..4bd2d1e6808
--- /dev/null
+++ b/compiler/testData/compileJavaAgainstKotlin/targets/getter.javaerr.txt
@@ -0,0 +1,3 @@
+getter.java:3:1:compiler.err.annotation.type.not.applicable
+
+
diff --git a/compiler/testData/compileJavaAgainstKotlin/targets/getter.kt b/compiler/testData/compileJavaAgainstKotlin/targets/getter.kt
new file mode 100644
index 00000000000..d4f36ed4e5b
--- /dev/null
+++ b/compiler/testData/compileJavaAgainstKotlin/targets/getter.kt
@@ -0,0 +1,4 @@
+package test
+
+target(AnnotationTarget.PROPERTY_GETTER)
+annotation class getter
\ No newline at end of file
diff --git a/compiler/testData/compileJavaAgainstKotlin/targets/getter.txt b/compiler/testData/compileJavaAgainstKotlin/targets/getter.txt
new file mode 100644
index 00000000000..2cb31f08715
--- /dev/null
+++ b/compiler/testData/compileJavaAgainstKotlin/targets/getter.txt
@@ -0,0 +1,5 @@
+package test
+
+kotlin.annotation.target(allowedTargets = {AnnotationTarget.PROPERTY_GETTER}) kotlin.annotation.annotation() java.lang.annotation.Target(value = {ElementType.METHOD}) internal final class getter : kotlin.Annotation {
+    public constructor getter()
+}
diff --git a/compiler/testData/compileJavaAgainstKotlin/targets/local.java b/compiler/testData/compileJavaAgainstKotlin/targets/local.java
new file mode 100644
index 00000000000..5ee8a3ada6d
--- /dev/null
+++ b/compiler/testData/compileJavaAgainstKotlin/targets/local.java
@@ -0,0 +1,9 @@
+package test;
+
+class My {
+
+    int foo(@local int i) {
+        @local int j = i + 1;
+        return j;
+    }
+}
\ No newline at end of file
diff --git a/compiler/testData/compileJavaAgainstKotlin/targets/local.javaerr.txt b/compiler/testData/compileJavaAgainstKotlin/targets/local.javaerr.txt
new file mode 100644
index 00000000000..f63c7f473bc
--- /dev/null
+++ b/compiler/testData/compileJavaAgainstKotlin/targets/local.javaerr.txt
@@ -0,0 +1,3 @@
+local.java:5:13:compiler.err.annotation.type.not.applicable
+
+
diff --git a/compiler/testData/compileJavaAgainstKotlin/targets/local.kt b/compiler/testData/compileJavaAgainstKotlin/targets/local.kt
new file mode 100644
index 00000000000..22315fd2751
--- /dev/null
+++ b/compiler/testData/compileJavaAgainstKotlin/targets/local.kt
@@ -0,0 +1,4 @@
+package test
+
+target(AnnotationTarget.LOCAL_VARIABLE)
+annotation class local
diff --git a/compiler/testData/compileJavaAgainstKotlin/targets/local.txt b/compiler/testData/compileJavaAgainstKotlin/targets/local.txt
new file mode 100644
index 00000000000..7731a09f388
--- /dev/null
+++ b/compiler/testData/compileJavaAgainstKotlin/targets/local.txt
@@ -0,0 +1,5 @@
+package test
+
+kotlin.annotation.target(allowedTargets = {AnnotationTarget.LOCAL_VARIABLE}) kotlin.annotation.annotation() java.lang.annotation.Target(value = {ElementType.LOCAL_VARIABLE}) internal final class local : kotlin.Annotation {
+    public constructor local()
+}
diff --git a/compiler/testData/compileJavaAgainstKotlin/targets/multiple.java b/compiler/testData/compileJavaAgainstKotlin/targets/multiple.java
new file mode 100644
index 00000000000..d0de4cf9b3a
--- /dev/null
+++ b/compiler/testData/compileJavaAgainstKotlin/targets/multiple.java
@@ -0,0 +1,8 @@
+package test;
+
+@multiple class My {
+
+    @multiple int foo(@multiple int i) {
+        return i + 1;
+    }
+}
\ No newline at end of file
diff --git a/compiler/testData/compileJavaAgainstKotlin/targets/multiple.javaerr.txt b/compiler/testData/compileJavaAgainstKotlin/targets/multiple.javaerr.txt
new file mode 100644
index 00000000000..0cf4373322b
--- /dev/null
+++ b/compiler/testData/compileJavaAgainstKotlin/targets/multiple.javaerr.txt
@@ -0,0 +1,2 @@
+multiple.java:5:23:compiler.err.annotation.type.not.applicable
+
diff --git a/compiler/testData/compileJavaAgainstKotlin/targets/multiple.kt b/compiler/testData/compileJavaAgainstKotlin/targets/multiple.kt
new file mode 100644
index 00000000000..e6917422932
--- /dev/null
+++ b/compiler/testData/compileJavaAgainstKotlin/targets/multiple.kt
@@ -0,0 +1,4 @@
+package test
+
+target(AnnotationTarget.CLASSIFIER, AnnotationTarget.FUNCTION)
+annotation class multiple
diff --git a/compiler/testData/compileJavaAgainstKotlin/targets/multiple.txt b/compiler/testData/compileJavaAgainstKotlin/targets/multiple.txt
new file mode 100644
index 00000000000..2a3a8c4e794
--- /dev/null
+++ b/compiler/testData/compileJavaAgainstKotlin/targets/multiple.txt
@@ -0,0 +1,5 @@
+package test
+
+kotlin.annotation.target(allowedTargets = {AnnotationTarget.CLASSIFIER, AnnotationTarget.FUNCTION}) kotlin.annotation.annotation() java.lang.annotation.Target(value = {ElementType.TYPE, ElementType.METHOD}) internal final class multiple : kotlin.Annotation {
+    public constructor multiple()
+}
diff --git a/compiler/testData/compileJavaAgainstKotlin/targets/package-info.java b/compiler/testData/compileJavaAgainstKotlin/targets/package-info.java
new file mode 100644
index 00000000000..660755836c1
--- /dev/null
+++ b/compiler/testData/compileJavaAgainstKotlin/targets/package-info.java
@@ -0,0 +1,5 @@
+@pck package test;
+
+@pck class My {
+
+}
\ No newline at end of file
diff --git a/compiler/testData/compileJavaAgainstKotlin/targets/package-info.javaerr.txt b/compiler/testData/compileJavaAgainstKotlin/targets/package-info.javaerr.txt
new file mode 100644
index 00000000000..c4f5202f765
--- /dev/null
+++ b/compiler/testData/compileJavaAgainstKotlin/targets/package-info.javaerr.txt
@@ -0,0 +1,2 @@
+package-info.java:3:1:compiler.err.annotation.type.not.applicable
+
diff --git a/compiler/testData/compileJavaAgainstKotlin/targets/package-info.kt b/compiler/testData/compileJavaAgainstKotlin/targets/package-info.kt
new file mode 100644
index 00000000000..4cddc103b42
--- /dev/null
+++ b/compiler/testData/compileJavaAgainstKotlin/targets/package-info.kt
@@ -0,0 +1,4 @@
+package test
+
+target(AnnotationTarget.PACKAGE)
+annotation class pck
\ No newline at end of file
diff --git a/compiler/testData/compileJavaAgainstKotlin/targets/package-info.txt b/compiler/testData/compileJavaAgainstKotlin/targets/package-info.txt
new file mode 100644
index 00000000000..e1012210dd7
--- /dev/null
+++ b/compiler/testData/compileJavaAgainstKotlin/targets/package-info.txt
@@ -0,0 +1,8 @@
+package test
+
+test.pck() public/*package*/ interface `package-info` {
+}
+
+kotlin.annotation.target(allowedTargets = {AnnotationTarget.PACKAGE}) kotlin.annotation.annotation() java.lang.annotation.Target(value = {ElementType.PACKAGE}) internal final class pck : kotlin.Annotation {
+    public constructor pck()
+}
diff --git a/compiler/testData/compileJavaAgainstKotlin/targets/parameter.java b/compiler/testData/compileJavaAgainstKotlin/targets/parameter.java
new file mode 100644
index 00000000000..7b6579c617c
--- /dev/null
+++ b/compiler/testData/compileJavaAgainstKotlin/targets/parameter.java
@@ -0,0 +1,8 @@
+package test;
+
+@parameter class My {
+
+    @parameter int foo(@parameter int i) {
+        return i + 1;
+    }
+}
\ No newline at end of file
diff --git a/compiler/testData/compileJavaAgainstKotlin/targets/parameter.javaerr.txt b/compiler/testData/compileJavaAgainstKotlin/targets/parameter.javaerr.txt
new file mode 100644
index 00000000000..b69bcb7eec8
--- /dev/null
+++ b/compiler/testData/compileJavaAgainstKotlin/targets/parameter.javaerr.txt
@@ -0,0 +1,2 @@
+parameter.java:3:1:compiler.err.annotation.type.not.applicable
+parameter.java:5:5:compiler.err.annotation.type.not.applicable
diff --git a/compiler/testData/compileJavaAgainstKotlin/targets/parameter.kt b/compiler/testData/compileJavaAgainstKotlin/targets/parameter.kt
new file mode 100644
index 00000000000..a0480e339b7
--- /dev/null
+++ b/compiler/testData/compileJavaAgainstKotlin/targets/parameter.kt
@@ -0,0 +1,4 @@
+package test
+
+target(AnnotationTarget.VALUE_PARAMETER)
+annotation class parameter
diff --git a/compiler/testData/compileJavaAgainstKotlin/targets/parameter.txt b/compiler/testData/compileJavaAgainstKotlin/targets/parameter.txt
new file mode 100644
index 00000000000..b96cb99dc91
--- /dev/null
+++ b/compiler/testData/compileJavaAgainstKotlin/targets/parameter.txt
@@ -0,0 +1,5 @@
+package test
+
+kotlin.annotation.target(allowedTargets = {AnnotationTarget.VALUE_PARAMETER}) kotlin.annotation.annotation() java.lang.annotation.Target(value = {ElementType.PARAMETER}) internal final class parameter : kotlin.Annotation {
+    public constructor parameter()
+}
diff --git a/compiler/testData/compileJavaAgainstKotlin/targets/property.java b/compiler/testData/compileJavaAgainstKotlin/targets/property.java
new file mode 100644
index 00000000000..d283ecf8802
--- /dev/null
+++ b/compiler/testData/compileJavaAgainstKotlin/targets/property.java
@@ -0,0 +1,7 @@
+package test;
+
+class My {
+    @property int prop;
+
+    @property int get() { return prop; }
+}
\ No newline at end of file
diff --git a/compiler/testData/compileJavaAgainstKotlin/targets/property.javaerr.txt b/compiler/testData/compileJavaAgainstKotlin/targets/property.javaerr.txt
new file mode 100644
index 00000000000..254a611f5cb
--- /dev/null
+++ b/compiler/testData/compileJavaAgainstKotlin/targets/property.javaerr.txt
@@ -0,0 +1,4 @@
+property.java:4:5:compiler.err.annotation.type.not.applicable
+property.java:6:5:compiler.err.annotation.type.not.applicable
+
+
diff --git a/compiler/testData/compileJavaAgainstKotlin/targets/property.kt b/compiler/testData/compileJavaAgainstKotlin/targets/property.kt
new file mode 100644
index 00000000000..8dfbeda314f
--- /dev/null
+++ b/compiler/testData/compileJavaAgainstKotlin/targets/property.kt
@@ -0,0 +1,4 @@
+package test
+
+target(AnnotationTarget.PROPERTY)
+annotation class property
diff --git a/compiler/testData/compileJavaAgainstKotlin/targets/property.txt b/compiler/testData/compileJavaAgainstKotlin/targets/property.txt
new file mode 100644
index 00000000000..636e36d33b1
--- /dev/null
+++ b/compiler/testData/compileJavaAgainstKotlin/targets/property.txt
@@ -0,0 +1,5 @@
+package test
+
+kotlin.annotation.target(allowedTargets = {AnnotationTarget.PROPERTY}) kotlin.annotation.annotation() java.lang.annotation.Target(value = {}) internal final class property : kotlin.Annotation {
+    public constructor property()
+}
diff --git a/compiler/testData/compileJavaAgainstKotlin/targets/setter.java b/compiler/testData/compileJavaAgainstKotlin/targets/setter.java
new file mode 100644
index 00000000000..d92426551b7
--- /dev/null
+++ b/compiler/testData/compileJavaAgainstKotlin/targets/setter.java
@@ -0,0 +1,8 @@
+package test;
+
+@setter class My {
+
+    @setter int foo() {
+        return 1;
+    }
+}
\ No newline at end of file
diff --git a/compiler/testData/compileJavaAgainstKotlin/targets/setter.javaerr.txt b/compiler/testData/compileJavaAgainstKotlin/targets/setter.javaerr.txt
new file mode 100644
index 00000000000..7147fea29cc
--- /dev/null
+++ b/compiler/testData/compileJavaAgainstKotlin/targets/setter.javaerr.txt
@@ -0,0 +1,3 @@
+setter.java:3:1:compiler.err.annotation.type.not.applicable
+
+
diff --git a/compiler/testData/compileJavaAgainstKotlin/targets/setter.kt b/compiler/testData/compileJavaAgainstKotlin/targets/setter.kt
new file mode 100644
index 00000000000..8d1a40ba08a
--- /dev/null
+++ b/compiler/testData/compileJavaAgainstKotlin/targets/setter.kt
@@ -0,0 +1,4 @@
+package test
+
+target(AnnotationTarget.PROPERTY_SETTER)
+annotation class setter
\ No newline at end of file
diff --git a/compiler/testData/compileJavaAgainstKotlin/targets/setter.txt b/compiler/testData/compileJavaAgainstKotlin/targets/setter.txt
new file mode 100644
index 00000000000..a9afdf028d3
--- /dev/null
+++ b/compiler/testData/compileJavaAgainstKotlin/targets/setter.txt
@@ -0,0 +1,5 @@
+package test
+
+kotlin.annotation.target(allowedTargets = {AnnotationTarget.PROPERTY_SETTER}) kotlin.annotation.annotation() java.lang.annotation.Target(value = {ElementType.METHOD}) internal final class setter : kotlin.Annotation {
+    public constructor setter()
+}
diff --git a/compiler/testData/compileKotlinAgainstCustomBinaries/missingEnumReferencedInAnnotationArgument/missingEnumReferencedInAnnotationArgument.txt b/compiler/testData/compileKotlinAgainstCustomBinaries/missingEnumReferencedInAnnotationArgument/missingEnumReferencedInAnnotationArgument.txt
index 2647ef88568..324116aa37a 100644
--- a/compiler/testData/compileKotlinAgainstCustomBinaries/missingEnumReferencedInAnnotationArgument/missingEnumReferencedInAnnotationArgument.txt
+++ b/compiler/testData/compileKotlinAgainstCustomBinaries/missingEnumReferencedInAnnotationArgument/missingEnumReferencedInAnnotationArgument.txt
@@ -1,6 +1,6 @@
 package test
 
-internal final annotation class Anno : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class Anno : kotlin.Annotation {
     public constructor Anno(/*0*/ e: [ERROR : test.E])
     internal final val e: [ERROR : test.E]
 }
diff --git a/compiler/testData/compileKotlinAgainstKotlin/AnnotationInTrait.A.kt b/compiler/testData/compileKotlinAgainstKotlin/AnnotationInTrait.A.kt
index a04ee6dda50..199cf2d375f 100644
--- a/compiler/testData/compileKotlinAgainstKotlin/AnnotationInTrait.A.kt
+++ b/compiler/testData/compileKotlinAgainstKotlin/AnnotationInTrait.A.kt
@@ -1,9 +1,6 @@
 package a
 
-import java.lang.annotation.*
-
-Retention(RetentionPolicy.RUNTIME)
-annotation class Ann
+annotation(retention = AnnotationRetention.RUNTIME) class Ann
 
 interface Tr {
     Ann
diff --git a/compiler/testData/compileKotlinAgainstKotlin/InlinedConstants.A.kt b/compiler/testData/compileKotlinAgainstKotlin/InlinedConstants.A.kt
index 35e5e84c913..dc9584be3c9 100644
--- a/compiler/testData/compileKotlinAgainstKotlin/InlinedConstants.A.kt
+++ b/compiler/testData/compileKotlinAgainstKotlin/InlinedConstants.A.kt
@@ -1,8 +1,5 @@
 package constants
 
-import java.lang.annotation.Retention
-import java.lang.annotation.RetentionPolicy
-
 public val b: Byte = 100
 public val s: Short = 20000
 public val i: Int = 2000000
@@ -14,5 +11,4 @@ public val c: Char = '\u03c0' // pi symbol
 
 public val str: String = ":)"
 
-@Retention(RetentionPolicy.RUNTIME)
-public annotation class AnnotationClass(public val value: String)
\ No newline at end of file
+public annotation(retention = AnnotationRetention.RUNTIME) class AnnotationClass(public val value: String)
\ No newline at end of file
diff --git a/compiler/testData/compileKotlinAgainstKotlin/KotlinPropertyAsAnnotationParameter.B.kt b/compiler/testData/compileKotlinAgainstKotlin/KotlinPropertyAsAnnotationParameter.B.kt
index 32e6000ec7a..86274b17551 100644
--- a/compiler/testData/compileKotlinAgainstKotlin/KotlinPropertyAsAnnotationParameter.B.kt
+++ b/compiler/testData/compileKotlinAgainstKotlin/KotlinPropertyAsAnnotationParameter.B.kt
@@ -1,5 +1,3 @@
-import java.lang.annotation.Retention
-import java.lang.annotation.RetentionPolicy
 import a.*
 
 Ann(i, s, f, d, l, b, bool, c, str)
@@ -8,8 +6,7 @@ class MyClass1
 Ann(i2, s2, f2, d2, l2, b2, bool2, c2, str2)
 class MyClass2
 
-Retention(RetentionPolicy.RUNTIME)
-annotation class Ann(
+annotation(retention = AnnotationRetention.RUNTIME) class Ann(
         val i: Int,
         val s: Short,
         val f: Float,
diff --git a/compiler/testData/constraintSystem/checkStatus/conflictingConstraints.bounds b/compiler/testData/constraintSystem/checkStatus/conflictingConstraints.bounds
index 5c41241ab88..c94c7bdeead 100644
--- a/compiler/testData/constraintSystem/checkStatus/conflictingConstraints.bounds
+++ b/compiler/testData/constraintSystem/checkStatus/conflictingConstraints.bounds
@@ -1,16 +1,18 @@
 VARIABLES T
 
-SUBTYPE T Int
-SUPERTYPE T String
+T <: Int
+T >: String
 
 type parameter bounds:
-T <: kotlin.Int(SPECIAL), >: kotlin.String(SPECIAL)
+T <: Int, >: String
+
 status:
 -hasCannotCaptureTypesError: false
 -hasConflictingConstraints: true
 -hasContradiction: true
 -hasErrorInConstrainingTypes: false
--hasTypeConstructorMismatch: false
+-hasParameterConstraintError: false
+-hasTypeInferenceIncorporationError: true
 -hasUnknownParameters: false
 -hasViolatedUpperBound: false
 -isSuccessful: false
diff --git a/compiler/testData/constraintSystem/checkStatus/conflictingConstraints.constraints b/compiler/testData/constraintSystem/checkStatus/conflictingConstraints.constraints
new file mode 100644
index 00000000000..73b1e047485
--- /dev/null
+++ b/compiler/testData/constraintSystem/checkStatus/conflictingConstraints.constraints
@@ -0,0 +1,4 @@
+VARIABLES T
+
+T <: Int
+T >: String
diff --git a/compiler/testData/constraintSystem/checkStatus/successful.bounds b/compiler/testData/constraintSystem/checkStatus/successful.bounds
index bdc70204b1c..c1078ef1761 100644
--- a/compiler/testData/constraintSystem/checkStatus/successful.bounds
+++ b/compiler/testData/constraintSystem/checkStatus/successful.bounds
@@ -1,19 +1,21 @@
 VARIABLES T
 
-SUBTYPE T Int
-SUPERTYPE T Int
+T <: Int
+T >: Int
 
 type parameter bounds:
-T <: kotlin.Int(SPECIAL), >: kotlin.Int(SPECIAL)
+T <: Int, >: Int
+
 status:
 -hasCannotCaptureTypesError: false
 -hasConflictingConstraints: false
 -hasContradiction: false
 -hasErrorInConstrainingTypes: false
--hasTypeConstructorMismatch: false
+-hasParameterConstraintError: false
+-hasTypeInferenceIncorporationError: false
 -hasUnknownParameters: false
 -hasViolatedUpperBound: false
 -isSuccessful: true
 
 result:
-T=kotlin.Int
+T=Int
diff --git a/compiler/testData/constraintSystem/checkStatus/successful.constraints b/compiler/testData/constraintSystem/checkStatus/successful.constraints
new file mode 100644
index 00000000000..a6d9b0b7d12
--- /dev/null
+++ b/compiler/testData/constraintSystem/checkStatus/successful.constraints
@@ -0,0 +1,4 @@
+VARIABLES T
+
+T <: Int
+T >: Int
diff --git a/compiler/testData/constraintSystem/checkStatus/typeConstructorMismatch.bounds b/compiler/testData/constraintSystem/checkStatus/typeConstructorMismatch.bounds
index b53d50cc22b..99a37d6f2a9 100644
--- a/compiler/testData/constraintSystem/checkStatus/typeConstructorMismatch.bounds
+++ b/compiler/testData/constraintSystem/checkStatus/typeConstructorMismatch.bounds
@@ -1,15 +1,17 @@
 VARIABLES T
 
-SUBTYPE List<T> Int
+List<T> <: Int
 
 type parameter bounds:
 T
+
 status:
 -hasCannotCaptureTypesError: false
 -hasConflictingConstraints: false
 -hasContradiction: true
 -hasErrorInConstrainingTypes: false
--hasTypeConstructorMismatch: true
+-hasParameterConstraintError: false
+-hasTypeInferenceIncorporationError: true
 -hasUnknownParameters: true
 -hasViolatedUpperBound: false
 -isSuccessful: false
diff --git a/compiler/testData/constraintSystem/checkStatus/typeConstructorMismatch.constraints b/compiler/testData/constraintSystem/checkStatus/typeConstructorMismatch.constraints
new file mode 100644
index 00000000000..eedca733b0e
--- /dev/null
+++ b/compiler/testData/constraintSystem/checkStatus/typeConstructorMismatch.constraints
@@ -0,0 +1,3 @@
+VARIABLES T
+
+List<T> <: Int
diff --git a/compiler/testData/constraintSystem/checkStatus/unknownParameters.bounds b/compiler/testData/constraintSystem/checkStatus/unknownParameters.bounds
index f6e6b7f85d6..db3ee6b0013 100644
--- a/compiler/testData/constraintSystem/checkStatus/unknownParameters.bounds
+++ b/compiler/testData/constraintSystem/checkStatus/unknownParameters.bounds
@@ -1,15 +1,17 @@
 VARIABLES T
 
-SUBTYPE Any Any
+Any <: Any
 
 type parameter bounds:
 T
+
 status:
 -hasCannotCaptureTypesError: false
 -hasConflictingConstraints: false
 -hasContradiction: false
 -hasErrorInConstrainingTypes: false
--hasTypeConstructorMismatch: false
+-hasParameterConstraintError: false
+-hasTypeInferenceIncorporationError: false
 -hasUnknownParameters: true
 -hasViolatedUpperBound: false
 -isSuccessful: false
diff --git a/compiler/testData/constraintSystem/checkStatus/unknownParameters.constraints b/compiler/testData/constraintSystem/checkStatus/unknownParameters.constraints
new file mode 100644
index 00000000000..01d5712133b
--- /dev/null
+++ b/compiler/testData/constraintSystem/checkStatus/unknownParameters.constraints
@@ -0,0 +1,3 @@
+VARIABLES T
+
+Any <: Any
diff --git a/compiler/testData/constraintSystem/computeValues/contradiction.bounds b/compiler/testData/constraintSystem/computeValues/contradiction.bounds
index 923bf99606b..bc12fb789f0 100644
--- a/compiler/testData/constraintSystem/computeValues/contradiction.bounds
+++ b/compiler/testData/constraintSystem/computeValues/contradiction.bounds
@@ -1,16 +1,18 @@
 VARIABLES T
 
-SUBTYPE T B
-SUPERTYPE T A
+T <: B
+T >: A
 
 type parameter bounds:
-T <: B(SPECIAL), >: A(SPECIAL)
+T <: B, >: A
+
 status:
 -hasCannotCaptureTypesError: false
 -hasConflictingConstraints: true
 -hasContradiction: true
 -hasErrorInConstrainingTypes: false
--hasTypeConstructorMismatch: false
+-hasParameterConstraintError: false
+-hasTypeInferenceIncorporationError: true
 -hasUnknownParameters: false
 -hasViolatedUpperBound: false
 -isSuccessful: false
diff --git a/compiler/testData/constraintSystem/computeValues/contradiction.constraints b/compiler/testData/constraintSystem/computeValues/contradiction.constraints
new file mode 100644
index 00000000000..86de4a85dd0
--- /dev/null
+++ b/compiler/testData/constraintSystem/computeValues/contradiction.constraints
@@ -0,0 +1,4 @@
+VARIABLES T
+
+T <: B
+T >: A
diff --git a/compiler/testData/constraintSystem/computeValues/subTypeOfUpperBounds.bounds b/compiler/testData/constraintSystem/computeValues/subTypeOfUpperBounds.bounds
index a9e09d438c8..a3bfb8d58b0 100644
--- a/compiler/testData/constraintSystem/computeValues/subTypeOfUpperBounds.bounds
+++ b/compiler/testData/constraintSystem/computeValues/subTypeOfUpperBounds.bounds
@@ -1,16 +1,18 @@
 VARIABLES T
 
-SUBTYPE T A
-SUBTYPE T B
+T <: A
+T <: B
 
 type parameter bounds:
-T <: A(SPECIAL), <: B(SPECIAL)
+T <: A, <: B
+
 status:
 -hasCannotCaptureTypesError: false
 -hasConflictingConstraints: false
 -hasContradiction: false
 -hasErrorInConstrainingTypes: false
--hasTypeConstructorMismatch: false
+-hasParameterConstraintError: false
+-hasTypeInferenceIncorporationError: false
 -hasUnknownParameters: false
 -hasViolatedUpperBound: false
 -isSuccessful: true
diff --git a/compiler/testData/constraintSystem/computeValues/subTypeOfUpperBounds.constraints b/compiler/testData/constraintSystem/computeValues/subTypeOfUpperBounds.constraints
new file mode 100644
index 00000000000..9cd0d24fe2c
--- /dev/null
+++ b/compiler/testData/constraintSystem/computeValues/subTypeOfUpperBounds.constraints
@@ -0,0 +1,4 @@
+VARIABLES T
+
+T <: A
+T <: B
diff --git a/compiler/testData/constraintSystem/computeValues/superTypeOfLowerBounds1.bounds b/compiler/testData/constraintSystem/computeValues/superTypeOfLowerBounds1.bounds
index 584a66d7afb..b4285612fe6 100644
--- a/compiler/testData/constraintSystem/computeValues/superTypeOfLowerBounds1.bounds
+++ b/compiler/testData/constraintSystem/computeValues/superTypeOfLowerBounds1.bounds
@@ -1,16 +1,18 @@
 VARIABLES T
 
-SUBTYPE T A
-SUPERTYPE T C
+T <: A
+T >: C
 
 type parameter bounds:
-T <: A(SPECIAL), >: C(SPECIAL)
+T <: A, >: C
+
 status:
 -hasCannotCaptureTypesError: false
 -hasConflictingConstraints: false
 -hasContradiction: false
 -hasErrorInConstrainingTypes: false
--hasTypeConstructorMismatch: false
+-hasParameterConstraintError: false
+-hasTypeInferenceIncorporationError: false
 -hasUnknownParameters: false
 -hasViolatedUpperBound: false
 -isSuccessful: true
diff --git a/compiler/testData/constraintSystem/computeValues/superTypeOfLowerBounds1.constraints b/compiler/testData/constraintSystem/computeValues/superTypeOfLowerBounds1.constraints
new file mode 100644
index 00000000000..40d55d2f8c8
--- /dev/null
+++ b/compiler/testData/constraintSystem/computeValues/superTypeOfLowerBounds1.constraints
@@ -0,0 +1,4 @@
+VARIABLES T
+
+T <: A
+T >: C
diff --git a/compiler/testData/constraintSystem/computeValues/superTypeOfLowerBounds2.bounds b/compiler/testData/constraintSystem/computeValues/superTypeOfLowerBounds2.bounds
index 318ac21cd9b..478086db7c2 100644
--- a/compiler/testData/constraintSystem/computeValues/superTypeOfLowerBounds2.bounds
+++ b/compiler/testData/constraintSystem/computeValues/superTypeOfLowerBounds2.bounds
@@ -1,17 +1,19 @@
 VARIABLES T
 
-SUBTYPE T A
-SUPERTYPE T B
-SUPERTYPE T C
+T <: A
+T >: B
+T >: C
 
 type parameter bounds:
-T <: A(SPECIAL), >: B(SPECIAL), >: C(SPECIAL)
+T <: A, >: B, >: C
+
 status:
 -hasCannotCaptureTypesError: false
 -hasConflictingConstraints: false
 -hasContradiction: false
 -hasErrorInConstrainingTypes: false
--hasTypeConstructorMismatch: false
+-hasParameterConstraintError: false
+-hasTypeInferenceIncorporationError: false
 -hasUnknownParameters: false
 -hasViolatedUpperBound: false
 -isSuccessful: true
diff --git a/compiler/testData/constraintSystem/computeValues/superTypeOfLowerBounds2.constraints b/compiler/testData/constraintSystem/computeValues/superTypeOfLowerBounds2.constraints
new file mode 100644
index 00000000000..e1fed467904
--- /dev/null
+++ b/compiler/testData/constraintSystem/computeValues/superTypeOfLowerBounds2.constraints
@@ -0,0 +1,5 @@
+VARIABLES T
+
+T <: A
+T >: B
+T >: C
diff --git a/compiler/testData/constraintSystem/declarations.kt b/compiler/testData/constraintSystem/declarations.kt
new file mode 100644
index 00000000000..7c8614eadfa
--- /dev/null
+++ b/compiler/testData/constraintSystem/declarations.kt
@@ -0,0 +1,14 @@
+fun foo<T, P, E>() = 42
+
+interface A
+interface B : A
+interface C : B
+
+interface Consumer<in T>
+interface Producer<out T>
+
+interface My<T>
+interface Successor<T> : My<T>
+
+interface Two<T, P>
+interface Fun<in T, out R>
\ No newline at end of file
diff --git a/compiler/testData/constraintSystem/declarations/declarations.kt b/compiler/testData/constraintSystem/declarations/declarations.kt
deleted file mode 100644
index 832e99dd7f9..00000000000
--- a/compiler/testData/constraintSystem/declarations/declarations.kt
+++ /dev/null
@@ -1,10 +0,0 @@
-fun foo<T, P: T>() = 42
-
-interface A
-interface B : A
-interface C : B
-
-interface Consumer<in T>
-interface Producer<out T>
-
-interface My<T>
\ No newline at end of file
diff --git a/compiler/testData/constraintSystem/integerValueTypes/byteOverflow.bounds b/compiler/testData/constraintSystem/integerValueTypes/byteOverflow.bounds
index 94f27a74d2f..cf0ce4a09e2 100644
--- a/compiler/testData/constraintSystem/integerValueTypes/byteOverflow.bounds
+++ b/compiler/testData/constraintSystem/integerValueTypes/byteOverflow.bounds
@@ -1,16 +1,18 @@
 VARIABLES T
 
-SUPERTYPE T IntegerValueType(1000)
-SUBTYPE T Byte
+T >: IntegerValueType(1000)
+T <: Byte
 
 type parameter bounds:
-T >: IntegerValueType(1000)(SPECIAL), <: kotlin.Byte(SPECIAL)
+T >: IntegerValueType(1000), <: Byte
+
 status:
 -hasCannotCaptureTypesError: false
 -hasConflictingConstraints: true
 -hasContradiction: true
 -hasErrorInConstrainingTypes: false
--hasTypeConstructorMismatch: false
+-hasParameterConstraintError: false
+-hasTypeInferenceIncorporationError: true
 -hasUnknownParameters: false
 -hasViolatedUpperBound: false
 -isSuccessful: false
diff --git a/compiler/testData/constraintSystem/integerValueTypes/byteOverflow.constraints b/compiler/testData/constraintSystem/integerValueTypes/byteOverflow.constraints
new file mode 100644
index 00000000000..0473f499c94
--- /dev/null
+++ b/compiler/testData/constraintSystem/integerValueTypes/byteOverflow.constraints
@@ -0,0 +1,4 @@
+VARIABLES T
+
+T >: IntegerValueType(1000)
+T <: Byte
diff --git a/compiler/testData/constraintSystem/integerValueTypes/defaultLong.bounds b/compiler/testData/constraintSystem/integerValueTypes/defaultLong.bounds
index b347c499c6d..74f5472c15c 100644
--- a/compiler/testData/constraintSystem/integerValueTypes/defaultLong.bounds
+++ b/compiler/testData/constraintSystem/integerValueTypes/defaultLong.bounds
@@ -1,19 +1,21 @@
 VARIABLES T
 
-SUPERTYPE T IntegerValueType(1)
-SUPERTYPE T IntegerValueType(10000000000)
+T >: IntegerValueType(1)
+T >: IntegerValueType(10000000000)
 
 type parameter bounds:
-T >: IntegerValueType(1)(SPECIAL), >: IntegerValueType(10000000000)(SPECIAL)
+T >: IntegerValueType(1), >: IntegerValueType(10000000000)
+
 status:
 -hasCannotCaptureTypesError: false
 -hasConflictingConstraints: false
 -hasContradiction: false
 -hasErrorInConstrainingTypes: false
--hasTypeConstructorMismatch: false
+-hasParameterConstraintError: false
+-hasTypeInferenceIncorporationError: false
 -hasUnknownParameters: false
 -hasViolatedUpperBound: false
 -isSuccessful: true
 
 result:
-T=kotlin.Long
+T=Long
diff --git a/compiler/testData/constraintSystem/integerValueTypes/defaultLong.constraints b/compiler/testData/constraintSystem/integerValueTypes/defaultLong.constraints
new file mode 100644
index 00000000000..6270d70a68a
--- /dev/null
+++ b/compiler/testData/constraintSystem/integerValueTypes/defaultLong.constraints
@@ -0,0 +1,4 @@
+VARIABLES T
+
+T >: IntegerValueType(1)
+T >: IntegerValueType(10000000000)
diff --git a/compiler/testData/constraintSystem/integerValueTypes/numberAndAny.bounds b/compiler/testData/constraintSystem/integerValueTypes/numberAndAny.bounds
index adadb2fe28c..7c413e2e518 100644
--- a/compiler/testData/constraintSystem/integerValueTypes/numberAndAny.bounds
+++ b/compiler/testData/constraintSystem/integerValueTypes/numberAndAny.bounds
@@ -1,19 +1,21 @@
 VARIABLES T
 
-SUPERTYPE T IntegerValueType(1)
-SUBTYPE T Any
+T >: IntegerValueType(1)
+T <: Any
 
 type parameter bounds:
-T >: IntegerValueType(1)(SPECIAL), <: kotlin.Any(SPECIAL)
+T >: IntegerValueType(1), <: Any
+
 status:
 -hasCannotCaptureTypesError: false
 -hasConflictingConstraints: false
 -hasContradiction: false
 -hasErrorInConstrainingTypes: false
--hasTypeConstructorMismatch: false
+-hasParameterConstraintError: false
+-hasTypeInferenceIncorporationError: false
 -hasUnknownParameters: false
 -hasViolatedUpperBound: false
 -isSuccessful: true
 
 result:
-T=kotlin.Int
+T=Int
diff --git a/compiler/testData/constraintSystem/integerValueTypes/numberAndAny.constraints b/compiler/testData/constraintSystem/integerValueTypes/numberAndAny.constraints
new file mode 100644
index 00000000000..da000c8feb0
--- /dev/null
+++ b/compiler/testData/constraintSystem/integerValueTypes/numberAndAny.constraints
@@ -0,0 +1,4 @@
+VARIABLES T
+
+T >: IntegerValueType(1)
+T <: Any
diff --git a/compiler/testData/constraintSystem/integerValueTypes/numberAndString.bounds b/compiler/testData/constraintSystem/integerValueTypes/numberAndString.bounds
index fdb976e6657..2bbaa4171d7 100644
--- a/compiler/testData/constraintSystem/integerValueTypes/numberAndString.bounds
+++ b/compiler/testData/constraintSystem/integerValueTypes/numberAndString.bounds
@@ -1,19 +1,21 @@
 VARIABLES T
 
-SUPERTYPE T IntegerValueType(1)
-SUPERTYPE T String
+T >: IntegerValueType(1)
+T >: String
 
 type parameter bounds:
-T >: IntegerValueType(1)(SPECIAL), >: kotlin.String(SPECIAL)
+T >: IntegerValueType(1), >: String
+
 status:
 -hasCannotCaptureTypesError: false
 -hasConflictingConstraints: false
 -hasContradiction: false
 -hasErrorInConstrainingTypes: false
--hasTypeConstructorMismatch: false
+-hasParameterConstraintError: false
+-hasTypeInferenceIncorporationError: false
 -hasUnknownParameters: false
 -hasViolatedUpperBound: false
 -isSuccessful: true
 
 result:
-T=kotlin.Comparable<out kotlin.Any?>
+T=Comparable<out Any?>
diff --git a/compiler/testData/constraintSystem/integerValueTypes/numberAndString.constraints b/compiler/testData/constraintSystem/integerValueTypes/numberAndString.constraints
new file mode 100644
index 00000000000..9f91f37e011
--- /dev/null
+++ b/compiler/testData/constraintSystem/integerValueTypes/numberAndString.constraints
@@ -0,0 +1,4 @@
+VARIABLES T
+
+T >: IntegerValueType(1)
+T >: String
diff --git a/compiler/testData/constraintSystem/integerValueTypes/severalNumbers.bounds b/compiler/testData/constraintSystem/integerValueTypes/severalNumbers.bounds
index a42d6b14b06..c9a92d60e95 100644
--- a/compiler/testData/constraintSystem/integerValueTypes/severalNumbers.bounds
+++ b/compiler/testData/constraintSystem/integerValueTypes/severalNumbers.bounds
@@ -1,19 +1,21 @@
 VARIABLES T
 
-SUPERTYPE T IntegerValueType(1)
-SUPERTYPE T IntegerValueType(1000)
+T >: IntegerValueType(1)
+T >: IntegerValueType(1000)
 
 type parameter bounds:
-T >: IntegerValueType(1)(SPECIAL), >: IntegerValueType(1000)(SPECIAL)
+T >: IntegerValueType(1), >: IntegerValueType(1000)
+
 status:
 -hasCannotCaptureTypesError: false
 -hasConflictingConstraints: false
 -hasContradiction: false
 -hasErrorInConstrainingTypes: false
--hasTypeConstructorMismatch: false
+-hasParameterConstraintError: false
+-hasTypeInferenceIncorporationError: false
 -hasUnknownParameters: false
 -hasViolatedUpperBound: false
 -isSuccessful: true
 
 result:
-T=kotlin.Int
+T=Int
diff --git a/compiler/testData/constraintSystem/integerValueTypes/severalNumbers.constraints b/compiler/testData/constraintSystem/integerValueTypes/severalNumbers.constraints
new file mode 100644
index 00000000000..bafce1a8007
--- /dev/null
+++ b/compiler/testData/constraintSystem/integerValueTypes/severalNumbers.constraints
@@ -0,0 +1,4 @@
+VARIABLES T
+
+T >: IntegerValueType(1)
+T >: IntegerValueType(1000)
diff --git a/compiler/testData/constraintSystem/integerValueTypes/simpleByte.bounds b/compiler/testData/constraintSystem/integerValueTypes/simpleByte.bounds
index cc023a871ae..e6dd0530abd 100644
--- a/compiler/testData/constraintSystem/integerValueTypes/simpleByte.bounds
+++ b/compiler/testData/constraintSystem/integerValueTypes/simpleByte.bounds
@@ -1,19 +1,21 @@
 VARIABLES T
 
-SUPERTYPE T IntegerValueType(1)
-SUBTYPE T Byte
+T >: IntegerValueType(1)
+T <: Byte
 
 type parameter bounds:
-T >: IntegerValueType(1)(SPECIAL), <: kotlin.Byte(SPECIAL)
+T >: IntegerValueType(1), <: Byte
+
 status:
 -hasCannotCaptureTypesError: false
 -hasConflictingConstraints: false
 -hasContradiction: false
 -hasErrorInConstrainingTypes: false
--hasTypeConstructorMismatch: false
+-hasParameterConstraintError: false
+-hasTypeInferenceIncorporationError: false
 -hasUnknownParameters: false
 -hasViolatedUpperBound: false
 -isSuccessful: true
 
 result:
-T=kotlin.Byte
+T=Byte
diff --git a/compiler/testData/constraintSystem/integerValueTypes/simpleByte.constraints b/compiler/testData/constraintSystem/integerValueTypes/simpleByte.constraints
new file mode 100644
index 00000000000..9da0fc9e2c2
--- /dev/null
+++ b/compiler/testData/constraintSystem/integerValueTypes/simpleByte.constraints
@@ -0,0 +1,4 @@
+VARIABLES T
+
+T >: IntegerValueType(1)
+T <: Byte
diff --git a/compiler/testData/constraintSystem/integerValueTypes/simpleInt.bounds b/compiler/testData/constraintSystem/integerValueTypes/simpleInt.bounds
index a6961daeb68..e5bfdb6bba6 100644
--- a/compiler/testData/constraintSystem/integerValueTypes/simpleInt.bounds
+++ b/compiler/testData/constraintSystem/integerValueTypes/simpleInt.bounds
@@ -1,18 +1,20 @@
 VARIABLES T
 
-SUPERTYPE T IntegerValueType(1)
+T >: IntegerValueType(1)
 
 type parameter bounds:
-T >: IntegerValueType(1)(SPECIAL)
+T >: IntegerValueType(1)
+
 status:
 -hasCannotCaptureTypesError: false
 -hasConflictingConstraints: false
 -hasContradiction: false
 -hasErrorInConstrainingTypes: false
--hasTypeConstructorMismatch: false
+-hasParameterConstraintError: false
+-hasTypeInferenceIncorporationError: false
 -hasUnknownParameters: false
 -hasViolatedUpperBound: false
 -isSuccessful: true
 
 result:
-T=kotlin.Int
+T=Int
diff --git a/compiler/testData/constraintSystem/integerValueTypes/simpleInt.constraints b/compiler/testData/constraintSystem/integerValueTypes/simpleInt.constraints
new file mode 100644
index 00000000000..aa8f78b19f4
--- /dev/null
+++ b/compiler/testData/constraintSystem/integerValueTypes/simpleInt.constraints
@@ -0,0 +1,3 @@
+VARIABLES T
+
+T >: IntegerValueType(1)
diff --git a/compiler/testData/constraintSystem/integerValueTypes/simpleShort.bounds b/compiler/testData/constraintSystem/integerValueTypes/simpleShort.bounds
index 04cdd23bcae..83c7f50083d 100644
--- a/compiler/testData/constraintSystem/integerValueTypes/simpleShort.bounds
+++ b/compiler/testData/constraintSystem/integerValueTypes/simpleShort.bounds
@@ -1,19 +1,21 @@
 VARIABLES T
 
-SUPERTYPE T IntegerValueType(1)
-SUBTYPE T Short
+T >: IntegerValueType(1)
+T <: Short
 
 type parameter bounds:
-T >: IntegerValueType(1)(SPECIAL), <: kotlin.Short(SPECIAL)
+T >: IntegerValueType(1), <: Short
+
 status:
 -hasCannotCaptureTypesError: false
 -hasConflictingConstraints: false
 -hasContradiction: false
 -hasErrorInConstrainingTypes: false
--hasTypeConstructorMismatch: false
+-hasParameterConstraintError: false
+-hasTypeInferenceIncorporationError: false
 -hasUnknownParameters: false
 -hasViolatedUpperBound: false
 -isSuccessful: true
 
 result:
-T=kotlin.Short
+T=Short
diff --git a/compiler/testData/constraintSystem/integerValueTypes/simpleShort.constraints b/compiler/testData/constraintSystem/integerValueTypes/simpleShort.constraints
new file mode 100644
index 00000000000..a3ba83baf5d
--- /dev/null
+++ b/compiler/testData/constraintSystem/integerValueTypes/simpleShort.constraints
@@ -0,0 +1,4 @@
+VARIABLES T
+
+T >: IntegerValueType(1)
+T <: Short
diff --git a/compiler/testData/constraintSystem/severalVariables/direct/contravariant/varEqDepEq.bounds b/compiler/testData/constraintSystem/severalVariables/direct/contravariant/varEqDepEq.bounds
new file mode 100644
index 00000000000..93379428dad
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/direct/contravariant/varEqDepEq.bounds
@@ -0,0 +1,23 @@
+VARIABLES T P
+
+T := Int
+P := Consumer<T>
+
+type parameter bounds:
+T := Int
+P := Consumer<T>*, := Consumer<Int>
+
+status:
+-hasCannotCaptureTypesError: false
+-hasConflictingConstraints: false
+-hasContradiction: false
+-hasErrorInConstrainingTypes: false
+-hasParameterConstraintError: false
+-hasTypeInferenceIncorporationError: false
+-hasUnknownParameters: false
+-hasViolatedUpperBound: false
+-isSuccessful: true
+
+result:
+T=Int
+P=Consumer<Int>
diff --git a/compiler/testData/constraintSystem/severalVariables/direct/contravariant/varEqDepEq.constraints b/compiler/testData/constraintSystem/severalVariables/direct/contravariant/varEqDepEq.constraints
new file mode 100644
index 00000000000..e4e3eb8e1b0
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/direct/contravariant/varEqDepEq.constraints
@@ -0,0 +1,4 @@
+VARIABLES T P
+
+T := Int
+P := Consumer<T>
diff --git a/compiler/testData/constraintSystem/severalVariables/direct/contravariant/varEqDepSub.bounds b/compiler/testData/constraintSystem/severalVariables/direct/contravariant/varEqDepSub.bounds
new file mode 100644
index 00000000000..52adc70cbf3
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/direct/contravariant/varEqDepSub.bounds
@@ -0,0 +1,23 @@
+VARIABLES T P
+
+T := Int
+P <: Consumer<T>
+
+type parameter bounds:
+T := Int
+P <: Consumer<T>*, <: Consumer<Int>
+
+status:
+-hasCannotCaptureTypesError: false
+-hasConflictingConstraints: false
+-hasContradiction: false
+-hasErrorInConstrainingTypes: false
+-hasParameterConstraintError: false
+-hasTypeInferenceIncorporationError: false
+-hasUnknownParameters: false
+-hasViolatedUpperBound: false
+-isSuccessful: true
+
+result:
+T=Int
+P=Consumer<Int>
diff --git a/compiler/testData/constraintSystem/severalVariables/direct/contravariant/varEqDepSub.constraints b/compiler/testData/constraintSystem/severalVariables/direct/contravariant/varEqDepSub.constraints
new file mode 100644
index 00000000000..67567cd2dee
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/direct/contravariant/varEqDepSub.constraints
@@ -0,0 +1,4 @@
+VARIABLES T P
+
+T := Int
+P <: Consumer<T>
diff --git a/compiler/testData/constraintSystem/severalVariables/direct/contravariant/varEqDepSuper.bounds b/compiler/testData/constraintSystem/severalVariables/direct/contravariant/varEqDepSuper.bounds
new file mode 100644
index 00000000000..2a6af20e622
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/direct/contravariant/varEqDepSuper.bounds
@@ -0,0 +1,23 @@
+VARIABLES T P
+
+T := Int
+P >: Consumer<T>
+
+type parameter bounds:
+T := Int
+P >: Consumer<T>*, >: Consumer<Int>
+
+status:
+-hasCannotCaptureTypesError: false
+-hasConflictingConstraints: false
+-hasContradiction: false
+-hasErrorInConstrainingTypes: false
+-hasParameterConstraintError: false
+-hasTypeInferenceIncorporationError: false
+-hasUnknownParameters: false
+-hasViolatedUpperBound: false
+-isSuccessful: true
+
+result:
+T=Int
+P=Consumer<Int>
diff --git a/compiler/testData/constraintSystem/severalVariables/direct/contravariant/varEqDepSuper.constraints b/compiler/testData/constraintSystem/severalVariables/direct/contravariant/varEqDepSuper.constraints
new file mode 100644
index 00000000000..52d5a35b1e8
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/direct/contravariant/varEqDepSuper.constraints
@@ -0,0 +1,4 @@
+VARIABLES T P
+
+T := Int
+P >: Consumer<T>
diff --git a/compiler/testData/constraintSystem/severalVariables/direct/contravariant/varSubDepEq.bounds b/compiler/testData/constraintSystem/severalVariables/direct/contravariant/varSubDepEq.bounds
new file mode 100644
index 00000000000..3f40aac7c0d
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/direct/contravariant/varSubDepEq.bounds
@@ -0,0 +1,23 @@
+VARIABLES T P
+
+T <: Int
+P := Consumer<T>
+
+type parameter bounds:
+T <: Int
+P := Consumer<T>*, >: Consumer<Int>
+
+status:
+-hasCannotCaptureTypesError: false
+-hasConflictingConstraints: false
+-hasContradiction: false
+-hasErrorInConstrainingTypes: false
+-hasParameterConstraintError: false
+-hasTypeInferenceIncorporationError: false
+-hasUnknownParameters: false
+-hasViolatedUpperBound: false
+-isSuccessful: true
+
+result:
+T=Int
+P=Consumer<Int>
diff --git a/compiler/testData/constraintSystem/severalVariables/direct/contravariant/varSubDepEq.constraints b/compiler/testData/constraintSystem/severalVariables/direct/contravariant/varSubDepEq.constraints
new file mode 100644
index 00000000000..53d27506f5e
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/direct/contravariant/varSubDepEq.constraints
@@ -0,0 +1,4 @@
+VARIABLES T P
+
+T <: Int
+P := Consumer<T>
diff --git a/compiler/testData/constraintSystem/severalVariables/direct/contravariant/varSubDepSub.bounds b/compiler/testData/constraintSystem/severalVariables/direct/contravariant/varSubDepSub.bounds
new file mode 100644
index 00000000000..eb2067accb7
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/direct/contravariant/varSubDepSub.bounds
@@ -0,0 +1,23 @@
+VARIABLES T P
+
+T <: Int
+P <: Consumer<T>
+
+type parameter bounds:
+T <: Int
+P <: Consumer<T>*
+
+status:
+-hasCannotCaptureTypesError: false
+-hasConflictingConstraints: false
+-hasContradiction: false
+-hasErrorInConstrainingTypes: false
+-hasParameterConstraintError: false
+-hasTypeInferenceIncorporationError: false
+-hasUnknownParameters: true
+-hasViolatedUpperBound: false
+-isSuccessful: false
+
+result:
+T=Int
+P=???
diff --git a/compiler/testData/constraintSystem/severalVariables/direct/contravariant/varSubDepSub.constraints b/compiler/testData/constraintSystem/severalVariables/direct/contravariant/varSubDepSub.constraints
new file mode 100644
index 00000000000..dfa315bf976
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/direct/contravariant/varSubDepSub.constraints
@@ -0,0 +1,4 @@
+VARIABLES T P
+
+T <: Int
+P <: Consumer<T>
diff --git a/compiler/testData/constraintSystem/severalVariables/direct/contravariant/varSubDepSuper.bounds b/compiler/testData/constraintSystem/severalVariables/direct/contravariant/varSubDepSuper.bounds
new file mode 100644
index 00000000000..93f9afb9610
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/direct/contravariant/varSubDepSuper.bounds
@@ -0,0 +1,23 @@
+VARIABLES T P
+
+T <: Int
+P >: Consumer<T>
+
+type parameter bounds:
+T <: Int
+P >: Consumer<T>*, >: Consumer<Int>
+
+status:
+-hasCannotCaptureTypesError: false
+-hasConflictingConstraints: false
+-hasContradiction: false
+-hasErrorInConstrainingTypes: false
+-hasParameterConstraintError: false
+-hasTypeInferenceIncorporationError: false
+-hasUnknownParameters: false
+-hasViolatedUpperBound: false
+-isSuccessful: true
+
+result:
+T=Int
+P=Consumer<Int>
diff --git a/compiler/testData/constraintSystem/severalVariables/direct/contravariant/varSubDepSuper.constraints b/compiler/testData/constraintSystem/severalVariables/direct/contravariant/varSubDepSuper.constraints
new file mode 100644
index 00000000000..fa629778192
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/direct/contravariant/varSubDepSuper.constraints
@@ -0,0 +1,4 @@
+VARIABLES T P
+
+T <: Int
+P >: Consumer<T>
diff --git a/compiler/testData/constraintSystem/severalVariables/direct/contravariant/varSuperDepEq.bounds b/compiler/testData/constraintSystem/severalVariables/direct/contravariant/varSuperDepEq.bounds
new file mode 100644
index 00000000000..a737ec275dd
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/direct/contravariant/varSuperDepEq.bounds
@@ -0,0 +1,23 @@
+VARIABLES T P
+
+T >: Int
+P := Consumer<T>
+
+type parameter bounds:
+T >: Int
+P := Consumer<T>*, <: Consumer<Int>
+
+status:
+-hasCannotCaptureTypesError: false
+-hasConflictingConstraints: false
+-hasContradiction: false
+-hasErrorInConstrainingTypes: false
+-hasParameterConstraintError: false
+-hasTypeInferenceIncorporationError: false
+-hasUnknownParameters: false
+-hasViolatedUpperBound: false
+-isSuccessful: true
+
+result:
+T=Int
+P=Consumer<Int>
diff --git a/compiler/testData/constraintSystem/severalVariables/direct/contravariant/varSuperDepEq.constraints b/compiler/testData/constraintSystem/severalVariables/direct/contravariant/varSuperDepEq.constraints
new file mode 100644
index 00000000000..0549095d95c
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/direct/contravariant/varSuperDepEq.constraints
@@ -0,0 +1,4 @@
+VARIABLES T P
+
+T >: Int
+P := Consumer<T>
diff --git a/compiler/testData/constraintSystem/severalVariables/direct/contravariant/varSuperDepSub.bounds b/compiler/testData/constraintSystem/severalVariables/direct/contravariant/varSuperDepSub.bounds
new file mode 100644
index 00000000000..732e2825709
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/direct/contravariant/varSuperDepSub.bounds
@@ -0,0 +1,23 @@
+VARIABLES T P
+
+T >: Int
+P <: Consumer<T>
+
+type parameter bounds:
+T >: Int
+P <: Consumer<T>*, <: Consumer<Int>
+
+status:
+-hasCannotCaptureTypesError: false
+-hasConflictingConstraints: false
+-hasContradiction: false
+-hasErrorInConstrainingTypes: false
+-hasParameterConstraintError: false
+-hasTypeInferenceIncorporationError: false
+-hasUnknownParameters: false
+-hasViolatedUpperBound: false
+-isSuccessful: true
+
+result:
+T=Int
+P=Consumer<Int>
diff --git a/compiler/testData/constraintSystem/severalVariables/direct/contravariant/varSuperDepSub.constraints b/compiler/testData/constraintSystem/severalVariables/direct/contravariant/varSuperDepSub.constraints
new file mode 100644
index 00000000000..eafcc55663e
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/direct/contravariant/varSuperDepSub.constraints
@@ -0,0 +1,4 @@
+VARIABLES T P
+
+T >: Int
+P <: Consumer<T>
diff --git a/compiler/testData/constraintSystem/severalVariables/direct/contravariant/varSuperDepSuper.bounds b/compiler/testData/constraintSystem/severalVariables/direct/contravariant/varSuperDepSuper.bounds
new file mode 100644
index 00000000000..53e2d9a1d0d
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/direct/contravariant/varSuperDepSuper.bounds
@@ -0,0 +1,23 @@
+VARIABLES T P
+
+T >: Int
+P >: Consumer<T>
+
+type parameter bounds:
+T >: Int
+P >: Consumer<T>*
+
+status:
+-hasCannotCaptureTypesError: false
+-hasConflictingConstraints: false
+-hasContradiction: false
+-hasErrorInConstrainingTypes: false
+-hasParameterConstraintError: false
+-hasTypeInferenceIncorporationError: false
+-hasUnknownParameters: true
+-hasViolatedUpperBound: false
+-isSuccessful: false
+
+result:
+T=Int
+P=???
diff --git a/compiler/testData/constraintSystem/severalVariables/direct/contravariant/varSuperDepSuper.constraints b/compiler/testData/constraintSystem/severalVariables/direct/contravariant/varSuperDepSuper.constraints
new file mode 100644
index 00000000000..3f9d691fab5
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/direct/contravariant/varSuperDepSuper.constraints
@@ -0,0 +1,4 @@
+VARIABLES T P
+
+T >: Int
+P >: Consumer<T>
diff --git a/compiler/testData/constraintSystem/severalVariables/direct/covariant/varEqDepEq.bounds b/compiler/testData/constraintSystem/severalVariables/direct/covariant/varEqDepEq.bounds
new file mode 100644
index 00000000000..a84ceea90b3
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/direct/covariant/varEqDepEq.bounds
@@ -0,0 +1,23 @@
+VARIABLES T P
+
+T := Int
+P := Producer<T>
+
+type parameter bounds:
+T := Int
+P := Producer<T>*, := Producer<Int>
+
+status:
+-hasCannotCaptureTypesError: false
+-hasConflictingConstraints: false
+-hasContradiction: false
+-hasErrorInConstrainingTypes: false
+-hasParameterConstraintError: false
+-hasTypeInferenceIncorporationError: false
+-hasUnknownParameters: false
+-hasViolatedUpperBound: false
+-isSuccessful: true
+
+result:
+T=Int
+P=Producer<Int>
diff --git a/compiler/testData/constraintSystem/severalVariables/direct/covariant/varEqDepEq.constraints b/compiler/testData/constraintSystem/severalVariables/direct/covariant/varEqDepEq.constraints
new file mode 100644
index 00000000000..b8682d147da
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/direct/covariant/varEqDepEq.constraints
@@ -0,0 +1,4 @@
+VARIABLES T P
+
+T := Int
+P := Producer<T>
diff --git a/compiler/testData/constraintSystem/severalVariables/direct/covariant/varEqDepSub.bounds b/compiler/testData/constraintSystem/severalVariables/direct/covariant/varEqDepSub.bounds
new file mode 100644
index 00000000000..333ccca8bef
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/direct/covariant/varEqDepSub.bounds
@@ -0,0 +1,23 @@
+VARIABLES T P
+
+T := Int
+P <: Producer<T>
+
+type parameter bounds:
+T := Int
+P <: Producer<T>*, <: Producer<Int>
+
+status:
+-hasCannotCaptureTypesError: false
+-hasConflictingConstraints: false
+-hasContradiction: false
+-hasErrorInConstrainingTypes: false
+-hasParameterConstraintError: false
+-hasTypeInferenceIncorporationError: false
+-hasUnknownParameters: false
+-hasViolatedUpperBound: false
+-isSuccessful: true
+
+result:
+T=Int
+P=Producer<Int>
diff --git a/compiler/testData/constraintSystem/severalVariables/direct/covariant/varEqDepSub.constraints b/compiler/testData/constraintSystem/severalVariables/direct/covariant/varEqDepSub.constraints
new file mode 100644
index 00000000000..35965dee809
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/direct/covariant/varEqDepSub.constraints
@@ -0,0 +1,4 @@
+VARIABLES T P
+
+T := Int
+P <: Producer<T>
diff --git a/compiler/testData/constraintSystem/severalVariables/direct/covariant/varEqDepSuper.bounds b/compiler/testData/constraintSystem/severalVariables/direct/covariant/varEqDepSuper.bounds
new file mode 100644
index 00000000000..cb9dc556a9a
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/direct/covariant/varEqDepSuper.bounds
@@ -0,0 +1,23 @@
+VARIABLES T P
+
+T := Int
+P >: Producer<T>
+
+type parameter bounds:
+T := Int
+P >: Producer<T>*, >: Producer<Int>
+
+status:
+-hasCannotCaptureTypesError: false
+-hasConflictingConstraints: false
+-hasContradiction: false
+-hasErrorInConstrainingTypes: false
+-hasParameterConstraintError: false
+-hasTypeInferenceIncorporationError: false
+-hasUnknownParameters: false
+-hasViolatedUpperBound: false
+-isSuccessful: true
+
+result:
+T=Int
+P=Producer<Int>
diff --git a/compiler/testData/constraintSystem/severalVariables/direct/covariant/varEqDepSuper.constraints b/compiler/testData/constraintSystem/severalVariables/direct/covariant/varEqDepSuper.constraints
new file mode 100644
index 00000000000..dc9922a8970
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/direct/covariant/varEqDepSuper.constraints
@@ -0,0 +1,4 @@
+VARIABLES T P
+
+T := Int
+P >: Producer<T>
diff --git a/compiler/testData/constraintSystem/severalVariables/direct/covariant/varSubDepEq.bounds b/compiler/testData/constraintSystem/severalVariables/direct/covariant/varSubDepEq.bounds
new file mode 100644
index 00000000000..158b947451b
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/direct/covariant/varSubDepEq.bounds
@@ -0,0 +1,23 @@
+VARIABLES T P
+
+T <: Int
+P := Producer<T>
+
+type parameter bounds:
+T <: Int
+P := Producer<T>*, <: Producer<Int>
+
+status:
+-hasCannotCaptureTypesError: false
+-hasConflictingConstraints: false
+-hasContradiction: false
+-hasErrorInConstrainingTypes: false
+-hasParameterConstraintError: false
+-hasTypeInferenceIncorporationError: false
+-hasUnknownParameters: false
+-hasViolatedUpperBound: false
+-isSuccessful: true
+
+result:
+T=Int
+P=Producer<Int>
diff --git a/compiler/testData/constraintSystem/severalVariables/direct/covariant/varSubDepEq.constraints b/compiler/testData/constraintSystem/severalVariables/direct/covariant/varSubDepEq.constraints
new file mode 100644
index 00000000000..e396ec93736
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/direct/covariant/varSubDepEq.constraints
@@ -0,0 +1,4 @@
+VARIABLES T P
+
+T <: Int
+P := Producer<T>
diff --git a/compiler/testData/constraintSystem/severalVariables/direct/covariant/varSubDepSub.bounds b/compiler/testData/constraintSystem/severalVariables/direct/covariant/varSubDepSub.bounds
new file mode 100644
index 00000000000..d06e4aabe62
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/direct/covariant/varSubDepSub.bounds
@@ -0,0 +1,23 @@
+VARIABLES T P
+
+T <: Int
+P <: Producer<T>
+
+type parameter bounds:
+T <: Int
+P <: Producer<T>*, <: Producer<Int>
+
+status:
+-hasCannotCaptureTypesError: false
+-hasConflictingConstraints: false
+-hasContradiction: false
+-hasErrorInConstrainingTypes: false
+-hasParameterConstraintError: false
+-hasTypeInferenceIncorporationError: false
+-hasUnknownParameters: false
+-hasViolatedUpperBound: false
+-isSuccessful: true
+
+result:
+T=Int
+P=Producer<Int>
diff --git a/compiler/testData/constraintSystem/severalVariables/direct/covariant/varSubDepSub.constraints b/compiler/testData/constraintSystem/severalVariables/direct/covariant/varSubDepSub.constraints
new file mode 100644
index 00000000000..591c1e73a05
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/direct/covariant/varSubDepSub.constraints
@@ -0,0 +1,4 @@
+VARIABLES T P
+
+T <: Int
+P <: Producer<T>
diff --git a/compiler/testData/constraintSystem/severalVariables/direct/covariant/varSubDepSuper.bounds b/compiler/testData/constraintSystem/severalVariables/direct/covariant/varSubDepSuper.bounds
new file mode 100644
index 00000000000..0cfe13d7fe4
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/direct/covariant/varSubDepSuper.bounds
@@ -0,0 +1,23 @@
+VARIABLES T P
+
+T <: Int
+P >: Producer<T>
+
+type parameter bounds:
+T <: Int
+P >: Producer<T>*
+
+status:
+-hasCannotCaptureTypesError: false
+-hasConflictingConstraints: false
+-hasContradiction: false
+-hasErrorInConstrainingTypes: false
+-hasParameterConstraintError: false
+-hasTypeInferenceIncorporationError: false
+-hasUnknownParameters: true
+-hasViolatedUpperBound: false
+-isSuccessful: false
+
+result:
+T=Int
+P=???
diff --git a/compiler/testData/constraintSystem/severalVariables/direct/covariant/varSubDepSuper.constraints b/compiler/testData/constraintSystem/severalVariables/direct/covariant/varSubDepSuper.constraints
new file mode 100644
index 00000000000..f5afe6e411d
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/direct/covariant/varSubDepSuper.constraints
@@ -0,0 +1,4 @@
+VARIABLES T P
+
+T <: Int
+P >: Producer<T>
diff --git a/compiler/testData/constraintSystem/severalVariables/direct/covariant/varSuperDepEq.bounds b/compiler/testData/constraintSystem/severalVariables/direct/covariant/varSuperDepEq.bounds
new file mode 100644
index 00000000000..58cd194a3a8
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/direct/covariant/varSuperDepEq.bounds
@@ -0,0 +1,23 @@
+VARIABLES T P
+
+T >: Int
+P := Producer<T>
+
+type parameter bounds:
+T >: Int
+P := Producer<T>*, >: Producer<Int>
+
+status:
+-hasCannotCaptureTypesError: false
+-hasConflictingConstraints: false
+-hasContradiction: false
+-hasErrorInConstrainingTypes: false
+-hasParameterConstraintError: false
+-hasTypeInferenceIncorporationError: false
+-hasUnknownParameters: false
+-hasViolatedUpperBound: false
+-isSuccessful: true
+
+result:
+T=Int
+P=Producer<Int>
diff --git a/compiler/testData/constraintSystem/severalVariables/direct/covariant/varSuperDepEq.constraints b/compiler/testData/constraintSystem/severalVariables/direct/covariant/varSuperDepEq.constraints
new file mode 100644
index 00000000000..80c0c77152d
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/direct/covariant/varSuperDepEq.constraints
@@ -0,0 +1,4 @@
+VARIABLES T P
+
+T >: Int
+P := Producer<T>
diff --git a/compiler/testData/constraintSystem/severalVariables/direct/covariant/varSuperDepSub.bounds b/compiler/testData/constraintSystem/severalVariables/direct/covariant/varSuperDepSub.bounds
new file mode 100644
index 00000000000..012c754855b
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/direct/covariant/varSuperDepSub.bounds
@@ -0,0 +1,23 @@
+VARIABLES T P
+
+T >: Int
+P <: Producer<T>
+
+type parameter bounds:
+T >: Int
+P <: Producer<T>*
+
+status:
+-hasCannotCaptureTypesError: false
+-hasConflictingConstraints: false
+-hasContradiction: false
+-hasErrorInConstrainingTypes: false
+-hasParameterConstraintError: false
+-hasTypeInferenceIncorporationError: false
+-hasUnknownParameters: true
+-hasViolatedUpperBound: false
+-isSuccessful: false
+
+result:
+T=Int
+P=???
diff --git a/compiler/testData/constraintSystem/severalVariables/direct/covariant/varSuperDepSub.constraints b/compiler/testData/constraintSystem/severalVariables/direct/covariant/varSuperDepSub.constraints
new file mode 100644
index 00000000000..d6697a53b90
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/direct/covariant/varSuperDepSub.constraints
@@ -0,0 +1,4 @@
+VARIABLES T P
+
+T >: Int
+P <: Producer<T>
diff --git a/compiler/testData/constraintSystem/severalVariables/direct/covariant/varSuperDepSuper.bounds b/compiler/testData/constraintSystem/severalVariables/direct/covariant/varSuperDepSuper.bounds
new file mode 100644
index 00000000000..7fcc24506eb
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/direct/covariant/varSuperDepSuper.bounds
@@ -0,0 +1,23 @@
+VARIABLES T P
+
+T >: Int
+P >: Producer<T>
+
+type parameter bounds:
+T >: Int
+P >: Producer<T>*, >: Producer<Int>
+
+status:
+-hasCannotCaptureTypesError: false
+-hasConflictingConstraints: false
+-hasContradiction: false
+-hasErrorInConstrainingTypes: false
+-hasParameterConstraintError: false
+-hasTypeInferenceIncorporationError: false
+-hasUnknownParameters: false
+-hasViolatedUpperBound: false
+-isSuccessful: true
+
+result:
+T=Int
+P=Producer<Int>
diff --git a/compiler/testData/constraintSystem/severalVariables/direct/covariant/varSuperDepSuper.constraints b/compiler/testData/constraintSystem/severalVariables/direct/covariant/varSuperDepSuper.constraints
new file mode 100644
index 00000000000..b2345b38016
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/direct/covariant/varSuperDepSuper.constraints
@@ -0,0 +1,4 @@
+VARIABLES T P
+
+T >: Int
+P >: Producer<T>
diff --git a/compiler/testData/constraintSystem/severalVariables/direct/invariant/varEqDepEq.bounds b/compiler/testData/constraintSystem/severalVariables/direct/invariant/varEqDepEq.bounds
new file mode 100644
index 00000000000..605be5c1245
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/direct/invariant/varEqDepEq.bounds
@@ -0,0 +1,23 @@
+VARIABLES T P
+
+T := Int
+P := My<T>
+
+type parameter bounds:
+T := Int
+P := My<T>*, := My<Int>
+
+status:
+-hasCannotCaptureTypesError: false
+-hasConflictingConstraints: false
+-hasContradiction: false
+-hasErrorInConstrainingTypes: false
+-hasParameterConstraintError: false
+-hasTypeInferenceIncorporationError: false
+-hasUnknownParameters: false
+-hasViolatedUpperBound: false
+-isSuccessful: true
+
+result:
+T=Int
+P=My<Int>
diff --git a/compiler/testData/constraintSystem/severalVariables/direct/invariant/varEqDepEq.constraints b/compiler/testData/constraintSystem/severalVariables/direct/invariant/varEqDepEq.constraints
new file mode 100644
index 00000000000..8dbe999f027
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/direct/invariant/varEqDepEq.constraints
@@ -0,0 +1,4 @@
+VARIABLES T P
+
+T := Int
+P := My<T>
diff --git a/compiler/testData/constraintSystem/severalVariables/direct/invariant/varEqDepSub.bounds b/compiler/testData/constraintSystem/severalVariables/direct/invariant/varEqDepSub.bounds
new file mode 100644
index 00000000000..4db5d355c22
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/direct/invariant/varEqDepSub.bounds
@@ -0,0 +1,23 @@
+VARIABLES T P
+
+T := Int
+P <: My<T>
+
+type parameter bounds:
+T := Int
+P <: My<T>*, <: My<Int>
+
+status:
+-hasCannotCaptureTypesError: false
+-hasConflictingConstraints: false
+-hasContradiction: false
+-hasErrorInConstrainingTypes: false
+-hasParameterConstraintError: false
+-hasTypeInferenceIncorporationError: false
+-hasUnknownParameters: false
+-hasViolatedUpperBound: false
+-isSuccessful: true
+
+result:
+T=Int
+P=My<Int>
diff --git a/compiler/testData/constraintSystem/severalVariables/direct/invariant/varEqDepSub.constraints b/compiler/testData/constraintSystem/severalVariables/direct/invariant/varEqDepSub.constraints
new file mode 100644
index 00000000000..3d7c94d3f01
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/direct/invariant/varEqDepSub.constraints
@@ -0,0 +1,4 @@
+VARIABLES T P
+
+T := Int
+P <: My<T>
diff --git a/compiler/testData/constraintSystem/severalVariables/direct/invariant/varEqDepSuper.bounds b/compiler/testData/constraintSystem/severalVariables/direct/invariant/varEqDepSuper.bounds
new file mode 100644
index 00000000000..cb02905c3de
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/direct/invariant/varEqDepSuper.bounds
@@ -0,0 +1,23 @@
+VARIABLES T P
+
+T := Int
+P >: My<T>
+
+type parameter bounds:
+T := Int
+P >: My<T>*, >: My<Int>
+
+status:
+-hasCannotCaptureTypesError: false
+-hasConflictingConstraints: false
+-hasContradiction: false
+-hasErrorInConstrainingTypes: false
+-hasParameterConstraintError: false
+-hasTypeInferenceIncorporationError: false
+-hasUnknownParameters: false
+-hasViolatedUpperBound: false
+-isSuccessful: true
+
+result:
+T=Int
+P=My<Int>
diff --git a/compiler/testData/constraintSystem/severalVariables/direct/invariant/varEqDepSuper.constraints b/compiler/testData/constraintSystem/severalVariables/direct/invariant/varEqDepSuper.constraints
new file mode 100644
index 00000000000..ce2fae0e68e
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/direct/invariant/varEqDepSuper.constraints
@@ -0,0 +1,4 @@
+VARIABLES T P
+
+T := Int
+P >: My<T>
diff --git a/compiler/testData/constraintSystem/severalVariables/direct/invariant/varSubDepEq.bounds b/compiler/testData/constraintSystem/severalVariables/direct/invariant/varSubDepEq.bounds
new file mode 100644
index 00000000000..ce9e75b129d
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/direct/invariant/varSubDepEq.bounds
@@ -0,0 +1,23 @@
+VARIABLES T P
+
+T <: Int
+P := My<T>
+
+type parameter bounds:
+T <: Int
+P := My<T>*
+
+status:
+-hasCannotCaptureTypesError: false
+-hasConflictingConstraints: false
+-hasContradiction: true
+-hasErrorInConstrainingTypes: false
+-hasParameterConstraintError: false
+-hasTypeInferenceIncorporationError: true
+-hasUnknownParameters: true
+-hasViolatedUpperBound: false
+-isSuccessful: false
+
+result:
+T=Int
+P=???
diff --git a/compiler/testData/constraintSystem/severalVariables/direct/invariant/varSubDepEq.constraints b/compiler/testData/constraintSystem/severalVariables/direct/invariant/varSubDepEq.constraints
new file mode 100644
index 00000000000..07b20eef913
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/direct/invariant/varSubDepEq.constraints
@@ -0,0 +1,4 @@
+VARIABLES T P
+
+T <: Int
+P := My<T>
diff --git a/compiler/testData/constraintSystem/severalVariables/direct/invariant/varSubDepSub.bounds b/compiler/testData/constraintSystem/severalVariables/direct/invariant/varSubDepSub.bounds
new file mode 100644
index 00000000000..772a83b45a2
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/direct/invariant/varSubDepSub.bounds
@@ -0,0 +1,23 @@
+VARIABLES T P
+
+T <: Int
+P <: My<T>
+
+type parameter bounds:
+T <: Int
+P <: My<T>*
+
+status:
+-hasCannotCaptureTypesError: false
+-hasConflictingConstraints: false
+-hasContradiction: false
+-hasErrorInConstrainingTypes: false
+-hasParameterConstraintError: false
+-hasTypeInferenceIncorporationError: false
+-hasUnknownParameters: true
+-hasViolatedUpperBound: false
+-isSuccessful: false
+
+result:
+T=Int
+P=???
diff --git a/compiler/testData/constraintSystem/severalVariables/direct/invariant/varSubDepSub.constraints b/compiler/testData/constraintSystem/severalVariables/direct/invariant/varSubDepSub.constraints
new file mode 100644
index 00000000000..3e58fb5b2a1
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/direct/invariant/varSubDepSub.constraints
@@ -0,0 +1,4 @@
+VARIABLES T P
+
+T <: Int
+P <: My<T>
diff --git a/compiler/testData/constraintSystem/severalVariables/direct/invariant/varSubDepSuper.bounds b/compiler/testData/constraintSystem/severalVariables/direct/invariant/varSubDepSuper.bounds
new file mode 100644
index 00000000000..57d3219b315
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/direct/invariant/varSubDepSuper.bounds
@@ -0,0 +1,23 @@
+VARIABLES T P
+
+T <: Int
+P >: My<T>
+
+type parameter bounds:
+T <: Int
+P >: My<T>*
+
+status:
+-hasCannotCaptureTypesError: false
+-hasConflictingConstraints: false
+-hasContradiction: false
+-hasErrorInConstrainingTypes: false
+-hasParameterConstraintError: false
+-hasTypeInferenceIncorporationError: false
+-hasUnknownParameters: true
+-hasViolatedUpperBound: false
+-isSuccessful: false
+
+result:
+T=Int
+P=???
diff --git a/compiler/testData/constraintSystem/severalVariables/direct/invariant/varSubDepSuper.constraints b/compiler/testData/constraintSystem/severalVariables/direct/invariant/varSubDepSuper.constraints
new file mode 100644
index 00000000000..802fa4fa77f
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/direct/invariant/varSubDepSuper.constraints
@@ -0,0 +1,4 @@
+VARIABLES T P
+
+T <: Int
+P >: My<T>
diff --git a/compiler/testData/constraintSystem/severalVariables/direct/invariant/varSuperDepEq.bounds b/compiler/testData/constraintSystem/severalVariables/direct/invariant/varSuperDepEq.bounds
new file mode 100644
index 00000000000..e063aadb4b0
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/direct/invariant/varSuperDepEq.bounds
@@ -0,0 +1,23 @@
+VARIABLES T P
+
+T >: Int
+P := My<T>
+
+type parameter bounds:
+T >: Int
+P := My<T>*
+
+status:
+-hasCannotCaptureTypesError: false
+-hasConflictingConstraints: false
+-hasContradiction: true
+-hasErrorInConstrainingTypes: false
+-hasParameterConstraintError: false
+-hasTypeInferenceIncorporationError: true
+-hasUnknownParameters: true
+-hasViolatedUpperBound: false
+-isSuccessful: false
+
+result:
+T=Int
+P=???
diff --git a/compiler/testData/constraintSystem/severalVariables/direct/invariant/varSuperDepEq.constraints b/compiler/testData/constraintSystem/severalVariables/direct/invariant/varSuperDepEq.constraints
new file mode 100644
index 00000000000..b4c5f83202f
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/direct/invariant/varSuperDepEq.constraints
@@ -0,0 +1,4 @@
+VARIABLES T P
+
+T >: Int
+P := My<T>
diff --git a/compiler/testData/constraintSystem/severalVariables/direct/invariant/varSuperDepSub.bounds b/compiler/testData/constraintSystem/severalVariables/direct/invariant/varSuperDepSub.bounds
new file mode 100644
index 00000000000..0e0efdceff8
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/direct/invariant/varSuperDepSub.bounds
@@ -0,0 +1,23 @@
+VARIABLES T P
+
+T >: Int
+P <: My<T>
+
+type parameter bounds:
+T >: Int
+P <: My<T>*
+
+status:
+-hasCannotCaptureTypesError: false
+-hasConflictingConstraints: false
+-hasContradiction: false
+-hasErrorInConstrainingTypes: false
+-hasParameterConstraintError: false
+-hasTypeInferenceIncorporationError: false
+-hasUnknownParameters: true
+-hasViolatedUpperBound: false
+-isSuccessful: false
+
+result:
+T=Int
+P=???
diff --git a/compiler/testData/constraintSystem/severalVariables/direct/invariant/varSuperDepSub.constraints b/compiler/testData/constraintSystem/severalVariables/direct/invariant/varSuperDepSub.constraints
new file mode 100644
index 00000000000..da6df183aa5
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/direct/invariant/varSuperDepSub.constraints
@@ -0,0 +1,4 @@
+VARIABLES T P
+
+T >: Int
+P <: My<T>
diff --git a/compiler/testData/constraintSystem/severalVariables/direct/invariant/varSuperDepSuper.bounds b/compiler/testData/constraintSystem/severalVariables/direct/invariant/varSuperDepSuper.bounds
new file mode 100644
index 00000000000..d02a3bda19f
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/direct/invariant/varSuperDepSuper.bounds
@@ -0,0 +1,23 @@
+VARIABLES T P
+
+T >: Int
+P >: My<T>
+
+type parameter bounds:
+T >: Int
+P >: My<T>*
+
+status:
+-hasCannotCaptureTypesError: false
+-hasConflictingConstraints: false
+-hasContradiction: false
+-hasErrorInConstrainingTypes: false
+-hasParameterConstraintError: false
+-hasTypeInferenceIncorporationError: false
+-hasUnknownParameters: true
+-hasViolatedUpperBound: false
+-isSuccessful: false
+
+result:
+T=Int
+P=???
diff --git a/compiler/testData/constraintSystem/severalVariables/direct/invariant/varSuperDepSuper.constraints b/compiler/testData/constraintSystem/severalVariables/direct/invariant/varSuperDepSuper.constraints
new file mode 100644
index 00000000000..34597d6a9a7
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/direct/invariant/varSuperDepSuper.constraints
@@ -0,0 +1,4 @@
+VARIABLES T P
+
+T >: Int
+P >: My<T>
diff --git a/compiler/testData/constraintSystem/severalVariables/interdependency/interdependency1.bounds b/compiler/testData/constraintSystem/severalVariables/interdependency/interdependency1.bounds
new file mode 100644
index 00000000000..7da19bb43dc
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/interdependency/interdependency1.bounds
@@ -0,0 +1,27 @@
+VARIABLES T P E
+FIX_VARIABLES
+
+P <: My<T>
+Successor<E> <: P
+Int <: T
+
+type parameter bounds:
+T := T*, := E*, >: Int, := Int
+P <: My<T>*, >: Successor<E>*, >: Successor<T>*, <: My<E>*, <: My<Int>, >: Successor<Int>, := Successor<Int>
+E := T*, := E*, >: Int, := Int
+
+status:
+-hasCannotCaptureTypesError: false
+-hasConflictingConstraints: false
+-hasContradiction: false
+-hasErrorInConstrainingTypes: false
+-hasParameterConstraintError: false
+-hasTypeInferenceIncorporationError: false
+-hasUnknownParameters: false
+-hasViolatedUpperBound: false
+-isSuccessful: true
+
+result:
+T=Int
+P=Successor<Int>
+E=Int
diff --git a/compiler/testData/constraintSystem/severalVariables/interdependency/interdependency1.constraints b/compiler/testData/constraintSystem/severalVariables/interdependency/interdependency1.constraints
new file mode 100644
index 00000000000..700a203d296
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/interdependency/interdependency1.constraints
@@ -0,0 +1,6 @@
+VARIABLES T P E
+FIX_VARIABLES
+
+P <: My<T>
+Successor<E> <: P
+Int <: T
diff --git a/compiler/testData/constraintSystem/severalVariables/interdependency/interdependency2.bounds b/compiler/testData/constraintSystem/severalVariables/interdependency/interdependency2.bounds
new file mode 100644
index 00000000000..d1c12fbfb04
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/interdependency/interdependency2.bounds
@@ -0,0 +1,27 @@
+VARIABLES T P E
+FIX_VARIABLES
+
+P <: My<T>
+Int <: T
+Successor<E> <: P
+
+type parameter bounds:
+T >: Int, := T*, := E*, := Int
+P <: My<T>*, >: Successor<E>*, >: Successor<T>*, <: My<E>*, <: My<Int>, >: Successor<Int>, := Successor<Int>
+E := T*, >: Int, := E*, := Int
+
+status:
+-hasCannotCaptureTypesError: false
+-hasConflictingConstraints: false
+-hasContradiction: false
+-hasErrorInConstrainingTypes: false
+-hasParameterConstraintError: false
+-hasTypeInferenceIncorporationError: false
+-hasUnknownParameters: false
+-hasViolatedUpperBound: false
+-isSuccessful: true
+
+result:
+T=Int
+P=Successor<Int>
+E=Int
diff --git a/compiler/testData/constraintSystem/severalVariables/interdependency/interdependency2.constraints b/compiler/testData/constraintSystem/severalVariables/interdependency/interdependency2.constraints
new file mode 100644
index 00000000000..c659df345ce
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/interdependency/interdependency2.constraints
@@ -0,0 +1,6 @@
+VARIABLES T P E
+FIX_VARIABLES
+
+P <: My<T>
+Int <: T
+Successor<E> <: P
diff --git a/compiler/testData/constraintSystem/severalVariables/interdependency/interdependency3.bounds b/compiler/testData/constraintSystem/severalVariables/interdependency/interdependency3.bounds
new file mode 100644
index 00000000000..3345b301150
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/interdependency/interdependency3.bounds
@@ -0,0 +1,27 @@
+VARIABLES T P E
+FIX_VARIABLES
+
+Int <: T
+Successor<E> <: P
+P <: My<T>
+
+type parameter bounds:
+T >: Int, := T*, := E*, := Int
+P >: Successor<E>*, <: My<T>*, >: Successor<T>*, <: My<E>*, <: My<Int>, >: Successor<Int>, := Successor<Int>
+E := T*, >: Int, := E*, := Int
+
+status:
+-hasCannotCaptureTypesError: false
+-hasConflictingConstraints: false
+-hasContradiction: false
+-hasErrorInConstrainingTypes: false
+-hasParameterConstraintError: false
+-hasTypeInferenceIncorporationError: false
+-hasUnknownParameters: false
+-hasViolatedUpperBound: false
+-isSuccessful: true
+
+result:
+T=Int
+P=Successor<Int>
+E=Int
diff --git a/compiler/testData/constraintSystem/severalVariables/interdependency/interdependency3.constraints b/compiler/testData/constraintSystem/severalVariables/interdependency/interdependency3.constraints
new file mode 100644
index 00000000000..c004de9df4c
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/interdependency/interdependency3.constraints
@@ -0,0 +1,6 @@
+VARIABLES T P E
+FIX_VARIABLES
+
+Int <: T
+Successor<E> <: P
+P <: My<T>
diff --git a/compiler/testData/constraintSystem/severalVariables/nullable/contravariant/varEqDepEq.bounds b/compiler/testData/constraintSystem/severalVariables/nullable/contravariant/varEqDepEq.bounds
new file mode 100644
index 00000000000..c75ca7b1e4b
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/nullable/contravariant/varEqDepEq.bounds
@@ -0,0 +1,23 @@
+VARIABLES T P
+
+T := Int
+P := Consumer<T?>
+
+type parameter bounds:
+T := Int, >: Int, <: Int?
+P := Consumer<T?>*, := Consumer<Int?>, <: Consumer<Int?>, >: Consumer<Int?>
+
+status:
+-hasCannotCaptureTypesError: false
+-hasConflictingConstraints: false
+-hasContradiction: false
+-hasErrorInConstrainingTypes: false
+-hasParameterConstraintError: false
+-hasTypeInferenceIncorporationError: false
+-hasUnknownParameters: false
+-hasViolatedUpperBound: false
+-isSuccessful: true
+
+result:
+T=Int
+P=Consumer<Int?>
diff --git a/compiler/testData/constraintSystem/severalVariables/nullable/contravariant/varEqDepEq.constraints b/compiler/testData/constraintSystem/severalVariables/nullable/contravariant/varEqDepEq.constraints
new file mode 100644
index 00000000000..c1736b057c7
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/nullable/contravariant/varEqDepEq.constraints
@@ -0,0 +1,4 @@
+VARIABLES T P
+
+T := Int
+P := Consumer<T?>
diff --git a/compiler/testData/constraintSystem/severalVariables/nullable/contravariant/varEqDepSub.bounds b/compiler/testData/constraintSystem/severalVariables/nullable/contravariant/varEqDepSub.bounds
new file mode 100644
index 00000000000..192ea287dd4
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/nullable/contravariant/varEqDepSub.bounds
@@ -0,0 +1,23 @@
+VARIABLES T P
+
+T := Int
+P <: Consumer<T?>
+
+type parameter bounds:
+T := Int
+P <: Consumer<T?>*, <: Consumer<Int?>
+
+status:
+-hasCannotCaptureTypesError: false
+-hasConflictingConstraints: false
+-hasContradiction: false
+-hasErrorInConstrainingTypes: false
+-hasParameterConstraintError: false
+-hasTypeInferenceIncorporationError: false
+-hasUnknownParameters: false
+-hasViolatedUpperBound: false
+-isSuccessful: true
+
+result:
+T=Int
+P=Consumer<Int?>
diff --git a/compiler/testData/constraintSystem/severalVariables/nullable/contravariant/varEqDepSub.constraints b/compiler/testData/constraintSystem/severalVariables/nullable/contravariant/varEqDepSub.constraints
new file mode 100644
index 00000000000..55f677f6ddb
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/nullable/contravariant/varEqDepSub.constraints
@@ -0,0 +1,4 @@
+VARIABLES T P
+
+T := Int
+P <: Consumer<T?>
diff --git a/compiler/testData/constraintSystem/severalVariables/nullable/contravariant/varEqDepSuper.bounds b/compiler/testData/constraintSystem/severalVariables/nullable/contravariant/varEqDepSuper.bounds
new file mode 100644
index 00000000000..cdc2b78a7ff
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/nullable/contravariant/varEqDepSuper.bounds
@@ -0,0 +1,23 @@
+VARIABLES T P
+
+T := Int
+P >: Consumer<T?>
+
+type parameter bounds:
+T := Int
+P >: Consumer<T?>*, >: Consumer<Int?>
+
+status:
+-hasCannotCaptureTypesError: false
+-hasConflictingConstraints: false
+-hasContradiction: false
+-hasErrorInConstrainingTypes: false
+-hasParameterConstraintError: false
+-hasTypeInferenceIncorporationError: false
+-hasUnknownParameters: false
+-hasViolatedUpperBound: false
+-isSuccessful: true
+
+result:
+T=Int
+P=Consumer<Int?>
diff --git a/compiler/testData/constraintSystem/severalVariables/nullable/contravariant/varEqDepSuper.constraints b/compiler/testData/constraintSystem/severalVariables/nullable/contravariant/varEqDepSuper.constraints
new file mode 100644
index 00000000000..09f513cc7b4
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/nullable/contravariant/varEqDepSuper.constraints
@@ -0,0 +1,4 @@
+VARIABLES T P
+
+T := Int
+P >: Consumer<T?>
diff --git a/compiler/testData/constraintSystem/severalVariables/nullable/contravariant/varSubDepEq.bounds b/compiler/testData/constraintSystem/severalVariables/nullable/contravariant/varSubDepEq.bounds
new file mode 100644
index 00000000000..f28d713b932
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/nullable/contravariant/varSubDepEq.bounds
@@ -0,0 +1,23 @@
+VARIABLES T P
+
+T <: Int
+P := Consumer<T?>
+
+type parameter bounds:
+T <: Int, <: Int?
+P := Consumer<T?>*, >: Consumer<Int?>
+
+status:
+-hasCannotCaptureTypesError: false
+-hasConflictingConstraints: false
+-hasContradiction: false
+-hasErrorInConstrainingTypes: false
+-hasParameterConstraintError: false
+-hasTypeInferenceIncorporationError: false
+-hasUnknownParameters: false
+-hasViolatedUpperBound: false
+-isSuccessful: true
+
+result:
+T=Int
+P=Consumer<Int?>
diff --git a/compiler/testData/constraintSystem/severalVariables/nullable/contravariant/varSubDepEq.constraints b/compiler/testData/constraintSystem/severalVariables/nullable/contravariant/varSubDepEq.constraints
new file mode 100644
index 00000000000..5271ac8ec41
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/nullable/contravariant/varSubDepEq.constraints
@@ -0,0 +1,4 @@
+VARIABLES T P
+
+T <: Int
+P := Consumer<T?>
diff --git a/compiler/testData/constraintSystem/severalVariables/nullable/contravariant/varSubDepSub.bounds b/compiler/testData/constraintSystem/severalVariables/nullable/contravariant/varSubDepSub.bounds
new file mode 100644
index 00000000000..3cf761b0bbc
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/nullable/contravariant/varSubDepSub.bounds
@@ -0,0 +1,23 @@
+VARIABLES T P
+
+T <: Int
+P <: Consumer<T?>
+
+type parameter bounds:
+T <: Int
+P <: Consumer<T?>*
+
+status:
+-hasCannotCaptureTypesError: false
+-hasConflictingConstraints: false
+-hasContradiction: false
+-hasErrorInConstrainingTypes: false
+-hasParameterConstraintError: false
+-hasTypeInferenceIncorporationError: false
+-hasUnknownParameters: true
+-hasViolatedUpperBound: false
+-isSuccessful: false
+
+result:
+T=Int
+P=???
diff --git a/compiler/testData/constraintSystem/severalVariables/nullable/contravariant/varSubDepSub.constraints b/compiler/testData/constraintSystem/severalVariables/nullable/contravariant/varSubDepSub.constraints
new file mode 100644
index 00000000000..ae64ed7c915
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/nullable/contravariant/varSubDepSub.constraints
@@ -0,0 +1,4 @@
+VARIABLES T P
+
+T <: Int
+P <: Consumer<T?>
diff --git a/compiler/testData/constraintSystem/severalVariables/nullable/contravariant/varSubDepSuper.bounds b/compiler/testData/constraintSystem/severalVariables/nullable/contravariant/varSubDepSuper.bounds
new file mode 100644
index 00000000000..22e08657fce
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/nullable/contravariant/varSubDepSuper.bounds
@@ -0,0 +1,23 @@
+VARIABLES T P
+
+T <: Int
+P >: Consumer<T?>
+
+type parameter bounds:
+T <: Int
+P >: Consumer<T?>*, >: Consumer<Int?>
+
+status:
+-hasCannotCaptureTypesError: false
+-hasConflictingConstraints: false
+-hasContradiction: false
+-hasErrorInConstrainingTypes: false
+-hasParameterConstraintError: false
+-hasTypeInferenceIncorporationError: false
+-hasUnknownParameters: false
+-hasViolatedUpperBound: false
+-isSuccessful: true
+
+result:
+T=Int
+P=Consumer<Int?>
diff --git a/compiler/testData/constraintSystem/severalVariables/nullable/contravariant/varSubDepSuper.constraints b/compiler/testData/constraintSystem/severalVariables/nullable/contravariant/varSubDepSuper.constraints
new file mode 100644
index 00000000000..5ed24171e25
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/nullable/contravariant/varSubDepSuper.constraints
@@ -0,0 +1,4 @@
+VARIABLES T P
+
+T <: Int
+P >: Consumer<T?>
diff --git a/compiler/testData/constraintSystem/severalVariables/nullable/contravariant/varSuperDepEq.bounds b/compiler/testData/constraintSystem/severalVariables/nullable/contravariant/varSuperDepEq.bounds
new file mode 100644
index 00000000000..198d5797635
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/nullable/contravariant/varSuperDepEq.bounds
@@ -0,0 +1,23 @@
+VARIABLES T P
+
+T >: Int
+P := Consumer<T?>
+
+type parameter bounds:
+T >: Int
+P := Consumer<T?>*, <: Consumer<Int?>
+
+status:
+-hasCannotCaptureTypesError: false
+-hasConflictingConstraints: false
+-hasContradiction: false
+-hasErrorInConstrainingTypes: false
+-hasParameterConstraintError: false
+-hasTypeInferenceIncorporationError: false
+-hasUnknownParameters: false
+-hasViolatedUpperBound: false
+-isSuccessful: true
+
+result:
+T=Int
+P=Consumer<Int?>
diff --git a/compiler/testData/constraintSystem/severalVariables/nullable/contravariant/varSuperDepEq.constraints b/compiler/testData/constraintSystem/severalVariables/nullable/contravariant/varSuperDepEq.constraints
new file mode 100644
index 00000000000..af1292bcb12
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/nullable/contravariant/varSuperDepEq.constraints
@@ -0,0 +1,4 @@
+VARIABLES T P
+
+T >: Int
+P := Consumer<T?>
diff --git a/compiler/testData/constraintSystem/severalVariables/nullable/contravariant/varSuperDepSub.bounds b/compiler/testData/constraintSystem/severalVariables/nullable/contravariant/varSuperDepSub.bounds
new file mode 100644
index 00000000000..f8802073cf1
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/nullable/contravariant/varSuperDepSub.bounds
@@ -0,0 +1,23 @@
+VARIABLES T P
+
+T >: Int
+P <: Consumer<T?>
+
+type parameter bounds:
+T >: Int
+P <: Consumer<T?>*, <: Consumer<Int?>
+
+status:
+-hasCannotCaptureTypesError: false
+-hasConflictingConstraints: false
+-hasContradiction: false
+-hasErrorInConstrainingTypes: false
+-hasParameterConstraintError: false
+-hasTypeInferenceIncorporationError: false
+-hasUnknownParameters: false
+-hasViolatedUpperBound: false
+-isSuccessful: true
+
+result:
+T=Int
+P=Consumer<Int?>
diff --git a/compiler/testData/constraintSystem/severalVariables/nullable/contravariant/varSuperDepSub.constraints b/compiler/testData/constraintSystem/severalVariables/nullable/contravariant/varSuperDepSub.constraints
new file mode 100644
index 00000000000..c40e9e4214e
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/nullable/contravariant/varSuperDepSub.constraints
@@ -0,0 +1,4 @@
+VARIABLES T P
+
+T >: Int
+P <: Consumer<T?>
diff --git a/compiler/testData/constraintSystem/severalVariables/nullable/contravariant/varSuperDepSuper.bounds b/compiler/testData/constraintSystem/severalVariables/nullable/contravariant/varSuperDepSuper.bounds
new file mode 100644
index 00000000000..a26fb134d3e
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/nullable/contravariant/varSuperDepSuper.bounds
@@ -0,0 +1,23 @@
+VARIABLES T P
+
+T >: Int
+P >: Consumer<T?>
+
+type parameter bounds:
+T >: Int
+P >: Consumer<T?>*
+
+status:
+-hasCannotCaptureTypesError: false
+-hasConflictingConstraints: false
+-hasContradiction: false
+-hasErrorInConstrainingTypes: false
+-hasParameterConstraintError: false
+-hasTypeInferenceIncorporationError: false
+-hasUnknownParameters: true
+-hasViolatedUpperBound: false
+-isSuccessful: false
+
+result:
+T=Int
+P=???
diff --git a/compiler/testData/constraintSystem/severalVariables/nullable/contravariant/varSuperDepSuper.constraints b/compiler/testData/constraintSystem/severalVariables/nullable/contravariant/varSuperDepSuper.constraints
new file mode 100644
index 00000000000..154953e0dc0
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/nullable/contravariant/varSuperDepSuper.constraints
@@ -0,0 +1,4 @@
+VARIABLES T P
+
+T >: Int
+P >: Consumer<T?>
diff --git a/compiler/testData/constraintSystem/severalVariables/nullable/covariant/varEqDepEq.bounds b/compiler/testData/constraintSystem/severalVariables/nullable/covariant/varEqDepEq.bounds
new file mode 100644
index 00000000000..2dce152d14c
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/nullable/covariant/varEqDepEq.bounds
@@ -0,0 +1,23 @@
+VARIABLES T P
+
+T := Int
+P := Producer<T?>
+
+type parameter bounds:
+T := Int, >: Int, <: Int?
+P := Producer<T?>*, := Producer<Int?>, >: Producer<Int?>, <: Producer<Int?>
+
+status:
+-hasCannotCaptureTypesError: false
+-hasConflictingConstraints: false
+-hasContradiction: false
+-hasErrorInConstrainingTypes: false
+-hasParameterConstraintError: false
+-hasTypeInferenceIncorporationError: false
+-hasUnknownParameters: false
+-hasViolatedUpperBound: false
+-isSuccessful: true
+
+result:
+T=Int
+P=Producer<Int?>
diff --git a/compiler/testData/constraintSystem/severalVariables/nullable/covariant/varEqDepEq.constraints b/compiler/testData/constraintSystem/severalVariables/nullable/covariant/varEqDepEq.constraints
new file mode 100644
index 00000000000..c26a6ffd4e8
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/nullable/covariant/varEqDepEq.constraints
@@ -0,0 +1,4 @@
+VARIABLES T P
+
+T := Int
+P := Producer<T?>
diff --git a/compiler/testData/constraintSystem/severalVariables/nullable/covariant/varEqDepSub.bounds b/compiler/testData/constraintSystem/severalVariables/nullable/covariant/varEqDepSub.bounds
new file mode 100644
index 00000000000..494df6e0593
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/nullable/covariant/varEqDepSub.bounds
@@ -0,0 +1,23 @@
+VARIABLES T P
+
+T := Int
+P <: Producer<T?>
+
+type parameter bounds:
+T := Int
+P <: Producer<T?>*, <: Producer<Int?>
+
+status:
+-hasCannotCaptureTypesError: false
+-hasConflictingConstraints: false
+-hasContradiction: false
+-hasErrorInConstrainingTypes: false
+-hasParameterConstraintError: false
+-hasTypeInferenceIncorporationError: false
+-hasUnknownParameters: false
+-hasViolatedUpperBound: false
+-isSuccessful: true
+
+result:
+T=Int
+P=Producer<Int?>
diff --git a/compiler/testData/constraintSystem/severalVariables/nullable/covariant/varEqDepSub.constraints b/compiler/testData/constraintSystem/severalVariables/nullable/covariant/varEqDepSub.constraints
new file mode 100644
index 00000000000..05b999bba72
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/nullable/covariant/varEqDepSub.constraints
@@ -0,0 +1,4 @@
+VARIABLES T P
+
+T := Int
+P <: Producer<T?>
diff --git a/compiler/testData/constraintSystem/severalVariables/nullable/covariant/varEqDepSuper.bounds b/compiler/testData/constraintSystem/severalVariables/nullable/covariant/varEqDepSuper.bounds
new file mode 100644
index 00000000000..3274bad3c3a
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/nullable/covariant/varEqDepSuper.bounds
@@ -0,0 +1,23 @@
+VARIABLES T P
+
+T := Int
+P >: Producer<T?>
+
+type parameter bounds:
+T := Int
+P >: Producer<T?>*, >: Producer<Int?>
+
+status:
+-hasCannotCaptureTypesError: false
+-hasConflictingConstraints: false
+-hasContradiction: false
+-hasErrorInConstrainingTypes: false
+-hasParameterConstraintError: false
+-hasTypeInferenceIncorporationError: false
+-hasUnknownParameters: false
+-hasViolatedUpperBound: false
+-isSuccessful: true
+
+result:
+T=Int
+P=Producer<Int?>
diff --git a/compiler/testData/constraintSystem/severalVariables/nullable/covariant/varEqDepSuper.constraints b/compiler/testData/constraintSystem/severalVariables/nullable/covariant/varEqDepSuper.constraints
new file mode 100644
index 00000000000..696c4319d1d
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/nullable/covariant/varEqDepSuper.constraints
@@ -0,0 +1,4 @@
+VARIABLES T P
+
+T := Int
+P >: Producer<T?>
diff --git a/compiler/testData/constraintSystem/severalVariables/nullable/covariant/varSubDepEq.bounds b/compiler/testData/constraintSystem/severalVariables/nullable/covariant/varSubDepEq.bounds
new file mode 100644
index 00000000000..01c64e2e871
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/nullable/covariant/varSubDepEq.bounds
@@ -0,0 +1,23 @@
+VARIABLES T P
+
+T <: Int
+P := Producer<T?>
+
+type parameter bounds:
+T <: Int, <: Int?
+P := Producer<T?>*, <: Producer<Int?>
+
+status:
+-hasCannotCaptureTypesError: false
+-hasConflictingConstraints: false
+-hasContradiction: false
+-hasErrorInConstrainingTypes: false
+-hasParameterConstraintError: false
+-hasTypeInferenceIncorporationError: false
+-hasUnknownParameters: false
+-hasViolatedUpperBound: false
+-isSuccessful: true
+
+result:
+T=Int
+P=Producer<Int?>
diff --git a/compiler/testData/constraintSystem/severalVariables/nullable/covariant/varSubDepEq.constraints b/compiler/testData/constraintSystem/severalVariables/nullable/covariant/varSubDepEq.constraints
new file mode 100644
index 00000000000..bca5d5feb30
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/nullable/covariant/varSubDepEq.constraints
@@ -0,0 +1,4 @@
+VARIABLES T P
+
+T <: Int
+P := Producer<T?>
diff --git a/compiler/testData/constraintSystem/severalVariables/nullable/covariant/varSubDepSub.bounds b/compiler/testData/constraintSystem/severalVariables/nullable/covariant/varSubDepSub.bounds
new file mode 100644
index 00000000000..bc211c8a178
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/nullable/covariant/varSubDepSub.bounds
@@ -0,0 +1,23 @@
+VARIABLES T P
+
+T <: Int
+P <: Producer<T?>
+
+type parameter bounds:
+T <: Int
+P <: Producer<T?>*, <: Producer<Int?>
+
+status:
+-hasCannotCaptureTypesError: false
+-hasConflictingConstraints: false
+-hasContradiction: false
+-hasErrorInConstrainingTypes: false
+-hasParameterConstraintError: false
+-hasTypeInferenceIncorporationError: false
+-hasUnknownParameters: false
+-hasViolatedUpperBound: false
+-isSuccessful: true
+
+result:
+T=Int
+P=Producer<Int?>
diff --git a/compiler/testData/constraintSystem/severalVariables/nullable/covariant/varSubDepSub.constraints b/compiler/testData/constraintSystem/severalVariables/nullable/covariant/varSubDepSub.constraints
new file mode 100644
index 00000000000..7a0eaffde51
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/nullable/covariant/varSubDepSub.constraints
@@ -0,0 +1,4 @@
+VARIABLES T P
+
+T <: Int
+P <: Producer<T?>
diff --git a/compiler/testData/constraintSystem/severalVariables/nullable/covariant/varSubDepSuper.bounds b/compiler/testData/constraintSystem/severalVariables/nullable/covariant/varSubDepSuper.bounds
new file mode 100644
index 00000000000..0205bd703c2
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/nullable/covariant/varSubDepSuper.bounds
@@ -0,0 +1,23 @@
+VARIABLES T P
+
+T <: Int
+P >: Producer<T?>
+
+type parameter bounds:
+T <: Int
+P >: Producer<T?>*
+
+status:
+-hasCannotCaptureTypesError: false
+-hasConflictingConstraints: false
+-hasContradiction: false
+-hasErrorInConstrainingTypes: false
+-hasParameterConstraintError: false
+-hasTypeInferenceIncorporationError: false
+-hasUnknownParameters: true
+-hasViolatedUpperBound: false
+-isSuccessful: false
+
+result:
+T=Int
+P=???
diff --git a/compiler/testData/constraintSystem/severalVariables/nullable/covariant/varSubDepSuper.constraints b/compiler/testData/constraintSystem/severalVariables/nullable/covariant/varSubDepSuper.constraints
new file mode 100644
index 00000000000..d0250712a47
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/nullable/covariant/varSubDepSuper.constraints
@@ -0,0 +1,4 @@
+VARIABLES T P
+
+T <: Int
+P >: Producer<T?>
diff --git a/compiler/testData/constraintSystem/severalVariables/nullable/covariant/varSuperDepEq.bounds b/compiler/testData/constraintSystem/severalVariables/nullable/covariant/varSuperDepEq.bounds
new file mode 100644
index 00000000000..b605afccf08
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/nullable/covariant/varSuperDepEq.bounds
@@ -0,0 +1,23 @@
+VARIABLES T P
+
+T >: Int
+P := Producer<T?>
+
+type parameter bounds:
+T >: Int
+P := Producer<T?>*, >: Producer<Int?>
+
+status:
+-hasCannotCaptureTypesError: false
+-hasConflictingConstraints: false
+-hasContradiction: false
+-hasErrorInConstrainingTypes: false
+-hasParameterConstraintError: false
+-hasTypeInferenceIncorporationError: false
+-hasUnknownParameters: false
+-hasViolatedUpperBound: false
+-isSuccessful: true
+
+result:
+T=Int
+P=Producer<Int?>
diff --git a/compiler/testData/constraintSystem/severalVariables/nullable/covariant/varSuperDepEq.constraints b/compiler/testData/constraintSystem/severalVariables/nullable/covariant/varSuperDepEq.constraints
new file mode 100644
index 00000000000..514bbd7d40c
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/nullable/covariant/varSuperDepEq.constraints
@@ -0,0 +1,4 @@
+VARIABLES T P
+
+T >: Int
+P := Producer<T?>
diff --git a/compiler/testData/constraintSystem/severalVariables/nullable/covariant/varSuperDepSub.bounds b/compiler/testData/constraintSystem/severalVariables/nullable/covariant/varSuperDepSub.bounds
new file mode 100644
index 00000000000..0c89b4904be
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/nullable/covariant/varSuperDepSub.bounds
@@ -0,0 +1,23 @@
+VARIABLES T P
+
+T >: Int
+P <: Producer<T?>
+
+type parameter bounds:
+T >: Int
+P <: Producer<T?>*
+
+status:
+-hasCannotCaptureTypesError: false
+-hasConflictingConstraints: false
+-hasContradiction: false
+-hasErrorInConstrainingTypes: false
+-hasParameterConstraintError: false
+-hasTypeInferenceIncorporationError: false
+-hasUnknownParameters: true
+-hasViolatedUpperBound: false
+-isSuccessful: false
+
+result:
+T=Int
+P=???
diff --git a/compiler/testData/constraintSystem/severalVariables/nullable/covariant/varSuperDepSub.constraints b/compiler/testData/constraintSystem/severalVariables/nullable/covariant/varSuperDepSub.constraints
new file mode 100644
index 00000000000..a38123fd422
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/nullable/covariant/varSuperDepSub.constraints
@@ -0,0 +1,4 @@
+VARIABLES T P
+
+T >: Int
+P <: Producer<T?>
diff --git a/compiler/testData/constraintSystem/severalVariables/nullable/covariant/varSuperDepSuper.bounds b/compiler/testData/constraintSystem/severalVariables/nullable/covariant/varSuperDepSuper.bounds
new file mode 100644
index 00000000000..a0983242baa
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/nullable/covariant/varSuperDepSuper.bounds
@@ -0,0 +1,23 @@
+VARIABLES T P
+
+T >: Int
+P >: Producer<T?>
+
+type parameter bounds:
+T >: Int
+P >: Producer<T?>*, >: Producer<Int?>
+
+status:
+-hasCannotCaptureTypesError: false
+-hasConflictingConstraints: false
+-hasContradiction: false
+-hasErrorInConstrainingTypes: false
+-hasParameterConstraintError: false
+-hasTypeInferenceIncorporationError: false
+-hasUnknownParameters: false
+-hasViolatedUpperBound: false
+-isSuccessful: true
+
+result:
+T=Int
+P=Producer<Int?>
diff --git a/compiler/testData/constraintSystem/severalVariables/nullable/covariant/varSuperDepSuper.constraints b/compiler/testData/constraintSystem/severalVariables/nullable/covariant/varSuperDepSuper.constraints
new file mode 100644
index 00000000000..3e222362b82
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/nullable/covariant/varSuperDepSuper.constraints
@@ -0,0 +1,4 @@
+VARIABLES T P
+
+T >: Int
+P >: Producer<T?>
diff --git a/compiler/testData/constraintSystem/severalVariables/nullable/invariant/varEqDepEq.bounds b/compiler/testData/constraintSystem/severalVariables/nullable/invariant/varEqDepEq.bounds
new file mode 100644
index 00000000000..a58d69765d7
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/nullable/invariant/varEqDepEq.bounds
@@ -0,0 +1,23 @@
+VARIABLES T P
+
+T := Int
+P := My<T?>
+
+type parameter bounds:
+T := Int, >: Int, <: Int?
+P := My<T?>*, := My<Int?>
+
+status:
+-hasCannotCaptureTypesError: false
+-hasConflictingConstraints: false
+-hasContradiction: false
+-hasErrorInConstrainingTypes: false
+-hasParameterConstraintError: false
+-hasTypeInferenceIncorporationError: false
+-hasUnknownParameters: false
+-hasViolatedUpperBound: false
+-isSuccessful: true
+
+result:
+T=Int
+P=My<Int?>
diff --git a/compiler/testData/constraintSystem/severalVariables/nullable/invariant/varEqDepEq.constraints b/compiler/testData/constraintSystem/severalVariables/nullable/invariant/varEqDepEq.constraints
new file mode 100644
index 00000000000..84f297651e6
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/nullable/invariant/varEqDepEq.constraints
@@ -0,0 +1,4 @@
+VARIABLES T P
+
+T := Int
+P := My<T?>
diff --git a/compiler/testData/constraintSystem/severalVariables/nullable/invariant/varEqDepSub.bounds b/compiler/testData/constraintSystem/severalVariables/nullable/invariant/varEqDepSub.bounds
new file mode 100644
index 00000000000..edd6bb74e33
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/nullable/invariant/varEqDepSub.bounds
@@ -0,0 +1,23 @@
+VARIABLES T P
+
+T := Int
+P <: My<T?>
+
+type parameter bounds:
+T := Int
+P <: My<T?>*, <: My<Int?>
+
+status:
+-hasCannotCaptureTypesError: false
+-hasConflictingConstraints: false
+-hasContradiction: false
+-hasErrorInConstrainingTypes: false
+-hasParameterConstraintError: false
+-hasTypeInferenceIncorporationError: false
+-hasUnknownParameters: false
+-hasViolatedUpperBound: false
+-isSuccessful: true
+
+result:
+T=Int
+P=My<Int?>
diff --git a/compiler/testData/constraintSystem/severalVariables/nullable/invariant/varEqDepSub.constraints b/compiler/testData/constraintSystem/severalVariables/nullable/invariant/varEqDepSub.constraints
new file mode 100644
index 00000000000..d37a697ae35
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/nullable/invariant/varEqDepSub.constraints
@@ -0,0 +1,4 @@
+VARIABLES T P
+
+T := Int
+P <: My<T?>
diff --git a/compiler/testData/constraintSystem/severalVariables/nullable/invariant/varEqDepSuper.bounds b/compiler/testData/constraintSystem/severalVariables/nullable/invariant/varEqDepSuper.bounds
new file mode 100644
index 00000000000..84bd8e2f19b
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/nullable/invariant/varEqDepSuper.bounds
@@ -0,0 +1,23 @@
+VARIABLES T P
+
+T := Int
+P >: My<T?>
+
+type parameter bounds:
+T := Int
+P >: My<T?>*, >: My<Int?>
+
+status:
+-hasCannotCaptureTypesError: false
+-hasConflictingConstraints: false
+-hasContradiction: false
+-hasErrorInConstrainingTypes: false
+-hasParameterConstraintError: false
+-hasTypeInferenceIncorporationError: false
+-hasUnknownParameters: false
+-hasViolatedUpperBound: false
+-isSuccessful: true
+
+result:
+T=Int
+P=My<Int?>
diff --git a/compiler/testData/constraintSystem/severalVariables/nullable/invariant/varEqDepSuper.constraints b/compiler/testData/constraintSystem/severalVariables/nullable/invariant/varEqDepSuper.constraints
new file mode 100644
index 00000000000..f693412f981
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/nullable/invariant/varEqDepSuper.constraints
@@ -0,0 +1,4 @@
+VARIABLES T P
+
+T := Int
+P >: My<T?>
diff --git a/compiler/testData/constraintSystem/severalVariables/nullable/invariant/varSubDepEq.bounds b/compiler/testData/constraintSystem/severalVariables/nullable/invariant/varSubDepEq.bounds
new file mode 100644
index 00000000000..109e639b135
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/nullable/invariant/varSubDepEq.bounds
@@ -0,0 +1,23 @@
+VARIABLES T P
+
+T <: Int
+P := My<T?>
+
+type parameter bounds:
+T <: Int
+P := My<T?>*
+
+status:
+-hasCannotCaptureTypesError: false
+-hasConflictingConstraints: false
+-hasContradiction: true
+-hasErrorInConstrainingTypes: false
+-hasParameterConstraintError: false
+-hasTypeInferenceIncorporationError: true
+-hasUnknownParameters: true
+-hasViolatedUpperBound: false
+-isSuccessful: false
+
+result:
+T=Int
+P=???
diff --git a/compiler/testData/constraintSystem/severalVariables/nullable/invariant/varSubDepEq.constraints b/compiler/testData/constraintSystem/severalVariables/nullable/invariant/varSubDepEq.constraints
new file mode 100644
index 00000000000..5fd3076befd
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/nullable/invariant/varSubDepEq.constraints
@@ -0,0 +1,4 @@
+VARIABLES T P
+
+T <: Int
+P := My<T?>
diff --git a/compiler/testData/constraintSystem/severalVariables/nullable/invariant/varSubDepSub.bounds b/compiler/testData/constraintSystem/severalVariables/nullable/invariant/varSubDepSub.bounds
new file mode 100644
index 00000000000..1398031e1db
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/nullable/invariant/varSubDepSub.bounds
@@ -0,0 +1,23 @@
+VARIABLES T P
+
+T <: Int
+P <: My<T?>
+
+type parameter bounds:
+T <: Int
+P <: My<T?>*
+
+status:
+-hasCannotCaptureTypesError: false
+-hasConflictingConstraints: false
+-hasContradiction: false
+-hasErrorInConstrainingTypes: false
+-hasParameterConstraintError: false
+-hasTypeInferenceIncorporationError: false
+-hasUnknownParameters: true
+-hasViolatedUpperBound: false
+-isSuccessful: false
+
+result:
+T=Int
+P=???
diff --git a/compiler/testData/constraintSystem/severalVariables/nullable/invariant/varSubDepSub.constraints b/compiler/testData/constraintSystem/severalVariables/nullable/invariant/varSubDepSub.constraints
new file mode 100644
index 00000000000..1814a0991d0
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/nullable/invariant/varSubDepSub.constraints
@@ -0,0 +1,4 @@
+VARIABLES T P
+
+T <: Int
+P <: My<T?>
diff --git a/compiler/testData/constraintSystem/severalVariables/nullable/invariant/varSubDepSuper.bounds b/compiler/testData/constraintSystem/severalVariables/nullable/invariant/varSubDepSuper.bounds
new file mode 100644
index 00000000000..b6bd04c1ee7
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/nullable/invariant/varSubDepSuper.bounds
@@ -0,0 +1,23 @@
+VARIABLES T P
+
+T <: Int
+P >: My<T?>
+
+type parameter bounds:
+T <: Int
+P >: My<T?>*
+
+status:
+-hasCannotCaptureTypesError: false
+-hasConflictingConstraints: false
+-hasContradiction: false
+-hasErrorInConstrainingTypes: false
+-hasParameterConstraintError: false
+-hasTypeInferenceIncorporationError: false
+-hasUnknownParameters: true
+-hasViolatedUpperBound: false
+-isSuccessful: false
+
+result:
+T=Int
+P=???
diff --git a/compiler/testData/constraintSystem/severalVariables/nullable/invariant/varSubDepSuper.constraints b/compiler/testData/constraintSystem/severalVariables/nullable/invariant/varSubDepSuper.constraints
new file mode 100644
index 00000000000..7b6aad251dc
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/nullable/invariant/varSubDepSuper.constraints
@@ -0,0 +1,4 @@
+VARIABLES T P
+
+T <: Int
+P >: My<T?>
diff --git a/compiler/testData/constraintSystem/severalVariables/nullable/invariant/varSuperDepEq.bounds b/compiler/testData/constraintSystem/severalVariables/nullable/invariant/varSuperDepEq.bounds
new file mode 100644
index 00000000000..364a456010a
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/nullable/invariant/varSuperDepEq.bounds
@@ -0,0 +1,23 @@
+VARIABLES T P
+
+T >: Int
+P := My<T?>
+
+type parameter bounds:
+T >: Int
+P := My<T?>*
+
+status:
+-hasCannotCaptureTypesError: false
+-hasConflictingConstraints: false
+-hasContradiction: true
+-hasErrorInConstrainingTypes: false
+-hasParameterConstraintError: false
+-hasTypeInferenceIncorporationError: true
+-hasUnknownParameters: true
+-hasViolatedUpperBound: false
+-isSuccessful: false
+
+result:
+T=Int
+P=???
diff --git a/compiler/testData/constraintSystem/severalVariables/nullable/invariant/varSuperDepEq.constraints b/compiler/testData/constraintSystem/severalVariables/nullable/invariant/varSuperDepEq.constraints
new file mode 100644
index 00000000000..e6f0b95000a
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/nullable/invariant/varSuperDepEq.constraints
@@ -0,0 +1,4 @@
+VARIABLES T P
+
+T >: Int
+P := My<T?>
diff --git a/compiler/testData/constraintSystem/severalVariables/nullable/invariant/varSuperDepSub.bounds b/compiler/testData/constraintSystem/severalVariables/nullable/invariant/varSuperDepSub.bounds
new file mode 100644
index 00000000000..812cef1a783
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/nullable/invariant/varSuperDepSub.bounds
@@ -0,0 +1,23 @@
+VARIABLES T P
+
+T >: Int
+P <: My<T?>
+
+type parameter bounds:
+T >: Int
+P <: My<T?>*
+
+status:
+-hasCannotCaptureTypesError: false
+-hasConflictingConstraints: false
+-hasContradiction: false
+-hasErrorInConstrainingTypes: false
+-hasParameterConstraintError: false
+-hasTypeInferenceIncorporationError: false
+-hasUnknownParameters: true
+-hasViolatedUpperBound: false
+-isSuccessful: false
+
+result:
+T=Int
+P=???
diff --git a/compiler/testData/constraintSystem/severalVariables/nullable/invariant/varSuperDepSub.constraints b/compiler/testData/constraintSystem/severalVariables/nullable/invariant/varSuperDepSub.constraints
new file mode 100644
index 00000000000..f78eb65acfe
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/nullable/invariant/varSuperDepSub.constraints
@@ -0,0 +1,4 @@
+VARIABLES T P
+
+T >: Int
+P <: My<T?>
diff --git a/compiler/testData/constraintSystem/severalVariables/nullable/invariant/varSuperDepSuper.bounds b/compiler/testData/constraintSystem/severalVariables/nullable/invariant/varSuperDepSuper.bounds
new file mode 100644
index 00000000000..bbe55fa05f8
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/nullable/invariant/varSuperDepSuper.bounds
@@ -0,0 +1,23 @@
+VARIABLES T P
+
+T >: Int
+P >: My<T?>
+
+type parameter bounds:
+T >: Int
+P >: My<T?>*
+
+status:
+-hasCannotCaptureTypesError: false
+-hasConflictingConstraints: false
+-hasContradiction: false
+-hasErrorInConstrainingTypes: false
+-hasParameterConstraintError: false
+-hasTypeInferenceIncorporationError: false
+-hasUnknownParameters: true
+-hasViolatedUpperBound: false
+-isSuccessful: false
+
+result:
+T=Int
+P=???
diff --git a/compiler/testData/constraintSystem/severalVariables/nullable/invariant/varSuperDepSuper.constraints b/compiler/testData/constraintSystem/severalVariables/nullable/invariant/varSuperDepSuper.constraints
new file mode 100644
index 00000000000..003e8f08470
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/nullable/invariant/varSuperDepSuper.constraints
@@ -0,0 +1,4 @@
+VARIABLES T P
+
+T >: Int
+P >: My<T?>
diff --git a/compiler/testData/constraintSystem/severalVariables/other/constraintForNullables.bounds b/compiler/testData/constraintSystem/severalVariables/other/constraintForNullables.bounds
new file mode 100644
index 00000000000..2b7abe5e0fb
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/other/constraintForNullables.bounds
@@ -0,0 +1,23 @@
+VARIABLES T P
+
+T? <: P?
+P <: Int
+
+type parameter bounds:
+T <: P?*, <: P*, <: Int, <: Int?
+P >: T*, <: Int
+
+status:
+-hasCannotCaptureTypesError: false
+-hasConflictingConstraints: false
+-hasContradiction: false
+-hasErrorInConstrainingTypes: false
+-hasParameterConstraintError: false
+-hasTypeInferenceIncorporationError: false
+-hasUnknownParameters: false
+-hasViolatedUpperBound: false
+-isSuccessful: true
+
+result:
+T=Int
+P=Int
diff --git a/compiler/testData/constraintSystem/severalVariables/other/constraintForNullables.constraints b/compiler/testData/constraintSystem/severalVariables/other/constraintForNullables.constraints
new file mode 100644
index 00000000000..673300163fa
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/other/constraintForNullables.constraints
@@ -0,0 +1,4 @@
+VARIABLES T P
+
+T? <: P?
+P <: Int
diff --git a/compiler/testData/constraintSystem/severalVariables/other/nestedConsumer.bounds b/compiler/testData/constraintSystem/severalVariables/other/nestedConsumer.bounds
new file mode 100644
index 00000000000..0981df3ed2a
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/other/nestedConsumer.bounds
@@ -0,0 +1,23 @@
+VARIABLES T P
+
+Int <: T
+P := Consumer<Consumer<T>>
+
+type parameter bounds:
+T >: Int
+P := Consumer<Consumer<T>>*, >: Consumer<Consumer<Int>>
+
+status:
+-hasCannotCaptureTypesError: false
+-hasConflictingConstraints: false
+-hasContradiction: false
+-hasErrorInConstrainingTypes: false
+-hasParameterConstraintError: false
+-hasTypeInferenceIncorporationError: false
+-hasUnknownParameters: false
+-hasViolatedUpperBound: false
+-isSuccessful: true
+
+result:
+T=Int
+P=Consumer<Consumer<Int>>
diff --git a/compiler/testData/constraintSystem/severalVariables/other/nestedConsumer.constraints b/compiler/testData/constraintSystem/severalVariables/other/nestedConsumer.constraints
new file mode 100644
index 00000000000..2bcb86860f2
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/other/nestedConsumer.constraints
@@ -0,0 +1,4 @@
+VARIABLES T P
+
+Int <: T
+P := Consumer<Consumer<T>>
diff --git a/compiler/testData/constraintSystem/severalVariables/other/nestedConsumer1.bounds b/compiler/testData/constraintSystem/severalVariables/other/nestedConsumer1.bounds
new file mode 100644
index 00000000000..a2a48f29dd7
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/other/nestedConsumer1.bounds
@@ -0,0 +1,23 @@
+VARIABLES T P
+
+Int <: T
+P <: Consumer<Consumer<Consumer<T>>>
+
+type parameter bounds:
+T >: Int
+P <: Consumer<Consumer<Consumer<T>>>*, <: Consumer<Consumer<Consumer<Int>>>
+
+status:
+-hasCannotCaptureTypesError: false
+-hasConflictingConstraints: false
+-hasContradiction: false
+-hasErrorInConstrainingTypes: false
+-hasParameterConstraintError: false
+-hasTypeInferenceIncorporationError: false
+-hasUnknownParameters: false
+-hasViolatedUpperBound: false
+-isSuccessful: true
+
+result:
+T=Int
+P=Consumer<Consumer<Consumer<Int>>>
diff --git a/compiler/testData/constraintSystem/severalVariables/other/nestedConsumer1.constraints b/compiler/testData/constraintSystem/severalVariables/other/nestedConsumer1.constraints
new file mode 100644
index 00000000000..42efc5e0b40
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/other/nestedConsumer1.constraints
@@ -0,0 +1,4 @@
+VARIABLES T P
+
+Int <: T
+P <: Consumer<Consumer<Consumer<T>>>
diff --git a/compiler/testData/constraintSystem/severalVariables/other/nestedInvConsumer.bounds b/compiler/testData/constraintSystem/severalVariables/other/nestedInvConsumer.bounds
new file mode 100644
index 00000000000..075eb977f1d
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/other/nestedInvConsumer.bounds
@@ -0,0 +1,23 @@
+VARIABLES T P
+
+Int <: T
+P <: My<My<Consumer<T>>>
+
+type parameter bounds:
+T >: Int
+P <: My<My<Consumer<T>>>*, <: My<out My<out Consumer<Int>>>
+
+status:
+-hasCannotCaptureTypesError: false
+-hasConflictingConstraints: false
+-hasContradiction: true
+-hasErrorInConstrainingTypes: false
+-hasParameterConstraintError: false
+-hasTypeInferenceIncorporationError: true
+-hasUnknownParameters: false
+-hasViolatedUpperBound: false
+-isSuccessful: false
+
+result:
+T=Int
+P=My<out My<out Consumer<Int>>>
diff --git a/compiler/testData/constraintSystem/severalVariables/other/nestedInvConsumer.constraints b/compiler/testData/constraintSystem/severalVariables/other/nestedInvConsumer.constraints
new file mode 100644
index 00000000000..9106bea3942
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/other/nestedInvConsumer.constraints
@@ -0,0 +1,4 @@
+VARIABLES T P
+
+Int <: T
+P <: My<My<Consumer<T>>>
diff --git a/compiler/testData/constraintSystem/severalVariables/other/nestedInvProducer.bounds b/compiler/testData/constraintSystem/severalVariables/other/nestedInvProducer.bounds
new file mode 100644
index 00000000000..954ba31220b
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/other/nestedInvProducer.bounds
@@ -0,0 +1,23 @@
+VARIABLES T P
+
+T <: Int
+P <: My<My<Producer<T>>>
+
+type parameter bounds:
+T <: Int
+P <: My<My<Producer<T>>>*, <: My<out My<out Producer<Int>>>
+
+status:
+-hasCannotCaptureTypesError: false
+-hasConflictingConstraints: false
+-hasContradiction: true
+-hasErrorInConstrainingTypes: false
+-hasParameterConstraintError: false
+-hasTypeInferenceIncorporationError: true
+-hasUnknownParameters: false
+-hasViolatedUpperBound: false
+-isSuccessful: false
+
+result:
+T=Int
+P=My<out My<out Producer<Int>>>
diff --git a/compiler/testData/constraintSystem/severalVariables/other/nestedInvProducer.constraints b/compiler/testData/constraintSystem/severalVariables/other/nestedInvProducer.constraints
new file mode 100644
index 00000000000..adddfa74b0a
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/other/nestedInvProducer.constraints
@@ -0,0 +1,4 @@
+VARIABLES T P
+
+T <: Int
+P <: My<My<Producer<T>>>
diff --git a/compiler/testData/constraintSystem/severalVariables/other/nestedProducer.bounds b/compiler/testData/constraintSystem/severalVariables/other/nestedProducer.bounds
new file mode 100644
index 00000000000..02bb5b42f4b
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/other/nestedProducer.bounds
@@ -0,0 +1,23 @@
+VARIABLES T P
+
+T <: Int
+P <: Producer<Producer<Producer<T>>>
+
+type parameter bounds:
+T <: Int
+P <: Producer<Producer<Producer<T>>>*, <: Producer<Producer<Producer<Int>>>
+
+status:
+-hasCannotCaptureTypesError: false
+-hasConflictingConstraints: false
+-hasContradiction: false
+-hasErrorInConstrainingTypes: false
+-hasParameterConstraintError: false
+-hasTypeInferenceIncorporationError: false
+-hasUnknownParameters: false
+-hasViolatedUpperBound: false
+-isSuccessful: true
+
+result:
+T=Int
+P=Producer<Producer<Producer<Int>>>
diff --git a/compiler/testData/constraintSystem/severalVariables/other/nestedProducer.constraints b/compiler/testData/constraintSystem/severalVariables/other/nestedProducer.constraints
new file mode 100644
index 00000000000..a6504127d85
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/other/nestedProducer.constraints
@@ -0,0 +1,4 @@
+VARIABLES T P
+
+T <: Int
+P <: Producer<Producer<Producer<T>>>
diff --git a/compiler/testData/constraintSystem/severalVariables/other/nestedProducerAndConsumer.bounds b/compiler/testData/constraintSystem/severalVariables/other/nestedProducerAndConsumer.bounds
new file mode 100644
index 00000000000..8a228f73979
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/other/nestedProducerAndConsumer.bounds
@@ -0,0 +1,23 @@
+VARIABLES T P
+
+Int <: T
+P <: Producer<Consumer<Producer<T>>>
+
+type parameter bounds:
+T >: Int
+P <: Producer<Consumer<Producer<T>>>*, <: Producer<Consumer<Producer<Int>>>
+
+status:
+-hasCannotCaptureTypesError: false
+-hasConflictingConstraints: false
+-hasContradiction: false
+-hasErrorInConstrainingTypes: false
+-hasParameterConstraintError: false
+-hasTypeInferenceIncorporationError: false
+-hasUnknownParameters: false
+-hasViolatedUpperBound: false
+-isSuccessful: true
+
+result:
+T=Int
+P=Producer<Consumer<Producer<Int>>>
diff --git a/compiler/testData/constraintSystem/severalVariables/other/nestedProducerAndConsumer.constraints b/compiler/testData/constraintSystem/severalVariables/other/nestedProducerAndConsumer.constraints
new file mode 100644
index 00000000000..ee92ca64885
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/other/nestedProducerAndConsumer.constraints
@@ -0,0 +1,4 @@
+VARIABLES T P
+
+Int <: T
+P <: Producer<Consumer<Producer<T>>>
diff --git a/compiler/testData/constraintSystem/severalVariables/other/severalOccurrences.bounds b/compiler/testData/constraintSystem/severalVariables/other/severalOccurrences.bounds
new file mode 100644
index 00000000000..2b703b86732
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/other/severalOccurrences.bounds
@@ -0,0 +1,23 @@
+VARIABLES T P
+
+T <: Int
+P <: Fun<Consumer<T>,Producer<T>>
+
+type parameter bounds:
+T <: Int
+P <: Fun<Consumer<T>, Producer<T>>*, <: Fun<Consumer<Int>, Producer<Int>>
+
+status:
+-hasCannotCaptureTypesError: false
+-hasConflictingConstraints: false
+-hasContradiction: false
+-hasErrorInConstrainingTypes: false
+-hasParameterConstraintError: false
+-hasTypeInferenceIncorporationError: false
+-hasUnknownParameters: false
+-hasViolatedUpperBound: false
+-isSuccessful: true
+
+result:
+T=Int
+P=Fun<Consumer<Int>, Producer<Int>>
diff --git a/compiler/testData/constraintSystem/severalVariables/other/severalOccurrences.constraints b/compiler/testData/constraintSystem/severalVariables/other/severalOccurrences.constraints
new file mode 100644
index 00000000000..61c4ed5cfcf
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/other/severalOccurrences.constraints
@@ -0,0 +1,4 @@
+VARIABLES T P
+
+T <: Int
+P <: Fun<Consumer<T>,Producer<T>>
diff --git a/compiler/testData/constraintSystem/severalVariables/other/simpleFun.bounds b/compiler/testData/constraintSystem/severalVariables/other/simpleFun.bounds
new file mode 100644
index 00000000000..0bb4a19c34c
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/other/simpleFun.bounds
@@ -0,0 +1,26 @@
+VARIABLES T P E
+
+Int <: T
+P <: String
+E <: Fun<T, P>
+
+type parameter bounds:
+T >: Int
+P <: String
+E <: Fun<T, P>*, <: Fun<Int, P>*, <: Fun<Int, String>, <: Fun<T, String>*
+
+status:
+-hasCannotCaptureTypesError: false
+-hasConflictingConstraints: false
+-hasContradiction: false
+-hasErrorInConstrainingTypes: false
+-hasParameterConstraintError: false
+-hasTypeInferenceIncorporationError: false
+-hasUnknownParameters: false
+-hasViolatedUpperBound: false
+-isSuccessful: true
+
+result:
+T=Int
+P=String
+E=Fun<Int, String>
\ No newline at end of file
diff --git a/compiler/testData/constraintSystem/severalVariables/other/simpleFun.constraints b/compiler/testData/constraintSystem/severalVariables/other/simpleFun.constraints
new file mode 100644
index 00000000000..cc3233beeec
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/other/simpleFun.constraints
@@ -0,0 +1,5 @@
+VARIABLES T P E
+
+Int <: T
+P <: String
+E <: Fun<T, P>
diff --git a/compiler/testData/constraintSystem/severalVariables/other/simpleThreeVars.bounds b/compiler/testData/constraintSystem/severalVariables/other/simpleThreeVars.bounds
new file mode 100644
index 00000000000..1f5b59f30f9
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/other/simpleThreeVars.bounds
@@ -0,0 +1,26 @@
+VARIABLES T P E
+
+T <: P
+P <: E
+E <: Int
+
+type parameter bounds:
+T <: P*, <: E*, <: Int
+P >: T*, <: E*, <: Int
+E >: T*, >: P*, <: Int
+
+status:
+-hasCannotCaptureTypesError: false
+-hasConflictingConstraints: false
+-hasContradiction: false
+-hasErrorInConstrainingTypes: false
+-hasParameterConstraintError: false
+-hasTypeInferenceIncorporationError: false
+-hasUnknownParameters: false
+-hasViolatedUpperBound: false
+-isSuccessful: true
+
+result:
+T=Int
+P=Int
+E=Int
diff --git a/compiler/testData/constraintSystem/severalVariables/other/simpleThreeVars.constraints b/compiler/testData/constraintSystem/severalVariables/other/simpleThreeVars.constraints
new file mode 100644
index 00000000000..50616113b85
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/other/simpleThreeVars.constraints
@@ -0,0 +1,5 @@
+VARIABLES T P E
+
+T <: P
+P <: E
+E <: Int
diff --git a/compiler/testData/constraintSystem/severalVariables/other/simpleThreeVarsNoIncorporation.bounds b/compiler/testData/constraintSystem/severalVariables/other/simpleThreeVarsNoIncorporation.bounds
new file mode 100644
index 00000000000..b4e6f9195b4
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/other/simpleThreeVarsNoIncorporation.bounds
@@ -0,0 +1,26 @@
+VARIABLES T P E
+
+T <: P
+P <: E
+Int <: E
+
+type parameter bounds:
+T <: P*, <: E*
+P >: T*, <: E*
+E >: T*, >: P*, >: Int
+
+status:
+-hasCannotCaptureTypesError: false
+-hasConflictingConstraints: false
+-hasContradiction: false
+-hasErrorInConstrainingTypes: false
+-hasParameterConstraintError: false
+-hasTypeInferenceIncorporationError: false
+-hasUnknownParameters: true
+-hasViolatedUpperBound: false
+-isSuccessful: false
+
+result:
+T=???
+P=???
+E=Int
diff --git a/compiler/testData/constraintSystem/severalVariables/other/simpleThreeVarsNoIncorporation.constraints b/compiler/testData/constraintSystem/severalVariables/other/simpleThreeVarsNoIncorporation.constraints
new file mode 100644
index 00000000000..4ffb5c15c74
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/other/simpleThreeVarsNoIncorporation.constraints
@@ -0,0 +1,5 @@
+VARIABLES T P E
+
+T <: P
+P <: E
+Int <: E
diff --git a/compiler/testData/constraintSystem/severalVariables/other/simpleThreeVarsNoIncorporationFixed.bounds b/compiler/testData/constraintSystem/severalVariables/other/simpleThreeVarsNoIncorporationFixed.bounds
new file mode 100644
index 00000000000..fb24c3779eb
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/other/simpleThreeVarsNoIncorporationFixed.bounds
@@ -0,0 +1,27 @@
+VARIABLES T P E
+FIX_VARIABLES
+
+T <: P
+P <: E
+Int <: E
+
+type parameter bounds:
+T <: P*, <: E*, <: Int, := Int
+P >: T*, <: E*, <: Int, := Int, >: Int
+E >: T*, >: P*, >: Int, := Int
+
+status:
+-hasCannotCaptureTypesError: false
+-hasConflictingConstraints: false
+-hasContradiction: false
+-hasErrorInConstrainingTypes: false
+-hasParameterConstraintError: false
+-hasTypeInferenceIncorporationError: false
+-hasUnknownParameters: false
+-hasViolatedUpperBound: false
+-isSuccessful: true
+
+result:
+T=Int
+P=Int
+E=Int
diff --git a/compiler/testData/constraintSystem/severalVariables/other/simpleThreeVarsNoIncorporationFixed.constraints b/compiler/testData/constraintSystem/severalVariables/other/simpleThreeVarsNoIncorporationFixed.constraints
new file mode 100644
index 00000000000..e926273422b
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/other/simpleThreeVarsNoIncorporationFixed.constraints
@@ -0,0 +1,6 @@
+VARIABLES T P E
+FIX_VARIABLES
+
+T <: P
+P <: E
+Int <: E
diff --git a/compiler/testData/constraintSystem/severalVariables/recursive/implicitlyRecursive.bounds b/compiler/testData/constraintSystem/severalVariables/recursive/implicitlyRecursive.bounds
new file mode 100644
index 00000000000..b3fced08758
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/recursive/implicitlyRecursive.bounds
@@ -0,0 +1,26 @@
+VARIABLES T P E
+
+T <: Producer<P>
+P <: Producer<E>
+E <: Producer<P>
+
+type parameter bounds:
+T <: Producer<P>*, <: Producer<Producer<E>>*, <: Producer<Producer<Producer<P>>>*
+P <: Producer<E>*
+E <: Producer<P>*
+
+status:
+-hasCannotCaptureTypesError: false
+-hasConflictingConstraints: false
+-hasContradiction: false
+-hasErrorInConstrainingTypes: false
+-hasParameterConstraintError: false
+-hasTypeInferenceIncorporationError: false
+-hasUnknownParameters: true
+-hasViolatedUpperBound: false
+-isSuccessful: false
+
+result:
+T=???
+P=???
+E=???
diff --git a/compiler/testData/constraintSystem/severalVariables/recursive/implicitlyRecursive.constraints b/compiler/testData/constraintSystem/severalVariables/recursive/implicitlyRecursive.constraints
new file mode 100644
index 00000000000..beb7ef775e1
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/recursive/implicitlyRecursive.constraints
@@ -0,0 +1,5 @@
+VARIABLES T P E
+
+T <: Producer<P>
+P <: Producer<E>
+E <: Producer<P>
diff --git a/compiler/testData/constraintSystem/severalVariables/recursive/mutuallyRecursive.bounds b/compiler/testData/constraintSystem/severalVariables/recursive/mutuallyRecursive.bounds
new file mode 100644
index 00000000000..3865153b06b
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/recursive/mutuallyRecursive.bounds
@@ -0,0 +1,23 @@
+VARIABLES T P
+
+T := My<P>
+P := Two<T,P>
+
+type parameter bounds:
+T := My<P>*
+P := Two<T, P>*
+
+status:
+-hasCannotCaptureTypesError: false
+-hasConflictingConstraints: false
+-hasContradiction: true
+-hasErrorInConstrainingTypes: false
+-hasParameterConstraintError: false
+-hasTypeInferenceIncorporationError: true
+-hasUnknownParameters: true
+-hasViolatedUpperBound: false
+-isSuccessful: false
+
+result:
+T=???
+P=???
diff --git a/compiler/testData/constraintSystem/severalVariables/recursive/mutuallyRecursive.constraints b/compiler/testData/constraintSystem/severalVariables/recursive/mutuallyRecursive.constraints
new file mode 100644
index 00000000000..2ed17521412
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/recursive/mutuallyRecursive.constraints
@@ -0,0 +1,4 @@
+VARIABLES T P
+
+T := My<P>
+P := Two<T,P>
diff --git a/compiler/testData/constraintSystem/checkStatus/violatedUpperBound.bounds b/compiler/testData/constraintSystem/severalVariables/recursive/simpleRecursive.bounds
similarity index 58%
rename from compiler/testData/constraintSystem/checkStatus/violatedUpperBound.bounds
rename to compiler/testData/constraintSystem/severalVariables/recursive/simpleRecursive.bounds
index b2e152f04dc..1648e2c0267 100644
--- a/compiler/testData/constraintSystem/checkStatus/violatedUpperBound.bounds
+++ b/compiler/testData/constraintSystem/severalVariables/recursive/simpleRecursive.bounds
@@ -1,18 +1,20 @@
 VARIABLES T
 
-SUBTYPE T Int
-SUBTYPE T String weak
+T := Int
+T := My<T>
 
 type parameter bounds:
-T <: kotlin.Int(SPECIAL), <: kotlin.String(TYPE_BOUND_POSITION(0))
+T := Int, := My<T>*, := My<Int>
+
 status:
 -hasCannotCaptureTypesError: false
 -hasConflictingConstraints: true
 -hasContradiction: true
 -hasErrorInConstrainingTypes: false
--hasTypeConstructorMismatch: false
+-hasParameterConstraintError: false
+-hasTypeInferenceIncorporationError: true
 -hasUnknownParameters: false
--hasViolatedUpperBound: true
+-hasViolatedUpperBound: false
 -isSuccessful: false
 
 result:
diff --git a/compiler/testData/constraintSystem/severalVariables/recursive/simpleRecursive.constraints b/compiler/testData/constraintSystem/severalVariables/recursive/simpleRecursive.constraints
new file mode 100644
index 00000000000..b9aa0ae37c9
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/recursive/simpleRecursive.constraints
@@ -0,0 +1,4 @@
+VARIABLES T
+
+T := Int
+T := My<T>
diff --git a/compiler/testData/constraintSystem/severalVariables/reversed/contravariant/varEqDepEq.bounds b/compiler/testData/constraintSystem/severalVariables/reversed/contravariant/varEqDepEq.bounds
new file mode 100644
index 00000000000..1795c416d39
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/reversed/contravariant/varEqDepEq.bounds
@@ -0,0 +1,23 @@
+VARIABLES T P
+
+P := Consumer<T>
+T := Int
+
+type parameter bounds:
+T := Int
+P := Consumer<T>*, := Consumer<Int>
+
+status:
+-hasCannotCaptureTypesError: false
+-hasConflictingConstraints: false
+-hasContradiction: false
+-hasErrorInConstrainingTypes: false
+-hasParameterConstraintError: false
+-hasTypeInferenceIncorporationError: false
+-hasUnknownParameters: false
+-hasViolatedUpperBound: false
+-isSuccessful: true
+
+result:
+T=Int
+P=Consumer<Int>
diff --git a/compiler/testData/constraintSystem/severalVariables/reversed/contravariant/varEqDepEq.constraints b/compiler/testData/constraintSystem/severalVariables/reversed/contravariant/varEqDepEq.constraints
new file mode 100644
index 00000000000..87ad3fd3433
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/reversed/contravariant/varEqDepEq.constraints
@@ -0,0 +1,4 @@
+VARIABLES T P
+
+P := Consumer<T>
+T := Int
diff --git a/compiler/testData/constraintSystem/severalVariables/reversed/contravariant/varEqDepSub.bounds b/compiler/testData/constraintSystem/severalVariables/reversed/contravariant/varEqDepSub.bounds
new file mode 100644
index 00000000000..401fd9530fd
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/reversed/contravariant/varEqDepSub.bounds
@@ -0,0 +1,23 @@
+VARIABLES T P
+
+P <: Consumer<T>
+T := Int
+
+type parameter bounds:
+T := Int
+P <: Consumer<T>*, <: Consumer<Int>
+
+status:
+-hasCannotCaptureTypesError: false
+-hasConflictingConstraints: false
+-hasContradiction: false
+-hasErrorInConstrainingTypes: false
+-hasParameterConstraintError: false
+-hasTypeInferenceIncorporationError: false
+-hasUnknownParameters: false
+-hasViolatedUpperBound: false
+-isSuccessful: true
+
+result:
+T=Int
+P=Consumer<Int>
diff --git a/compiler/testData/constraintSystem/severalVariables/reversed/contravariant/varEqDepSub.constraints b/compiler/testData/constraintSystem/severalVariables/reversed/contravariant/varEqDepSub.constraints
new file mode 100644
index 00000000000..351d8eaf131
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/reversed/contravariant/varEqDepSub.constraints
@@ -0,0 +1,4 @@
+VARIABLES T P
+
+P <: Consumer<T>
+T := Int
diff --git a/compiler/testData/constraintSystem/severalVariables/reversed/contravariant/varEqDepSuper.bounds b/compiler/testData/constraintSystem/severalVariables/reversed/contravariant/varEqDepSuper.bounds
new file mode 100644
index 00000000000..2a742d23c3a
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/reversed/contravariant/varEqDepSuper.bounds
@@ -0,0 +1,23 @@
+VARIABLES T P
+
+P >: Consumer<T>
+T := Int
+
+type parameter bounds:
+T := Int
+P >: Consumer<T>*, >: Consumer<Int>
+
+status:
+-hasCannotCaptureTypesError: false
+-hasConflictingConstraints: false
+-hasContradiction: false
+-hasErrorInConstrainingTypes: false
+-hasParameterConstraintError: false
+-hasTypeInferenceIncorporationError: false
+-hasUnknownParameters: false
+-hasViolatedUpperBound: false
+-isSuccessful: true
+
+result:
+T=Int
+P=Consumer<Int>
diff --git a/compiler/testData/constraintSystem/severalVariables/reversed/contravariant/varEqDepSuper.constraints b/compiler/testData/constraintSystem/severalVariables/reversed/contravariant/varEqDepSuper.constraints
new file mode 100644
index 00000000000..369da5efafd
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/reversed/contravariant/varEqDepSuper.constraints
@@ -0,0 +1,4 @@
+VARIABLES T P
+
+P >: Consumer<T>
+T := Int
diff --git a/compiler/testData/constraintSystem/severalVariables/reversed/contravariant/varSubDepEq.bounds b/compiler/testData/constraintSystem/severalVariables/reversed/contravariant/varSubDepEq.bounds
new file mode 100644
index 00000000000..a149983ad25
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/reversed/contravariant/varSubDepEq.bounds
@@ -0,0 +1,23 @@
+VARIABLES T P
+
+P := Consumer<T>
+T <: Int
+
+type parameter bounds:
+T <: Int
+P := Consumer<T>*, >: Consumer<Int>
+
+status:
+-hasCannotCaptureTypesError: false
+-hasConflictingConstraints: false
+-hasContradiction: false
+-hasErrorInConstrainingTypes: false
+-hasParameterConstraintError: false
+-hasTypeInferenceIncorporationError: false
+-hasUnknownParameters: false
+-hasViolatedUpperBound: false
+-isSuccessful: true
+
+result:
+T=Int
+P=Consumer<Int>
diff --git a/compiler/testData/constraintSystem/severalVariables/reversed/contravariant/varSubDepEq.constraints b/compiler/testData/constraintSystem/severalVariables/reversed/contravariant/varSubDepEq.constraints
new file mode 100644
index 00000000000..32270663ab3
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/reversed/contravariant/varSubDepEq.constraints
@@ -0,0 +1,4 @@
+VARIABLES T P
+
+P := Consumer<T>
+T <: Int
diff --git a/compiler/testData/constraintSystem/severalVariables/reversed/contravariant/varSubDepSub.bounds b/compiler/testData/constraintSystem/severalVariables/reversed/contravariant/varSubDepSub.bounds
new file mode 100644
index 00000000000..389ff911b14
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/reversed/contravariant/varSubDepSub.bounds
@@ -0,0 +1,23 @@
+VARIABLES T P
+
+P <: Consumer<T>
+T <: Int
+
+type parameter bounds:
+T <: Int
+P <: Consumer<T>*
+
+status:
+-hasCannotCaptureTypesError: false
+-hasConflictingConstraints: false
+-hasContradiction: false
+-hasErrorInConstrainingTypes: false
+-hasParameterConstraintError: false
+-hasTypeInferenceIncorporationError: false
+-hasUnknownParameters: true
+-hasViolatedUpperBound: false
+-isSuccessful: false
+
+result:
+T=Int
+P=???
diff --git a/compiler/testData/constraintSystem/severalVariables/reversed/contravariant/varSubDepSub.constraints b/compiler/testData/constraintSystem/severalVariables/reversed/contravariant/varSubDepSub.constraints
new file mode 100644
index 00000000000..554dba141ff
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/reversed/contravariant/varSubDepSub.constraints
@@ -0,0 +1,4 @@
+VARIABLES T P
+
+P <: Consumer<T>
+T <: Int
diff --git a/compiler/testData/constraintSystem/severalVariables/reversed/contravariant/varSubDepSuper.bounds b/compiler/testData/constraintSystem/severalVariables/reversed/contravariant/varSubDepSuper.bounds
new file mode 100644
index 00000000000..99b6278f3a9
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/reversed/contravariant/varSubDepSuper.bounds
@@ -0,0 +1,23 @@
+VARIABLES T P
+
+P >: Consumer<T>
+T <: Int
+
+type parameter bounds:
+T <: Int
+P >: Consumer<T>*, >: Consumer<Int>
+
+status:
+-hasCannotCaptureTypesError: false
+-hasConflictingConstraints: false
+-hasContradiction: false
+-hasErrorInConstrainingTypes: false
+-hasParameterConstraintError: false
+-hasTypeInferenceIncorporationError: false
+-hasUnknownParameters: false
+-hasViolatedUpperBound: false
+-isSuccessful: true
+
+result:
+T=Int
+P=Consumer<Int>
diff --git a/compiler/testData/constraintSystem/severalVariables/reversed/contravariant/varSubDepSuper.constraints b/compiler/testData/constraintSystem/severalVariables/reversed/contravariant/varSubDepSuper.constraints
new file mode 100644
index 00000000000..133d23b9695
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/reversed/contravariant/varSubDepSuper.constraints
@@ -0,0 +1,4 @@
+VARIABLES T P
+
+P >: Consumer<T>
+T <: Int
diff --git a/compiler/testData/constraintSystem/severalVariables/reversed/contravariant/varSuperDepEq.bounds b/compiler/testData/constraintSystem/severalVariables/reversed/contravariant/varSuperDepEq.bounds
new file mode 100644
index 00000000000..56d84654e41
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/reversed/contravariant/varSuperDepEq.bounds
@@ -0,0 +1,23 @@
+VARIABLES T P
+
+P := Consumer<T>
+T >: Int
+
+type parameter bounds:
+T >: Int
+P := Consumer<T>*, <: Consumer<Int>
+
+status:
+-hasCannotCaptureTypesError: false
+-hasConflictingConstraints: false
+-hasContradiction: false
+-hasErrorInConstrainingTypes: false
+-hasParameterConstraintError: false
+-hasTypeInferenceIncorporationError: false
+-hasUnknownParameters: false
+-hasViolatedUpperBound: false
+-isSuccessful: true
+
+result:
+T=Int
+P=Consumer<Int>
diff --git a/compiler/testData/constraintSystem/severalVariables/reversed/contravariant/varSuperDepEq.constraints b/compiler/testData/constraintSystem/severalVariables/reversed/contravariant/varSuperDepEq.constraints
new file mode 100644
index 00000000000..bc5ef67d057
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/reversed/contravariant/varSuperDepEq.constraints
@@ -0,0 +1,4 @@
+VARIABLES T P
+
+P := Consumer<T>
+T >: Int
diff --git a/compiler/testData/constraintSystem/severalVariables/reversed/contravariant/varSuperDepSub.bounds b/compiler/testData/constraintSystem/severalVariables/reversed/contravariant/varSuperDepSub.bounds
new file mode 100644
index 00000000000..96d7264ad3b
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/reversed/contravariant/varSuperDepSub.bounds
@@ -0,0 +1,23 @@
+VARIABLES T P
+
+P <: Consumer<T>
+T >: Int
+
+type parameter bounds:
+T >: Int
+P <: Consumer<T>*, <: Consumer<Int>
+
+status:
+-hasCannotCaptureTypesError: false
+-hasConflictingConstraints: false
+-hasContradiction: false
+-hasErrorInConstrainingTypes: false
+-hasParameterConstraintError: false
+-hasTypeInferenceIncorporationError: false
+-hasUnknownParameters: false
+-hasViolatedUpperBound: false
+-isSuccessful: true
+
+result:
+T=Int
+P=Consumer<Int>
diff --git a/compiler/testData/constraintSystem/severalVariables/reversed/contravariant/varSuperDepSub.constraints b/compiler/testData/constraintSystem/severalVariables/reversed/contravariant/varSuperDepSub.constraints
new file mode 100644
index 00000000000..8aa51d752f8
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/reversed/contravariant/varSuperDepSub.constraints
@@ -0,0 +1,4 @@
+VARIABLES T P
+
+P <: Consumer<T>
+T >: Int
diff --git a/compiler/testData/constraintSystem/severalVariables/reversed/contravariant/varSuperDepSuper.bounds b/compiler/testData/constraintSystem/severalVariables/reversed/contravariant/varSuperDepSuper.bounds
new file mode 100644
index 00000000000..2a8fe671e57
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/reversed/contravariant/varSuperDepSuper.bounds
@@ -0,0 +1,23 @@
+VARIABLES T P
+
+P >: Consumer<T>
+T >: Int
+
+type parameter bounds:
+T >: Int
+P >: Consumer<T>*
+
+status:
+-hasCannotCaptureTypesError: false
+-hasConflictingConstraints: false
+-hasContradiction: false
+-hasErrorInConstrainingTypes: false
+-hasParameterConstraintError: false
+-hasTypeInferenceIncorporationError: false
+-hasUnknownParameters: true
+-hasViolatedUpperBound: false
+-isSuccessful: false
+
+result:
+T=Int
+P=???
diff --git a/compiler/testData/constraintSystem/severalVariables/reversed/contravariant/varSuperDepSuper.constraints b/compiler/testData/constraintSystem/severalVariables/reversed/contravariant/varSuperDepSuper.constraints
new file mode 100644
index 00000000000..5508d75c40b
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/reversed/contravariant/varSuperDepSuper.constraints
@@ -0,0 +1,4 @@
+VARIABLES T P
+
+P >: Consumer<T>
+T >: Int
diff --git a/compiler/testData/constraintSystem/severalVariables/reversed/covariant/varEqDepEq.bounds b/compiler/testData/constraintSystem/severalVariables/reversed/covariant/varEqDepEq.bounds
new file mode 100644
index 00000000000..a3773af2958
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/reversed/covariant/varEqDepEq.bounds
@@ -0,0 +1,23 @@
+VARIABLES T P
+
+P := Producer<T>
+T := Int
+
+type parameter bounds:
+T := Int
+P := Producer<T>*, := Producer<Int>
+
+status:
+-hasCannotCaptureTypesError: false
+-hasConflictingConstraints: false
+-hasContradiction: false
+-hasErrorInConstrainingTypes: false
+-hasParameterConstraintError: false
+-hasTypeInferenceIncorporationError: false
+-hasUnknownParameters: false
+-hasViolatedUpperBound: false
+-isSuccessful: true
+
+result:
+T=Int
+P=Producer<Int>
diff --git a/compiler/testData/constraintSystem/severalVariables/reversed/covariant/varEqDepEq.constraints b/compiler/testData/constraintSystem/severalVariables/reversed/covariant/varEqDepEq.constraints
new file mode 100644
index 00000000000..e7fb378f929
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/reversed/covariant/varEqDepEq.constraints
@@ -0,0 +1,4 @@
+VARIABLES T P
+
+P := Producer<T>
+T := Int
diff --git a/compiler/testData/constraintSystem/severalVariables/reversed/covariant/varEqDepSub.bounds b/compiler/testData/constraintSystem/severalVariables/reversed/covariant/varEqDepSub.bounds
new file mode 100644
index 00000000000..0d8ad2b94ac
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/reversed/covariant/varEqDepSub.bounds
@@ -0,0 +1,23 @@
+VARIABLES T P
+
+P <: Producer<T>
+T := Int
+
+type parameter bounds:
+T := Int
+P <: Producer<T>*, <: Producer<Int>
+
+status:
+-hasCannotCaptureTypesError: false
+-hasConflictingConstraints: false
+-hasContradiction: false
+-hasErrorInConstrainingTypes: false
+-hasParameterConstraintError: false
+-hasTypeInferenceIncorporationError: false
+-hasUnknownParameters: false
+-hasViolatedUpperBound: false
+-isSuccessful: true
+
+result:
+T=Int
+P=Producer<Int>
diff --git a/compiler/testData/constraintSystem/severalVariables/reversed/covariant/varEqDepSub.constraints b/compiler/testData/constraintSystem/severalVariables/reversed/covariant/varEqDepSub.constraints
new file mode 100644
index 00000000000..29dd6ed603c
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/reversed/covariant/varEqDepSub.constraints
@@ -0,0 +1,4 @@
+VARIABLES T P
+
+P <: Producer<T>
+T := Int
diff --git a/compiler/testData/constraintSystem/severalVariables/reversed/covariant/varEqDepSuper.bounds b/compiler/testData/constraintSystem/severalVariables/reversed/covariant/varEqDepSuper.bounds
new file mode 100644
index 00000000000..300b1ea3056
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/reversed/covariant/varEqDepSuper.bounds
@@ -0,0 +1,23 @@
+VARIABLES T P
+
+P >: Producer<T>
+T := Int
+
+type parameter bounds:
+T := Int
+P >: Producer<T>*, >: Producer<Int>
+
+status:
+-hasCannotCaptureTypesError: false
+-hasConflictingConstraints: false
+-hasContradiction: false
+-hasErrorInConstrainingTypes: false
+-hasParameterConstraintError: false
+-hasTypeInferenceIncorporationError: false
+-hasUnknownParameters: false
+-hasViolatedUpperBound: false
+-isSuccessful: true
+
+result:
+T=Int
+P=Producer<Int>
diff --git a/compiler/testData/constraintSystem/severalVariables/reversed/covariant/varEqDepSuper.constraints b/compiler/testData/constraintSystem/severalVariables/reversed/covariant/varEqDepSuper.constraints
new file mode 100644
index 00000000000..ef7338d2564
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/reversed/covariant/varEqDepSuper.constraints
@@ -0,0 +1,4 @@
+VARIABLES T P
+
+P >: Producer<T>
+T := Int
diff --git a/compiler/testData/constraintSystem/severalVariables/reversed/covariant/varSubDepEq.bounds b/compiler/testData/constraintSystem/severalVariables/reversed/covariant/varSubDepEq.bounds
new file mode 100644
index 00000000000..9fa78404a59
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/reversed/covariant/varSubDepEq.bounds
@@ -0,0 +1,23 @@
+VARIABLES T P
+
+P := Producer<T>
+T <: Int
+
+type parameter bounds:
+T <: Int
+P := Producer<T>*, <: Producer<Int>
+
+status:
+-hasCannotCaptureTypesError: false
+-hasConflictingConstraints: false
+-hasContradiction: false
+-hasErrorInConstrainingTypes: false
+-hasParameterConstraintError: false
+-hasTypeInferenceIncorporationError: false
+-hasUnknownParameters: false
+-hasViolatedUpperBound: false
+-isSuccessful: true
+
+result:
+T=Int
+P=Producer<Int>
diff --git a/compiler/testData/constraintSystem/severalVariables/reversed/covariant/varSubDepEq.constraints b/compiler/testData/constraintSystem/severalVariables/reversed/covariant/varSubDepEq.constraints
new file mode 100644
index 00000000000..fb8e245ccf5
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/reversed/covariant/varSubDepEq.constraints
@@ -0,0 +1,4 @@
+VARIABLES T P
+
+P := Producer<T>
+T <: Int
diff --git a/compiler/testData/constraintSystem/severalVariables/reversed/covariant/varSubDepSub.bounds b/compiler/testData/constraintSystem/severalVariables/reversed/covariant/varSubDepSub.bounds
new file mode 100644
index 00000000000..01a5fec3d57
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/reversed/covariant/varSubDepSub.bounds
@@ -0,0 +1,23 @@
+VARIABLES T P
+
+P <: Producer<T>
+T <: Int
+
+type parameter bounds:
+T <: Int
+P <: Producer<T>*, <: Producer<Int>
+
+status:
+-hasCannotCaptureTypesError: false
+-hasConflictingConstraints: false
+-hasContradiction: false
+-hasErrorInConstrainingTypes: false
+-hasParameterConstraintError: false
+-hasTypeInferenceIncorporationError: false
+-hasUnknownParameters: false
+-hasViolatedUpperBound: false
+-isSuccessful: true
+
+result:
+T=Int
+P=Producer<Int>
diff --git a/compiler/testData/constraintSystem/severalVariables/reversed/covariant/varSubDepSub.constraints b/compiler/testData/constraintSystem/severalVariables/reversed/covariant/varSubDepSub.constraints
new file mode 100644
index 00000000000..2d0376eff10
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/reversed/covariant/varSubDepSub.constraints
@@ -0,0 +1,4 @@
+VARIABLES T P
+
+P <: Producer<T>
+T <: Int
diff --git a/compiler/testData/constraintSystem/severalVariables/reversed/covariant/varSubDepSuper.bounds b/compiler/testData/constraintSystem/severalVariables/reversed/covariant/varSubDepSuper.bounds
new file mode 100644
index 00000000000..c0813347848
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/reversed/covariant/varSubDepSuper.bounds
@@ -0,0 +1,23 @@
+VARIABLES T P
+
+P >: Producer<T>
+T <: Int
+
+type parameter bounds:
+T <: Int
+P >: Producer<T>*
+
+status:
+-hasCannotCaptureTypesError: false
+-hasConflictingConstraints: false
+-hasContradiction: false
+-hasErrorInConstrainingTypes: false
+-hasParameterConstraintError: false
+-hasTypeInferenceIncorporationError: false
+-hasUnknownParameters: true
+-hasViolatedUpperBound: false
+-isSuccessful: false
+
+result:
+T=Int
+P=???
diff --git a/compiler/testData/constraintSystem/severalVariables/reversed/covariant/varSubDepSuper.constraints b/compiler/testData/constraintSystem/severalVariables/reversed/covariant/varSubDepSuper.constraints
new file mode 100644
index 00000000000..b917df226fe
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/reversed/covariant/varSubDepSuper.constraints
@@ -0,0 +1,4 @@
+VARIABLES T P
+
+P >: Producer<T>
+T <: Int
diff --git a/compiler/testData/constraintSystem/severalVariables/reversed/covariant/varSuperDepEq.bounds b/compiler/testData/constraintSystem/severalVariables/reversed/covariant/varSuperDepEq.bounds
new file mode 100644
index 00000000000..4207c874b2f
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/reversed/covariant/varSuperDepEq.bounds
@@ -0,0 +1,23 @@
+VARIABLES T P
+
+P := Producer<T>
+T >: Int
+
+type parameter bounds:
+T >: Int
+P := Producer<T>*, >: Producer<Int>
+
+status:
+-hasCannotCaptureTypesError: false
+-hasConflictingConstraints: false
+-hasContradiction: false
+-hasErrorInConstrainingTypes: false
+-hasParameterConstraintError: false
+-hasTypeInferenceIncorporationError: false
+-hasUnknownParameters: false
+-hasViolatedUpperBound: false
+-isSuccessful: true
+
+result:
+T=Int
+P=Producer<Int>
diff --git a/compiler/testData/constraintSystem/severalVariables/reversed/covariant/varSuperDepEq.constraints b/compiler/testData/constraintSystem/severalVariables/reversed/covariant/varSuperDepEq.constraints
new file mode 100644
index 00000000000..ef9b6856bc2
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/reversed/covariant/varSuperDepEq.constraints
@@ -0,0 +1,4 @@
+VARIABLES T P
+
+P := Producer<T>
+T >: Int
diff --git a/compiler/testData/constraintSystem/severalVariables/reversed/covariant/varSuperDepSub.bounds b/compiler/testData/constraintSystem/severalVariables/reversed/covariant/varSuperDepSub.bounds
new file mode 100644
index 00000000000..8ae260d9c7c
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/reversed/covariant/varSuperDepSub.bounds
@@ -0,0 +1,23 @@
+VARIABLES T P
+
+P <: Producer<T>
+T >: Int
+
+type parameter bounds:
+T >: Int
+P <: Producer<T>*
+
+status:
+-hasCannotCaptureTypesError: false
+-hasConflictingConstraints: false
+-hasContradiction: false
+-hasErrorInConstrainingTypes: false
+-hasParameterConstraintError: false
+-hasTypeInferenceIncorporationError: false
+-hasUnknownParameters: true
+-hasViolatedUpperBound: false
+-isSuccessful: false
+
+result:
+T=Int
+P=???
diff --git a/compiler/testData/constraintSystem/severalVariables/reversed/covariant/varSuperDepSub.constraints b/compiler/testData/constraintSystem/severalVariables/reversed/covariant/varSuperDepSub.constraints
new file mode 100644
index 00000000000..c59156c590c
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/reversed/covariant/varSuperDepSub.constraints
@@ -0,0 +1,4 @@
+VARIABLES T P
+
+P <: Producer<T>
+T >: Int
diff --git a/compiler/testData/constraintSystem/severalVariables/reversed/covariant/varSuperDepSuper.bounds b/compiler/testData/constraintSystem/severalVariables/reversed/covariant/varSuperDepSuper.bounds
new file mode 100644
index 00000000000..8d7e1902c21
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/reversed/covariant/varSuperDepSuper.bounds
@@ -0,0 +1,23 @@
+VARIABLES T P
+
+P >: Producer<T>
+T >: Int
+
+type parameter bounds:
+T >: Int
+P >: Producer<T>*, >: Producer<Int>
+
+status:
+-hasCannotCaptureTypesError: false
+-hasConflictingConstraints: false
+-hasContradiction: false
+-hasErrorInConstrainingTypes: false
+-hasParameterConstraintError: false
+-hasTypeInferenceIncorporationError: false
+-hasUnknownParameters: false
+-hasViolatedUpperBound: false
+-isSuccessful: true
+
+result:
+T=Int
+P=Producer<Int>
diff --git a/compiler/testData/constraintSystem/severalVariables/reversed/covariant/varSuperDepSuper.constraints b/compiler/testData/constraintSystem/severalVariables/reversed/covariant/varSuperDepSuper.constraints
new file mode 100644
index 00000000000..225dedbb5ee
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/reversed/covariant/varSuperDepSuper.constraints
@@ -0,0 +1,4 @@
+VARIABLES T P
+
+P >: Producer<T>
+T >: Int
diff --git a/compiler/testData/constraintSystem/severalVariables/reversed/invariant/varEqDepEq.bounds b/compiler/testData/constraintSystem/severalVariables/reversed/invariant/varEqDepEq.bounds
new file mode 100644
index 00000000000..22b57745b7b
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/reversed/invariant/varEqDepEq.bounds
@@ -0,0 +1,23 @@
+VARIABLES T P
+
+P := My<T>
+T := Int
+
+type parameter bounds:
+T := Int
+P := My<T>*, := My<Int>
+
+status:
+-hasCannotCaptureTypesError: false
+-hasConflictingConstraints: false
+-hasContradiction: false
+-hasErrorInConstrainingTypes: false
+-hasParameterConstraintError: false
+-hasTypeInferenceIncorporationError: false
+-hasUnknownParameters: false
+-hasViolatedUpperBound: false
+-isSuccessful: true
+
+result:
+T=Int
+P=My<Int>
diff --git a/compiler/testData/constraintSystem/severalVariables/reversed/invariant/varEqDepEq.constraints b/compiler/testData/constraintSystem/severalVariables/reversed/invariant/varEqDepEq.constraints
new file mode 100644
index 00000000000..4d2c01477ce
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/reversed/invariant/varEqDepEq.constraints
@@ -0,0 +1,4 @@
+VARIABLES T P
+
+P := My<T>
+T := Int
diff --git a/compiler/testData/constraintSystem/severalVariables/reversed/invariant/varEqDepSub.bounds b/compiler/testData/constraintSystem/severalVariables/reversed/invariant/varEqDepSub.bounds
new file mode 100644
index 00000000000..d87dd002dc8
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/reversed/invariant/varEqDepSub.bounds
@@ -0,0 +1,23 @@
+VARIABLES T P
+
+P <: My<T>
+T := Int
+
+type parameter bounds:
+T := Int
+P <: My<T>*, <: My<Int>
+
+status:
+-hasCannotCaptureTypesError: false
+-hasConflictingConstraints: false
+-hasContradiction: false
+-hasErrorInConstrainingTypes: false
+-hasParameterConstraintError: false
+-hasTypeInferenceIncorporationError: false
+-hasUnknownParameters: false
+-hasViolatedUpperBound: false
+-isSuccessful: true
+
+result:
+T=Int
+P=My<Int>
diff --git a/compiler/testData/constraintSystem/severalVariables/reversed/invariant/varEqDepSub.constraints b/compiler/testData/constraintSystem/severalVariables/reversed/invariant/varEqDepSub.constraints
new file mode 100644
index 00000000000..82eb3f24f17
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/reversed/invariant/varEqDepSub.constraints
@@ -0,0 +1,4 @@
+VARIABLES T P
+
+P <: My<T>
+T := Int
diff --git a/compiler/testData/constraintSystem/severalVariables/reversed/invariant/varEqDepSuper.bounds b/compiler/testData/constraintSystem/severalVariables/reversed/invariant/varEqDepSuper.bounds
new file mode 100644
index 00000000000..cb319b51e66
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/reversed/invariant/varEqDepSuper.bounds
@@ -0,0 +1,23 @@
+VARIABLES T P
+
+P >: My<T>
+T := Int
+
+type parameter bounds:
+T := Int
+P >: My<T>*, >: My<Int>
+
+status:
+-hasCannotCaptureTypesError: false
+-hasConflictingConstraints: false
+-hasContradiction: false
+-hasErrorInConstrainingTypes: false
+-hasParameterConstraintError: false
+-hasTypeInferenceIncorporationError: false
+-hasUnknownParameters: false
+-hasViolatedUpperBound: false
+-isSuccessful: true
+
+result:
+T=Int
+P=My<Int>
diff --git a/compiler/testData/constraintSystem/severalVariables/reversed/invariant/varEqDepSuper.constraints b/compiler/testData/constraintSystem/severalVariables/reversed/invariant/varEqDepSuper.constraints
new file mode 100644
index 00000000000..579046f1a40
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/reversed/invariant/varEqDepSuper.constraints
@@ -0,0 +1,4 @@
+VARIABLES T P
+
+P >: My<T>
+T := Int
diff --git a/compiler/testData/constraintSystem/severalVariables/reversed/invariant/varSubDepEq.bounds b/compiler/testData/constraintSystem/severalVariables/reversed/invariant/varSubDepEq.bounds
new file mode 100644
index 00000000000..48e44a1583b
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/reversed/invariant/varSubDepEq.bounds
@@ -0,0 +1,23 @@
+VARIABLES T P
+
+P := My<T>
+T <: Int
+
+type parameter bounds:
+T <: Int
+P := My<T>*
+
+status:
+-hasCannotCaptureTypesError: false
+-hasConflictingConstraints: false
+-hasContradiction: true
+-hasErrorInConstrainingTypes: false
+-hasParameterConstraintError: false
+-hasTypeInferenceIncorporationError: true
+-hasUnknownParameters: true
+-hasViolatedUpperBound: false
+-isSuccessful: false
+
+result:
+T=Int
+P=???
diff --git a/compiler/testData/constraintSystem/severalVariables/reversed/invariant/varSubDepEq.constraints b/compiler/testData/constraintSystem/severalVariables/reversed/invariant/varSubDepEq.constraints
new file mode 100644
index 00000000000..77fa46314fd
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/reversed/invariant/varSubDepEq.constraints
@@ -0,0 +1,4 @@
+VARIABLES T P
+
+P := My<T>
+T <: Int
diff --git a/compiler/testData/constraintSystem/severalVariables/reversed/invariant/varSubDepSub.bounds b/compiler/testData/constraintSystem/severalVariables/reversed/invariant/varSubDepSub.bounds
new file mode 100644
index 00000000000..8b737201b99
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/reversed/invariant/varSubDepSub.bounds
@@ -0,0 +1,23 @@
+VARIABLES T P
+
+P <: My<T>
+T <: Int
+
+type parameter bounds:
+T <: Int
+P <: My<T>*
+
+status:
+-hasCannotCaptureTypesError: false
+-hasConflictingConstraints: false
+-hasContradiction: false
+-hasErrorInConstrainingTypes: false
+-hasParameterConstraintError: false
+-hasTypeInferenceIncorporationError: false
+-hasUnknownParameters: true
+-hasViolatedUpperBound: false
+-isSuccessful: false
+
+result:
+T=Int
+P=???
diff --git a/compiler/testData/constraintSystem/severalVariables/reversed/invariant/varSubDepSub.constraints b/compiler/testData/constraintSystem/severalVariables/reversed/invariant/varSubDepSub.constraints
new file mode 100644
index 00000000000..3ec171fd99d
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/reversed/invariant/varSubDepSub.constraints
@@ -0,0 +1,4 @@
+VARIABLES T P
+
+P <: My<T>
+T <: Int
diff --git a/compiler/testData/constraintSystem/severalVariables/reversed/invariant/varSubDepSuper.bounds b/compiler/testData/constraintSystem/severalVariables/reversed/invariant/varSubDepSuper.bounds
new file mode 100644
index 00000000000..bc766a0170e
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/reversed/invariant/varSubDepSuper.bounds
@@ -0,0 +1,23 @@
+VARIABLES T P
+
+P >: My<T>
+T <: Int
+
+type parameter bounds:
+T <: Int
+P >: My<T>*
+
+status:
+-hasCannotCaptureTypesError: false
+-hasConflictingConstraints: false
+-hasContradiction: false
+-hasErrorInConstrainingTypes: false
+-hasParameterConstraintError: false
+-hasTypeInferenceIncorporationError: false
+-hasUnknownParameters: true
+-hasViolatedUpperBound: false
+-isSuccessful: false
+
+result:
+T=Int
+P=???
diff --git a/compiler/testData/constraintSystem/severalVariables/reversed/invariant/varSubDepSuper.constraints b/compiler/testData/constraintSystem/severalVariables/reversed/invariant/varSubDepSuper.constraints
new file mode 100644
index 00000000000..51521bac5f5
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/reversed/invariant/varSubDepSuper.constraints
@@ -0,0 +1,4 @@
+VARIABLES T P
+
+P >: My<T>
+T <: Int
diff --git a/compiler/testData/constraintSystem/severalVariables/reversed/invariant/varSuperDepEq.bounds b/compiler/testData/constraintSystem/severalVariables/reversed/invariant/varSuperDepEq.bounds
new file mode 100644
index 00000000000..43a0a302b7c
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/reversed/invariant/varSuperDepEq.bounds
@@ -0,0 +1,23 @@
+VARIABLES T P
+
+P := My<T>
+T >: Int
+
+type parameter bounds:
+T >: Int
+P := My<T>*
+
+status:
+-hasCannotCaptureTypesError: false
+-hasConflictingConstraints: false
+-hasContradiction: true
+-hasErrorInConstrainingTypes: false
+-hasParameterConstraintError: false
+-hasTypeInferenceIncorporationError: true
+-hasUnknownParameters: true
+-hasViolatedUpperBound: false
+-isSuccessful: false
+
+result:
+T=Int
+P=???
diff --git a/compiler/testData/constraintSystem/severalVariables/reversed/invariant/varSuperDepEq.constraints b/compiler/testData/constraintSystem/severalVariables/reversed/invariant/varSuperDepEq.constraints
new file mode 100644
index 00000000000..855195c6593
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/reversed/invariant/varSuperDepEq.constraints
@@ -0,0 +1,4 @@
+VARIABLES T P
+
+P := My<T>
+T >: Int
diff --git a/compiler/testData/constraintSystem/severalVariables/reversed/invariant/varSuperDepSub.bounds b/compiler/testData/constraintSystem/severalVariables/reversed/invariant/varSuperDepSub.bounds
new file mode 100644
index 00000000000..8f6fa7723b7
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/reversed/invariant/varSuperDepSub.bounds
@@ -0,0 +1,23 @@
+VARIABLES T P
+
+P <: My<T>
+T >: Int
+
+type parameter bounds:
+T >: Int
+P <: My<T>*
+
+status:
+-hasCannotCaptureTypesError: false
+-hasConflictingConstraints: false
+-hasContradiction: false
+-hasErrorInConstrainingTypes: false
+-hasParameterConstraintError: false
+-hasTypeInferenceIncorporationError: false
+-hasUnknownParameters: true
+-hasViolatedUpperBound: false
+-isSuccessful: false
+
+result:
+T=Int
+P=???
diff --git a/compiler/testData/constraintSystem/severalVariables/reversed/invariant/varSuperDepSub.constraints b/compiler/testData/constraintSystem/severalVariables/reversed/invariant/varSuperDepSub.constraints
new file mode 100644
index 00000000000..cb57ae20f53
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/reversed/invariant/varSuperDepSub.constraints
@@ -0,0 +1,4 @@
+VARIABLES T P
+
+P <: My<T>
+T >: Int
diff --git a/compiler/testData/constraintSystem/severalVariables/reversed/invariant/varSuperDepSuper.bounds b/compiler/testData/constraintSystem/severalVariables/reversed/invariant/varSuperDepSuper.bounds
new file mode 100644
index 00000000000..47a058f35a9
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/reversed/invariant/varSuperDepSuper.bounds
@@ -0,0 +1,23 @@
+VARIABLES T P
+
+P >: My<T>
+T >: Int
+
+type parameter bounds:
+T >: Int
+P >: My<T>*
+
+status:
+-hasCannotCaptureTypesError: false
+-hasConflictingConstraints: false
+-hasContradiction: false
+-hasErrorInConstrainingTypes: false
+-hasParameterConstraintError: false
+-hasTypeInferenceIncorporationError: false
+-hasUnknownParameters: true
+-hasViolatedUpperBound: false
+-isSuccessful: false
+
+result:
+T=Int
+P=???
diff --git a/compiler/testData/constraintSystem/severalVariables/reversed/invariant/varSuperDepSuper.constraints b/compiler/testData/constraintSystem/severalVariables/reversed/invariant/varSuperDepSuper.constraints
new file mode 100644
index 00000000000..57f94b389e7
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/reversed/invariant/varSuperDepSuper.constraints
@@ -0,0 +1,4 @@
+VARIABLES T P
+
+P >: My<T>
+T >: Int
diff --git a/compiler/testData/constraintSystem/severalVariables/simpleDependency.bounds b/compiler/testData/constraintSystem/severalVariables/simpleDependency.bounds
index d8a26467e48..16181e690db 100644
--- a/compiler/testData/constraintSystem/severalVariables/simpleDependency.bounds
+++ b/compiler/testData/constraintSystem/severalVariables/simpleDependency.bounds
@@ -1,21 +1,22 @@
 VARIABLES T P
 
-SUBTYPE T Int
+T <: Int
 
 type parameter bounds:
-T <: kotlin.Int(SPECIAL)
-P <: kotlin.Int(COMPOUND_CONSTRAINT_POSITION(TYPE_BOUND_POSITION(1), SPECIAL)
+T <: Int
+P
+
 status:
 -hasCannotCaptureTypesError: false
 -hasConflictingConstraints: false
 -hasContradiction: false
 -hasErrorInConstrainingTypes: false
--hasTypeConstructorMismatch: false
--hasUnknownParameters: false
+-hasParameterConstraintError: false
+-hasTypeInferenceIncorporationError: false
+-hasUnknownParameters: true
 -hasViolatedUpperBound: false
--isSuccessful: true
+-isSuccessful: false
 
 result:
-T=kotlin.Int
-P=kotlin.Int
-
+T=Int
+P=???
diff --git a/compiler/testData/constraintSystem/severalVariables/simpleDependency.constraints b/compiler/testData/constraintSystem/severalVariables/simpleDependency.constraints
new file mode 100644
index 00000000000..edc91fdd59c
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/simpleDependency.constraints
@@ -0,0 +1,3 @@
+VARIABLES T P
+
+T <: Int
diff --git a/compiler/testData/constraintSystem/severalVariables/simpleEquality.bounds b/compiler/testData/constraintSystem/severalVariables/simpleEquality.bounds
new file mode 100644
index 00000000000..cd17ade2378
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/simpleEquality.bounds
@@ -0,0 +1,23 @@
+VARIABLES T P
+
+T <: Int
+T := P
+
+type parameter bounds:
+T <: Int, := P*
+P <: Int, := T*
+
+status:
+-hasCannotCaptureTypesError: false
+-hasConflictingConstraints: false
+-hasContradiction: false
+-hasErrorInConstrainingTypes: false
+-hasParameterConstraintError: false
+-hasTypeInferenceIncorporationError: false
+-hasUnknownParameters: false
+-hasViolatedUpperBound: false
+-isSuccessful: true
+
+result:
+T=Int
+P=Int
diff --git a/compiler/testData/constraintSystem/severalVariables/simpleEquality.constraints b/compiler/testData/constraintSystem/severalVariables/simpleEquality.constraints
new file mode 100644
index 00000000000..4a053567d4c
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/simpleEquality.constraints
@@ -0,0 +1,4 @@
+VARIABLES T P
+
+T <: Int
+T := P
diff --git a/compiler/testData/constraintSystem/severalVariables/simpleEquality1.bounds b/compiler/testData/constraintSystem/severalVariables/simpleEquality1.bounds
new file mode 100644
index 00000000000..838f4ec7630
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/simpleEquality1.bounds
@@ -0,0 +1,23 @@
+VARIABLES T P
+
+Int <: T
+T := P
+
+type parameter bounds:
+T >: Int, := P*
+P >: Int, := T*
+
+status:
+-hasCannotCaptureTypesError: false
+-hasConflictingConstraints: false
+-hasContradiction: false
+-hasErrorInConstrainingTypes: false
+-hasParameterConstraintError: false
+-hasTypeInferenceIncorporationError: false
+-hasUnknownParameters: false
+-hasViolatedUpperBound: false
+-isSuccessful: true
+
+result:
+T=Int
+P=Int
diff --git a/compiler/testData/constraintSystem/severalVariables/simpleEquality1.constraints b/compiler/testData/constraintSystem/severalVariables/simpleEquality1.constraints
new file mode 100644
index 00000000000..c048debe4f8
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/simpleEquality1.constraints
@@ -0,0 +1,4 @@
+VARIABLES T P
+
+Int <: T
+T := P
diff --git a/compiler/testData/constraintSystem/severalVariables/simpleReversedDependency.bounds b/compiler/testData/constraintSystem/severalVariables/simpleReversedDependency.bounds
new file mode 100644
index 00000000000..cf9fc0fa44a
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/simpleReversedDependency.bounds
@@ -0,0 +1,23 @@
+VARIABLES T P
+
+T <: Int
+T <: P
+
+type parameter bounds:
+T <: Int, <: P*
+P >: T*
+
+status:
+-hasCannotCaptureTypesError: false
+-hasConflictingConstraints: false
+-hasContradiction: false
+-hasErrorInConstrainingTypes: false
+-hasParameterConstraintError: false
+-hasTypeInferenceIncorporationError: false
+-hasUnknownParameters: true
+-hasViolatedUpperBound: false
+-isSuccessful: false
+
+result:
+T=Int
+P=???
diff --git a/compiler/testData/constraintSystem/severalVariables/simpleReversedDependency.constraints b/compiler/testData/constraintSystem/severalVariables/simpleReversedDependency.constraints
new file mode 100644
index 00000000000..990c06be17a
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/simpleReversedDependency.constraints
@@ -0,0 +1,4 @@
+VARIABLES T P
+
+T <: Int
+T <: P
diff --git a/compiler/testData/constraintSystem/severalVariables/simpleSubtype.bounds b/compiler/testData/constraintSystem/severalVariables/simpleSubtype.bounds
new file mode 100644
index 00000000000..f3c152d1d39
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/simpleSubtype.bounds
@@ -0,0 +1,23 @@
+VARIABLES T P
+
+T <: Int
+P <: T
+
+type parameter bounds:
+T <: Int, >: P*
+P <: T*, <: Int
+
+status:
+-hasCannotCaptureTypesError: false
+-hasConflictingConstraints: false
+-hasContradiction: false
+-hasErrorInConstrainingTypes: false
+-hasParameterConstraintError: false
+-hasTypeInferenceIncorporationError: false
+-hasUnknownParameters: false
+-hasViolatedUpperBound: false
+-isSuccessful: true
+
+result:
+T=Int
+P=Int
diff --git a/compiler/testData/constraintSystem/severalVariables/simpleSubtype.constraints b/compiler/testData/constraintSystem/severalVariables/simpleSubtype.constraints
new file mode 100644
index 00000000000..4c33878795e
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/simpleSubtype.constraints
@@ -0,0 +1,4 @@
+VARIABLES T P
+
+T <: Int
+P <: T
diff --git a/compiler/testData/constraintSystem/severalVariables/simpleSubtype1.bounds b/compiler/testData/constraintSystem/severalVariables/simpleSubtype1.bounds
new file mode 100644
index 00000000000..43f191ef7b0
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/simpleSubtype1.bounds
@@ -0,0 +1,23 @@
+VARIABLES T P
+
+Int <: T
+T <: P
+
+type parameter bounds:
+T >: Int, <: P*
+P >: Int, >: T*
+
+status:
+-hasCannotCaptureTypesError: false
+-hasConflictingConstraints: false
+-hasContradiction: false
+-hasErrorInConstrainingTypes: false
+-hasParameterConstraintError: false
+-hasTypeInferenceIncorporationError: false
+-hasUnknownParameters: false
+-hasViolatedUpperBound: false
+-isSuccessful: true
+
+result:
+T=Int
+P=Int
diff --git a/compiler/testData/constraintSystem/severalVariables/simpleSubtype1.constraints b/compiler/testData/constraintSystem/severalVariables/simpleSubtype1.constraints
new file mode 100644
index 00000000000..7953a434603
--- /dev/null
+++ b/compiler/testData/constraintSystem/severalVariables/simpleSubtype1.constraints
@@ -0,0 +1,4 @@
+VARIABLES T P
+
+Int <: T
+T <: P
diff --git a/compiler/testData/constraintSystem/variance/consumer.bounds b/compiler/testData/constraintSystem/variance/consumer.bounds
index 460d635c820..c240da76aad 100644
--- a/compiler/testData/constraintSystem/variance/consumer.bounds
+++ b/compiler/testData/constraintSystem/variance/consumer.bounds
@@ -1,15 +1,17 @@
 VARIABLES T
 
-SUBTYPE Consumer<A> Consumer<T>
+Consumer<A> <: Consumer<T>
 
 type parameter bounds:
-T <: A(SPECIAL)
+T <: A
+
 status:
 -hasCannotCaptureTypesError: false
 -hasConflictingConstraints: false
 -hasContradiction: false
 -hasErrorInConstrainingTypes: false
--hasTypeConstructorMismatch: false
+-hasParameterConstraintError: false
+-hasTypeInferenceIncorporationError: false
 -hasUnknownParameters: false
 -hasViolatedUpperBound: false
 -isSuccessful: true
diff --git a/compiler/testData/constraintSystem/variance/consumer.constraints b/compiler/testData/constraintSystem/variance/consumer.constraints
new file mode 100644
index 00000000000..7c8111bd7cb
--- /dev/null
+++ b/compiler/testData/constraintSystem/variance/consumer.constraints
@@ -0,0 +1,3 @@
+VARIABLES T
+
+Consumer<A> <: Consumer<T>
diff --git a/compiler/testData/constraintSystem/variance/invariant.bounds b/compiler/testData/constraintSystem/variance/invariant.bounds
index 957eb13f98b..01e9e36d310 100644
--- a/compiler/testData/constraintSystem/variance/invariant.bounds
+++ b/compiler/testData/constraintSystem/variance/invariant.bounds
@@ -1,15 +1,17 @@
 VARIABLES T
 
-SUBTYPE My<T> My<A>
+My<T> <: My<A>
 
 type parameter bounds:
-T := A(SPECIAL)
+T := A
+
 status:
 -hasCannotCaptureTypesError: false
 -hasConflictingConstraints: false
 -hasContradiction: false
 -hasErrorInConstrainingTypes: false
--hasTypeConstructorMismatch: false
+-hasParameterConstraintError: false
+-hasTypeInferenceIncorporationError: false
 -hasUnknownParameters: false
 -hasViolatedUpperBound: false
 -isSuccessful: true
diff --git a/compiler/testData/constraintSystem/variance/invariant.constraints b/compiler/testData/constraintSystem/variance/invariant.constraints
new file mode 100644
index 00000000000..239de367350
--- /dev/null
+++ b/compiler/testData/constraintSystem/variance/invariant.constraints
@@ -0,0 +1,3 @@
+VARIABLES T
+
+My<T> <: My<A>
diff --git a/compiler/testData/constraintSystem/variance/producer.bounds b/compiler/testData/constraintSystem/variance/producer.bounds
index 47b00045c22..583b68e8847 100644
--- a/compiler/testData/constraintSystem/variance/producer.bounds
+++ b/compiler/testData/constraintSystem/variance/producer.bounds
@@ -1,15 +1,17 @@
 VARIABLES T
 
-SUBTYPE Producer<A> Producer<T>
+Producer<A> <: Producer<T>
 
 type parameter bounds:
-T >: A(SPECIAL)
+T >: A
+
 status:
 -hasCannotCaptureTypesError: false
 -hasConflictingConstraints: false
 -hasContradiction: false
 -hasErrorInConstrainingTypes: false
--hasTypeConstructorMismatch: false
+-hasParameterConstraintError: false
+-hasTypeInferenceIncorporationError: false
 -hasUnknownParameters: false
 -hasViolatedUpperBound: false
 -isSuccessful: true
diff --git a/compiler/testData/constraintSystem/variance/producer.constraints b/compiler/testData/constraintSystem/variance/producer.constraints
new file mode 100644
index 00000000000..a9efb4e6e39
--- /dev/null
+++ b/compiler/testData/constraintSystem/variance/producer.constraints
@@ -0,0 +1,3 @@
+VARIABLES T
+
+Producer<A> <: Producer<T>
diff --git a/compiler/testData/diagnostics/tests/Builders.kt b/compiler/testData/diagnostics/tests/Builders.kt
index 2f334cd72d5..0d539318003 100644
--- a/compiler/testData/diagnostics/tests/Builders.kt
+++ b/compiler/testData/diagnostics/tests/Builders.kt
@@ -135,7 +135,7 @@ class A() : BodyTag("a") {
     get() = attributes["href"]
     set(value) {
        if (value != null) {
-           attributes.put("href", value)
+           attributes.put("href", <!DEBUG_INFO_SMARTCAST!>value<!>)
 //         attributes["href"] = value //doesn't work: KT-1355
        }
     }
diff --git a/compiler/testData/diagnostics/tests/Casts.kt b/compiler/testData/diagnostics/tests/Casts.kt
index 46f575f2730..3ac37660d11 100644
--- a/compiler/testData/diagnostics/tests/Casts.kt
+++ b/compiler/testData/diagnostics/tests/Casts.kt
@@ -18,6 +18,6 @@ fun test() : Unit {
   val <!UNUSED_VARIABLE!>s<!> = "" <!USELESS_CAST!>as Any<!>
   ("" as String?)?.length()
   (data@("" as String?))?.length()
-  (@data()( "" as String?))?.length()
+  (<!WRONG_ANNOTATION_TARGET!>@data()<!>( "" as String?))?.length()
   Unit
 }
diff --git a/compiler/testData/diagnostics/tests/LValueAssignment.kt b/compiler/testData/diagnostics/tests/LValueAssignment.kt
index 3cdb597d207..ded49c502fc 100644
--- a/compiler/testData/diagnostics/tests/LValueAssignment.kt
+++ b/compiler/testData/diagnostics/tests/LValueAssignment.kt
@@ -39,7 +39,7 @@ class D() {
 fun foo(): Unit {}
 
 fun cannotBe() {
-    var <!UNUSED_VARIABLE!>i<!>: Int = 5
+    var i: Int = 5
 
     <!UNRESOLVED_REFERENCE!>z<!> = 30;
     <!VARIABLE_EXPECTED!>""<!> = "";
@@ -135,4 +135,4 @@ fun Array<Int>.checkThis() {
 
 abstract class Ab {
     abstract fun getArray() : Array<Int>
-}
+}
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/TraitOverrideObjectMethods.txt b/compiler/testData/diagnostics/tests/TraitOverrideObjectMethods.txt
index 6cd3c885d45..4e261e98d7d 100644
--- a/compiler/testData/diagnostics/tests/TraitOverrideObjectMethods.txt
+++ b/compiler/testData/diagnostics/tests/TraitOverrideObjectMethods.txt
@@ -2,7 +2,7 @@ package
 
 internal interface MyTrait : java.lang.Object {
     protected/*protected and package*/ open override /*1*/ /*fake_override*/ fun clone(): kotlin.Any!
-    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any!): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
     public abstract override /*1*/ fun finalize(): kotlin.Unit
     public final override /*1*/ /*fake_override*/ fun getClass(): java.lang.Class<*>!
     public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
diff --git a/compiler/testData/diagnostics/tests/UnusedParameters.kt b/compiler/testData/diagnostics/tests/UnusedParameters.kt
index a160285e259..17e344f27d5 100644
--- a/compiler/testData/diagnostics/tests/UnusedParameters.kt
+++ b/compiler/testData/diagnostics/tests/UnusedParameters.kt
@@ -26,3 +26,7 @@ fun get(p: Any) {
 
 fun set(p: Any) {
 }
+
+fun foo(s: String) {
+    s.<!UNRESOLVED_REFERENCE!>xxx<!> = 1
+}
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/UnusedParameters.txt b/compiler/testData/diagnostics/tests/UnusedParameters.txt
index d52fc07037f..9ce670bf8e4 100644
--- a/compiler/testData/diagnostics/tests/UnusedParameters.txt
+++ b/compiler/testData/diagnostics/tests/UnusedParameters.txt
@@ -1,6 +1,7 @@
 package
 
 internal fun f(/*0*/ a: kotlin.Int, /*1*/ b: kotlin.Int, /*2*/ c: kotlin.Int = ...): kotlin.Unit
+internal fun foo(/*0*/ s: kotlin.String): kotlin.Unit
 internal fun get(/*0*/ p: kotlin.Any): kotlin.Unit
 internal fun set(/*0*/ p: kotlin.Any): kotlin.Unit
 internal fun kotlin.Any.get(/*0*/ thisRef: kotlin.Any?, /*1*/ prop: kotlin.PropertyMetadata): kotlin.String
diff --git a/compiler/testData/diagnostics/tests/ValAndFunOverrideCompatibilityClash.txt b/compiler/testData/diagnostics/tests/ValAndFunOverrideCompatibilityClash.txt
index 7aa796b4868..eb76293c0e7 100644
--- a/compiler/testData/diagnostics/tests/ValAndFunOverrideCompatibilityClash.txt
+++ b/compiler/testData/diagnostics/tests/ValAndFunOverrideCompatibilityClash.txt
@@ -23,41 +23,41 @@ internal final class Foo1 : java.util.ArrayList<kotlin.Int> {
     invisible_fake final override /*1*/ /*fake_override*/ var elementData: kotlin.Array<(out) kotlin.Any!>!
     protected/*protected and package*/ final override /*1*/ /*fake_override*/ var modCount: kotlin.Int
     invisible_fake final override /*1*/ /*fake_override*/ var size: kotlin.Int
-    public open override /*1*/ /*fake_override*/ fun add(/*0*/ index: kotlin.Int, /*1*/ element: kotlin.Int!): kotlin.Unit
-    public open override /*1*/ /*fake_override*/ fun add(/*0*/ e: kotlin.Int!): kotlin.Boolean
-    public open override /*1*/ /*fake_override*/ fun addAll(/*0*/ c: (kotlin.MutableCollection<out kotlin.Int!>..kotlin.Collection<kotlin.Int!>?)): kotlin.Boolean
-    public open override /*1*/ /*fake_override*/ fun addAll(/*0*/ index: kotlin.Int, /*1*/ c: (kotlin.MutableCollection<out kotlin.Int!>..kotlin.Collection<kotlin.Int!>?)): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun add(/*0*/ e: kotlin.Int): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun add(/*0*/ index: kotlin.Int, /*1*/ element: kotlin.Int): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun addAll(/*0*/ c: kotlin.Collection<kotlin.Int>): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun addAll(/*0*/ index: kotlin.Int, /*1*/ c: kotlin.Collection<kotlin.Int>): kotlin.Boolean
     invisible_fake open override /*1*/ /*fake_override*/ fun batchRemove(/*0*/ p0: kotlin.(Mutable)Collection<*>!, /*1*/ p1: kotlin.Boolean): kotlin.Boolean
     public open override /*1*/ /*fake_override*/ fun clear(): kotlin.Unit
-    public open override /*1*/ /*fake_override*/ fun clone(): kotlin.Any!
-    public open override /*1*/ /*fake_override*/ fun contains(/*0*/ o: kotlin.Any!): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun clone(): kotlin.Any
+    public open override /*1*/ /*fake_override*/ fun contains(/*0*/ o: kotlin.Any?): kotlin.Boolean
     public open override /*1*/ /*fake_override*/ fun containsAll(/*0*/ c: kotlin.Collection<kotlin.Any?>): kotlin.Boolean
     invisible_fake open override /*1*/ /*fake_override*/ fun elementData(/*0*/ p0: kotlin.Int): kotlin.Int!
     public open override /*1*/ /*fake_override*/ fun ensureCapacity(/*0*/ p0: kotlin.Int): kotlin.Unit
     invisible_fake open override /*1*/ /*fake_override*/ fun ensureCapacityInternal(/*0*/ p0: kotlin.Int): kotlin.Unit
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
     invisible_fake open override /*1*/ /*fake_override*/ fun fastRemove(/*0*/ p0: kotlin.Int): kotlin.Unit
-    public open override /*1*/ /*fake_override*/ fun get(/*0*/ index: kotlin.Int): kotlin.Int!
+    public open override /*1*/ /*fake_override*/ fun get(/*0*/ index: kotlin.Int): kotlin.Int
     invisible_fake open override /*1*/ /*fake_override*/ fun grow(/*0*/ p0: kotlin.Int): kotlin.Unit
     public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
-    public open override /*1*/ /*fake_override*/ fun indexOf(/*0*/ o: kotlin.Any!): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun indexOf(/*0*/ o: kotlin.Any?): kotlin.Int
     public open override /*1*/ /*fake_override*/ fun isEmpty(): kotlin.Boolean
-    public open override /*1*/ /*fake_override*/ fun iterator(): kotlin.(Mutable)Iterator<kotlin.Int!>!
-    public open override /*1*/ /*fake_override*/ fun lastIndexOf(/*0*/ o: kotlin.Any!): kotlin.Int
-    public open override /*1*/ /*fake_override*/ fun listIterator(): kotlin.(Mutable)ListIterator<kotlin.Int!>!
-    public open override /*1*/ /*fake_override*/ fun listIterator(/*0*/ index: kotlin.Int): kotlin.(Mutable)ListIterator<kotlin.Int!>!
+    public open override /*1*/ /*fake_override*/ fun iterator(): kotlin.MutableIterator<kotlin.Int>
+    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.Int>
+    public open override /*1*/ /*fake_override*/ fun listIterator(/*0*/ index: kotlin.Int): kotlin.MutableListIterator<kotlin.Int>
     invisible_fake open override /*1*/ /*fake_override*/ fun outOfBoundsMsg(/*0*/ p0: kotlin.Int): kotlin.String!
     invisible_fake open override /*1*/ /*fake_override*/ fun rangeCheck(/*0*/ p0: kotlin.Int): kotlin.Unit
     invisible_fake open override /*1*/ /*fake_override*/ fun rangeCheckForAdd(/*0*/ p0: kotlin.Int): kotlin.Unit
     invisible_fake open override /*1*/ /*fake_override*/ fun readObject(/*0*/ p0: java.io.ObjectInputStream!): 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.Int!
-    public open override /*1*/ /*fake_override*/ fun removeAll(/*0*/ c: kotlin.(Mutable)Collection<*>!): kotlin.Boolean
+    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.Int
+    public open override /*1*/ /*fake_override*/ fun removeAll(/*0*/ c: kotlin.Collection<*>): kotlin.Boolean
     protected/*protected and package*/ open override /*1*/ /*fake_override*/ fun removeRange(/*0*/ p0: kotlin.Int, /*1*/ p1: kotlin.Int): kotlin.Unit
-    public open override /*1*/ /*fake_override*/ fun retainAll(/*0*/ c: kotlin.(Mutable)Collection<*>!): kotlin.Boolean
-    public open override /*1*/ /*fake_override*/ fun set(/*0*/ index: kotlin.Int, /*1*/ element: kotlin.Int!): kotlin.Int!
+    public open override /*1*/ /*fake_override*/ fun retainAll(/*0*/ c: kotlin.Collection<*>): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun set(/*0*/ index: kotlin.Int, /*1*/ element: kotlin.Int): kotlin.Int
     public open override /*1*/ /*fake_override*/ fun size(): kotlin.Int
-    public open override /*1*/ /*fake_override*/ fun subList(/*0*/ fromIndex: kotlin.Int, /*1*/ toIndex: kotlin.Int): kotlin.(Mutable)List<kotlin.Int!>!
+    public open override /*1*/ /*fake_override*/ fun subList(/*0*/ fromIndex: kotlin.Int, /*1*/ toIndex: kotlin.Int): kotlin.MutableList<kotlin.Int>
     public open override /*1*/ /*fake_override*/ fun toArray(): kotlin.Array<(out) kotlin.Any!>!
     public open override /*1*/ /*fake_override*/ fun </*0*/ T> toArray(/*0*/ p0: kotlin.Array<(out) T!>!): kotlin.Array<(out) T!>!
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
diff --git a/compiler/testData/diagnostics/tests/annotations/AnnotatedConstructor.txt b/compiler/testData/diagnostics/tests/annotations/AnnotatedConstructor.txt
index 24db66192dc..496574921bd 100644
--- a/compiler/testData/diagnostics/tests/annotations/AnnotatedConstructor.txt
+++ b/compiler/testData/diagnostics/tests/annotations/AnnotatedConstructor.txt
@@ -8,7 +8,7 @@ internal final class Annotated {
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
 }
 
-internal final annotation class ann : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class ann : kotlin.Annotation {
     public constructor ann()
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
     public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
diff --git a/compiler/testData/diagnostics/tests/annotations/AnnotatedLocalObjectFun.txt b/compiler/testData/diagnostics/tests/annotations/AnnotatedLocalObjectFun.txt
index 21dbc11cf3e..fcce010b9b2 100644
--- a/compiler/testData/diagnostics/tests/annotations/AnnotatedLocalObjectFun.txt
+++ b/compiler/testData/diagnostics/tests/annotations/AnnotatedLocalObjectFun.txt
@@ -2,7 +2,7 @@ package
 
 internal fun foo(): kotlin.Unit
 
-internal final annotation class My : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class My : kotlin.Annotation {
     public constructor My()
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
     public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
diff --git a/compiler/testData/diagnostics/tests/annotations/AnnotatedLocalObjectProperty.txt b/compiler/testData/diagnostics/tests/annotations/AnnotatedLocalObjectProperty.txt
index f382ca4e9e7..260fc95945a 100644
--- a/compiler/testData/diagnostics/tests/annotations/AnnotatedLocalObjectProperty.txt
+++ b/compiler/testData/diagnostics/tests/annotations/AnnotatedLocalObjectProperty.txt
@@ -2,7 +2,7 @@ package
 
 internal fun foo(): kotlin.Int
 
-internal final annotation class My : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class My : kotlin.Annotation {
     public constructor My()
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
     public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
diff --git a/compiler/testData/diagnostics/tests/annotations/AnnotatedLoop.txt b/compiler/testData/diagnostics/tests/annotations/AnnotatedLoop.txt
index 21dbc11cf3e..fcce010b9b2 100644
--- a/compiler/testData/diagnostics/tests/annotations/AnnotatedLoop.txt
+++ b/compiler/testData/diagnostics/tests/annotations/AnnotatedLoop.txt
@@ -2,7 +2,7 @@ package
 
 internal fun foo(): kotlin.Unit
 
-internal final annotation class My : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class My : kotlin.Annotation {
     public constructor My()
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
     public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
diff --git a/compiler/testData/diagnostics/tests/annotations/AnnotatedResultType.kt b/compiler/testData/diagnostics/tests/annotations/AnnotatedResultType.kt
index 00839cb1af6..c38ec8d9835 100644
--- a/compiler/testData/diagnostics/tests/annotations/AnnotatedResultType.kt
+++ b/compiler/testData/diagnostics/tests/annotations/AnnotatedResultType.kt
@@ -1,4 +1,5 @@
 // Result type can be annotated
+target(AnnotationTarget.TYPE)
 annotation class My(val x: Int)
 
 fun foo(): @My(42) Int = 24
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/annotations/AnnotatedResultType.txt b/compiler/testData/diagnostics/tests/annotations/AnnotatedResultType.txt
index bf4e310fa60..76c1bb536a0 100644
--- a/compiler/testData/diagnostics/tests/annotations/AnnotatedResultType.txt
+++ b/compiler/testData/diagnostics/tests/annotations/AnnotatedResultType.txt
@@ -1,8 +1,8 @@
 package
 
-internal fun foo(): @[My(x = IntegerValueType(42))] kotlin.Int
+internal fun foo(): @[My(x = 42)] kotlin.Int
 
-internal final annotation class My : kotlin.Annotation {
+kotlin.annotation.target(allowedTargets = {AnnotationTarget.TYPE}) kotlin.annotation.annotation() internal final class My : kotlin.Annotation {
     public constructor My(/*0*/ x: kotlin.Int)
     internal final val x: kotlin.Int
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
diff --git a/compiler/testData/diagnostics/tests/annotations/AnnotatedTryCatch.txt b/compiler/testData/diagnostics/tests/annotations/AnnotatedTryCatch.txt
index 8df46703222..6d159c39fe1 100644
--- a/compiler/testData/diagnostics/tests/annotations/AnnotatedTryCatch.txt
+++ b/compiler/testData/diagnostics/tests/annotations/AnnotatedTryCatch.txt
@@ -2,7 +2,7 @@ package
 
 internal fun foo(/*0*/ arg: kotlin.Int): kotlin.Int
 
-internal final annotation class My : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class My : kotlin.Annotation {
     public constructor My()
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
     public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
diff --git a/compiler/testData/diagnostics/tests/annotations/AnnotationAsDefaultParameter.kt b/compiler/testData/diagnostics/tests/annotations/AnnotationAsDefaultParameter.kt
new file mode 100644
index 00000000000..4d09e688396
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/annotations/AnnotationAsDefaultParameter.kt
@@ -0,0 +1,5 @@
+annotation class Base(val x: Int)
+
+annotation class UseBase(val b: Base = Base(0))
+
+UseBase class My
diff --git a/compiler/testData/diagnostics/tests/annotations/AnnotationAsDefaultParameter.txt b/compiler/testData/diagnostics/tests/annotations/AnnotationAsDefaultParameter.txt
new file mode 100644
index 00000000000..0231895ca4b
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/annotations/AnnotationAsDefaultParameter.txt
@@ -0,0 +1,24 @@
+package
+
+kotlin.annotation.annotation() internal final class Base : kotlin.Annotation {
+    public constructor Base(/*0*/ x: kotlin.Int)
+    internal final val x: kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+UseBase() internal final class My {
+    public constructor My()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+kotlin.annotation.annotation() internal final class UseBase : kotlin.Annotation {
+    public constructor UseBase(/*0*/ b: Base = ...)
+    internal final val b: Base
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
diff --git a/compiler/testData/diagnostics/tests/annotations/AnnotationForClassTypeParameter.txt b/compiler/testData/diagnostics/tests/annotations/AnnotationForClassTypeParameter.txt
index 62b649f6ceb..060db6d4c60 100644
--- a/compiler/testData/diagnostics/tests/annotations/AnnotationForClassTypeParameter.txt
+++ b/compiler/testData/diagnostics/tests/annotations/AnnotationForClassTypeParameter.txt
@@ -1,13 +1,13 @@
 package
 
-internal final annotation class A1 : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class A1 : kotlin.Annotation {
     public constructor A1()
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
     public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
 }
 
-internal final annotation class A2 : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class A2 : kotlin.Annotation {
     public constructor A2(/*0*/ some: kotlin.Int = ...)
     internal final val some: kotlin.Int
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
diff --git a/compiler/testData/diagnostics/tests/annotations/AnnotationForFunctionTypeParameter.txt b/compiler/testData/diagnostics/tests/annotations/AnnotationForFunctionTypeParameter.txt
index 018ee58aa90..7ca10075d05 100644
--- a/compiler/testData/diagnostics/tests/annotations/AnnotationForFunctionTypeParameter.txt
+++ b/compiler/testData/diagnostics/tests/annotations/AnnotationForFunctionTypeParameter.txt
@@ -2,14 +2,14 @@ package
 
 internal fun </*0*/ T> topFun(): kotlin.Int
 
-internal final annotation class A1 : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class A1 : kotlin.Annotation {
     public constructor A1()
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
     public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
 }
 
-internal final annotation class A2 : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class A2 : kotlin.Annotation {
     public constructor A2(/*0*/ some: kotlin.Int = ...)
     internal final val some: kotlin.Int
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
diff --git a/compiler/testData/diagnostics/tests/annotations/AnnotationOnObject.txt b/compiler/testData/diagnostics/tests/annotations/AnnotationOnObject.txt
index 8eebf0033a6..58c743b8ff7 100644
--- a/compiler/testData/diagnostics/tests/annotations/AnnotationOnObject.txt
+++ b/compiler/testData/diagnostics/tests/annotations/AnnotationOnObject.txt
@@ -2,7 +2,7 @@ package
 
 package test {
 
-    internal final annotation class A : kotlin.Annotation {
+    kotlin.annotation.annotation() internal final class A : kotlin.Annotation {
         public constructor A(/*0*/ a: kotlin.Int = ..., /*1*/ b: kotlin.String = ..., /*2*/ c: kotlin.String)
         internal final val a: kotlin.Int
         internal final val b: kotlin.String
@@ -12,7 +12,7 @@ package test {
         public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
     }
 
-    test.A(a = IntegerValueType(12), c = "Hello") internal object SomeObject {
+    test.A(a = 12, c = "Hello") internal object SomeObject {
         private constructor SomeObject()
         public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
         public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
diff --git a/compiler/testData/diagnostics/tests/annotations/AnnotationsForClasses.txt b/compiler/testData/diagnostics/tests/annotations/AnnotationsForClasses.txt
index a6c370183cd..cd4d9230b13 100644
--- a/compiler/testData/diagnostics/tests/annotations/AnnotationsForClasses.txt
+++ b/compiler/testData/diagnostics/tests/annotations/AnnotationsForClasses.txt
@@ -1,13 +1,13 @@
 package
 
-java.lang.Deprecated() internal final annotation class my : kotlin.Annotation {
+kotlin.annotation.annotation() java.lang.Deprecated() internal final class my : kotlin.Annotation {
     public constructor my()
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
     public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
 }
 
-java.lang.Deprecated() internal final annotation class my1 : kotlin.Annotation {
+kotlin.annotation.annotation() java.lang.Deprecated() internal final class my1 : kotlin.Annotation {
     public constructor my1()
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
     public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
diff --git a/compiler/testData/diagnostics/tests/annotations/AnnotationsForPropertyTypeParameter.txt b/compiler/testData/diagnostics/tests/annotations/AnnotationsForPropertyTypeParameter.txt
index d7945ba9075..7606613f710 100644
--- a/compiler/testData/diagnostics/tests/annotations/AnnotationsForPropertyTypeParameter.txt
+++ b/compiler/testData/diagnostics/tests/annotations/AnnotationsForPropertyTypeParameter.txt
@@ -2,14 +2,14 @@ package
 
 internal val </*0*/ T> topProp: kotlin.Int = 12
 
-internal final annotation class A1 : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class A1 : kotlin.Annotation {
     public constructor A1()
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
     public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
 }
 
-internal final annotation class A2 : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class A2 : kotlin.Annotation {
     public constructor A2(/*0*/ some: kotlin.Int = ...)
     internal final val some: kotlin.Int
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
diff --git a/compiler/testData/diagnostics/tests/annotations/BasicAnnotations.txt b/compiler/testData/diagnostics/tests/annotations/BasicAnnotations.txt
index ca8b44cb323..d22174c1d06 100644
--- a/compiler/testData/diagnostics/tests/annotations/BasicAnnotations.txt
+++ b/compiler/testData/diagnostics/tests/annotations/BasicAnnotations.txt
@@ -2,19 +2,19 @@ package
 
 my() internal fun foo(): kotlin.Unit
 my1() internal fun foo2(): kotlin.Unit
-my1(i = IntegerValueType(2)) internal fun foo3(): kotlin.Unit
+my1(i = 2) internal fun foo3(): kotlin.Unit
 my2() internal fun foo4(): kotlin.Unit
 my2() internal fun foo41(): kotlin.Unit
-my2(i = IntegerValueType(2)) internal fun foo42(): kotlin.Unit
+my2(i = 2) internal fun foo42(): kotlin.Unit
 
-internal final annotation class my : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class my : kotlin.Annotation {
     public constructor my()
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
     public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
 }
 
-internal final annotation class my1 : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class my1 : kotlin.Annotation {
     public constructor my1(/*0*/ i: kotlin.Int)
     internal final val i: kotlin.Int
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
@@ -22,7 +22,7 @@ internal final annotation class my1 : kotlin.Annotation {
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
 }
 
-internal final annotation class my2 : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class my2 : kotlin.Annotation {
     public constructor my2(/*0*/ i: kotlin.Int = ...)
     internal final val i: kotlin.Int
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
diff --git a/compiler/testData/diagnostics/tests/annotations/ConstructorCall.txt b/compiler/testData/diagnostics/tests/annotations/ConstructorCall.txt
index 0c2884b2794..282baf803a7 100644
--- a/compiler/testData/diagnostics/tests/annotations/ConstructorCall.txt
+++ b/compiler/testData/diagnostics/tests/annotations/ConstructorCall.txt
@@ -1,20 +1,20 @@
 package
 
-Ann2(a = Ann1(a = IntegerValueType(1))) internal val a: kotlin.Int = 1
-Ann2(a = Ann1(a = IntegerValueType(1))) internal val c: kotlin.Int = 2
+Ann2(a = Ann1(a = 1)) internal val a: kotlin.Int = 1
+Ann2(a = Ann1(a = 1)) internal val c: kotlin.Int = 2
 internal fun bar(/*0*/ a: Ann = ...): kotlin.Unit
 internal fun foo(): kotlin.Unit
 internal fun </*0*/ T> javaClass(): java.lang.Class<T>
 internal fun kotlin.String.invoke(): kotlin.Unit
 
-internal final annotation class Ann : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class Ann : kotlin.Annotation {
     public constructor Ann()
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
     public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
 }
 
-internal final annotation class Ann1 : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class Ann1 : kotlin.Annotation {
     public constructor Ann1(/*0*/ a: kotlin.Int)
     internal final val a: kotlin.Int
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
@@ -22,7 +22,7 @@ internal final annotation class Ann1 : kotlin.Annotation {
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
 }
 
-internal final annotation class Ann2 : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class Ann2 : kotlin.Annotation {
     public constructor Ann2(/*0*/ a: Ann1)
     internal final val a: Ann1
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
@@ -30,7 +30,7 @@ internal final annotation class Ann2 : kotlin.Annotation {
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
 }
 
-internal final annotation class Ann3 : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class Ann3 : kotlin.Annotation {
     public constructor Ann3(/*0*/ a: Ann1 = ...)
     internal final val a: Ann1
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
@@ -38,7 +38,7 @@ internal final annotation class Ann3 : kotlin.Annotation {
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
 }
 
-internal final annotation class Ann4 : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class Ann4 : kotlin.Annotation {
     public constructor Ann4(/*0*/ value: kotlin.String)
     internal final val value: kotlin.String
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
diff --git a/compiler/testData/diagnostics/tests/annotations/DanglingInScript.kt b/compiler/testData/diagnostics/tests/annotations/DanglingInScript.kt
index e5ea165258e..aaa6c306aeb 100644
--- a/compiler/testData/diagnostics/tests/annotations/DanglingInScript.kt
+++ b/compiler/testData/diagnostics/tests/annotations/DanglingInScript.kt
@@ -1,5 +1,5 @@
 // FILE: script.kts
 
-annotation class Ann
+@annotation class Ann
 
 @Ann<!SYNTAX!><!>
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/annotations/DanglingMixed.txt b/compiler/testData/diagnostics/tests/annotations/DanglingMixed.txt
index f6b20078b1e..21d8689635a 100644
--- a/compiler/testData/diagnostics/tests/annotations/DanglingMixed.txt
+++ b/compiler/testData/diagnostics/tests/annotations/DanglingMixed.txt
@@ -1,13 +1,13 @@
 package
 
-internal final annotation class Ann : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class Ann : kotlin.Annotation {
     public constructor Ann()
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
     public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
 }
 
-internal final annotation class Ann2 : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class Ann2 : kotlin.Annotation {
     public constructor Ann2()
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
     public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
diff --git a/compiler/testData/diagnostics/tests/annotations/DanglingNoBrackets.txt b/compiler/testData/diagnostics/tests/annotations/DanglingNoBrackets.txt
index 9c246457a26..07b847fab59 100644
--- a/compiler/testData/diagnostics/tests/annotations/DanglingNoBrackets.txt
+++ b/compiler/testData/diagnostics/tests/annotations/DanglingNoBrackets.txt
@@ -1,6 +1,6 @@
 package
 
-internal final annotation class Ann : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class Ann : kotlin.Annotation {
     public constructor Ann()
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
     public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
diff --git a/compiler/testData/diagnostics/tests/annotations/DanglingWithBrackets.txt b/compiler/testData/diagnostics/tests/annotations/DanglingWithBrackets.txt
index ecc8869fdd9..0bb690e6be8 100644
--- a/compiler/testData/diagnostics/tests/annotations/DanglingWithBrackets.txt
+++ b/compiler/testData/diagnostics/tests/annotations/DanglingWithBrackets.txt
@@ -1,6 +1,6 @@
 package
 
-internal final annotation class Ann : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class Ann : kotlin.Annotation {
     public constructor Ann()
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
     public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
diff --git a/compiler/testData/diagnostics/tests/annotations/JavaAnnotationConstructors.txt b/compiler/testData/diagnostics/tests/annotations/JavaAnnotationConstructors.txt
index f5009eff58f..873cccd65d5 100644
--- a/compiler/testData/diagnostics/tests/annotations/JavaAnnotationConstructors.txt
+++ b/compiler/testData/diagnostics/tests/annotations/JavaAnnotationConstructors.txt
@@ -1,13 +1,13 @@
 package
 
-java.lang.annotation.Retention(value = RetentionPolicy.CLASS) internal final annotation class my : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class my : kotlin.Annotation {
     public constructor my()
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
     public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
 }
 
-java.lang.annotation.Retention(value = RetentionPolicy.RUNTIME) java.lang.annotation.Target(value = {ElementType.ANNOTATION_TYPE, ElementType.CONSTRUCTOR}) internal final annotation class my1 : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class my1 : kotlin.Annotation {
     public constructor my1()
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
     public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
diff --git a/compiler/testData/diagnostics/tests/annotations/MutuallyRecursivelyAnnotatedGlobalFunction.txt b/compiler/testData/diagnostics/tests/annotations/MutuallyRecursivelyAnnotatedGlobalFunction.txt
index 1a968299ed7..27dc28b3fa2 100644
--- a/compiler/testData/diagnostics/tests/annotations/MutuallyRecursivelyAnnotatedGlobalFunction.txt
+++ b/compiler/testData/diagnostics/tests/annotations/MutuallyRecursivelyAnnotatedGlobalFunction.txt
@@ -3,7 +3,7 @@ package
 ann() internal fun bar(): kotlin.Int
 ann() internal fun foo(): kotlin.Int
 
-internal final annotation class ann : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class ann : kotlin.Annotation {
     public constructor ann(/*0*/ x: kotlin.Int)
     internal final val x: kotlin.Int
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
diff --git a/compiler/testData/diagnostics/tests/annotations/RecursivelyAnnotated.txt b/compiler/testData/diagnostics/tests/annotations/RecursivelyAnnotated.txt
index fb9a04575dc..4fbbf722b26 100644
--- a/compiler/testData/diagnostics/tests/annotations/RecursivelyAnnotated.txt
+++ b/compiler/testData/diagnostics/tests/annotations/RecursivelyAnnotated.txt
@@ -1,6 +1,6 @@
 package
 
-RecursivelyAnnotated(x = IntegerValueType(1)) internal final annotation class RecursivelyAnnotated : kotlin.Annotation {
+RecursivelyAnnotated(x = 1) kotlin.annotation.annotation() internal final class RecursivelyAnnotated : kotlin.Annotation {
     public constructor RecursivelyAnnotated(/*0*/ x: kotlin.Int)
     internal final val x: kotlin.Int
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
diff --git a/compiler/testData/diagnostics/tests/annotations/RecursivelyAnnotatedFunctionParameter.txt b/compiler/testData/diagnostics/tests/annotations/RecursivelyAnnotatedFunctionParameter.txt
index 06458119e3f..3e581906594 100644
--- a/compiler/testData/diagnostics/tests/annotations/RecursivelyAnnotatedFunctionParameter.txt
+++ b/compiler/testData/diagnostics/tests/annotations/RecursivelyAnnotatedFunctionParameter.txt
@@ -2,7 +2,7 @@ package
 
 internal fun foo(/*0*/ ann() x: kotlin.Int): kotlin.Int
 
-internal final annotation class ann : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class ann : kotlin.Annotation {
     public constructor ann(/*0*/ x: kotlin.Int)
     internal final val x: kotlin.Int
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
diff --git a/compiler/testData/diagnostics/tests/annotations/RecursivelyAnnotatedGlobalFunction.txt b/compiler/testData/diagnostics/tests/annotations/RecursivelyAnnotatedGlobalFunction.txt
index d2c0ba12aba..02471ce11b6 100644
--- a/compiler/testData/diagnostics/tests/annotations/RecursivelyAnnotatedGlobalFunction.txt
+++ b/compiler/testData/diagnostics/tests/annotations/RecursivelyAnnotatedGlobalFunction.txt
@@ -2,7 +2,7 @@ package
 
 ann() internal fun foo(): kotlin.Int
 
-internal final annotation class ann : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class ann : kotlin.Annotation {
     public constructor ann(/*0*/ x: kotlin.Int)
     internal final val x: kotlin.Int
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
diff --git a/compiler/testData/diagnostics/tests/annotations/RecursivelyAnnotatedGlobalProperty.txt b/compiler/testData/diagnostics/tests/annotations/RecursivelyAnnotatedGlobalProperty.txt
index f8efd97dd87..b1510e02906 100644
--- a/compiler/testData/diagnostics/tests/annotations/RecursivelyAnnotatedGlobalProperty.txt
+++ b/compiler/testData/diagnostics/tests/annotations/RecursivelyAnnotatedGlobalProperty.txt
@@ -2,7 +2,7 @@ package
 
 ann(x = 1) internal val x: kotlin.Int = 1
 
-internal final annotation class ann : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class ann : kotlin.Annotation {
     public constructor ann(/*0*/ x: kotlin.Int)
     internal final val x: kotlin.Int
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
diff --git a/compiler/testData/diagnostics/tests/annotations/RecursivelyAnnotatedParameter.txt b/compiler/testData/diagnostics/tests/annotations/RecursivelyAnnotatedParameter.txt
index f2ba95e7bb6..39cd83556cd 100644
--- a/compiler/testData/diagnostics/tests/annotations/RecursivelyAnnotatedParameter.txt
+++ b/compiler/testData/diagnostics/tests/annotations/RecursivelyAnnotatedParameter.txt
@@ -1,8 +1,8 @@
 package
 
-internal final annotation class RecursivelyAnnotated : kotlin.Annotation {
-    public constructor RecursivelyAnnotated(/*0*/ RecursivelyAnnotated(x = IntegerValueType(1)) x: kotlin.Int)
-    RecursivelyAnnotated(x = IntegerValueType(1)) internal final val x: kotlin.Int
+kotlin.annotation.annotation() internal final class RecursivelyAnnotated : kotlin.Annotation {
+    public constructor RecursivelyAnnotated(/*0*/ RecursivelyAnnotated(x = 1) x: kotlin.Int)
+    RecursivelyAnnotated(x = 1) internal final val x: kotlin.Int
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
     public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
diff --git a/compiler/testData/diagnostics/tests/annotations/RecursivelyAnnotatedParameterType.kt b/compiler/testData/diagnostics/tests/annotations/RecursivelyAnnotatedParameterType.kt
index fbe79905ad2..a44dfffb3f1 100644
--- a/compiler/testData/diagnostics/tests/annotations/RecursivelyAnnotatedParameterType.kt
+++ b/compiler/testData/diagnostics/tests/annotations/RecursivelyAnnotatedParameterType.kt
@@ -1,2 +1,3 @@
 // Class constructor parameter type CAN be recursively annotated
+target(AnnotationTarget.TYPE)
 annotation class RecursivelyAnnotated(val x: @RecursivelyAnnotated(1) Int)
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/annotations/RecursivelyAnnotatedParameterType.txt b/compiler/testData/diagnostics/tests/annotations/RecursivelyAnnotatedParameterType.txt
index 65b104b7cec..a5994d556c1 100644
--- a/compiler/testData/diagnostics/tests/annotations/RecursivelyAnnotatedParameterType.txt
+++ b/compiler/testData/diagnostics/tests/annotations/RecursivelyAnnotatedParameterType.txt
@@ -1,8 +1,8 @@
 package
 
-internal final annotation class RecursivelyAnnotated : kotlin.Annotation {
-    public constructor RecursivelyAnnotated(/*0*/ x: @[RecursivelyAnnotated(x = IntegerValueType(1))] kotlin.Int)
-    internal final val x: @[RecursivelyAnnotated(x = IntegerValueType(1))] kotlin.Int
+kotlin.annotation.target(allowedTargets = {AnnotationTarget.TYPE}) kotlin.annotation.annotation() internal final class RecursivelyAnnotated : kotlin.Annotation {
+    public constructor RecursivelyAnnotated(/*0*/ x: @[RecursivelyAnnotated(x = 1)] kotlin.Int)
+    internal final val x: @[RecursivelyAnnotated(x = 1)] kotlin.Int
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
     public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
diff --git a/compiler/testData/diagnostics/tests/annotations/RecursivelyAnnotatedParameterWithAt.txt b/compiler/testData/diagnostics/tests/annotations/RecursivelyAnnotatedParameterWithAt.txt
index f2ba95e7bb6..39cd83556cd 100644
--- a/compiler/testData/diagnostics/tests/annotations/RecursivelyAnnotatedParameterWithAt.txt
+++ b/compiler/testData/diagnostics/tests/annotations/RecursivelyAnnotatedParameterWithAt.txt
@@ -1,8 +1,8 @@
 package
 
-internal final annotation class RecursivelyAnnotated : kotlin.Annotation {
-    public constructor RecursivelyAnnotated(/*0*/ RecursivelyAnnotated(x = IntegerValueType(1)) x: kotlin.Int)
-    RecursivelyAnnotated(x = IntegerValueType(1)) internal final val x: kotlin.Int
+kotlin.annotation.annotation() internal final class RecursivelyAnnotated : kotlin.Annotation {
+    public constructor RecursivelyAnnotated(/*0*/ RecursivelyAnnotated(x = 1) x: kotlin.Int)
+    RecursivelyAnnotated(x = 1) internal final val x: kotlin.Int
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
     public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
diff --git a/compiler/testData/diagnostics/tests/annotations/RecursivelyAnnotatedProperty.txt b/compiler/testData/diagnostics/tests/annotations/RecursivelyAnnotatedProperty.txt
index 3e9d365c990..f8e48441007 100644
--- a/compiler/testData/diagnostics/tests/annotations/RecursivelyAnnotatedProperty.txt
+++ b/compiler/testData/diagnostics/tests/annotations/RecursivelyAnnotatedProperty.txt
@@ -8,7 +8,7 @@ internal final class My {
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
 }
 
-internal final annotation class ann : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class ann : kotlin.Annotation {
     public constructor ann(/*0*/ x: kotlin.Int)
     internal final val x: kotlin.Int
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
diff --git a/compiler/testData/diagnostics/tests/annotations/RecursivelyIncorrectlyAnnotatedParameter.txt b/compiler/testData/diagnostics/tests/annotations/RecursivelyIncorrectlyAnnotatedParameter.txt
index ad23ca551a4..2bc4d2a30c0 100644
--- a/compiler/testData/diagnostics/tests/annotations/RecursivelyIncorrectlyAnnotatedParameter.txt
+++ b/compiler/testData/diagnostics/tests/annotations/RecursivelyIncorrectlyAnnotatedParameter.txt
@@ -1,8 +1,8 @@
 package
 
 internal final class RecursivelyAnnotated {
-    public constructor RecursivelyAnnotated(/*0*/ RecursivelyAnnotated(x = IntegerValueType(1)) x: kotlin.Int)
-    RecursivelyAnnotated(x = IntegerValueType(1)) internal final val x: kotlin.Int
+    public constructor RecursivelyAnnotated(/*0*/ RecursivelyAnnotated(x = 1) x: kotlin.Int)
+    RecursivelyAnnotated(x = 1) internal final val x: kotlin.Int
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
     public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
diff --git a/compiler/testData/diagnostics/tests/annotations/WrongAnnotationArgsOnObject.txt b/compiler/testData/diagnostics/tests/annotations/WrongAnnotationArgsOnObject.txt
index 21d20839c5c..5c3b870ce33 100644
--- a/compiler/testData/diagnostics/tests/annotations/WrongAnnotationArgsOnObject.txt
+++ b/compiler/testData/diagnostics/tests/annotations/WrongAnnotationArgsOnObject.txt
@@ -3,7 +3,7 @@ package
 package test {
     internal val some: test.SomeObject
 
-    internal final annotation class BadAnnotation : kotlin.Annotation {
+    kotlin.annotation.annotation() internal final class BadAnnotation : kotlin.Annotation {
         public constructor BadAnnotation(/*0*/ s: kotlin.String)
         internal final val s: kotlin.String
         public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
@@ -11,7 +11,7 @@ package test {
         public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
     }
 
-    test.BadAnnotation(s = IntegerValueType(1)) internal object SomeObject {
+    test.BadAnnotation(s = 1) internal object SomeObject {
         private constructor SomeObject()
         public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
         public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
diff --git a/compiler/testData/diagnostics/tests/annotations/annotationInheritance.txt b/compiler/testData/diagnostics/tests/annotations/annotationInheritance.txt
index f65d2209b73..964e089f8ed 100644
--- a/compiler/testData/diagnostics/tests/annotations/annotationInheritance.txt
+++ b/compiler/testData/diagnostics/tests/annotations/annotationInheritance.txt
@@ -2,28 +2,28 @@ package
 
 internal val a: T
 
-internal final annotation class Ann : C {
+kotlin.annotation.annotation() internal final class Ann : C {
     public constructor Ann()
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
     public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
 }
 
-internal final annotation class Ann2 : T {
+kotlin.annotation.annotation() internal final class Ann2 : T {
     public constructor Ann2()
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
     public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
 }
 
-internal final annotation class Ann3 : T {
+kotlin.annotation.annotation() internal final class Ann3 : T {
     public constructor Ann3()
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
     public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
 }
 
-internal final annotation class Ann4 : C, T {
+kotlin.annotation.annotation() internal final class Ann4 : C, T {
     public constructor Ann4()
     public open override /*2*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
     public open override /*2*/ /*fake_override*/ fun hashCode(): kotlin.Int
diff --git a/compiler/testData/diagnostics/tests/annotations/annotationModifier.kt b/compiler/testData/diagnostics/tests/annotations/annotationModifier.kt
index 8c5e211eead..46d4acfba75 100644
--- a/compiler/testData/diagnostics/tests/annotations/annotationModifier.kt
+++ b/compiler/testData/diagnostics/tests/annotations/annotationModifier.kt
@@ -1,15 +1,15 @@
 annotation class B
 
 class A {
-   <!ILLEGAL_ANNOTATION_KEYWORD!>annotation<!> companion object {}
+   <!WRONG_ANNOTATION_TARGET!>annotation<!> companion object {}
 }
 
-<!ILLEGAL_ANNOTATION_KEYWORD!>annotation<!> object O {}
+<!WRONG_ANNOTATION_TARGET!>annotation<!> object O {}
 
-<!ILLEGAL_ANNOTATION_KEYWORD!>annotation<!> interface T {}
+<!WRONG_ANNOTATION_TARGET!>annotation<!> interface T {}
 
-<!ILLEGAL_ANNOTATION_KEYWORD!>annotation<!> fun f() = 0
+<!WRONG_ANNOTATION_TARGET!>annotation<!> fun f() = 0
 
-<!ILLEGAL_ANNOTATION_KEYWORD!>annotation<!> val x = 0
+<!WRONG_ANNOTATION_TARGET!>annotation<!> val x = 0
 
-<!ILLEGAL_ANNOTATION_KEYWORD!>annotation<!> var y = 0
+<!WRONG_ANNOTATION_TARGET!>annotation<!> var y = 0
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/annotations/annotationModifier.txt b/compiler/testData/diagnostics/tests/annotations/annotationModifier.txt
index a576fe07507..de139ac73c1 100644
--- a/compiler/testData/diagnostics/tests/annotations/annotationModifier.txt
+++ b/compiler/testData/diagnostics/tests/annotations/annotationModifier.txt
@@ -1,8 +1,8 @@
 package
 
-internal val x: kotlin.Int = 0
-internal var y: kotlin.Int
-internal fun f(): kotlin.Int
+kotlin.annotation.annotation() internal val x: kotlin.Int = 0
+kotlin.annotation.annotation() internal var y: kotlin.Int
+kotlin.annotation.annotation() internal fun f(): kotlin.Int
 
 internal final class A {
     public constructor A()
@@ -10,7 +10,7 @@ internal final class A {
     public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
 
-    public companion object Companion {
+    kotlin.annotation.annotation() public companion object Companion {
         private constructor Companion()
         public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
         public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
@@ -18,21 +18,21 @@ internal final class A {
     }
 }
 
-internal final annotation class B : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class B : kotlin.Annotation {
     public constructor B()
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
     public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
 }
 
-internal object O {
+kotlin.annotation.annotation() internal object O {
     private constructor O()
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
     public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
 }
 
-internal interface T : kotlin.Annotation {
+kotlin.annotation.annotation() internal interface T {
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
     public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
diff --git a/compiler/testData/diagnostics/tests/annotations/annotationParameterMustBeConstant/booleanLocalVal.txt b/compiler/testData/diagnostics/tests/annotations/annotationParameterMustBeConstant/booleanLocalVal.txt
index 98b3a61f3a6..c4dcedead55 100644
--- a/compiler/testData/diagnostics/tests/annotations/annotationParameterMustBeConstant/booleanLocalVal.txt
+++ b/compiler/testData/diagnostics/tests/annotations/annotationParameterMustBeConstant/booleanLocalVal.txt
@@ -2,7 +2,7 @@ package
 
 internal fun foo(): kotlin.Unit
 
-internal final annotation class Ann : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class Ann : kotlin.Annotation {
     public constructor Ann(/*0*/ vararg i: kotlin.Boolean /*kotlin.BooleanArray*/)
     internal final val i: kotlin.BooleanArray
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
diff --git a/compiler/testData/diagnostics/tests/annotations/annotationParameterMustBeConstant/compareAndEquals.txt b/compiler/testData/diagnostics/tests/annotations/annotationParameterMustBeConstant/compareAndEquals.txt
index 98b3a61f3a6..c4dcedead55 100644
--- a/compiler/testData/diagnostics/tests/annotations/annotationParameterMustBeConstant/compareAndEquals.txt
+++ b/compiler/testData/diagnostics/tests/annotations/annotationParameterMustBeConstant/compareAndEquals.txt
@@ -2,7 +2,7 @@ package
 
 internal fun foo(): kotlin.Unit
 
-internal final annotation class Ann : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class Ann : kotlin.Annotation {
     public constructor Ann(/*0*/ vararg i: kotlin.Boolean /*kotlin.BooleanArray*/)
     internal final val i: kotlin.BooleanArray
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
diff --git a/compiler/testData/diagnostics/tests/annotations/annotationParameterMustBeConstant/enumConst.txt b/compiler/testData/diagnostics/tests/annotations/annotationParameterMustBeConstant/enumConst.txt
index 9548f773149..6aff3a44df4 100644
--- a/compiler/testData/diagnostics/tests/annotations/annotationParameterMustBeConstant/enumConst.txt
+++ b/compiler/testData/diagnostics/tests/annotations/annotationParameterMustBeConstant/enumConst.txt
@@ -2,7 +2,7 @@ package
 
 internal val e: MyEnum
 
-internal final annotation class AnnE : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class AnnE : kotlin.Annotation {
     public constructor AnnE(/*0*/ i: MyEnum)
     internal final val i: MyEnum
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
diff --git a/compiler/testData/diagnostics/tests/annotations/annotationParameterMustBeConstant/javaProperties.txt b/compiler/testData/diagnostics/tests/annotations/annotationParameterMustBeConstant/javaProperties.txt
index 60ec1a463c3..6b3e2e6c5b8 100644
--- a/compiler/testData/diagnostics/tests/annotations/annotationParameterMustBeConstant/javaProperties.txt
+++ b/compiler/testData/diagnostics/tests/annotations/annotationParameterMustBeConstant/javaProperties.txt
@@ -7,7 +7,7 @@ Ann(i = {1, 1, 1}) internal final class A {
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
 }
 
-internal final annotation class Ann : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class Ann : kotlin.Annotation {
     public constructor Ann(/*0*/ vararg i: kotlin.Int /*kotlin.IntArray*/)
     internal final val i: kotlin.IntArray
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
diff --git a/compiler/testData/diagnostics/tests/annotations/annotationParameterMustBeConstant/kotlinProperties.txt b/compiler/testData/diagnostics/tests/annotations/annotationParameterMustBeConstant/kotlinProperties.txt
index 8f8c736994c..923186e5b28 100644
--- a/compiler/testData/diagnostics/tests/annotations/annotationParameterMustBeConstant/kotlinProperties.txt
+++ b/compiler/testData/diagnostics/tests/annotations/annotationParameterMustBeConstant/kotlinProperties.txt
@@ -7,7 +7,7 @@ internal val i4: kotlin.Int = 1
 internal var i5: kotlin.Int
 internal var i6: kotlin.Int
 
-internal final annotation class Ann : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class Ann : kotlin.Annotation {
     public constructor Ann(/*0*/ vararg i: kotlin.Int /*kotlin.IntArray*/)
     internal final val i: kotlin.IntArray
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
diff --git a/compiler/testData/diagnostics/tests/annotations/annotationParameterMustBeConstant/strings.txt b/compiler/testData/diagnostics/tests/annotations/annotationParameterMustBeConstant/strings.txt
index 65763ee3097..643282d24c9 100644
--- a/compiler/testData/diagnostics/tests/annotations/annotationParameterMustBeConstant/strings.txt
+++ b/compiler/testData/diagnostics/tests/annotations/annotationParameterMustBeConstant/strings.txt
@@ -3,7 +3,7 @@ package
 internal val topLevel: kotlin.String = "topLevel"
 internal fun foo(): kotlin.Unit
 
-internal final annotation class Ann : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class Ann : kotlin.Annotation {
     public constructor Ann(/*0*/ vararg i: kotlin.String /*kotlin.Array<out kotlin.String>*/)
     internal final val i: kotlin.Array<out kotlin.String>
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
diff --git a/compiler/testData/diagnostics/tests/annotations/annotationsOnLambdaAsCallArgument.kt b/compiler/testData/diagnostics/tests/annotations/annotationsOnLambdaAsCallArgument.kt
index 352a0d9fe3f..11ff6202e1c 100644
--- a/compiler/testData/diagnostics/tests/annotations/annotationsOnLambdaAsCallArgument.kt
+++ b/compiler/testData/diagnostics/tests/annotations/annotationsOnLambdaAsCallArgument.kt
@@ -1,4 +1,5 @@
-annotation class Ann(val x: Int = 1)
+target(AnnotationTarget.EXPRESSION)
+annotation(repeatable = true) class Ann(val x: Int = 1)
 
 inline fun bar(block: () -> Int): Int = block()
 
diff --git a/compiler/testData/diagnostics/tests/annotations/annotationsOnLambdaAsCallArgument.txt b/compiler/testData/diagnostics/tests/annotations/annotationsOnLambdaAsCallArgument.txt
index e765ee0269a..98a9c0f6da4 100644
--- a/compiler/testData/diagnostics/tests/annotations/annotationsOnLambdaAsCallArgument.txt
+++ b/compiler/testData/diagnostics/tests/annotations/annotationsOnLambdaAsCallArgument.txt
@@ -3,7 +3,7 @@ package
 kotlin.inline() internal fun bar(/*0*/ block: () -> kotlin.Int): kotlin.Int
 internal fun foo(): kotlin.Unit
 
-internal final annotation class Ann : kotlin.Annotation {
+kotlin.annotation.target(allowedTargets = {AnnotationTarget.EXPRESSION}) kotlin.annotation.annotation(repeatable = true) internal final class Ann : kotlin.Annotation {
     public constructor Ann(/*0*/ x: kotlin.Int = ...)
     internal final val x: kotlin.Int
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
diff --git a/compiler/testData/diagnostics/tests/annotations/atAnnotationResolve.kt b/compiler/testData/diagnostics/tests/annotations/atAnnotationResolve.kt
index ae8a5d0a94f..2443d32f32a 100644
--- a/compiler/testData/diagnostics/tests/annotations/atAnnotationResolve.kt
+++ b/compiler/testData/diagnostics/tests/annotations/atAnnotationResolve.kt
@@ -1,5 +1,8 @@
 // !DIAGNOSTICS: -UNUSED_PARAMETER
-annotation class Ann(val x: Int = 6)
+target(AnnotationTarget.TYPE, AnnotationTarget.CLASSIFIER,
+       AnnotationTarget.CONSTRUCTOR, AnnotationTarget.FUNCTION,
+       AnnotationTarget.EXPRESSION, AnnotationTarget.PROPERTY)
+annotation(repeatable = true) class Ann(val x: Int = 6)
 
 @Ann(1) @Ann(2) @Ann(3) @private class A @Ann constructor() {
     @Ann(x = 5) fun foo() {
diff --git a/compiler/testData/diagnostics/tests/annotations/atAnnotationResolve.txt b/compiler/testData/diagnostics/tests/annotations/atAnnotationResolve.txt
index f52947cfa19..8304ffac487 100644
--- a/compiler/testData/diagnostics/tests/annotations/atAnnotationResolve.txt
+++ b/compiler/testData/diagnostics/tests/annotations/atAnnotationResolve.txt
@@ -1,16 +1,16 @@
 package
 
-Ann(x = IntegerValueType(1)) Ann(x = IntegerValueType(2)) Ann(x = IntegerValueType(3)) private final class A {
+Ann(x = 1) Ann(x = 2) Ann(x = 3) private final class A {
     Ann() public constructor A()
     Ann() internal final val x: kotlin.Int = 1
-    internal final fun bar(/*0*/ x: @[Ann(x = IntegerValueType(1)) Ann(x = IntegerValueType(2)) Ann(x = IntegerValueType(3))] kotlin.Int): kotlin.Unit
+    internal final fun bar(/*0*/ x: @[Ann(x = 1) Ann(x = 2) Ann(x = 3)] kotlin.Int): kotlin.Unit
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
-    Ann(x = IntegerValueType(5)) internal final fun foo(): kotlin.Unit
+    Ann(x = 5) internal final fun foo(): kotlin.Unit
     public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
 }
 
-internal final annotation class Ann : kotlin.Annotation {
+kotlin.annotation.target(allowedTargets = {AnnotationTarget.TYPE, AnnotationTarget.CLASSIFIER, AnnotationTarget.CONSTRUCTOR, AnnotationTarget.FUNCTION, AnnotationTarget.EXPRESSION, AnnotationTarget.PROPERTY}) kotlin.annotation.annotation(repeatable = true) internal final class Ann : kotlin.Annotation {
     public constructor Ann(/*0*/ x: kotlin.Int = ...)
     internal final val x: kotlin.Int
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
diff --git a/compiler/testData/diagnostics/tests/annotations/extensionFunctionType.txt b/compiler/testData/diagnostics/tests/annotations/extensionFunctionType.txt
index dbef146c30d..d7f1091fb38 100644
--- a/compiler/testData/diagnostics/tests/annotations/extensionFunctionType.txt
+++ b/compiler/testData/diagnostics/tests/annotations/extensionFunctionType.txt
@@ -10,7 +10,7 @@ internal interface Some {
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
 }
 
-internal final annotation class ann : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class ann : kotlin.Annotation {
     public constructor ann()
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
     public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
diff --git a/compiler/testData/diagnostics/tests/annotations/forParameterAnnotationResolve.txt b/compiler/testData/diagnostics/tests/annotations/forParameterAnnotationResolve.txt
index 585ecd5808b..295d0ab72c5 100644
--- a/compiler/testData/diagnostics/tests/annotations/forParameterAnnotationResolve.txt
+++ b/compiler/testData/diagnostics/tests/annotations/forParameterAnnotationResolve.txt
@@ -15,7 +15,7 @@ kotlin.data() internal final class A {
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
 }
 
-internal final annotation class Ann : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class Ann : kotlin.Annotation {
     public constructor Ann(/*0*/ x: kotlin.Int)
     internal final val x: kotlin.Int
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
diff --git a/compiler/testData/diagnostics/tests/annotations/invalidTypesInAnnotationConstructor.txt b/compiler/testData/diagnostics/tests/annotations/invalidTypesInAnnotationConstructor.txt
index d5a67e9a496..0c727b02bec 100644
--- a/compiler/testData/diagnostics/tests/annotations/invalidTypesInAnnotationConstructor.txt
+++ b/compiler/testData/diagnostics/tests/annotations/invalidTypesInAnnotationConstructor.txt
@@ -2,7 +2,7 @@ package
 
 package test {
 
-    internal final annotation class Ann1 : kotlin.Annotation {
+    kotlin.annotation.annotation() internal final class Ann1 : kotlin.Annotation {
         public constructor Ann1(/*0*/ p1: kotlin.Int, /*1*/ p2: kotlin.Byte, /*2*/ p3: kotlin.Short, /*3*/ p4: kotlin.Long, /*4*/ p5: kotlin.Double, /*5*/ p6: kotlin.Float, /*6*/ p7: kotlin.Char, /*7*/ p8: kotlin.Boolean)
         internal final val p1: kotlin.Int
         internal final val p2: kotlin.Byte
@@ -17,7 +17,7 @@ package test {
         public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
     }
 
-    internal final annotation class Ann2 : kotlin.Annotation {
+    kotlin.annotation.annotation() internal final class Ann2 : kotlin.Annotation {
         public constructor Ann2(/*0*/ p1: kotlin.String)
         internal final val p1: kotlin.String
         public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
@@ -25,7 +25,7 @@ package test {
         public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
     }
 
-    internal final annotation class Ann3 : kotlin.Annotation {
+    kotlin.annotation.annotation() internal final class Ann3 : kotlin.Annotation {
         public constructor Ann3(/*0*/ p1: test.Ann1)
         internal final val p1: test.Ann1
         public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
@@ -33,7 +33,7 @@ package test {
         public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
     }
 
-    internal final annotation class Ann4 : kotlin.Annotation {
+    kotlin.annotation.annotation() internal final class Ann4 : kotlin.Annotation {
         public constructor Ann4(/*0*/ p1: kotlin.IntArray, /*1*/ p2: kotlin.ByteArray, /*2*/ p3: kotlin.ShortArray, /*3*/ p4: kotlin.LongArray, /*4*/ p5: kotlin.DoubleArray, /*5*/ p6: kotlin.FloatArray, /*6*/ p7: kotlin.CharArray, /*7*/ p8: kotlin.BooleanArray)
         internal final val p1: kotlin.IntArray
         internal final val p2: kotlin.ByteArray
@@ -48,7 +48,7 @@ package test {
         public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
     }
 
-    internal final annotation class Ann5 : kotlin.Annotation {
+    kotlin.annotation.annotation() internal final class Ann5 : kotlin.Annotation {
         public constructor Ann5(/*0*/ p1: test.MyEnum)
         internal final val p1: test.MyEnum
         public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
@@ -56,7 +56,7 @@ package test {
         public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
     }
 
-    internal final annotation class Ann6 : kotlin.Annotation {
+    kotlin.annotation.annotation() internal final class Ann6 : kotlin.Annotation {
         public constructor Ann6(/*0*/ p: java.lang.Class<*>)
         internal final val p: java.lang.Class<*>
         public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
@@ -64,7 +64,7 @@ package test {
         public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
     }
 
-    internal final annotation class Ann7 : kotlin.Annotation {
+    kotlin.annotation.annotation() internal final class Ann7 : kotlin.Annotation {
         public constructor Ann7(/*0*/ p: java.lang.annotation.RetentionPolicy)
         internal final val p: java.lang.annotation.RetentionPolicy
         public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
@@ -72,7 +72,7 @@ package test {
         public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
     }
 
-    internal final annotation class Ann8 : kotlin.Annotation {
+    kotlin.annotation.annotation() internal final class Ann8 : kotlin.Annotation {
         public constructor Ann8(/*0*/ p1: kotlin.Array<kotlin.String>, /*1*/ p2: kotlin.Array<java.lang.Class<*>>, /*2*/ p3: kotlin.Array<test.MyEnum>, /*3*/ p4: kotlin.Array<test.Ann1>)
         internal final val p1: kotlin.Array<kotlin.String>
         internal final val p2: kotlin.Array<java.lang.Class<*>>
@@ -83,7 +83,7 @@ package test {
         public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
     }
 
-    internal final annotation class Ann9 : kotlin.Annotation {
+    kotlin.annotation.annotation() internal final class Ann9 : kotlin.Annotation {
         public constructor Ann9(/*0*/ vararg p1: kotlin.String /*kotlin.Array<out kotlin.String>*/, /*1*/ vararg p2: java.lang.Class<*> /*kotlin.Array<out java.lang.Class<*>>*/, /*2*/ vararg p3: test.MyEnum /*kotlin.Array<out test.MyEnum>*/, /*3*/ vararg p4: test.Ann1 /*kotlin.Array<out test.Ann1>*/, /*4*/ vararg p5: kotlin.Int /*kotlin.IntArray*/)
         internal final val p1: kotlin.Array<out kotlin.String>
         internal final val p2: kotlin.Array<out java.lang.Class<*>>
@@ -95,7 +95,7 @@ package test {
         public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
     }
 
-    internal final annotation class InAnn1 : kotlin.Annotation {
+    kotlin.annotation.annotation() internal final class InAnn1 : kotlin.Annotation {
         public constructor InAnn1(/*0*/ p1: kotlin.Int?, /*1*/ p3: kotlin.Short?, /*2*/ p4: kotlin.Long?, /*3*/ p5: kotlin.Double?, /*4*/ p6: kotlin.Float?, /*5*/ p7: kotlin.Char?, /*6*/ p8: kotlin.Boolean?)
         internal final val p1: kotlin.Int?
         internal final val p3: kotlin.Short?
@@ -109,7 +109,7 @@ package test {
         public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
     }
 
-    internal final annotation class InAnn10 : kotlin.Annotation {
+    kotlin.annotation.annotation() internal final class InAnn10 : kotlin.Annotation {
         public constructor InAnn10(/*0*/ p1: kotlin.String?)
         internal final val p1: kotlin.String?
         public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
@@ -117,7 +117,7 @@ package test {
         public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
     }
 
-    internal final annotation class InAnn11 : kotlin.Annotation {
+    kotlin.annotation.annotation() internal final class InAnn11 : kotlin.Annotation {
         public constructor InAnn11(/*0*/ p1: test.Ann1?)
         internal final val p1: test.Ann1?
         public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
@@ -125,7 +125,7 @@ package test {
         public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
     }
 
-    internal final annotation class InAnn12 : kotlin.Annotation {
+    kotlin.annotation.annotation() internal final class InAnn12 : kotlin.Annotation {
         public constructor InAnn12(/*0*/ p1: test.MyEnum?)
         internal final val p1: test.MyEnum?
         public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
@@ -133,7 +133,7 @@ package test {
         public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
     }
 
-    internal final annotation class InAnn4 : kotlin.Annotation {
+    kotlin.annotation.annotation() internal final class InAnn4 : kotlin.Annotation {
         public constructor InAnn4(/*0*/ p1: kotlin.Array<kotlin.Int>, /*1*/ p2: kotlin.Array<kotlin.Int>?)
         internal final val p1: kotlin.Array<kotlin.Int>
         internal final val p2: kotlin.Array<kotlin.Int>?
@@ -142,7 +142,7 @@ package test {
         public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
     }
 
-    internal final annotation class InAnn6 : kotlin.Annotation {
+    kotlin.annotation.annotation() internal final class InAnn6 : kotlin.Annotation {
         public constructor InAnn6(/*0*/ p: java.lang.Class<*>?)
         internal final val p: java.lang.Class<*>?
         public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
@@ -150,7 +150,7 @@ package test {
         public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
     }
 
-    internal final annotation class InAnn7 : kotlin.Annotation {
+    kotlin.annotation.annotation() internal final class InAnn7 : kotlin.Annotation {
         public constructor InAnn7(/*0*/ p: java.lang.annotation.RetentionPolicy?)
         internal final val p: java.lang.annotation.RetentionPolicy?
         public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
@@ -158,7 +158,7 @@ package test {
         public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
     }
 
-    internal final annotation class InAnn8 : kotlin.Annotation {
+    kotlin.annotation.annotation() internal final class InAnn8 : kotlin.Annotation {
         public constructor InAnn8(/*0*/ p1: kotlin.Array<kotlin.Int>, /*1*/ p2: kotlin.Array<kotlin.Int?>, /*2*/ p3: kotlin.Array<test.MyClass>, /*3*/ p4: kotlin.Array<kotlin.IntArray>)
         internal final val p1: kotlin.Array<kotlin.Int>
         internal final val p2: kotlin.Array<kotlin.Int?>
@@ -169,7 +169,7 @@ package test {
         public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
     }
 
-    internal final annotation class InAnn9 : kotlin.Annotation {
+    kotlin.annotation.annotation() internal final class InAnn9 : kotlin.Annotation {
         public constructor InAnn9(/*0*/ p: test.MyClass)
         internal final val p: test.MyClass
         public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
diff --git a/compiler/testData/diagnostics/tests/annotations/kt1860-positive.kt b/compiler/testData/diagnostics/tests/annotations/kt1860-positive.kt
index c23fa9142a0..c4751e8cf8b 100644
--- a/compiler/testData/diagnostics/tests/annotations/kt1860-positive.kt
+++ b/compiler/testData/diagnostics/tests/annotations/kt1860-positive.kt
@@ -1,3 +1,4 @@
+target(AnnotationTarget.VALUE_PARAMETER, AnnotationTarget.EXPRESSION)
 annotation class test
 
 fun foo(test <!UNUSED_PARAMETER!>f<!> : Int) {}
diff --git a/compiler/testData/diagnostics/tests/annotations/kt1860-positive.txt b/compiler/testData/diagnostics/tests/annotations/kt1860-positive.txt
index 47eb0519cf7..bb12f4d9876 100644
--- a/compiler/testData/diagnostics/tests/annotations/kt1860-positive.txt
+++ b/compiler/testData/diagnostics/tests/annotations/kt1860-positive.txt
@@ -11,7 +11,7 @@ internal final class Hello {
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
 }
 
-internal final annotation class test : kotlin.Annotation {
+kotlin.annotation.target(allowedTargets = {AnnotationTarget.VALUE_PARAMETER, AnnotationTarget.EXPRESSION}) kotlin.annotation.annotation() internal final class test : kotlin.Annotation {
     public constructor test()
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
     public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
diff --git a/compiler/testData/diagnostics/tests/annotations/kt1886annotationBody.txt b/compiler/testData/diagnostics/tests/annotations/kt1886annotationBody.txt
index eace797f536..8a04f9cd324 100644
--- a/compiler/testData/diagnostics/tests/annotations/kt1886annotationBody.txt
+++ b/compiler/testData/diagnostics/tests/annotations/kt1886annotationBody.txt
@@ -1,20 +1,20 @@
 package
 
-internal final annotation class Annotation1 : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class Annotation1 : kotlin.Annotation {
     public constructor Annotation1()
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
     public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
 }
 
-internal final annotation class Annotation10 : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class Annotation10 : kotlin.Annotation {
     public constructor Annotation10()
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
     public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
 }
 
-internal final annotation class Annotation2 : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class Annotation2 : kotlin.Annotation {
     public constructor Annotation2()
     public final val s: kotlin.String = ""
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
@@ -22,7 +22,7 @@ internal final annotation class Annotation2 : kotlin.Annotation {
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
 }
 
-internal final annotation class Annotation3 : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class Annotation3 : kotlin.Annotation {
     public constructor Annotation3()
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
     public final fun foo(): kotlin.Unit
@@ -30,7 +30,7 @@ internal final annotation class Annotation3 : kotlin.Annotation {
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
 }
 
-internal final annotation class Annotation4 : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class Annotation4 : kotlin.Annotation {
     public constructor Annotation4()
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
     public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
@@ -44,7 +44,7 @@ internal final annotation class Annotation4 : kotlin.Annotation {
     }
 }
 
-internal final annotation class Annotation5 : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class Annotation5 : kotlin.Annotation {
     public constructor Annotation5()
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
     public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
@@ -58,14 +58,14 @@ internal final annotation class Annotation5 : kotlin.Annotation {
     }
 }
 
-internal final annotation class Annotation6 : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class Annotation6 : kotlin.Annotation {
     public constructor Annotation6()
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
     public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
 }
 
-internal final annotation class Annotation7 : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class Annotation7 : kotlin.Annotation {
     public constructor Annotation7(/*0*/ name: kotlin.String)
     internal final val name: kotlin.String
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
@@ -73,7 +73,7 @@ internal final annotation class Annotation7 : kotlin.Annotation {
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
 }
 
-internal final annotation class Annotation8 : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class Annotation8 : kotlin.Annotation {
     public constructor Annotation8(/*0*/ name: kotlin.String = ...)
     internal final var name: kotlin.String
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
@@ -81,7 +81,7 @@ internal final annotation class Annotation8 : kotlin.Annotation {
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
 }
 
-internal final annotation class Annotation9 : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class Annotation9 : kotlin.Annotation {
     public constructor Annotation9(/*0*/ name: kotlin.String)
     internal final val name: kotlin.String
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
diff --git a/compiler/testData/diagnostics/tests/annotations/missingValOnParameter.txt b/compiler/testData/diagnostics/tests/annotations/missingValOnParameter.txt
index 7811b7df8c2..d97e7526c9d 100644
--- a/compiler/testData/diagnostics/tests/annotations/missingValOnParameter.txt
+++ b/compiler/testData/diagnostics/tests/annotations/missingValOnParameter.txt
@@ -1,6 +1,6 @@
 package
 
-internal final annotation class Ann : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class Ann : kotlin.Annotation {
     public constructor Ann(/*0*/ a: kotlin.Int, /*1*/ b: kotlin.Int, /*2*/ c: kotlin.String)
     internal final val a: kotlin.Int
     internal final var b: kotlin.Int
diff --git a/compiler/testData/diagnostics/tests/annotations/noNameProperty.txt b/compiler/testData/diagnostics/tests/annotations/noNameProperty.txt
index f6c24f088a1..d21bd493602 100644
--- a/compiler/testData/diagnostics/tests/annotations/noNameProperty.txt
+++ b/compiler/testData/diagnostics/tests/annotations/noNameProperty.txt
@@ -1,6 +1,6 @@
 package
 
-internal final annotation class Ann : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class Ann : kotlin.Annotation {
     public constructor Ann(/*0*/ x: kotlin.Int, /*1*/ <no name provided>: [ERROR : Type annotation was missing for parameter <no name provided>])
     internal final val <no name provided>: [ERROR : Annotation is absent]
     internal final val x: kotlin.Int
diff --git a/compiler/testData/diagnostics/tests/annotations/onExpression.kt b/compiler/testData/diagnostics/tests/annotations/onExpression.kt
index 72697adbaf5..f1d47b1fde4 100644
--- a/compiler/testData/diagnostics/tests/annotations/onExpression.kt
+++ b/compiler/testData/diagnostics/tests/annotations/onExpression.kt
@@ -1,3 +1,4 @@
 fun foo() = @ann 1
 
+target(AnnotationTarget.EXPRESSION)
 annotation class ann
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/annotations/onExpression.txt b/compiler/testData/diagnostics/tests/annotations/onExpression.txt
index b081ffe6529..483adc1101c 100644
--- a/compiler/testData/diagnostics/tests/annotations/onExpression.txt
+++ b/compiler/testData/diagnostics/tests/annotations/onExpression.txt
@@ -2,7 +2,7 @@ package
 
 internal fun foo(): kotlin.Int
 
-internal final annotation class ann : kotlin.Annotation {
+kotlin.annotation.target(allowedTargets = {AnnotationTarget.EXPRESSION}) kotlin.annotation.annotation() internal final class ann : kotlin.Annotation {
     public constructor ann()
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
     public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
diff --git a/compiler/testData/diagnostics/tests/annotations/onFunctionParameter.txt b/compiler/testData/diagnostics/tests/annotations/onFunctionParameter.txt
index bceef25b890..275ad1ebb8c 100644
--- a/compiler/testData/diagnostics/tests/annotations/onFunctionParameter.txt
+++ b/compiler/testData/diagnostics/tests/annotations/onFunctionParameter.txt
@@ -4,7 +4,7 @@ internal val bar: (kotlin.Int) -> kotlin.Unit
 internal val bas: (kotlin.Int) -> kotlin.Unit
 internal fun test(/*0*/ ann() p: kotlin.Int): kotlin.Unit
 
-internal final annotation class ann : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class ann : kotlin.Annotation {
     public constructor ann()
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
     public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
diff --git a/compiler/testData/diagnostics/tests/annotations/onInitializer.kt b/compiler/testData/diagnostics/tests/annotations/onInitializer.kt
index 94e69bbf308..150b324718d 100644
--- a/compiler/testData/diagnostics/tests/annotations/onInitializer.kt
+++ b/compiler/testData/diagnostics/tests/annotations/onInitializer.kt
@@ -1,15 +1,15 @@
 class A {
-    ann init {}
-    @ann init {}
-    <!UNRESOLVED_REFERENCE!>aaa<!> init {}
-    <!UNRESOLVED_REFERENCE!>@aaa<!> init {}
+    <!WRONG_ANNOTATION_TARGET!>ann<!> init {}
+    <!WRONG_ANNOTATION_TARGET!>@ann<!> init {}
+    <!UNRESOLVED_REFERENCE, WRONG_ANNOTATION_TARGET!>aaa<!> init {}
+    <!UNRESOLVED_REFERENCE, WRONG_ANNOTATION_TARGET!>@aaa<!> init {}
 }
 
 interface T {
-    <!ANONYMOUS_INITIALIZER_IN_TRAIT!>ann init {}<!>
-    <!ANONYMOUS_INITIALIZER_IN_TRAIT!>@ann init {}<!>
-    <!ANONYMOUS_INITIALIZER_IN_TRAIT!><!UNRESOLVED_REFERENCE!>aaa<!> init {}<!>
-    <!ANONYMOUS_INITIALIZER_IN_TRAIT!><!UNRESOLVED_REFERENCE!>@aaa<!> init {}<!>
+    <!ANONYMOUS_INITIALIZER_IN_TRAIT!><!WRONG_ANNOTATION_TARGET!>ann<!> init {}<!>
+    <!ANONYMOUS_INITIALIZER_IN_TRAIT!><!WRONG_ANNOTATION_TARGET!>@ann<!> init {}<!>
+    <!ANONYMOUS_INITIALIZER_IN_TRAIT!><!UNRESOLVED_REFERENCE, WRONG_ANNOTATION_TARGET!>aaa<!> init {}<!>
+    <!ANONYMOUS_INITIALIZER_IN_TRAIT!><!UNRESOLVED_REFERENCE, WRONG_ANNOTATION_TARGET!>@aaa<!> init {}<!>
 }
 
 annotation class ann
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/annotations/onInitializer.txt b/compiler/testData/diagnostics/tests/annotations/onInitializer.txt
index 56ed2530a13..f986750a6e9 100644
--- a/compiler/testData/diagnostics/tests/annotations/onInitializer.txt
+++ b/compiler/testData/diagnostics/tests/annotations/onInitializer.txt
@@ -13,7 +13,7 @@ internal interface T {
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
 }
 
-internal final annotation class ann : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class ann : kotlin.Annotation {
     public constructor ann()
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
     public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
diff --git a/compiler/testData/diagnostics/tests/annotations/onLoops.txt b/compiler/testData/diagnostics/tests/annotations/onLoops.txt
index 1023249041d..9d3e9a20d6b 100644
--- a/compiler/testData/diagnostics/tests/annotations/onLoops.txt
+++ b/compiler/testData/diagnostics/tests/annotations/onLoops.txt
@@ -2,7 +2,7 @@ package
 
 internal fun test(): kotlin.Unit
 
-internal final annotation class ann : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class ann : kotlin.Annotation {
     public constructor ann()
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
     public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
diff --git a/compiler/testData/diagnostics/tests/annotations/onLoopsUnreachable.txt b/compiler/testData/diagnostics/tests/annotations/onLoopsUnreachable.txt
index 1023249041d..9d3e9a20d6b 100644
--- a/compiler/testData/diagnostics/tests/annotations/onLoopsUnreachable.txt
+++ b/compiler/testData/diagnostics/tests/annotations/onLoopsUnreachable.txt
@@ -2,7 +2,7 @@ package
 
 internal fun test(): kotlin.Unit
 
-internal final annotation class ann : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class ann : kotlin.Annotation {
     public constructor ann()
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
     public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
diff --git a/compiler/testData/diagnostics/tests/annotations/onMultiDeclaration.txt b/compiler/testData/diagnostics/tests/annotations/onMultiDeclaration.txt
index 64919807789..638c6f3ebde 100644
--- a/compiler/testData/diagnostics/tests/annotations/onMultiDeclaration.txt
+++ b/compiler/testData/diagnostics/tests/annotations/onMultiDeclaration.txt
@@ -14,7 +14,7 @@ kotlin.data() internal final class P {
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
 }
 
-internal final annotation class ann : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class ann : kotlin.Annotation {
     public constructor ann()
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
     public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
diff --git a/compiler/testData/diagnostics/tests/annotations/options/annotation.kt b/compiler/testData/diagnostics/tests/annotations/options/annotation.kt
new file mode 100644
index 00000000000..fd33f6dff3c
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/annotations/options/annotation.kt
@@ -0,0 +1,17 @@
+// Annotations used for annotations :)
+enum class Target {
+    CLASSIFIER,
+    FUNCTION
+}
+
+target(Target.CLASSIFIER)
+public annotation class target(vararg val allowedTargets: Target)
+
+target(Target.CLASSIFIER)
+public annotation(AnnotationRetention.SOURCE) class annotation(
+    val retention: AnnotationRetention = AnnotationRetention.RUNTIME,
+    val repeatable: Boolean = false
+)
+
+annotation class some
+
diff --git a/compiler/testData/diagnostics/tests/annotations/options/annotation.txt b/compiler/testData/diagnostics/tests/annotations/options/annotation.txt
new file mode 100644
index 00000000000..6e7bdae469f
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/annotations/options/annotation.txt
@@ -0,0 +1,59 @@
+package
+
+internal final enum class Target : kotlin.Enum<Target> {
+    public enum entry CLASSIFIER : Target {
+        private constructor CLASSIFIER()
+        public final override /*1*/ /*fake_override*/ fun compareTo(/*0*/ other: Target): kotlin.Int
+        public final override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public final override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public final override /*1*/ /*fake_override*/ fun name(): kotlin.String
+        public final override /*1*/ /*fake_override*/ fun ordinal(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    public enum entry FUNCTION : Target {
+        private constructor FUNCTION()
+        public final override /*1*/ /*fake_override*/ fun compareTo(/*0*/ other: Target): kotlin.Int
+        public final override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public final override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public final override /*1*/ /*fake_override*/ fun name(): kotlin.String
+        public final override /*1*/ /*fake_override*/ fun ordinal(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    private constructor Target()
+    public final override /*1*/ /*fake_override*/ fun compareTo(/*0*/ other: Target): kotlin.Int
+    public final override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public final override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public final override /*1*/ /*fake_override*/ fun name(): kotlin.String
+    public final override /*1*/ /*fake_override*/ fun ordinal(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    // Static members
+    public final /*synthesized*/ fun valueOf(/*0*/ value: kotlin.String): Target
+    public final /*synthesized*/ fun values(): kotlin.Array<Target>
+}
+
+target(allowedTargets = {Target.CLASSIFIER}) annotation(retention = AnnotationRetention.SOURCE) public final class annotation : kotlin.Annotation {
+    public constructor annotation(/*0*/ retention: kotlin.annotation.AnnotationRetention = ..., /*1*/ repeatable: kotlin.Boolean = ...)
+    internal final val repeatable: kotlin.Boolean
+    internal final val retention: kotlin.annotation.AnnotationRetention
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+annotation() internal final class some : kotlin.Annotation {
+    public constructor some()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+target(allowedTargets = {Target.CLASSIFIER}) annotation() public final class target : kotlin.Annotation {
+    public constructor target(/*0*/ vararg allowedTargets: Target /*kotlin.Array<out Target>*/)
+    internal final val allowedTargets: kotlin.Array<out Target>
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
diff --git a/compiler/testData/diagnostics/tests/annotations/options/annotationAsArg.kt b/compiler/testData/diagnostics/tests/annotations/options/annotationAsArg.kt
new file mode 100644
index 00000000000..5484366eef0
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/annotations/options/annotationAsArg.kt
@@ -0,0 +1,14 @@
+class Annotation(val x: Int) {
+    fun baz() {}
+    fun bar() = x
+}
+
+fun foo(annotation: Annotation): Int {
+    if (annotation.bar() == 0) {
+        annotation.baz()
+        return 0
+    }
+    else {
+        return -1
+    }
+}
diff --git a/compiler/testData/diagnostics/tests/annotations/options/annotationAsArg.txt b/compiler/testData/diagnostics/tests/annotations/options/annotationAsArg.txt
new file mode 100644
index 00000000000..7d88c4c5161
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/annotations/options/annotationAsArg.txt
@@ -0,0 +1,13 @@
+package
+
+internal fun foo(/*0*/ annotation: Annotation): kotlin.Int
+
+internal final class Annotation {
+    public constructor Annotation(/*0*/ x: kotlin.Int)
+    internal final val x: kotlin.Int
+    internal final fun bar(): kotlin.Int
+    internal final fun baz(): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
diff --git a/compiler/testData/diagnostics/tests/annotations/options/annotationAsArgComplex.kt b/compiler/testData/diagnostics/tests/annotations/options/annotationAsArgComplex.kt
new file mode 100644
index 00000000000..e2c064206da
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/annotations/options/annotationAsArgComplex.kt
@@ -0,0 +1,10 @@
+// !DIAGNOSTICS: -UNUSED_VARIABLE
+class Annotation {
+    fun setProblemGroup() {}
+    fun getQuickFixes() = 0
+}
+
+fun registerQuickFix(annotation: Annotation) {
+    annotation.setProblemGroup()
+    val fixes = annotation.getQuickFixes()
+}
diff --git a/compiler/testData/diagnostics/tests/annotations/options/annotationAsArgComplex.txt b/compiler/testData/diagnostics/tests/annotations/options/annotationAsArgComplex.txt
new file mode 100644
index 00000000000..663d7b216bd
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/annotations/options/annotationAsArgComplex.txt
@@ -0,0 +1,12 @@
+package
+
+internal fun registerQuickFix(/*0*/ annotation: Annotation): kotlin.Unit
+
+internal final class Annotation {
+    public constructor Annotation()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    internal final fun getQuickFixes(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    internal final fun setProblemGroup(): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
diff --git a/compiler/testData/diagnostics/tests/annotations/options/brackets.kt b/compiler/testData/diagnostics/tests/annotations/options/brackets.kt
new file mode 100644
index 00000000000..303fae05cfc
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/annotations/options/brackets.kt
@@ -0,0 +1,3 @@
+annotation() class emptyBrackets
+
+emptyBrackets class base
diff --git a/compiler/testData/diagnostics/tests/annotations/options/brackets.txt b/compiler/testData/diagnostics/tests/annotations/options/brackets.txt
new file mode 100644
index 00000000000..58f0f9f3087
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/annotations/options/brackets.txt
@@ -0,0 +1,15 @@
+package
+
+emptyBrackets() internal final class base {
+    public constructor base()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+kotlin.annotation.annotation() internal final class emptyBrackets : kotlin.Annotation {
+    public constructor emptyBrackets()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
diff --git a/compiler/testData/diagnostics/tests/annotations/options/repeatable.kt b/compiler/testData/diagnostics/tests/annotations/options/repeatable.kt
new file mode 100644
index 00000000000..d4080ec2f62
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/annotations/options/repeatable.kt
@@ -0,0 +1,3 @@
+annotation(repeatable = true) class repann
+
+repann repann class DoubleAnnotated
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/annotations/options/repeatable.txt b/compiler/testData/diagnostics/tests/annotations/options/repeatable.txt
new file mode 100644
index 00000000000..a396fa6b17f
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/annotations/options/repeatable.txt
@@ -0,0 +1,15 @@
+package
+
+repann() repann() internal final class DoubleAnnotated {
+    public constructor DoubleAnnotated()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+kotlin.annotation.annotation(repeatable = true) internal final class repann : kotlin.Annotation {
+    public constructor repann()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
diff --git a/compiler/testData/diagnostics/tests/annotations/options/retention.kt b/compiler/testData/diagnostics/tests/annotations/options/retention.kt
new file mode 100644
index 00000000000..b2faff44864
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/annotations/options/retention.kt
@@ -0,0 +1,3 @@
+annotation(AnnotationRetention.SOURCE) class sourceann
+
+sourceann class AnnotatedAtSource
diff --git a/compiler/testData/diagnostics/tests/annotations/options/retention.txt b/compiler/testData/diagnostics/tests/annotations/options/retention.txt
new file mode 100644
index 00000000000..b96dea2f173
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/annotations/options/retention.txt
@@ -0,0 +1,15 @@
+package
+
+sourceann() internal final class AnnotatedAtSource {
+    public constructor AnnotatedAtSource()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+kotlin.annotation.annotation(retention = AnnotationRetention.SOURCE) internal final class sourceann : kotlin.Annotation {
+    public constructor sourceann()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
diff --git a/compiler/testData/diagnostics/tests/annotations/options/target.kt b/compiler/testData/diagnostics/tests/annotations/options/target.kt
new file mode 100644
index 00000000000..1b47729396a
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/annotations/options/target.kt
@@ -0,0 +1,5 @@
+target(AnnotationTarget.CLASSIFIER)
+annotation class base
+
+base data class My
+
diff --git a/compiler/testData/diagnostics/tests/annotations/options/target.txt b/compiler/testData/diagnostics/tests/annotations/options/target.txt
new file mode 100644
index 00000000000..09152f6db0f
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/annotations/options/target.txt
@@ -0,0 +1,16 @@
+package
+
+base() kotlin.data() internal final class My {
+    public constructor My()
+    public final /*synthesized*/ fun copy(): My
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+kotlin.annotation.target(allowedTargets = {AnnotationTarget.CLASSIFIER}) kotlin.annotation.annotation() internal final class base : kotlin.Annotation {
+    public constructor base()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
diff --git a/compiler/testData/diagnostics/tests/annotations/options/targets/accessors.kt b/compiler/testData/diagnostics/tests/annotations/options/targets/accessors.kt
new file mode 100644
index 00000000000..a5f5fd27205
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/annotations/options/targets/accessors.kt
@@ -0,0 +1,16 @@
+target(AnnotationTarget.PROPERTY_GETTER)
+annotation class smartget
+
+target(AnnotationTarget.PROPERTY_SETTER)
+annotation class smartset
+
+target(AnnotationTarget.FUNCTION)
+annotation class base
+
+class My(x: Int) {
+    <!WRONG_ANNOTATION_TARGET!>smartget<!> var y = x
+        <!WRONG_ANNOTATION_TARGET!>@base<!> @smartget <!WRONG_ANNOTATION_TARGET!>@smartset<!> get
+        <!WRONG_ANNOTATION_TARGET!>@base<!> <!WRONG_ANNOTATION_TARGET!>@smartget<!> @smartset set
+
+    base <!WRONG_ANNOTATION_TARGET!>smartget<!> <!WRONG_ANNOTATION_TARGET!>smartset<!> fun foo() = y
+}
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/annotations/options/targets/accessors.txt b/compiler/testData/diagnostics/tests/annotations/options/targets/accessors.txt
new file mode 100644
index 00000000000..641527b226c
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/annotations/options/targets/accessors.txt
@@ -0,0 +1,31 @@
+package
+
+internal final class My {
+    public constructor My(/*0*/ x: kotlin.Int)
+    smartget() internal final var y: kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    base() smartget() smartset() internal final fun foo(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+kotlin.annotation.target(allowedTargets = {AnnotationTarget.FUNCTION}) kotlin.annotation.annotation() internal final class base : kotlin.Annotation {
+    public constructor base()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+kotlin.annotation.target(allowedTargets = {AnnotationTarget.PROPERTY_GETTER}) kotlin.annotation.annotation() internal final class smartget : kotlin.Annotation {
+    public constructor smartget()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+kotlin.annotation.target(allowedTargets = {AnnotationTarget.PROPERTY_SETTER}) kotlin.annotation.annotation() internal final class smartset : kotlin.Annotation {
+    public constructor smartset()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
diff --git a/compiler/testData/diagnostics/tests/annotations/options/targets/annotation.kt b/compiler/testData/diagnostics/tests/annotations/options/targets/annotation.kt
new file mode 100644
index 00000000000..7b789761ccb
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/annotations/options/targets/annotation.kt
@@ -0,0 +1,20 @@
+target(AnnotationTarget.ANNOTATION_CLASS) annotation class base
+
+base annotation class derived
+
+<!WRONG_ANNOTATION_TARGET!>base<!> class correct(<!WRONG_ANNOTATION_TARGET!>base<!> val x: Int) {
+    <!WRONG_ANNOTATION_TARGET!>base<!> constructor(): this(0)
+}
+
+<!WRONG_ANNOTATION_TARGET!>base<!> enum class My {
+    <!WRONG_ANNOTATION_TARGET!>@base<!> FIRST,
+    <!WRONG_ANNOTATION_TARGET!>@base<!> SECOND
+}
+
+<!WRONG_ANNOTATION_TARGET!>base<!> fun foo(<!WRONG_ANNOTATION_TARGET!>base<!> y: <!WRONG_ANNOTATION_TARGET!>@base<!> Int): Int {
+    <!WRONG_ANNOTATION_TARGET!>@base<!> fun bar(<!WRONG_ANNOTATION_TARGET!>base<!> z: <!WRONG_ANNOTATION_TARGET!>@base<!> Int) = z + 1
+    <!WRONG_ANNOTATION_TARGET!>@base<!> val local = bar(y)
+    return local
+}
+
+<!WRONG_ANNOTATION_TARGET!>base<!> val z = 0
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/annotations/options/targets/annotation.txt b/compiler/testData/diagnostics/tests/annotations/options/targets/annotation.txt
new file mode 100644
index 00000000000..4a78537850d
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/annotations/options/targets/annotation.txt
@@ -0,0 +1,61 @@
+package
+
+base() internal val z: kotlin.Int = 0
+base() internal fun foo(/*0*/ base() y: @[base()] kotlin.Int): kotlin.Int
+
+base() internal final enum class My : kotlin.Enum<My> {
+    base() public enum entry FIRST : My {
+        private constructor FIRST()
+        public final override /*1*/ /*fake_override*/ fun compareTo(/*0*/ other: My): kotlin.Int
+        public final override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public final override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public final override /*1*/ /*fake_override*/ fun name(): kotlin.String
+        public final override /*1*/ /*fake_override*/ fun ordinal(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    base() public enum entry SECOND : My {
+        private constructor SECOND()
+        public final override /*1*/ /*fake_override*/ fun compareTo(/*0*/ other: My): kotlin.Int
+        public final override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public final override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public final override /*1*/ /*fake_override*/ fun name(): kotlin.String
+        public final override /*1*/ /*fake_override*/ fun ordinal(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    private constructor My()
+    public final override /*1*/ /*fake_override*/ fun compareTo(/*0*/ other: My): kotlin.Int
+    public final override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public final override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public final override /*1*/ /*fake_override*/ fun name(): kotlin.String
+    public final override /*1*/ /*fake_override*/ fun ordinal(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    // Static members
+    public final /*synthesized*/ fun valueOf(/*0*/ value: kotlin.String): My
+    public final /*synthesized*/ fun values(): kotlin.Array<My>
+}
+
+kotlin.annotation.target(allowedTargets = {AnnotationTarget.ANNOTATION_CLASS}) kotlin.annotation.annotation() internal final class base : kotlin.Annotation {
+    public constructor base()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+base() internal final class correct {
+    base() public constructor correct()
+    public constructor correct(/*0*/ base() x: kotlin.Int)
+    base() internal final val x: kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+base() kotlin.annotation.annotation() internal final class derived : kotlin.Annotation {
+    public constructor derived()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
diff --git a/compiler/testData/diagnostics/tests/annotations/options/targets/classifier.kt b/compiler/testData/diagnostics/tests/annotations/options/targets/classifier.kt
new file mode 100644
index 00000000000..1bedffc957d
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/annotations/options/targets/classifier.kt
@@ -0,0 +1,21 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+target(AnnotationTarget.CLASSIFIER) annotation class base
+
+base annotation class derived
+
+base class correct(<!WRONG_ANNOTATION_TARGET!>base<!> val x: Int, <!WRONG_ANNOTATION_TARGET!>base<!> w: <!WRONG_ANNOTATION_TARGET!>@base<!> Int) {
+    <!WRONG_ANNOTATION_TARGET!>base<!> constructor(): this(0, 0)
+}
+
+base enum class My <!WRONG_ANNOTATION_TARGET!>@base<!> constructor() {
+    <!WRONG_ANNOTATION_TARGET!>@base<!> FIRST,
+    <!WRONG_ANNOTATION_TARGET!>@base<!> SECOND
+}
+
+<!WRONG_ANNOTATION_TARGET!>base<!> fun foo(<!WRONG_ANNOTATION_TARGET!>base<!> y: <!WRONG_ANNOTATION_TARGET!>@base<!> Int): Int {
+    <!WRONG_ANNOTATION_TARGET!>@base<!> fun bar(<!WRONG_ANNOTATION_TARGET!>base<!> z: <!WRONG_ANNOTATION_TARGET!>@base<!> Int) = z + 1
+    <!WRONG_ANNOTATION_TARGET!>@base<!> val local = bar(y)
+    return local
+}
+
+<!WRONG_ANNOTATION_TARGET!>base<!> val z = 0
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/annotations/options/targets/classifier.txt b/compiler/testData/diagnostics/tests/annotations/options/targets/classifier.txt
new file mode 100644
index 00000000000..b9bb02b00a6
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/annotations/options/targets/classifier.txt
@@ -0,0 +1,61 @@
+package
+
+base() internal val z: kotlin.Int = 0
+base() internal fun foo(/*0*/ base() y: @[base()] kotlin.Int): kotlin.Int
+
+base() internal final enum class My : kotlin.Enum<My> {
+    base() public enum entry FIRST : My {
+        private constructor FIRST()
+        public final override /*1*/ /*fake_override*/ fun compareTo(/*0*/ other: My): kotlin.Int
+        public final override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public final override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public final override /*1*/ /*fake_override*/ fun name(): kotlin.String
+        public final override /*1*/ /*fake_override*/ fun ordinal(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    base() public enum entry SECOND : My {
+        private constructor SECOND()
+        public final override /*1*/ /*fake_override*/ fun compareTo(/*0*/ other: My): kotlin.Int
+        public final override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public final override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public final override /*1*/ /*fake_override*/ fun name(): kotlin.String
+        public final override /*1*/ /*fake_override*/ fun ordinal(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    base() private constructor My()
+    public final override /*1*/ /*fake_override*/ fun compareTo(/*0*/ other: My): kotlin.Int
+    public final override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public final override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public final override /*1*/ /*fake_override*/ fun name(): kotlin.String
+    public final override /*1*/ /*fake_override*/ fun ordinal(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    // Static members
+    public final /*synthesized*/ fun valueOf(/*0*/ value: kotlin.String): My
+    public final /*synthesized*/ fun values(): kotlin.Array<My>
+}
+
+kotlin.annotation.target(allowedTargets = {AnnotationTarget.CLASSIFIER}) kotlin.annotation.annotation() internal final class base : kotlin.Annotation {
+    public constructor base()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+base() internal final class correct {
+    base() public constructor correct()
+    public constructor correct(/*0*/ base() x: kotlin.Int, /*1*/ base() w: @[base()] kotlin.Int)
+    base() internal final val x: kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+base() kotlin.annotation.annotation() internal final class derived : kotlin.Annotation {
+    public constructor derived()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
diff --git a/compiler/testData/diagnostics/tests/annotations/options/targets/constructor.kt b/compiler/testData/diagnostics/tests/annotations/options/targets/constructor.kt
new file mode 100644
index 00000000000..dce66d46d27
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/annotations/options/targets/constructor.kt
@@ -0,0 +1,20 @@
+target(AnnotationTarget.CONSTRUCTOR) annotation class base
+
+<!WRONG_ANNOTATION_TARGET!>base<!> annotation class derived
+
+<!WRONG_ANNOTATION_TARGET!>base<!> class correct(<!WRONG_ANNOTATION_TARGET!>base<!> val x: Int) {
+    base constructor(): this(0)
+}
+
+<!WRONG_ANNOTATION_TARGET!>base<!> enum class My @base constructor() {
+    <!WRONG_ANNOTATION_TARGET!>@base<!> FIRST,
+    <!WRONG_ANNOTATION_TARGET!>@base<!> SECOND
+}
+
+<!WRONG_ANNOTATION_TARGET!>base<!> fun foo(<!WRONG_ANNOTATION_TARGET!>base<!> y: <!WRONG_ANNOTATION_TARGET!>@base<!> Int): Int {
+    <!WRONG_ANNOTATION_TARGET!>@base<!> fun bar(<!WRONG_ANNOTATION_TARGET!>base<!> z: <!WRONG_ANNOTATION_TARGET!>@base<!> Int) = z + 1
+    <!WRONG_ANNOTATION_TARGET!>@base<!> val local = bar(y)
+    return local
+}
+
+<!WRONG_ANNOTATION_TARGET!>base<!> val z = 0
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/annotations/options/targets/constructor.txt b/compiler/testData/diagnostics/tests/annotations/options/targets/constructor.txt
new file mode 100644
index 00000000000..1aecd91bde6
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/annotations/options/targets/constructor.txt
@@ -0,0 +1,61 @@
+package
+
+base() internal val z: kotlin.Int = 0
+base() internal fun foo(/*0*/ base() y: @[base()] kotlin.Int): kotlin.Int
+
+base() internal final enum class My : kotlin.Enum<My> {
+    base() public enum entry FIRST : My {
+        private constructor FIRST()
+        public final override /*1*/ /*fake_override*/ fun compareTo(/*0*/ other: My): kotlin.Int
+        public final override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public final override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public final override /*1*/ /*fake_override*/ fun name(): kotlin.String
+        public final override /*1*/ /*fake_override*/ fun ordinal(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    base() public enum entry SECOND : My {
+        private constructor SECOND()
+        public final override /*1*/ /*fake_override*/ fun compareTo(/*0*/ other: My): kotlin.Int
+        public final override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public final override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public final override /*1*/ /*fake_override*/ fun name(): kotlin.String
+        public final override /*1*/ /*fake_override*/ fun ordinal(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    base() private constructor My()
+    public final override /*1*/ /*fake_override*/ fun compareTo(/*0*/ other: My): kotlin.Int
+    public final override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public final override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public final override /*1*/ /*fake_override*/ fun name(): kotlin.String
+    public final override /*1*/ /*fake_override*/ fun ordinal(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    // Static members
+    public final /*synthesized*/ fun valueOf(/*0*/ value: kotlin.String): My
+    public final /*synthesized*/ fun values(): kotlin.Array<My>
+}
+
+kotlin.annotation.target(allowedTargets = {AnnotationTarget.CONSTRUCTOR}) kotlin.annotation.annotation() internal final class base : kotlin.Annotation {
+    public constructor base()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+base() internal final class correct {
+    base() public constructor correct()
+    public constructor correct(/*0*/ base() x: kotlin.Int)
+    base() internal final val x: kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+base() kotlin.annotation.annotation() internal final class derived : kotlin.Annotation {
+    public constructor derived()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
diff --git a/compiler/testData/diagnostics/tests/annotations/options/targets/empty.kt b/compiler/testData/diagnostics/tests/annotations/options/targets/empty.kt
new file mode 100644
index 00000000000..5af7fcb516c
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/annotations/options/targets/empty.kt
@@ -0,0 +1,21 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+target() annotation class empty
+
+<!WRONG_ANNOTATION_TARGET!>empty<!> annotation class derived
+
+<!WRONG_ANNOTATION_TARGET!>empty<!> class correct(<!WRONG_ANNOTATION_TARGET!>empty<!> val x: Int, <!WRONG_ANNOTATION_TARGET!>empty<!> w: <!WRONG_ANNOTATION_TARGET!>@empty<!> Int) {
+    <!WRONG_ANNOTATION_TARGET!>empty<!> constructor(): this(0, 0)
+}
+
+<!WRONG_ANNOTATION_TARGET!>empty<!> enum class My <!WRONG_ANNOTATION_TARGET!>@empty<!> constructor() {
+    <!WRONG_ANNOTATION_TARGET!>@empty<!> FIRST,
+    <!WRONG_ANNOTATION_TARGET!>@empty<!> SECOND
+}
+
+<!WRONG_ANNOTATION_TARGET!>empty<!> fun foo(<!WRONG_ANNOTATION_TARGET!>empty<!> y: <!WRONG_ANNOTATION_TARGET!>@empty<!> Int): Int {
+    <!WRONG_ANNOTATION_TARGET!>@empty<!> fun bar(<!WRONG_ANNOTATION_TARGET!>empty<!> z: <!WRONG_ANNOTATION_TARGET!>@empty<!> Int) = z + 1
+    <!WRONG_ANNOTATION_TARGET!>@empty<!> val local = bar(y)
+    return local
+}
+
+<!WRONG_ANNOTATION_TARGET!>empty<!> val z = <!WRONG_ANNOTATION_TARGET!>@empty<!> 0
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/annotations/options/targets/empty.txt b/compiler/testData/diagnostics/tests/annotations/options/targets/empty.txt
new file mode 100644
index 00000000000..20ef832c08c
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/annotations/options/targets/empty.txt
@@ -0,0 +1,61 @@
+package
+
+empty() internal val z: kotlin.Int
+empty() internal fun foo(/*0*/ empty() y: @[empty()] kotlin.Int): kotlin.Int
+
+empty() internal final enum class My : kotlin.Enum<My> {
+    empty() public enum entry FIRST : My {
+        private constructor FIRST()
+        public final override /*1*/ /*fake_override*/ fun compareTo(/*0*/ other: My): kotlin.Int
+        public final override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public final override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public final override /*1*/ /*fake_override*/ fun name(): kotlin.String
+        public final override /*1*/ /*fake_override*/ fun ordinal(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    empty() public enum entry SECOND : My {
+        private constructor SECOND()
+        public final override /*1*/ /*fake_override*/ fun compareTo(/*0*/ other: My): kotlin.Int
+        public final override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public final override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public final override /*1*/ /*fake_override*/ fun name(): kotlin.String
+        public final override /*1*/ /*fake_override*/ fun ordinal(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    empty() private constructor My()
+    public final override /*1*/ /*fake_override*/ fun compareTo(/*0*/ other: My): kotlin.Int
+    public final override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public final override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public final override /*1*/ /*fake_override*/ fun name(): kotlin.String
+    public final override /*1*/ /*fake_override*/ fun ordinal(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    // Static members
+    public final /*synthesized*/ fun valueOf(/*0*/ value: kotlin.String): My
+    public final /*synthesized*/ fun values(): kotlin.Array<My>
+}
+
+empty() internal final class correct {
+    empty() public constructor correct()
+    public constructor correct(/*0*/ empty() x: kotlin.Int, /*1*/ empty() w: @[empty()] kotlin.Int)
+    empty() internal final val x: kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+empty() kotlin.annotation.annotation() internal final class derived : kotlin.Annotation {
+    public constructor derived()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+kotlin.annotation.target(allowedTargets = {}) kotlin.annotation.annotation() internal final class empty : kotlin.Annotation {
+    public constructor empty()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
diff --git a/compiler/testData/diagnostics/tests/annotations/options/targets/expr.kt b/compiler/testData/diagnostics/tests/annotations/options/targets/expr.kt
new file mode 100644
index 00000000000..fff356d1dc8
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/annotations/options/targets/expr.kt
@@ -0,0 +1,11 @@
+annotation class base
+
+target(AnnotationTarget.EXPRESSION) annotation class special
+
+fun transform(i: Int, tr: (Int) -> Int): Int = <!WRONG_ANNOTATION_TARGET!>@base<!> @special tr(@special i)
+
+base <!WRONG_ANNOTATION_TARGET!>special<!> fun foo(i: Int): Int {
+    val j = <!WRONG_ANNOTATION_TARGET!>@base<!> @special i + 1
+    if (j == 1) return foo(@special <!WRONG_ANNOTATION_TARGET!>@base<!> 42)
+    return transform(@special j, <!WRONG_ANNOTATION_TARGET!>@base<!> @special { @special it * 2 })
+}
diff --git a/compiler/testData/diagnostics/tests/annotations/options/targets/expr.txt b/compiler/testData/diagnostics/tests/annotations/options/targets/expr.txt
new file mode 100644
index 00000000000..58e6479fa39
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/annotations/options/targets/expr.txt
@@ -0,0 +1,18 @@
+package
+
+base() special() internal fun foo(/*0*/ i: kotlin.Int): kotlin.Int
+internal fun transform(/*0*/ i: kotlin.Int, /*1*/ tr: (kotlin.Int) -> kotlin.Int): kotlin.Int
+
+kotlin.annotation.annotation() internal final class base : kotlin.Annotation {
+    public constructor base()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+kotlin.annotation.target(allowedTargets = {AnnotationTarget.EXPRESSION}) kotlin.annotation.annotation() internal final class special : kotlin.Annotation {
+    public constructor special()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
diff --git a/compiler/testData/diagnostics/tests/annotations/options/targets/file.kt b/compiler/testData/diagnostics/tests/annotations/options/targets/file.kt
new file mode 100644
index 00000000000..76072bdaf90
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/annotations/options/targets/file.kt
@@ -0,0 +1,23 @@
+// FILE: annotation.kt
+
+package test
+
+target(AnnotationTarget.FILE) annotation class special
+
+annotation class common
+
+// FILE: other.kt
+
+@file:special 
+
+package test
+
+<!WRONG_ANNOTATION_TARGET!>special<!> class Incorrect
+
+// FILE: another.kt
+
+<!WRONG_ANNOTATION_TARGET!>@file:common<!>
+
+package test
+
+common class Correct
diff --git a/compiler/testData/diagnostics/tests/annotations/options/targets/file.txt b/compiler/testData/diagnostics/tests/annotations/options/targets/file.txt
new file mode 100644
index 00000000000..084c6b9a796
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/annotations/options/targets/file.txt
@@ -0,0 +1,32 @@
+package
+
+package test {
+
+    test.common() internal final class Correct {
+        public constructor Correct()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    test.special() internal final class Incorrect {
+        public constructor Incorrect()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    kotlin.annotation.annotation() internal final class common : kotlin.Annotation {
+        public constructor common()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    kotlin.annotation.target(allowedTargets = {AnnotationTarget.FILE}) kotlin.annotation.annotation() internal final class special : kotlin.Annotation {
+        public constructor special()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+}
diff --git a/compiler/testData/diagnostics/tests/annotations/options/targets/function.kt b/compiler/testData/diagnostics/tests/annotations/options/targets/function.kt
new file mode 100644
index 00000000000..7c6251bb42f
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/annotations/options/targets/function.kt
@@ -0,0 +1,22 @@
+target(AnnotationTarget.FUNCTION) annotation class base
+
+<!WRONG_ANNOTATION_TARGET!>base<!> annotation class derived
+
+<!WRONG_ANNOTATION_TARGET!>base<!> class correct(<!WRONG_ANNOTATION_TARGET!>base<!> val x: Int) {
+    <!WRONG_ANNOTATION_TARGET!>base<!> constructor(): this(0)
+
+    base public fun baz() {}
+}
+
+<!WRONG_ANNOTATION_TARGET!>base<!> enum class My <!WRONG_ANNOTATION_TARGET!>@base<!> constructor() {
+    <!WRONG_ANNOTATION_TARGET!>@base<!> FIRST,
+    <!WRONG_ANNOTATION_TARGET!>@base<!> SECOND
+}
+
+base fun foo(<!WRONG_ANNOTATION_TARGET!>base<!> y: <!WRONG_ANNOTATION_TARGET!>@base<!> Int): Int {
+    @base fun bar(<!WRONG_ANNOTATION_TARGET!>base<!> z: <!WRONG_ANNOTATION_TARGET!>@base<!> Int) = z + 1
+    <!WRONG_ANNOTATION_TARGET!>@base<!> val local = bar(y)
+    return local
+}
+
+<!WRONG_ANNOTATION_TARGET!>base<!> val z = 0
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/annotations/options/targets/function.txt b/compiler/testData/diagnostics/tests/annotations/options/targets/function.txt
new file mode 100644
index 00000000000..fd0f3cc25a5
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/annotations/options/targets/function.txt
@@ -0,0 +1,62 @@
+package
+
+base() internal val z: kotlin.Int = 0
+base() internal fun foo(/*0*/ base() y: @[base()] kotlin.Int): kotlin.Int
+
+base() internal final enum class My : kotlin.Enum<My> {
+    base() public enum entry FIRST : My {
+        private constructor FIRST()
+        public final override /*1*/ /*fake_override*/ fun compareTo(/*0*/ other: My): kotlin.Int
+        public final override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public final override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public final override /*1*/ /*fake_override*/ fun name(): kotlin.String
+        public final override /*1*/ /*fake_override*/ fun ordinal(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    base() public enum entry SECOND : My {
+        private constructor SECOND()
+        public final override /*1*/ /*fake_override*/ fun compareTo(/*0*/ other: My): kotlin.Int
+        public final override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public final override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public final override /*1*/ /*fake_override*/ fun name(): kotlin.String
+        public final override /*1*/ /*fake_override*/ fun ordinal(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    base() private constructor My()
+    public final override /*1*/ /*fake_override*/ fun compareTo(/*0*/ other: My): kotlin.Int
+    public final override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public final override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public final override /*1*/ /*fake_override*/ fun name(): kotlin.String
+    public final override /*1*/ /*fake_override*/ fun ordinal(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    // Static members
+    public final /*synthesized*/ fun valueOf(/*0*/ value: kotlin.String): My
+    public final /*synthesized*/ fun values(): kotlin.Array<My>
+}
+
+kotlin.annotation.target(allowedTargets = {AnnotationTarget.FUNCTION}) kotlin.annotation.annotation() internal final class base : kotlin.Annotation {
+    public constructor base()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+base() internal final class correct {
+    base() public constructor correct()
+    public constructor correct(/*0*/ base() x: kotlin.Int)
+    base() internal final val x: kotlin.Int
+    base() public final fun baz(): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+base() kotlin.annotation.annotation() internal final class derived : kotlin.Annotation {
+    public constructor derived()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
diff --git a/compiler/testData/diagnostics/tests/annotations/options/targets/funtypeargs.kt b/compiler/testData/diagnostics/tests/annotations/options/targets/funtypeargs.kt
new file mode 100644
index 00000000000..d158d935f4e
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/annotations/options/targets/funtypeargs.kt
@@ -0,0 +1,13 @@
+target(AnnotationTarget.EXPRESSION) 
+annotation class special
+
+target(AnnotationTarget.TYPE) 
+annotation class base
+
+fun transform(i: Int, tr: (@<!DEBUG_INFO_MISSING_UNRESOLVED!>special<!> Int) -> Int): Int = @special tr(@special i)
+
+fun foo(i: Int): Int {
+    val j = @special i + 1
+    if (j == 1) return foo(@special 42)
+    return transform(@special j, @special { i: @base Int -> <!WRONG_ANNOTATION_TARGET!>@base<!> i * 2 })
+}
diff --git a/compiler/testData/diagnostics/tests/annotations/options/targets/funtypeargs.txt b/compiler/testData/diagnostics/tests/annotations/options/targets/funtypeargs.txt
new file mode 100644
index 00000000000..f0528388ae0
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/annotations/options/targets/funtypeargs.txt
@@ -0,0 +1,18 @@
+package
+
+internal fun foo(/*0*/ i: kotlin.Int): kotlin.Int
+internal fun transform(/*0*/ i: kotlin.Int, /*1*/ tr: (kotlin.Int) -> kotlin.Int): kotlin.Int
+
+kotlin.annotation.target(allowedTargets = {AnnotationTarget.TYPE}) kotlin.annotation.annotation() internal final class base : kotlin.Annotation {
+    public constructor base()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+kotlin.annotation.target(allowedTargets = {AnnotationTarget.EXPRESSION}) kotlin.annotation.annotation() internal final class special : kotlin.Annotation {
+    public constructor special()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
diff --git a/compiler/testData/diagnostics/tests/annotations/options/targets/incorrect.kt b/compiler/testData/diagnostics/tests/annotations/options/targets/incorrect.kt
new file mode 100644
index 00000000000..d6dd3e4fcc1
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/annotations/options/targets/incorrect.kt
@@ -0,0 +1,21 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+target(AnnotationTarget.<!UNRESOLVED_REFERENCE!>INIT<!>) annotation class incorrect
+
+<!WRONG_ANNOTATION_TARGET!>incorrect<!> annotation class derived
+
+<!WRONG_ANNOTATION_TARGET!>incorrect<!> class correct(<!WRONG_ANNOTATION_TARGET!>incorrect<!> val x: Int, <!WRONG_ANNOTATION_TARGET!>incorrect<!> w: <!WRONG_ANNOTATION_TARGET!>@incorrect<!> Int) {
+    <!WRONG_ANNOTATION_TARGET!>incorrect<!> constructor(): this(0, 0)
+}
+
+<!WRONG_ANNOTATION_TARGET!>incorrect<!> enum class My <!WRONG_ANNOTATION_TARGET!>@incorrect<!> constructor() {
+    <!WRONG_ANNOTATION_TARGET!>@incorrect<!> FIRST,
+    <!WRONG_ANNOTATION_TARGET!>@incorrect<!> SECOND
+}
+
+<!WRONG_ANNOTATION_TARGET!>incorrect<!> fun foo(<!WRONG_ANNOTATION_TARGET!>incorrect<!> y: <!WRONG_ANNOTATION_TARGET!>@incorrect<!> Int): Int {
+    <!WRONG_ANNOTATION_TARGET!>@incorrect<!> fun bar(<!WRONG_ANNOTATION_TARGET!>incorrect<!> z: <!WRONG_ANNOTATION_TARGET!>@incorrect<!> Int) = z + 1
+    <!WRONG_ANNOTATION_TARGET!>@incorrect<!> val local = bar(y)
+    return local
+}
+
+<!WRONG_ANNOTATION_TARGET!>incorrect<!> val z = <!WRONG_ANNOTATION_TARGET!>@incorrect<!> 0
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/annotations/options/targets/incorrect.txt b/compiler/testData/diagnostics/tests/annotations/options/targets/incorrect.txt
new file mode 100644
index 00000000000..7349f38fb4a
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/annotations/options/targets/incorrect.txt
@@ -0,0 +1,61 @@
+package
+
+incorrect() internal val z: kotlin.Int
+incorrect() internal fun foo(/*0*/ incorrect() y: @[incorrect()] kotlin.Int): kotlin.Int
+
+incorrect() internal final enum class My : kotlin.Enum<My> {
+    incorrect() public enum entry FIRST : My {
+        private constructor FIRST()
+        public final override /*1*/ /*fake_override*/ fun compareTo(/*0*/ other: My): kotlin.Int
+        public final override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public final override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public final override /*1*/ /*fake_override*/ fun name(): kotlin.String
+        public final override /*1*/ /*fake_override*/ fun ordinal(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    incorrect() public enum entry SECOND : My {
+        private constructor SECOND()
+        public final override /*1*/ /*fake_override*/ fun compareTo(/*0*/ other: My): kotlin.Int
+        public final override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public final override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public final override /*1*/ /*fake_override*/ fun name(): kotlin.String
+        public final override /*1*/ /*fake_override*/ fun ordinal(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    incorrect() private constructor My()
+    public final override /*1*/ /*fake_override*/ fun compareTo(/*0*/ other: My): kotlin.Int
+    public final override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public final override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public final override /*1*/ /*fake_override*/ fun name(): kotlin.String
+    public final override /*1*/ /*fake_override*/ fun ordinal(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    // Static members
+    public final /*synthesized*/ fun valueOf(/*0*/ value: kotlin.String): My
+    public final /*synthesized*/ fun values(): kotlin.Array<My>
+}
+
+incorrect() internal final class correct {
+    incorrect() public constructor correct()
+    public constructor correct(/*0*/ incorrect() x: kotlin.Int, /*1*/ incorrect() w: @[incorrect()] kotlin.Int)
+    incorrect() internal final val x: kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+incorrect() kotlin.annotation.annotation() internal final class derived : kotlin.Annotation {
+    public constructor derived()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+kotlin.annotation.target(allowedTargets = {}) kotlin.annotation.annotation() internal final class incorrect : kotlin.Annotation {
+    public constructor incorrect()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
diff --git a/compiler/testData/diagnostics/tests/annotations/options/targets/init.kt b/compiler/testData/diagnostics/tests/annotations/options/targets/init.kt
new file mode 100644
index 00000000000..e87e08a03a1
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/annotations/options/targets/init.kt
@@ -0,0 +1,6 @@
+annotation class base
+
+base class My {
+    <!WRONG_ANNOTATION_TARGET!>@base<!> init {
+    }
+}
diff --git a/compiler/testData/diagnostics/tests/annotations/options/targets/init.txt b/compiler/testData/diagnostics/tests/annotations/options/targets/init.txt
new file mode 100644
index 00000000000..c6358f550ed
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/annotations/options/targets/init.txt
@@ -0,0 +1,15 @@
+package
+
+base() internal final class My {
+    public constructor My()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+kotlin.annotation.annotation() internal final class base : kotlin.Annotation {
+    public constructor base()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
diff --git a/compiler/testData/diagnostics/tests/annotations/options/targets/local.kt b/compiler/testData/diagnostics/tests/annotations/options/targets/local.kt
new file mode 100644
index 00000000000..ebe2cd8a8e7
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/annotations/options/targets/local.kt
@@ -0,0 +1,20 @@
+target(AnnotationTarget.LOCAL_VARIABLE) annotation class base
+
+<!WRONG_ANNOTATION_TARGET!>base<!> annotation class derived
+
+<!WRONG_ANNOTATION_TARGET!>base<!> class correct(<!WRONG_ANNOTATION_TARGET!>base<!> val x: Int) {
+    <!WRONG_ANNOTATION_TARGET!>base<!> constructor(): this(0)
+}
+
+<!WRONG_ANNOTATION_TARGET!>base<!> enum class My {
+    <!WRONG_ANNOTATION_TARGET!>@base<!> FIRST,
+    <!WRONG_ANNOTATION_TARGET!>@base<!> SECOND
+}
+
+<!WRONG_ANNOTATION_TARGET!>base<!> fun foo(<!WRONG_ANNOTATION_TARGET!>base<!> y: <!WRONG_ANNOTATION_TARGET!>@base<!> Int): Int {
+    <!WRONG_ANNOTATION_TARGET!>@base<!> fun bar(<!WRONG_ANNOTATION_TARGET!>base<!> z: <!WRONG_ANNOTATION_TARGET!>@base<!> Int) = z + 1
+    @base val local = bar(y)
+    return local
+}
+
+<!WRONG_ANNOTATION_TARGET!>base<!> val z = 0
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/annotations/options/targets/local.txt b/compiler/testData/diagnostics/tests/annotations/options/targets/local.txt
new file mode 100644
index 00000000000..ef69abc5583
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/annotations/options/targets/local.txt
@@ -0,0 +1,61 @@
+package
+
+base() internal val z: kotlin.Int = 0
+base() internal fun foo(/*0*/ base() y: @[base()] kotlin.Int): kotlin.Int
+
+base() internal final enum class My : kotlin.Enum<My> {
+    base() public enum entry FIRST : My {
+        private constructor FIRST()
+        public final override /*1*/ /*fake_override*/ fun compareTo(/*0*/ other: My): kotlin.Int
+        public final override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public final override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public final override /*1*/ /*fake_override*/ fun name(): kotlin.String
+        public final override /*1*/ /*fake_override*/ fun ordinal(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    base() public enum entry SECOND : My {
+        private constructor SECOND()
+        public final override /*1*/ /*fake_override*/ fun compareTo(/*0*/ other: My): kotlin.Int
+        public final override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public final override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public final override /*1*/ /*fake_override*/ fun name(): kotlin.String
+        public final override /*1*/ /*fake_override*/ fun ordinal(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    private constructor My()
+    public final override /*1*/ /*fake_override*/ fun compareTo(/*0*/ other: My): kotlin.Int
+    public final override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public final override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public final override /*1*/ /*fake_override*/ fun name(): kotlin.String
+    public final override /*1*/ /*fake_override*/ fun ordinal(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    // Static members
+    public final /*synthesized*/ fun valueOf(/*0*/ value: kotlin.String): My
+    public final /*synthesized*/ fun values(): kotlin.Array<My>
+}
+
+kotlin.annotation.target(allowedTargets = {AnnotationTarget.LOCAL_VARIABLE}) kotlin.annotation.annotation() internal final class base : kotlin.Annotation {
+    public constructor base()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+base() internal final class correct {
+    base() public constructor correct()
+    public constructor correct(/*0*/ base() x: kotlin.Int)
+    base() internal final val x: kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+base() kotlin.annotation.annotation() internal final class derived : kotlin.Annotation {
+    public constructor derived()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
diff --git a/compiler/testData/diagnostics/tests/annotations/options/targets/nested.kt b/compiler/testData/diagnostics/tests/annotations/options/targets/nested.kt
new file mode 100644
index 00000000000..150737260e9
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/annotations/options/targets/nested.kt
@@ -0,0 +1,15 @@
+target(AnnotationTarget.CLASSIFIER)
+annotation class base
+
+target(AnnotationTarget.ANNOTATION_CLASS)
+annotation class meta
+
+base class Outer {
+    base <!WRONG_ANNOTATION_TARGET!>meta<!> class Nested
+
+    base meta annotation class Annotated
+
+    fun foo() {
+        @base <!WRONG_ANNOTATION_TARGET!>@meta<!> class Local
+    }
+}
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/annotations/options/targets/nested.txt b/compiler/testData/diagnostics/tests/annotations/options/targets/nested.txt
new file mode 100644
index 00000000000..8387782eb3f
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/annotations/options/targets/nested.txt
@@ -0,0 +1,37 @@
+package
+
+base() internal final class Outer {
+    public constructor Outer()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    internal final fun foo(): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    base() meta() kotlin.annotation.annotation() internal final class Annotated : kotlin.Annotation {
+        public constructor Annotated()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    base() meta() internal final class Nested {
+        public constructor Nested()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+}
+
+kotlin.annotation.target(allowedTargets = {AnnotationTarget.CLASSIFIER}) kotlin.annotation.annotation() internal final class base : kotlin.Annotation {
+    public constructor base()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+kotlin.annotation.target(allowedTargets = {AnnotationTarget.ANNOTATION_CLASS}) kotlin.annotation.annotation() internal final class meta : kotlin.Annotation {
+    public constructor meta()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
diff --git a/compiler/testData/diagnostics/tests/annotations/options/targets/property.kt b/compiler/testData/diagnostics/tests/annotations/options/targets/property.kt
new file mode 100644
index 00000000000..5ae884fc531
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/annotations/options/targets/property.kt
@@ -0,0 +1,21 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+target(AnnotationTarget.PROPERTY) annotation class base
+
+<!WRONG_ANNOTATION_TARGET!>base<!> annotation class derived
+
+<!WRONG_ANNOTATION_TARGET!>base<!> class correct(base val x: Int, <!WRONG_ANNOTATION_TARGET!>base<!> w: Int) {
+    <!WRONG_ANNOTATION_TARGET!>base<!> constructor(): this(0, 0)
+}
+
+<!WRONG_ANNOTATION_TARGET!>base<!> enum class My {
+    @base FIRST,
+    @base SECOND
+}
+
+<!WRONG_ANNOTATION_TARGET!>base<!> fun foo(<!WRONG_ANNOTATION_TARGET!>base<!> y: <!WRONG_ANNOTATION_TARGET!>@base<!> Int): Int {
+    <!WRONG_ANNOTATION_TARGET!>@base<!> fun bar(<!WRONG_ANNOTATION_TARGET!>base<!> z: <!WRONG_ANNOTATION_TARGET!>@base<!> Int) = z + 1
+    <!WRONG_ANNOTATION_TARGET!>@base<!> val local = bar(y)
+    return local
+}
+
+base val z = 0
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/annotations/options/targets/property.txt b/compiler/testData/diagnostics/tests/annotations/options/targets/property.txt
new file mode 100644
index 00000000000..51a25e3e6e0
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/annotations/options/targets/property.txt
@@ -0,0 +1,61 @@
+package
+
+base() internal val z: kotlin.Int = 0
+base() internal fun foo(/*0*/ base() y: @[base()] kotlin.Int): kotlin.Int
+
+base() internal final enum class My : kotlin.Enum<My> {
+    base() public enum entry FIRST : My {
+        private constructor FIRST()
+        public final override /*1*/ /*fake_override*/ fun compareTo(/*0*/ other: My): kotlin.Int
+        public final override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public final override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public final override /*1*/ /*fake_override*/ fun name(): kotlin.String
+        public final override /*1*/ /*fake_override*/ fun ordinal(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    base() public enum entry SECOND : My {
+        private constructor SECOND()
+        public final override /*1*/ /*fake_override*/ fun compareTo(/*0*/ other: My): kotlin.Int
+        public final override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public final override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public final override /*1*/ /*fake_override*/ fun name(): kotlin.String
+        public final override /*1*/ /*fake_override*/ fun ordinal(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    private constructor My()
+    public final override /*1*/ /*fake_override*/ fun compareTo(/*0*/ other: My): kotlin.Int
+    public final override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public final override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public final override /*1*/ /*fake_override*/ fun name(): kotlin.String
+    public final override /*1*/ /*fake_override*/ fun ordinal(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    // Static members
+    public final /*synthesized*/ fun valueOf(/*0*/ value: kotlin.String): My
+    public final /*synthesized*/ fun values(): kotlin.Array<My>
+}
+
+kotlin.annotation.target(allowedTargets = {AnnotationTarget.PROPERTY}) kotlin.annotation.annotation() internal final class base : kotlin.Annotation {
+    public constructor base()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+base() internal final class correct {
+    base() public constructor correct()
+    public constructor correct(/*0*/ base() x: kotlin.Int, /*1*/ base() w: kotlin.Int)
+    base() internal final val x: kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+base() kotlin.annotation.annotation() internal final class derived : kotlin.Annotation {
+    public constructor derived()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
diff --git a/compiler/testData/diagnostics/tests/annotations/options/targets/returntype.kt b/compiler/testData/diagnostics/tests/annotations/options/targets/returntype.kt
new file mode 100644
index 00000000000..ccbb7aab7bc
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/annotations/options/targets/returntype.kt
@@ -0,0 +1,9 @@
+annotation class base
+
+target(AnnotationTarget.TYPE)
+annotation class typed
+
+base class My(val x: <!WRONG_ANNOTATION_TARGET!>@base<!> @typed Int, y: <!WRONG_ANNOTATION_TARGET!>@base<!> @typed Int) {
+    val z: <!WRONG_ANNOTATION_TARGET!>@base<!> @typed Int = y
+    fun foo(): <!WRONG_ANNOTATION_TARGET!>@base<!> @typed Int = z
+}
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/annotations/options/targets/returntype.txt b/compiler/testData/diagnostics/tests/annotations/options/targets/returntype.txt
new file mode 100644
index 00000000000..134aba571d9
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/annotations/options/targets/returntype.txt
@@ -0,0 +1,25 @@
+package
+
+base() internal final class My {
+    public constructor My(/*0*/ x: @[base() typed()] kotlin.Int, /*1*/ y: @[base() typed()] kotlin.Int)
+    internal final val x: @[base() typed()] kotlin.Int
+    internal final val z: @[base() typed()] kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    internal final fun foo(): @[base() typed()] kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+kotlin.annotation.annotation() internal final class base : kotlin.Annotation {
+    public constructor base()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+kotlin.annotation.target(allowedTargets = {AnnotationTarget.TYPE}) kotlin.annotation.annotation() internal final class typed : kotlin.Annotation {
+    public constructor typed()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
diff --git a/compiler/testData/diagnostics/tests/annotations/options/targets/suppress.kt b/compiler/testData/diagnostics/tests/annotations/options/targets/suppress.kt
new file mode 100644
index 00000000000..066006b3085
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/annotations/options/targets/suppress.kt
@@ -0,0 +1,5 @@
+@file:suppress("abc")
+
+fun foo(): Int {
+    @suppress("xyz") return 1
+}
diff --git a/compiler/testData/diagnostics/tests/annotations/options/targets/suppress.txt b/compiler/testData/diagnostics/tests/annotations/options/targets/suppress.txt
new file mode 100644
index 00000000000..de1d6f17577
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/annotations/options/targets/suppress.txt
@@ -0,0 +1,3 @@
+package
+
+internal fun foo(): kotlin.Int
diff --git a/compiler/testData/diagnostics/tests/annotations/options/targets/type.kt b/compiler/testData/diagnostics/tests/annotations/options/targets/type.kt
new file mode 100644
index 00000000000..d3f8e3d8a23
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/annotations/options/targets/type.kt
@@ -0,0 +1,20 @@
+target(AnnotationTarget.TYPE) annotation class base
+
+<!WRONG_ANNOTATION_TARGET!>base<!> annotation class derived
+
+<!WRONG_ANNOTATION_TARGET!>base<!> class correct(<!WRONG_ANNOTATION_TARGET!>base<!> val x: @base Int) {
+    <!WRONG_ANNOTATION_TARGET!>base<!> constructor(): this(0)
+}
+
+<!WRONG_ANNOTATION_TARGET!>base<!> enum class My <!WRONG_ANNOTATION_TARGET!>@base<!> constructor() {
+    <!WRONG_ANNOTATION_TARGET!>@base<!> FIRST,
+    <!WRONG_ANNOTATION_TARGET!>@base<!> SECOND
+}
+
+<!WRONG_ANNOTATION_TARGET!>base<!> fun foo(<!WRONG_ANNOTATION_TARGET!>base<!> y: @base Int): Int {
+    <!WRONG_ANNOTATION_TARGET!>@base<!> fun bar(<!WRONG_ANNOTATION_TARGET!>base<!> z: @base Int) = z + 1
+    <!WRONG_ANNOTATION_TARGET!>@base<!> val local = bar(y)
+    return local
+}
+
+<!WRONG_ANNOTATION_TARGET!>base<!> val z = 0
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/annotations/options/targets/type.txt b/compiler/testData/diagnostics/tests/annotations/options/targets/type.txt
new file mode 100644
index 00000000000..cb2288581ff
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/annotations/options/targets/type.txt
@@ -0,0 +1,61 @@
+package
+
+base() internal val z: kotlin.Int = 0
+base() internal fun foo(/*0*/ base() y: @[base()] kotlin.Int): kotlin.Int
+
+base() internal final enum class My : kotlin.Enum<My> {
+    base() public enum entry FIRST : My {
+        private constructor FIRST()
+        public final override /*1*/ /*fake_override*/ fun compareTo(/*0*/ other: My): kotlin.Int
+        public final override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public final override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public final override /*1*/ /*fake_override*/ fun name(): kotlin.String
+        public final override /*1*/ /*fake_override*/ fun ordinal(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    base() public enum entry SECOND : My {
+        private constructor SECOND()
+        public final override /*1*/ /*fake_override*/ fun compareTo(/*0*/ other: My): kotlin.Int
+        public final override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public final override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public final override /*1*/ /*fake_override*/ fun name(): kotlin.String
+        public final override /*1*/ /*fake_override*/ fun ordinal(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    base() private constructor My()
+    public final override /*1*/ /*fake_override*/ fun compareTo(/*0*/ other: My): kotlin.Int
+    public final override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public final override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public final override /*1*/ /*fake_override*/ fun name(): kotlin.String
+    public final override /*1*/ /*fake_override*/ fun ordinal(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    // Static members
+    public final /*synthesized*/ fun valueOf(/*0*/ value: kotlin.String): My
+    public final /*synthesized*/ fun values(): kotlin.Array<My>
+}
+
+kotlin.annotation.target(allowedTargets = {AnnotationTarget.TYPE}) kotlin.annotation.annotation() internal final class base : kotlin.Annotation {
+    public constructor base()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+base() internal final class correct {
+    base() public constructor correct()
+    public constructor correct(/*0*/ base() x: @[base()] kotlin.Int)
+    base() internal final val x: @[base()] kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+base() kotlin.annotation.annotation() internal final class derived : kotlin.Annotation {
+    public constructor derived()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
diff --git a/compiler/testData/diagnostics/tests/annotations/options/targets/typeargs.kt b/compiler/testData/diagnostics/tests/annotations/options/targets/typeargs.kt
new file mode 100644
index 00000000000..31e91705afd
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/annotations/options/targets/typeargs.kt
@@ -0,0 +1,3 @@
+annotation class base
+
+val x: List<@<!DEBUG_INFO_MISSING_UNRESOLVED!>base<!> String>? = null
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/annotations/options/targets/typeargs.txt b/compiler/testData/diagnostics/tests/annotations/options/targets/typeargs.txt
new file mode 100644
index 00000000000..df24e4d4b28
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/annotations/options/targets/typeargs.txt
@@ -0,0 +1,10 @@
+package
+
+internal val x: kotlin.List<kotlin.String>? = null
+
+kotlin.annotation.annotation() internal final class base : kotlin.Annotation {
+    public constructor base()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
diff --git a/compiler/testData/diagnostics/tests/annotations/options/targets/valueparam.kt b/compiler/testData/diagnostics/tests/annotations/options/targets/valueparam.kt
new file mode 100644
index 00000000000..226f95273e6
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/annotations/options/targets/valueparam.kt
@@ -0,0 +1,21 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+target(AnnotationTarget.VALUE_PARAMETER) annotation class base
+
+<!WRONG_ANNOTATION_TARGET!>base<!> annotation class derived
+
+<!WRONG_ANNOTATION_TARGET!>base<!> class correct(<!WRONG_ANNOTATION_TARGET!>base<!> val x: Int, base w: Int) {
+    <!WRONG_ANNOTATION_TARGET!>base<!> constructor(): this(0, 0)
+}
+
+<!WRONG_ANNOTATION_TARGET!>base<!> enum class My {
+    <!WRONG_ANNOTATION_TARGET!>@base<!> FIRST,
+    <!WRONG_ANNOTATION_TARGET!>@base<!> SECOND
+}
+
+<!WRONG_ANNOTATION_TARGET!>base<!> fun foo(base y: <!WRONG_ANNOTATION_TARGET!>@base<!> Int): Int {
+    <!WRONG_ANNOTATION_TARGET!>@base<!> fun bar(base z: <!WRONG_ANNOTATION_TARGET!>@base<!> Int) = z + 1
+    <!WRONG_ANNOTATION_TARGET!>@base<!> val local = bar(y)
+    return local
+}
+
+<!WRONG_ANNOTATION_TARGET!>base<!> val z = 0
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/annotations/options/targets/valueparam.txt b/compiler/testData/diagnostics/tests/annotations/options/targets/valueparam.txt
new file mode 100644
index 00000000000..2bf1f70df71
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/annotations/options/targets/valueparam.txt
@@ -0,0 +1,61 @@
+package
+
+base() internal val z: kotlin.Int = 0
+base() internal fun foo(/*0*/ base() y: @[base()] kotlin.Int): kotlin.Int
+
+base() internal final enum class My : kotlin.Enum<My> {
+    base() public enum entry FIRST : My {
+        private constructor FIRST()
+        public final override /*1*/ /*fake_override*/ fun compareTo(/*0*/ other: My): kotlin.Int
+        public final override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public final override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public final override /*1*/ /*fake_override*/ fun name(): kotlin.String
+        public final override /*1*/ /*fake_override*/ fun ordinal(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    base() public enum entry SECOND : My {
+        private constructor SECOND()
+        public final override /*1*/ /*fake_override*/ fun compareTo(/*0*/ other: My): kotlin.Int
+        public final override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public final override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public final override /*1*/ /*fake_override*/ fun name(): kotlin.String
+        public final override /*1*/ /*fake_override*/ fun ordinal(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    private constructor My()
+    public final override /*1*/ /*fake_override*/ fun compareTo(/*0*/ other: My): kotlin.Int
+    public final override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public final override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public final override /*1*/ /*fake_override*/ fun name(): kotlin.String
+    public final override /*1*/ /*fake_override*/ fun ordinal(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    // Static members
+    public final /*synthesized*/ fun valueOf(/*0*/ value: kotlin.String): My
+    public final /*synthesized*/ fun values(): kotlin.Array<My>
+}
+
+kotlin.annotation.target(allowedTargets = {AnnotationTarget.VALUE_PARAMETER}) kotlin.annotation.annotation() internal final class base : kotlin.Annotation {
+    public constructor base()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+base() internal final class correct {
+    base() public constructor correct()
+    public constructor correct(/*0*/ base() x: kotlin.Int, /*1*/ base() w: kotlin.Int)
+    base() internal final val x: kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+base() kotlin.annotation.annotation() internal final class derived : kotlin.Annotation {
+    public constructor derived()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
diff --git a/compiler/testData/diagnostics/tests/callableReference/function/abstractClassConstructors.txt b/compiler/testData/diagnostics/tests/callableReference/function/abstractClassConstructors.txt
index 7461e6948ce..74af0216149 100644
--- a/compiler/testData/diagnostics/tests/callableReference/function/abstractClassConstructors.txt
+++ b/compiler/testData/diagnostics/tests/callableReference/function/abstractClassConstructors.txt
@@ -15,7 +15,7 @@ internal abstract class B {
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
 }
 
-internal final annotation class C : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class C : kotlin.Annotation {
     public constructor C()
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
     public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
diff --git a/compiler/testData/diagnostics/tests/callableReference/function/callableRefrenceOnNestedObject.kt b/compiler/testData/diagnostics/tests/callableReference/function/callableRefrenceOnNestedObject.kt
index 6e62db4637a..76c0a667973 100644
--- a/compiler/testData/diagnostics/tests/callableReference/function/callableRefrenceOnNestedObject.kt
+++ b/compiler/testData/diagnostics/tests/callableReference/function/callableRefrenceOnNestedObject.kt
@@ -5,5 +5,5 @@ open class A {
 }
 
 fun test() {
-    A.B.(A::foo)()
-}
\ No newline at end of file
+    (A::foo)(A.B)
+}
diff --git a/compiler/testData/diagnostics/tests/callableReference/function/differentPackageClass.kt b/compiler/testData/diagnostics/tests/callableReference/function/differentPackageClass.kt
index 593a279e949..1d0c327455f 100644
--- a/compiler/testData/diagnostics/tests/callableReference/function/differentPackageClass.kt
+++ b/compiler/testData/diagnostics/tests/callableReference/function/differentPackageClass.kt
@@ -22,7 +22,7 @@ fun main() {
     val y = first.A::bar
     val z = A::baz
 
-    checkSubtype<KMemberFunction0<A, Unit>>(x)
-    checkSubtype<KMemberFunction1<A, Int, Unit>>(y)
-    checkSubtype<KMemberFunction0<A, String>>(z)
+    checkSubtype<KFunction1<A, Unit>>(x)
+    checkSubtype<KFunction2<A, Int, Unit>>(y)
+    checkSubtype<KFunction1<A, String>>(z)
 }
diff --git a/compiler/testData/diagnostics/tests/callableReference/function/differentPackageExtension.kt b/compiler/testData/diagnostics/tests/callableReference/function/differentPackageExtension.kt
index 96b8072ed12..6b26e8a0b3b 100644
--- a/compiler/testData/diagnostics/tests/callableReference/function/differentPackageExtension.kt
+++ b/compiler/testData/diagnostics/tests/callableReference/function/differentPackageExtension.kt
@@ -14,7 +14,7 @@ fun A.baz() {}
 
 package other
 
-import kotlin.reflect.KExtensionFunction0
+import kotlin.reflect.KFunction1
 
 import first.A
 import first.foo
@@ -24,5 +24,5 @@ fun main() {
     first.A::<!UNRESOLVED_REFERENCE!>bar<!>
     A::<!UNRESOLVED_REFERENCE!>baz<!>
 
-    checkSubtype<KExtensionFunction0<A, Unit>>(x)
-}
\ No newline at end of file
+    checkSubtype<KFunction1<A, Unit>>(x)
+}
diff --git a/compiler/testData/diagnostics/tests/callableReference/function/extensionFromClass.kt b/compiler/testData/diagnostics/tests/callableReference/function/extensionFromClass.kt
index 7429eb453e2..273919e3ed7 100644
--- a/compiler/testData/diagnostics/tests/callableReference/function/extensionFromClass.kt
+++ b/compiler/testData/diagnostics/tests/callableReference/function/extensionFromClass.kt
@@ -8,9 +8,9 @@ class A {
         val y = ::bar
         val z = ::baz
 
-        checkSubtype<KExtensionFunction0<A, Unit>>(x)
-        checkSubtype<KExtensionFunction1<A, Int, Unit>>(y)
-        checkSubtype<KExtensionFunction0<A, String>>(z)
+        checkSubtype<KFunction1<A, Unit>>(x)
+        checkSubtype<KFunction2<A, Int, Unit>>(y)
+        checkSubtype<KFunction1<A, String>>(z)
     }
 }
 
diff --git a/compiler/testData/diagnostics/tests/callableReference/function/extensionFromExtension.kt b/compiler/testData/diagnostics/tests/callableReference/function/extensionFromExtension.kt
index a6d251a97ed..7c7a7ea2b2b 100644
--- a/compiler/testData/diagnostics/tests/callableReference/function/extensionFromExtension.kt
+++ b/compiler/testData/diagnostics/tests/callableReference/function/extensionFromExtension.kt
@@ -9,9 +9,9 @@ fun A.main() {
     val y = ::bar
     val z = ::baz
 
-    checkSubtype<KExtensionFunction0<A, Unit>>(x)
-    checkSubtype<KExtensionFunction1<A, Int, Unit>>(y)
-    checkSubtype<KExtensionFunction0<A, String>>(z)
+    checkSubtype<KFunction1<A, Unit>>(x)
+    checkSubtype<KFunction2<A, Int, Unit>>(y)
+    checkSubtype<KFunction1<A, String>>(z)
 }
 
 fun A.foo() {}
diff --git a/compiler/testData/diagnostics/tests/callableReference/function/extensionFromExtensionInClass.kt b/compiler/testData/diagnostics/tests/callableReference/function/extensionFromExtensionInClass.kt
index b45cfba2230..b0b4893a4c7 100644
--- a/compiler/testData/diagnostics/tests/callableReference/function/extensionFromExtensionInClass.kt
+++ b/compiler/testData/diagnostics/tests/callableReference/function/extensionFromExtensionInClass.kt
@@ -10,9 +10,9 @@ class A {
         val y = ::bar
         val z = ::baz
 
-        checkSubtype<KExtensionFunction0<A, Unit>>(x)
-        checkSubtype<KExtensionFunction1<A, Int, Unit>>(y)
-        checkSubtype<KExtensionFunction0<A, String>>(z)
+        checkSubtype<KFunction1<A, Unit>>(x)
+        checkSubtype<KFunction2<A, Int, Unit>>(y)
+        checkSubtype<KFunction1<A, String>>(z)
     }
 }
 
diff --git a/compiler/testData/diagnostics/tests/callableReference/function/extensionFromTopLevel.kt b/compiler/testData/diagnostics/tests/callableReference/function/extensionFromTopLevel.kt
index f19de82cb9a..3d69d34d670 100644
--- a/compiler/testData/diagnostics/tests/callableReference/function/extensionFromTopLevel.kt
+++ b/compiler/testData/diagnostics/tests/callableReference/function/extensionFromTopLevel.kt
@@ -13,11 +13,11 @@ fun main() {
     val y = A::bar
     val z = A::baz
 
-    checkSubtype<KExtensionFunction0<A, Unit>>(x)
-    checkSubtype<KExtensionFunction1<A, Int, Unit>>(y)
-    checkSubtype<KExtensionFunction0<A, String>>(z)
+    checkSubtype<KFunction1<A, Unit>>(x)
+    checkSubtype<KFunction2<A, Int, Unit>>(y)
+    checkSubtype<KFunction1<A, String>>(z)
 
-    checkSubtype<KExtensionFunction<A, Unit>>(x)
-    checkSubtype<KExtensionFunction<A, Unit>>(y)
-    checkSubtype<KExtensionFunction<A, String>>(z)
+    checkSubtype<KFunction<Unit>>(x)
+    checkSubtype<KFunction<Unit>>(y)
+    checkSubtype<KFunction<String>>(z)
 }
diff --git a/compiler/testData/diagnostics/tests/callableReference/function/extensionOnNullable.kt b/compiler/testData/diagnostics/tests/callableReference/function/extensionOnNullable.kt
index aa4f0ba464a..5434e7241ab 100644
--- a/compiler/testData/diagnostics/tests/callableReference/function/extensionOnNullable.kt
+++ b/compiler/testData/diagnostics/tests/callableReference/function/extensionOnNullable.kt
@@ -8,5 +8,5 @@ class A {
 
 fun A?.foo() {}
 
-val f: KMemberFunction0<A, Unit> = A::foo
-val g: KExtensionFunction0<A, Unit> = A?::foo
+val f: KFunction1<A, Unit> = A::foo
+val g: KFunction1<A, Unit> = A?::foo
diff --git a/compiler/testData/diagnostics/tests/callableReference/function/extensionOnNullable.txt b/compiler/testData/diagnostics/tests/callableReference/function/extensionOnNullable.txt
index 4fc98ce4243..7db185b8dcc 100644
--- a/compiler/testData/diagnostics/tests/callableReference/function/extensionOnNullable.txt
+++ b/compiler/testData/diagnostics/tests/callableReference/function/extensionOnNullable.txt
@@ -1,7 +1,7 @@
 package
 
-internal val f: kotlin.reflect.KMemberFunction0<A, kotlin.Unit>
-internal val g: kotlin.reflect.KExtensionFunction0<A, kotlin.Unit>
+internal val f: kotlin.reflect.KFunction1<A, kotlin.Unit>
+internal val g: kotlin.reflect.KFunction1<A, kotlin.Unit>
 internal fun A?.foo(): kotlin.Unit
 
 internal final class A {
diff --git a/compiler/testData/diagnostics/tests/callableReference/function/genericClassFromTopLevel.kt b/compiler/testData/diagnostics/tests/callableReference/function/genericClassFromTopLevel.kt
index 17447b9cc58..4127983d232 100644
--- a/compiler/testData/diagnostics/tests/callableReference/function/genericClassFromTopLevel.kt
+++ b/compiler/testData/diagnostics/tests/callableReference/function/genericClassFromTopLevel.kt
@@ -1,6 +1,6 @@
 // !CHECK_TYPE
 
-import kotlin.reflect.KMemberFunction0
+import kotlin.reflect.KFunction1
 
 class A<T>(val t: T) {
     fun foo(): T = t
@@ -9,5 +9,5 @@ class A<T>(val t: T) {
 fun bar() {
     val x = A<String>::foo
 
-    checkSubtype<KMemberFunction0<A<String>, String>>(x)
+    checkSubtype<KFunction1<A<String>, String>>(x)
 }
diff --git a/compiler/testData/diagnostics/tests/callableReference/function/innerConstructorFromClass.kt b/compiler/testData/diagnostics/tests/callableReference/function/innerConstructorFromClass.kt
index 8d1a6dce2eb..62e6ab9194d 100644
--- a/compiler/testData/diagnostics/tests/callableReference/function/innerConstructorFromClass.kt
+++ b/compiler/testData/diagnostics/tests/callableReference/function/innerConstructorFromClass.kt
@@ -1,6 +1,6 @@
 // !CHECK_TYPE
 // !DIAGNOSTICS: -UNUSED_EXPRESSION
-import kotlin.reflect.KMemberFunction0
+import kotlin.reflect.KFunction1
 
 class A {
     inner class Inner
@@ -9,8 +9,8 @@ class A {
         val x = ::Inner
         val y = A::Inner
 
-        checkSubtype<KMemberFunction0<A, A.Inner>>(x)
-        checkSubtype<KMemberFunction0<A, Inner>>(y)
+        checkSubtype<KFunction1<A, A.Inner>>(x)
+        checkSubtype<KFunction1<A, Inner>>(y)
     }
     
     companion object {
@@ -18,7 +18,7 @@ class A {
             ::<!INACCESSIBLE_OUTER_CLASS_EXPRESSION!>Inner<!>
             val y = A::Inner
 
-            checkSubtype<KMemberFunction0<A, A.Inner>>(y)
+            checkSubtype<KFunction1<A, A.Inner>>(y)
         }
     }
 }
@@ -28,6 +28,6 @@ class B {
         ::<!UNRESOLVED_REFERENCE!>Inner<!>
         val y = A::Inner
 
-        checkSubtype<KMemberFunction0<A, A.Inner>>(y)
+        checkSubtype<KFunction1<A, A.Inner>>(y)
     }
-}
\ No newline at end of file
+}
diff --git a/compiler/testData/diagnostics/tests/callableReference/function/innerConstructorFromExtension.kt b/compiler/testData/diagnostics/tests/callableReference/function/innerConstructorFromExtension.kt
index c89325b538e..b23bcdf370d 100644
--- a/compiler/testData/diagnostics/tests/callableReference/function/innerConstructorFromExtension.kt
+++ b/compiler/testData/diagnostics/tests/callableReference/function/innerConstructorFromExtension.kt
@@ -1,6 +1,6 @@
 // !CHECK_TYPE
 // !DIAGNOSTICS: -UNUSED_EXPRESSION
-import kotlin.reflect.KMemberFunction0
+import kotlin.reflect.KFunction1
 
 class A {
     inner class Inner
@@ -10,13 +10,13 @@ fun A.main() {
     val x = ::Inner
     val y = A::Inner
 
-    checkSubtype<KMemberFunction0<A, A.Inner>>(x)
-    checkSubtype<KMemberFunction0<A, A.Inner>>(y)
+    checkSubtype<KFunction1<A, A.Inner>>(x)
+    checkSubtype<KFunction1<A, A.Inner>>(y)
 }
 
 fun Int.main() {
     ::<!UNRESOLVED_REFERENCE!>Inner<!>
     val y = A::Inner
 
-    checkSubtype<KMemberFunction0<A, A.Inner>>(y)
-}
\ No newline at end of file
+    checkSubtype<KFunction1<A, A.Inner>>(y)
+}
diff --git a/compiler/testData/diagnostics/tests/callableReference/function/innerConstructorFromTopLevel.kt b/compiler/testData/diagnostics/tests/callableReference/function/innerConstructorFromTopLevel.kt
index ad744c2c321..b606d6dbd27 100644
--- a/compiler/testData/diagnostics/tests/callableReference/function/innerConstructorFromTopLevel.kt
+++ b/compiler/testData/diagnostics/tests/callableReference/function/innerConstructorFromTopLevel.kt
@@ -1,6 +1,6 @@
 // !CHECK_TYPE
 // !DIAGNOSTICS: -UNUSED_EXPRESSION
-import kotlin.reflect.KMemberFunction0
+import kotlin.reflect.KFunction1
 
 class A {
     inner class Inner
@@ -10,5 +10,5 @@ fun main() {
     ::<!UNRESOLVED_REFERENCE!>Inner<!>
     val y = A::Inner
 
-    checkSubtype<KMemberFunction0<A, A.Inner>>(y)
-}
\ No newline at end of file
+    checkSubtype<KFunction1<A, A.Inner>>(y)
+}
diff --git a/compiler/testData/diagnostics/tests/callableReference/function/longQualifiedName.kt b/compiler/testData/diagnostics/tests/callableReference/function/longQualifiedName.kt
index bade88299a3..143296f288d 100644
--- a/compiler/testData/diagnostics/tests/callableReference/function/longQualifiedName.kt
+++ b/compiler/testData/diagnostics/tests/callableReference/function/longQualifiedName.kt
@@ -9,10 +9,10 @@ class D {
 
 // FILE: b.kt
 
-import kotlin.reflect.KMemberFunction0
+import kotlin.reflect.KFunction1
 
 fun main() {
     val x = a.b.c.D::foo
 
-    checkSubtype<KMemberFunction0<a.b.c.D, Int>>(x)
+    checkSubtype<KFunction1<a.b.c.D, Int>>(x)
 }
diff --git a/compiler/testData/diagnostics/tests/callableReference/function/longQualifiedNameGeneric.kt b/compiler/testData/diagnostics/tests/callableReference/function/longQualifiedNameGeneric.kt
index 4fdbc8db48a..755f7118aee 100644
--- a/compiler/testData/diagnostics/tests/callableReference/function/longQualifiedNameGeneric.kt
+++ b/compiler/testData/diagnostics/tests/callableReference/function/longQualifiedNameGeneric.kt
@@ -9,10 +9,10 @@ class D<E, F> {
 
 // FILE: b.kt
 
-import kotlin.reflect.KMemberFunction2
+import kotlin.reflect.KFunction3
 
 fun main() {
     val x = a.b.c.D<String, Int>::foo
 
-    checkSubtype<KMemberFunction2<a.b.c.D<String, Int>, String, Int, a.b.c.D<String, Int>>>(x)
+    checkSubtype<KFunction3<a.b.c.D<String, Int>, String, Int, a.b.c.D<String, Int>>>(x)
 }
diff --git a/compiler/testData/diagnostics/tests/callableReference/function/memberFromClass.kt b/compiler/testData/diagnostics/tests/callableReference/function/memberFromClass.kt
index da7cdb14875..908e073857b 100644
--- a/compiler/testData/diagnostics/tests/callableReference/function/memberFromClass.kt
+++ b/compiler/testData/diagnostics/tests/callableReference/function/memberFromClass.kt
@@ -12,8 +12,8 @@ class A {
         val y = ::bar
         val z = ::baz
 
-        checkSubtype<KMemberFunction0<A, Unit>>(x)
-        checkSubtype<KMemberFunction1<A, Int, Unit>>(y)
-        checkSubtype<KMemberFunction0<A, String>>(z)
+        checkSubtype<KFunction1<A, Unit>>(x)
+        checkSubtype<KFunction2<A, Int, Unit>>(y)
+        checkSubtype<KFunction1<A, String>>(z)
     }
 }
diff --git a/compiler/testData/diagnostics/tests/callableReference/function/memberFromExtension.kt b/compiler/testData/diagnostics/tests/callableReference/function/memberFromExtension.kt
index 307e5edcdd2..045edb34120 100644
--- a/compiler/testData/diagnostics/tests/callableReference/function/memberFromExtension.kt
+++ b/compiler/testData/diagnostics/tests/callableReference/function/memberFromExtension.kt
@@ -13,7 +13,7 @@ fun A.main() {
     val y = ::bar
     val z = ::baz
 
-    checkSubtype<KMemberFunction0<A, Unit>>(x)
-    checkSubtype<KMemberFunction1<A, Int, Unit>>(y)
-    checkSubtype<KMemberFunction0<A, String>>(z)
+    checkSubtype<KFunction1<A, Unit>>(x)
+    checkSubtype<KFunction2<A, Int, Unit>>(y)
+    checkSubtype<KFunction1<A, String>>(z)
 }
diff --git a/compiler/testData/diagnostics/tests/callableReference/function/memberFromExtensionInClass.kt b/compiler/testData/diagnostics/tests/callableReference/function/memberFromExtensionInClass.kt
index 90b04455703..5789a95e8af 100644
--- a/compiler/testData/diagnostics/tests/callableReference/function/memberFromExtensionInClass.kt
+++ b/compiler/testData/diagnostics/tests/callableReference/function/memberFromExtensionInClass.kt
@@ -14,8 +14,8 @@ class B {
         val y = ::bar
         val z = ::baz
 
-        checkSubtype<KMemberFunction0<A, Unit>>(x)
-        checkSubtype<KMemberFunction1<A, Int, Unit>>(y)
-        checkSubtype<KMemberFunction0<A, String>>(z)
+        checkSubtype<KFunction1<A, Unit>>(x)
+        checkSubtype<KFunction2<A, Int, Unit>>(y)
+        checkSubtype<KFunction1<A, String>>(z)
     }
 }
diff --git a/compiler/testData/diagnostics/tests/callableReference/function/memberFromTopLevel.kt b/compiler/testData/diagnostics/tests/callableReference/function/memberFromTopLevel.kt
index 4a5a9399be4..68705bf7cbf 100644
--- a/compiler/testData/diagnostics/tests/callableReference/function/memberFromTopLevel.kt
+++ b/compiler/testData/diagnostics/tests/callableReference/function/memberFromTopLevel.kt
@@ -13,11 +13,11 @@ fun main() {
     val y = A::bar
     val z = A::baz
 
-    checkSubtype<KMemberFunction0<A, Unit>>(x)
-    checkSubtype<KMemberFunction1<A, Int, Unit>>(y)
-    checkSubtype<KMemberFunction0<A, String>>(z)
+    checkSubtype<KFunction1<A, Unit>>(x)
+    checkSubtype<KFunction2<A, Int, Unit>>(y)
+    checkSubtype<KFunction1<A, String>>(z)
 
-    checkSubtype<KMemberFunction<A, Unit>>(x)
-    checkSubtype<KMemberFunction<A, Unit>>(y)
-    checkSubtype<KMemberFunction<A, String>>(z)
+    checkSubtype<KFunction<Unit>>(x)
+    checkSubtype<KFunction<Unit>>(y)
+    checkSubtype<KFunction<String>>(z)
 }
diff --git a/compiler/testData/diagnostics/tests/callableReference/function/noAmbiguityMemberVsExtension.kt b/compiler/testData/diagnostics/tests/callableReference/function/noAmbiguityMemberVsExtension.kt
index 773833fcc44..f8cbe71c6b2 100644
--- a/compiler/testData/diagnostics/tests/callableReference/function/noAmbiguityMemberVsExtension.kt
+++ b/compiler/testData/diagnostics/tests/callableReference/function/noAmbiguityMemberVsExtension.kt
@@ -1,6 +1,6 @@
 // !CHECK_TYPE
 
-import kotlin.reflect.KMemberFunction0
+import kotlin.reflect.KFunction1
 
 class A {
     fun foo() = 42
@@ -11,5 +11,5 @@ fun A.foo() {}
 fun main() {
     val x = A::foo
 
-    checkSubtype<KMemberFunction0<A, Int>>(x)
+    checkSubtype<KFunction1<A, Int>>(x)
 }
diff --git a/compiler/testData/diagnostics/tests/callableReference/function/noAmbiguityMemberVsTopLevel.kt b/compiler/testData/diagnostics/tests/callableReference/function/noAmbiguityMemberVsTopLevel.kt
index 542a48f4ffa..6424f6c7f19 100644
--- a/compiler/testData/diagnostics/tests/callableReference/function/noAmbiguityMemberVsTopLevel.kt
+++ b/compiler/testData/diagnostics/tests/callableReference/function/noAmbiguityMemberVsTopLevel.kt
@@ -1,6 +1,6 @@
 // !CHECK_TYPE
 
-import kotlin.reflect.KMemberFunction0
+import kotlin.reflect.KFunction1
 
 fun foo() {}
 
@@ -10,6 +10,6 @@ class A {
     fun main() {
         val x = ::foo
 
-        checkSubtype<KMemberFunction0<A, Unit>>(x)
+        checkSubtype<KFunction1<A, Unit>>(x)
     }
 }
diff --git a/compiler/testData/diagnostics/tests/callableReference/function/renameOnImport.kt b/compiler/testData/diagnostics/tests/callableReference/function/renameOnImport.kt
index 287fe53908a..0d7c73d8a06 100644
--- a/compiler/testData/diagnostics/tests/callableReference/function/renameOnImport.kt
+++ b/compiler/testData/diagnostics/tests/callableReference/function/renameOnImport.kt
@@ -25,6 +25,6 @@ fun main() {
     val z = AA::bazbaz
 
     checkSubtype<KFunction0<Unit>>(x)
-    checkSubtype<KMemberFunction0<AA, Int>>(y)
-    checkSubtype<KExtensionFunction1<AA, String, Unit>>(z)
+    checkSubtype<KFunction1<AA, Int>>(y)
+    checkSubtype<KFunction2<AA, String, Unit>>(z)
 }
diff --git a/compiler/testData/diagnostics/tests/callableReference/property/abstractPropertyViaSubclasses.kt b/compiler/testData/diagnostics/tests/callableReference/property/abstractPropertyViaSubclasses.kt
index 0f5adfb8e4b..36ec672d567 100644
--- a/compiler/testData/diagnostics/tests/callableReference/property/abstractPropertyViaSubclasses.kt
+++ b/compiler/testData/diagnostics/tests/callableReference/property/abstractPropertyViaSubclasses.kt
@@ -1,6 +1,6 @@
 // !CHECK_TYPE
 
-import kotlin.reflect.KMemberProperty
+import kotlin.reflect.KProperty1
 
 interface Base {
     val x: Any
@@ -20,17 +20,17 @@ class C : B() {
 
 fun test() {
     val base = Base::x
-    checkSubtype<KMemberProperty<Base, Any>>(base)
+    checkSubtype<KProperty1<Base, Any>>(base)
     checkSubtype<Any>(base.get(A()))
     checkSubtype<Number>(<!TYPE_MISMATCH!>base.get(B())<!>)
     checkSubtype<Int>(<!TYPE_MISMATCH!>base.get(C())<!>)
 
     val a = A::x
-    checkSubtype<KMemberProperty<A, String>>(a)
+    checkSubtype<KProperty1<A, String>>(a)
     checkSubtype<String>(a.get(A()))
     checkSubtype<Number>(<!TYPE_MISMATCH!>a.get(<!TYPE_MISMATCH!>B()<!>)<!>)
 
     val b = B::x
-    checkSubtype<KMemberProperty<B, Number>>(b)
+    checkSubtype<KProperty1<B, Number>>(b)
     checkSubtype<Int>(<!TYPE_MISMATCH!>b.get(C())<!>)
 }
diff --git a/compiler/testData/diagnostics/tests/callableReference/property/accessViaSubclass.kt b/compiler/testData/diagnostics/tests/callableReference/property/accessViaSubclass.kt
index 44bba28e333..ec5c86975b4 100644
--- a/compiler/testData/diagnostics/tests/callableReference/property/accessViaSubclass.kt
+++ b/compiler/testData/diagnostics/tests/callableReference/property/accessViaSubclass.kt
@@ -1,6 +1,6 @@
 // !CHECK_TYPE
 
-import kotlin.reflect.KMemberProperty
+import kotlin.reflect.KProperty1
 
 open class Base {
     val foo: Int = 42
@@ -10,6 +10,6 @@ open class Derived : Base()
 
 fun test() {
     val o = Base::foo
-    checkSubtype<KMemberProperty<Base, Int>>(o)
+    checkSubtype<KProperty1<Base, Int>>(o)
     checkSubtype<Int>(o.get(Derived()))
 }
diff --git a/compiler/testData/diagnostics/tests/callableReference/property/classFromClass.kt b/compiler/testData/diagnostics/tests/callableReference/property/classFromClass.kt
index 65ef1ee9ca2..b5d3570a170 100644
--- a/compiler/testData/diagnostics/tests/callableReference/property/classFromClass.kt
+++ b/compiler/testData/diagnostics/tests/callableReference/property/classFromClass.kt
@@ -6,7 +6,7 @@ class A(var g: A) {
     val f: Int = 0
 
     fun test() {
-        val fRef: KMemberProperty<A, Int> = ::f
-        val gRef: KMutableMemberProperty<A, A> = ::g
+        val fRef: KProperty1<A, Int> = ::f
+        val gRef: KMutableProperty1<A, A> = ::g
     }
 }
diff --git a/compiler/testData/diagnostics/tests/callableReference/property/extensionFromClass.kt b/compiler/testData/diagnostics/tests/callableReference/property/extensionFromClass.kt
index ac92c4a0dbc..e28b2c4c6d2 100644
--- a/compiler/testData/diagnostics/tests/callableReference/property/extensionFromClass.kt
+++ b/compiler/testData/diagnostics/tests/callableReference/property/extensionFromClass.kt
@@ -4,8 +4,8 @@ import kotlin.reflect.*
 
 class A {
     fun test() {
-        val fooRef: KExtensionProperty<A, String> = ::foo
-        val barRef: KMutableExtensionProperty<A, Int> = ::bar
+        val fooRef: KProperty1<A, String> = ::foo
+        val barRef: KMutableProperty1<A, Int> = ::bar
     }
 }
 
diff --git a/compiler/testData/diagnostics/tests/callableReference/property/extensionFromTopLevel.kt b/compiler/testData/diagnostics/tests/callableReference/property/extensionFromTopLevel.kt
index afb67c72591..6da7eaec881 100644
--- a/compiler/testData/diagnostics/tests/callableReference/property/extensionFromTopLevel.kt
+++ b/compiler/testData/diagnostics/tests/callableReference/property/extensionFromTopLevel.kt
@@ -12,18 +12,14 @@ var Int.meaning: Long
 fun test() {
     val f = String::countCharacters
     
-    checkSubtype<KTopLevelExtensionProperty<String, Int>>(f)
-    checkSubtype<KExtensionProperty<String, Int>>(f)
-    checkSubtype<KMutableExtensionProperty<String, Int>>(<!TYPE_MISMATCH!>f<!>)
+    checkSubtype<KProperty1<String, Int>>(f)
+    checkSubtype<KMutableProperty1<String, Int>>(<!TYPE_MISMATCH!>f<!>)
     checkSubtype<Int>(f.get("abc"))
     f.<!UNRESOLVED_REFERENCE!>set<!>("abc", 0)
 
     val g = Int::meaning
 
-    checkSubtype<KTopLevelExtensionProperty<Int, Long>>(g)
-    checkSubtype<KExtensionProperty<Int, Long>>(g)
-    checkSubtype<KMutableTopLevelExtensionProperty<Int, Long>>(g)
-    checkSubtype<KMutableExtensionProperty<Int, Long>>(g)
+    checkSubtype<KMutableProperty1<Int, Long>>(g)
     checkSubtype<Long>(g.get(0))
     g.set(1, 0L)
 }
diff --git a/compiler/testData/diagnostics/tests/callableReference/property/genericClass.kt b/compiler/testData/diagnostics/tests/callableReference/property/genericClass.kt
index a741e69b357..3c1181248c1 100644
--- a/compiler/testData/diagnostics/tests/callableReference/property/genericClass.kt
+++ b/compiler/testData/diagnostics/tests/callableReference/property/genericClass.kt
@@ -1,6 +1,6 @@
 // !CHECK_TYPE
 
-import kotlin.reflect.KMemberProperty
+import kotlin.reflect.KProperty1
 
 class A<T>(val t: T) {
     val foo: T = t
@@ -8,9 +8,9 @@ class A<T>(val t: T) {
 
 fun bar() {
     val x = A<String>::foo
-    checkSubtype<KMemberProperty<A<String>, String>>(x)
-    checkSubtype<KMemberProperty<A<String>, Any?>>(x)
+    checkSubtype<KProperty1<A<String>, String>>(x)
+    checkSubtype<KProperty1<A<String>, Any?>>(x)
 
     val y = A<*>::foo
-    checkSubtype<KMemberProperty<A<*>, Any?>>(y)
+    checkSubtype<KProperty1<A<*>, Any?>>(y)
 }
diff --git a/compiler/testData/diagnostics/tests/callableReference/property/javaInstanceField.kt b/compiler/testData/diagnostics/tests/callableReference/property/javaInstanceField.kt
index 7304ad21fdf..901c2f1d084 100644
--- a/compiler/testData/diagnostics/tests/callableReference/property/javaInstanceField.kt
+++ b/compiler/testData/diagnostics/tests/callableReference/property/javaInstanceField.kt
@@ -17,10 +17,10 @@ public class JavaClass {
 import kotlin.reflect.*
 
 fun test() {
-    val pubFinRef: KMemberProperty<JavaClass, Int> = JavaClass::publicFinal
-    val pubMutRef: KMutableMemberProperty<JavaClass, Long> = JavaClass::publicMutable
-    val protFinRef: KMemberProperty<JavaClass, Double> = JavaClass::protectedFinal
-    val protMutRef: KMutableMemberProperty<JavaClass, Char> = JavaClass::protectedMutable
-    val privFinRef: KMemberProperty<JavaClass, String?> = JavaClass::<!INVISIBLE_MEMBER!>privateFinal<!>
-    val privMutRef: KMutableMemberProperty<JavaClass, Any?> = JavaClass::<!INVISIBLE_MEMBER!>privateMutable<!>
+    val pubFinRef: KProperty1<JavaClass, Int> = JavaClass::publicFinal
+    val pubMutRef: KMutableProperty1<JavaClass, Long> = JavaClass::publicMutable
+    val protFinRef: KProperty1<JavaClass, Double> = JavaClass::protectedFinal
+    val protMutRef: KMutableProperty1<JavaClass, Char> = JavaClass::protectedMutable
+    val privFinRef: KProperty1<JavaClass, String?> = JavaClass::<!INVISIBLE_MEMBER!>privateFinal<!>
+    val privMutRef: KMutableProperty1<JavaClass, Any?> = JavaClass::<!INVISIBLE_MEMBER!>privateMutable<!>
 }
diff --git a/compiler/testData/diagnostics/tests/callableReference/property/javaStaticFieldViaImport.kt b/compiler/testData/diagnostics/tests/callableReference/property/javaStaticFieldViaImport.kt
index 1d3017e8e4a..6109457f932 100644
--- a/compiler/testData/diagnostics/tests/callableReference/property/javaStaticFieldViaImport.kt
+++ b/compiler/testData/diagnostics/tests/callableReference/property/javaStaticFieldViaImport.kt
@@ -1,4 +1,3 @@
-// !CHECK_TYPE
 // !DIAGNOSTICS:-UNUSED_VARIABLE
 // FILE: JavaClass.java
 
@@ -20,8 +19,8 @@ import JavaClass.*
 import kotlin.reflect.*
 
 fun test() {
-    val pubFinRef: KTopLevelProperty<String> = ::publicFinal
-    val pubMutRef: KMutableTopLevelProperty<Any?> = ::publicMutable
+    val pubFinRef: KProperty0<String> = ::publicFinal
+    val pubMutRef: KMutableProperty0<Any?> = ::publicMutable
     val protFinRef: KProperty<Double> = ::protectedFinal
     val protMutRef: KMutableProperty<Char> = ::protectedMutable
     val privFinRef: KProperty<JavaClass?> = ::<!INVISIBLE_MEMBER!>privateFinal<!>
diff --git a/compiler/testData/diagnostics/tests/callableReference/property/kt7564.kt b/compiler/testData/diagnostics/tests/callableReference/property/kt7564.kt
index acbf68eb5d4..26295d99f72 100644
--- a/compiler/testData/diagnostics/tests/callableReference/property/kt7564.kt
+++ b/compiler/testData/diagnostics/tests/callableReference/property/kt7564.kt
@@ -6,7 +6,7 @@ class A(var g: A) {
     val f: Int = 0
 
     fun test() {
-        checkSubtype<KMemberProperty<A, Int>>(::f)
-        checkSubtype<KMutableMemberProperty<A, A>>(::g)
+        checkSubtype<KProperty1<A, Int>>(::f)
+        checkSubtype<KMutableProperty1<A, A>>(::g)
     }
-}
\ No newline at end of file
+}
diff --git a/compiler/testData/diagnostics/tests/callableReference/property/kt7945_unrelatedClass.kt b/compiler/testData/diagnostics/tests/callableReference/property/kt7945_unrelatedClass.kt
index f9c917d5be8..2354ecf0ba7 100644
--- a/compiler/testData/diagnostics/tests/callableReference/property/kt7945_unrelatedClass.kt
+++ b/compiler/testData/diagnostics/tests/callableReference/property/kt7945_unrelatedClass.kt
@@ -1,10 +1,10 @@
 // !DIAGNOSTICS: -UNUSED_PARAMETER
 
-import kotlin.reflect.KMemberProperty
+import kotlin.reflect.KProperty1
 
 class TestClass(var prop: Int)
 open class OtherClass
-fun OtherClass.test(prop: KMemberProperty<TestClass, Int>): Unit = throw Exception()
+fun OtherClass.test(prop: KProperty1<TestClass, Int>): Unit = throw Exception()
 class OtherClass2: OtherClass() {
     val result = test(TestClass::<!UNRESOLVED_REFERENCE!>result<!>)
 }
diff --git a/compiler/testData/diagnostics/tests/callableReference/property/kt7945_unrelatedClass.txt b/compiler/testData/diagnostics/tests/callableReference/property/kt7945_unrelatedClass.txt
index d99d7aa2d2c..013fce270d6 100644
--- a/compiler/testData/diagnostics/tests/callableReference/property/kt7945_unrelatedClass.txt
+++ b/compiler/testData/diagnostics/tests/callableReference/property/kt7945_unrelatedClass.txt
@@ -1,6 +1,6 @@
 package
 
-internal fun OtherClass.test(/*0*/ prop: kotlin.reflect.KMemberProperty<TestClass, kotlin.Int>): kotlin.Unit
+internal fun OtherClass.test(/*0*/ prop: kotlin.reflect.KProperty1<TestClass, kotlin.Int>): kotlin.Unit
 
 internal open class OtherClass {
     public constructor OtherClass()
diff --git a/compiler/testData/diagnostics/tests/callableReference/property/memberFromExtension.kt b/compiler/testData/diagnostics/tests/callableReference/property/memberFromExtension.kt
index 24b84678ee1..32958ec26ab 100644
--- a/compiler/testData/diagnostics/tests/callableReference/property/memberFromExtension.kt
+++ b/compiler/testData/diagnostics/tests/callableReference/property/memberFromExtension.kt
@@ -15,9 +15,9 @@ fun A.test() {
     val y = ::bar
     val z = ::self
 
-    checkSubtype<KMemberProperty<A, Unit>>(x)
-    checkSubtype<KMutableMemberProperty<A, String>>(y)
-    checkSubtype<KMutableMemberProperty<A, A>>(z)
+    checkSubtype<KProperty1<A, Unit>>(x)
+    checkSubtype<KMutableProperty1<A, String>>(y)
+    checkSubtype<KMutableProperty1<A, A>>(z)
 
     y.set(z.get(A()), x.get(A()).toString())
 }
diff --git a/compiler/testData/diagnostics/tests/callableReference/property/memberFromTopLevel.kt b/compiler/testData/diagnostics/tests/callableReference/property/memberFromTopLevel.kt
index 14be337f739..0afa68cc50a 100644
--- a/compiler/testData/diagnostics/tests/callableReference/property/memberFromTopLevel.kt
+++ b/compiler/testData/diagnostics/tests/callableReference/property/memberFromTopLevel.kt
@@ -10,16 +10,16 @@ class A {
 fun test() {
     val p = A::foo
 
-    checkSubtype<KMemberProperty<A, Int>>(p)
-    checkSubtype<KMutableMemberProperty<A, Int>>(<!TYPE_MISMATCH!>p<!>)
+    checkSubtype<KProperty1<A, Int>>(p)
+    checkSubtype<KMutableProperty1<A, Int>>(<!TYPE_MISMATCH!>p<!>)
     checkSubtype<Int>(p.get(A()))
     p.get(<!NO_VALUE_FOR_PARAMETER!>)<!>
     p.<!UNRESOLVED_REFERENCE!>set<!>(A(), 239)
 
     val q = A::bar
 
-    checkSubtype<KMemberProperty<A, String>>(q)
-    checkSubtype<KMutableMemberProperty<A, String>>(q)
+    checkSubtype<KProperty1<A, String>>(q)
+    checkSubtype<KMutableProperty1<A, String>>(q)
     checkSubtype<String>(q.get(A()))
     q.set(A(), "q")
 }
diff --git a/compiler/testData/diagnostics/tests/callableReference/property/samePriorityForFunctionsAndProperties.kt b/compiler/testData/diagnostics/tests/callableReference/property/samePriorityForFunctionsAndProperties.kt
index 2065b87f8d4..6bedc84c041 100644
--- a/compiler/testData/diagnostics/tests/callableReference/property/samePriorityForFunctionsAndProperties.kt
+++ b/compiler/testData/diagnostics/tests/callableReference/property/samePriorityForFunctionsAndProperties.kt
@@ -1,6 +1,6 @@
 // !CHECK_TYPE
 
-import kotlin.reflect.KMemberProperty
+import kotlin.reflect.KProperty1
 
 class C {
     val baz: Int = 12
@@ -9,5 +9,5 @@ class C {
 fun Int.baz() {}
 
 fun test() {
-    C::baz checkType { _<KMemberProperty<C, Int>>() }
-}
\ No newline at end of file
+    C::baz checkType { _<KProperty1<C, Int>>() }
+}
diff --git a/compiler/testData/diagnostics/tests/callableReference/property/topLevelFromTopLevel.kt b/compiler/testData/diagnostics/tests/callableReference/property/topLevelFromTopLevel.kt
index d9fcb90c7ff..ce7ccf72c9d 100644
--- a/compiler/testData/diagnostics/tests/callableReference/property/topLevelFromTopLevel.kt
+++ b/compiler/testData/diagnostics/tests/callableReference/property/topLevelFromTopLevel.kt
@@ -7,12 +7,9 @@ val y: String get() = "y"
 
 fun testX() {
     val xx = ::x
-    checkSubtype<KMutableTopLevelProperty<Int>>(xx)
-    checkSubtype<KMutableTopLevelVariable<Int>>(xx)
-    checkSubtype<KTopLevelProperty<Int>>(xx)
-    checkSubtype<KTopLevelVariable<Int>>(xx)
+    checkSubtype<KMutableProperty0<Int>>(xx)
+    checkSubtype<KProperty0<Int>>(xx)
     checkSubtype<KMutableProperty<Int>>(xx)
-    checkSubtype<KMutableVariable<Int>>(xx)
     checkSubtype<KProperty<Int>>(xx)
     checkSubtype<KCallable<Int>>(xx)
 
@@ -23,8 +20,8 @@ fun testX() {
 
 fun testY() {
     val yy = ::y
-    checkSubtype<KMutableTopLevelProperty<String>>(<!TYPE_MISMATCH!>yy<!>)
-    checkSubtype<KTopLevelVariable<String>>(yy)
+    checkSubtype<KMutableProperty0<String>>(<!TYPE_MISMATCH!>yy<!>)
+    checkSubtype<KProperty0<String>>(yy)
     checkSubtype<KMutableProperty<String>>(<!TYPE_MISMATCH!>yy<!>)
     checkSubtype<KProperty<String>>(yy)
     checkSubtype<KCallable<String>>(yy)
diff --git a/compiler/testData/diagnostics/tests/checkArguments/SpreadVarargs.kt b/compiler/testData/diagnostics/tests/checkArguments/SpreadVarargs.kt
index 783a1951a2c..2337f8ca911 100644
--- a/compiler/testData/diagnostics/tests/checkArguments/SpreadVarargs.kt
+++ b/compiler/testData/diagnostics/tests/checkArguments/SpreadVarargs.kt
@@ -42,10 +42,10 @@ fun main(args : Array<String>) {
 
     joinG(1, "2")
     joinG(<!NON_VARARG_SPREAD!>*<!>1, "2")
-    <!TYPE_INFERENCE_TYPE_CONSTRUCTOR_MISMATCH!>joinG<!>(1, *<!TYPE_MISMATCH!>"2"<!>)
+    <!TYPE_INFERENCE_PARAMETER_CONSTRAINT_ERROR!>joinG<!>(1, *<!TYPE_MISMATCH!>"2"<!>)
     joinG(x = 1, a = *a)
     joinG(x = 1, a = "2")
-    <!TYPE_INFERENCE_TYPE_CONSTRUCTOR_MISMATCH!>joinG<!>(x = <!NON_VARARG_SPREAD!>*<!>1, a = *<!TYPE_MISMATCH!>"2"<!>)
+    <!TYPE_INFERENCE_PARAMETER_CONSTRAINT_ERROR!>joinG<!>(x = <!NON_VARARG_SPREAD!>*<!>1, a = *<!TYPE_MISMATCH!>"2"<!>)
     joinG(1, *a)
     joinG(1, *a, "3")
     joinG(1, "4", *a, "3")
diff --git a/compiler/testData/diagnostics/tests/classLiteral/classLiteralType.kt b/compiler/testData/diagnostics/tests/classLiteral/classLiteralType.kt
new file mode 100644
index 00000000000..1ca87eac20c
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/classLiteral/classLiteralType.kt
@@ -0,0 +1,9 @@
+import kotlin.reflect.KClass
+
+class A
+class B
+
+val a1 : KClass<*> = A::class
+val a2 : KClass<A> = A::class
+val a3 : KClass<B> = <!TYPE_MISMATCH!>A::class<!>
+val a4 : B = <!TYPE_MISMATCH!>A::class<!>
diff --git a/compiler/testData/diagnostics/tests/classLiteral/classLiteralType.txt b/compiler/testData/diagnostics/tests/classLiteral/classLiteralType.txt
new file mode 100644
index 00000000000..642f545fe46
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/classLiteral/classLiteralType.txt
@@ -0,0 +1,20 @@
+package 
+
+internal val a1: kotlin.reflect.KClass<*>
+internal val a2: kotlin.reflect.KClass<A>
+internal val a3: kotlin.reflect.KClass<B>
+internal val a4: B
+
+internal final class A {
+    public constructor A()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+internal final class B {
+    public constructor B()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
diff --git a/compiler/testData/diagnostics/tests/declarationChecks/FunctionWithMissingNames.txt b/compiler/testData/diagnostics/tests/declarationChecks/FunctionWithMissingNames.txt
index 7b7614be495..bb83655f05b 100644
--- a/compiler/testData/diagnostics/tests/declarationChecks/FunctionWithMissingNames.txt
+++ b/compiler/testData/diagnostics/tests/declarationChecks/FunctionWithMissingNames.txt
@@ -29,7 +29,7 @@ internal final class Outer {
     internal final fun B.<no name provided>(): kotlin.Unit
 }
 
-internal final annotation class a : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class a : kotlin.Annotation {
     public constructor a()
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
     public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
diff --git a/compiler/testData/diagnostics/tests/declarationChecks/illegalModifiersOnClass.txt b/compiler/testData/diagnostics/tests/declarationChecks/illegalModifiersOnClass.txt
index 45b31383fca..afd5407a54f 100644
--- a/compiler/testData/diagnostics/tests/declarationChecks/illegalModifiersOnClass.txt
+++ b/compiler/testData/diagnostics/tests/declarationChecks/illegalModifiersOnClass.txt
@@ -83,7 +83,7 @@ internal interface D {
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
 }
 
-internal open annotation class E : kotlin.Annotation {
+kotlin.annotation.annotation() internal open class E : kotlin.Annotation {
     public constructor E()
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
     public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
diff --git a/compiler/testData/diagnostics/tests/delegation/DelegationToJavaIface.txt b/compiler/testData/diagnostics/tests/delegation/DelegationToJavaIface.txt
index 18399c5fefe..6ba09e9a8d9 100644
--- a/compiler/testData/diagnostics/tests/delegation/DelegationToJavaIface.txt
+++ b/compiler/testData/diagnostics/tests/delegation/DelegationToJavaIface.txt
@@ -11,13 +11,13 @@ internal final class TestIface : java.lang.Runnable {
 internal final class TestObject : java.lang.Object {
     public constructor TestObject(/*0*/ o: java.lang.Object)
     protected open override /*1*/ /*delegation*/ fun clone(): kotlin.Any!
-    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any!): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
     protected open override /*1*/ /*delegation*/ fun finalize(): kotlin.Unit
     public final override /*1*/ /*fake_override*/ fun getClass(): java.lang.Class<*>!
     public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
     public final override /*1*/ /*fake_override*/ fun notify(): kotlin.Unit
     public final override /*1*/ /*fake_override*/ fun notifyAll(): kotlin.Unit
-    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String!
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
     public final override /*1*/ /*fake_override*/ fun wait(): kotlin.Unit
     public final override /*1*/ /*fake_override*/ fun wait(/*0*/ p0: kotlin.Long): kotlin.Unit
     public final override /*1*/ /*fake_override*/ fun wait(/*0*/ p0: kotlin.Long, /*1*/ p1: kotlin.Int): kotlin.Unit
diff --git a/compiler/testData/diagnostics/tests/deparenthesize/annotatedSafeCall.kt b/compiler/testData/diagnostics/tests/deparenthesize/annotatedSafeCall.kt
index 1d4b00298cf..b191ad37d03 100644
--- a/compiler/testData/diagnostics/tests/deparenthesize/annotatedSafeCall.kt
+++ b/compiler/testData/diagnostics/tests/deparenthesize/annotatedSafeCall.kt
@@ -1,3 +1,4 @@
+target(AnnotationTarget.EXPRESSION)
 annotation class foo
 
 fun f(s : String?) : Boolean {
diff --git a/compiler/testData/diagnostics/tests/deparenthesize/annotatedSafeCall.txt b/compiler/testData/diagnostics/tests/deparenthesize/annotatedSafeCall.txt
index a096f8c95ce..0e1cfbb02fd 100644
--- a/compiler/testData/diagnostics/tests/deparenthesize/annotatedSafeCall.txt
+++ b/compiler/testData/diagnostics/tests/deparenthesize/annotatedSafeCall.txt
@@ -2,7 +2,7 @@ package
 
 internal fun f(/*0*/ s: kotlin.String?): kotlin.Boolean
 
-internal final annotation class foo : kotlin.Annotation {
+kotlin.annotation.target(allowedTargets = {AnnotationTarget.EXPRESSION}) kotlin.annotation.annotation() internal final class foo : kotlin.Annotation {
     public constructor foo()
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
     public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
diff --git a/compiler/testData/diagnostics/tests/deprecated/annotationUsage.txt b/compiler/testData/diagnostics/tests/deprecated/annotationUsage.txt
index 2400bc23c00..0df0472fb3e 100644
--- a/compiler/testData/diagnostics/tests/deprecated/annotationUsage.txt
+++ b/compiler/testData/diagnostics/tests/deprecated/annotationUsage.txt
@@ -14,14 +14,14 @@ obsoleteWithParam(text = "text") internal final class Obsolete2 {
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
 }
 
-kotlin.deprecated(value = "text") internal final annotation class obsolete : kotlin.Annotation {
+kotlin.deprecated(value = "text") kotlin.annotation.annotation() internal final class obsolete : kotlin.Annotation {
     public constructor obsolete()
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
     public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
 }
 
-kotlin.deprecated(value = "text") internal final annotation class obsoleteWithParam : kotlin.Annotation {
+kotlin.deprecated(value = "text") kotlin.annotation.annotation() internal final class obsoleteWithParam : kotlin.Annotation {
     public constructor obsoleteWithParam(/*0*/ text: kotlin.String)
     internal final val text: kotlin.String
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
diff --git a/compiler/testData/diagnostics/tests/deprecated/functionUsage.txt b/compiler/testData/diagnostics/tests/deprecated/functionUsage.txt
index 1a6a2ce718b..23441709f8e 100644
--- a/compiler/testData/diagnostics/tests/deprecated/functionUsage.txt
+++ b/compiler/testData/diagnostics/tests/deprecated/functionUsage.txt
@@ -5,7 +5,7 @@ internal fun block(): kotlin.Unit
 internal fun expression(): UsefulClass
 internal fun invoker(): kotlin.Unit
 internal fun reflection(): kotlin.reflect.KFunction1<kotlin.Int, UsefulClass>
-internal fun reflection2(): kotlin.reflect.KMemberFunction0<UsefulClass, kotlin.Unit>
+internal fun reflection2(): kotlin.reflect.KFunction1<UsefulClass, kotlin.Unit>
 kotlin.deprecated(value = "does nothing good") internal fun kotlin.Any.doNothing(): kotlin.String
 
 internal final class Delegation {
diff --git a/compiler/testData/diagnostics/tests/duplicateJvmSignature/missingNames.txt b/compiler/testData/diagnostics/tests/duplicateJvmSignature/missingNames.txt
index 0d573d1c24f..0ec587b3416 100644
--- a/compiler/testData/diagnostics/tests/duplicateJvmSignature/missingNames.txt
+++ b/compiler/testData/diagnostics/tests/duplicateJvmSignature/missingNames.txt
@@ -32,7 +32,7 @@ internal final enum class <no name provided> : kotlin.Enum<<no name provided>> {
     public final /*synthesized*/ fun values(): kotlin.Array<<no name provided>>
 }
 
-internal final annotation class <no name provided> : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class <no name provided> : kotlin.Annotation {
     public constructor <no name provided>()
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
     public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
@@ -81,7 +81,7 @@ internal final class Outer {
         public final /*synthesized*/ fun values(): kotlin.Array<Outer.<no name provided>>
     }
 
-    internal final annotation class <no name provided> : kotlin.Annotation {
+    kotlin.annotation.annotation() internal final class <no name provided> : kotlin.Annotation {
         public constructor <no name provided>()
         public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
         public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
diff --git a/compiler/testData/diagnostics/tests/duplicateJvmSignature/specialNames/classObject.kt b/compiler/testData/diagnostics/tests/duplicateJvmSignature/specialNames/classObject.kt
index f4fc2430b45..7cb3dde5a54 100644
--- a/compiler/testData/diagnostics/tests/duplicateJvmSignature/specialNames/classObject.kt
+++ b/compiler/testData/diagnostics/tests/duplicateJvmSignature/specialNames/classObject.kt
@@ -3,9 +3,3 @@ class C {
 
     val <!REDECLARATION!>Companion<!> = C
 }
-
-class D {
-    companion <!CONFLICTING_JVM_DECLARATIONS!>object<!> {}
-
-    <!CONFLICTING_JVM_DECLARATIONS!>val `OBJECT$`<!> = D
-}
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/duplicateJvmSignature/specialNames/classObject.txt b/compiler/testData/diagnostics/tests/duplicateJvmSignature/specialNames/classObject.txt
index 4fac25c9706..d0332ec3902 100644
--- a/compiler/testData/diagnostics/tests/duplicateJvmSignature/specialNames/classObject.txt
+++ b/compiler/testData/diagnostics/tests/duplicateJvmSignature/specialNames/classObject.txt
@@ -14,18 +14,3 @@ internal final class C {
         public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
     }
 }
-
-internal final class D {
-    public constructor D()
-    internal final val `OBJECT$`: D.Companion
-    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
-    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
-    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
-
-    public companion object Companion {
-        private constructor Companion()
-        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
-        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
-        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
-    }
-}
diff --git a/compiler/testData/diagnostics/tests/duplicateJvmSignature/specialNames/classObjectCopiedFieldObject.kt b/compiler/testData/diagnostics/tests/duplicateJvmSignature/specialNames/classObjectCopiedFieldObject.kt
index 63f2176ecf8..a95ee845d35 100644
--- a/compiler/testData/diagnostics/tests/duplicateJvmSignature/specialNames/classObjectCopiedFieldObject.kt
+++ b/compiler/testData/diagnostics/tests/duplicateJvmSignature/specialNames/classObjectCopiedFieldObject.kt
@@ -11,11 +11,3 @@ class C {
     }
 
 }
-
-class D {
-    companion <!CONFLICTING_JVM_DECLARATIONS!>object<!> {
-        <!CONFLICTING_JVM_DECLARATIONS!>val `OBJECT$`<!> = this
-    }
-
-    val `OBJECT$` = D
-}
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/duplicateJvmSignature/specialNames/classObjectCopiedFieldObject.txt b/compiler/testData/diagnostics/tests/duplicateJvmSignature/specialNames/classObjectCopiedFieldObject.txt
index 353977e4cb0..4971046d69d 100644
--- a/compiler/testData/diagnostics/tests/duplicateJvmSignature/specialNames/classObjectCopiedFieldObject.txt
+++ b/compiler/testData/diagnostics/tests/duplicateJvmSignature/specialNames/classObjectCopiedFieldObject.txt
@@ -29,19 +29,3 @@ internal final class C {
         public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
     }
 }
-
-internal final class D {
-    public constructor D()
-    internal final val `OBJECT$`: D.Companion
-    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
-    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
-    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
-
-    public companion object Companion {
-        private constructor Companion()
-        internal final val `OBJECT$`: D.Companion
-        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
-        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
-        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
-    }
-}
diff --git a/compiler/testData/diagnostics/tests/enum/enumWithAnnotationKeyword.kt b/compiler/testData/diagnostics/tests/enum/enumWithAnnotationKeyword.kt
new file mode 100644
index 00000000000..2405fd9523a
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/enum/enumWithAnnotationKeyword.kt
@@ -0,0 +1,3 @@
+data <!WRONG_ANNOTATION_TARGET!>annotation<!> enum class E {
+    D
+}
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/enum/enumWithAnnotationKeyword.txt b/compiler/testData/diagnostics/tests/enum/enumWithAnnotationKeyword.txt
new file mode 100644
index 00000000000..68956113db3
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/enum/enumWithAnnotationKeyword.txt
@@ -0,0 +1,27 @@
+package
+
+kotlin.data() kotlin.annotation.annotation() internal final enum class E : kotlin.Enum<E> {
+    public enum entry D : E {
+        private constructor D()
+        public final override /*1*/ /*fake_override*/ fun compareTo(/*0*/ other: E): kotlin.Int
+        public final override /*1*/ /*fake_override*/ fun copy(): E
+        public final override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public final override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public final override /*1*/ /*fake_override*/ fun name(): kotlin.String
+        public final override /*1*/ /*fake_override*/ fun ordinal(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    private constructor E()
+    public final override /*1*/ /*fake_override*/ fun compareTo(/*0*/ other: E): kotlin.Int
+    public final /*synthesized*/ fun copy(): E
+    public final override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public final override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public final override /*1*/ /*fake_override*/ fun name(): kotlin.String
+    public final override /*1*/ /*fake_override*/ fun ordinal(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    // Static members
+    public final /*synthesized*/ fun valueOf(/*0*/ value: kotlin.String): E
+    public final /*synthesized*/ fun values(): kotlin.Array<E>
+}
diff --git a/compiler/testData/diagnostics/tests/enum/interfaceWithEnumKeyword.kt b/compiler/testData/diagnostics/tests/enum/interfaceWithEnumKeyword.kt
new file mode 100644
index 00000000000..2bc34f6a387
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/enum/interfaceWithEnumKeyword.kt
@@ -0,0 +1,8 @@
+<!ILLEGAL_ENUM_ANNOTATION!>enum<!> interface Some {
+    // Enum part
+    <!ABSTRACT_MEMBER_NOT_IMPLEMENTED, ENUM_ENTRY_USES_DEPRECATED_OR_NO_DELIMITER!>D<!>
+
+    // Interface like part
+    fun test()
+    val foo: Int
+}
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/enum/interfaceWithEnumKeyword.txt b/compiler/testData/diagnostics/tests/enum/interfaceWithEnumKeyword.txt
new file mode 100644
index 00000000000..77763a6a677
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/enum/interfaceWithEnumKeyword.txt
@@ -0,0 +1,18 @@
+package
+
+internal interface Some {
+    public enum entry D : Some {
+        private constructor D()
+        internal abstract override /*1*/ /*fake_override*/ val foo: kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        internal abstract override /*1*/ /*fake_override*/ fun test(): kotlin.Unit
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    internal abstract val foo: kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    internal abstract fun test(): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
diff --git a/compiler/testData/diagnostics/tests/enum/modifiersOnEnumEntry.kt b/compiler/testData/diagnostics/tests/enum/modifiersOnEnumEntry.kt
index 4cd63001527..2a76a527fb7 100644
--- a/compiler/testData/diagnostics/tests/enum/modifiersOnEnumEntry.kt
+++ b/compiler/testData/diagnostics/tests/enum/modifiersOnEnumEntry.kt
@@ -14,7 +14,7 @@ enum class E {
     <!ILLEGAL_MODIFIER!>final<!> FINAL,
 
     <!ILLEGAL_MODIFIER!>inner<!> INNER,
-    <!ILLEGAL_MODIFIER!>annotation<!> ANNOTATION,
+    <!ENUM_ENTRY_USES_DEPRECATED_OR_NO_DELIMITER!>annotation<!> ANNOTATION,
     <!ILLEGAL_MODIFIER!>enum<!> ENUM,
     <!ILLEGAL_MODIFIER!>out<!> OUT,
     <!ILLEGAL_MODIFIER!>in<!> IN,
diff --git a/compiler/testData/diagnostics/tests/enum/modifiersOnEnumEntry.txt b/compiler/testData/diagnostics/tests/enum/modifiersOnEnumEntry.txt
index 37b38f2a0f9..bb2397fee56 100644
--- a/compiler/testData/diagnostics/tests/enum/modifiersOnEnumEntry.txt
+++ b/compiler/testData/diagnostics/tests/enum/modifiersOnEnumEntry.txt
@@ -102,6 +102,16 @@ internal final enum class E : kotlin.Enum<E> {
         public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
     }
 
+    public enum entry annotation : E {
+        private constructor annotation()
+        public final override /*1*/ /*fake_override*/ fun compareTo(/*0*/ other: E): kotlin.Int
+        public final override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public final override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public final override /*1*/ /*fake_override*/ fun name(): kotlin.String
+        public final override /*1*/ /*fake_override*/ fun ordinal(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
     public enum entry ANNOTATION : E {
         private constructor ANNOTATION()
         public final override /*1*/ /*fake_override*/ fun compareTo(/*0*/ other: E): kotlin.Int
diff --git a/compiler/testData/diagnostics/tests/evaluate/divisionByZero.txt b/compiler/testData/diagnostics/tests/evaluate/divisionByZero.txt
index 5e7d7081d39..a59c065f023 100644
--- a/compiler/testData/diagnostics/tests/evaluate/divisionByZero.txt
+++ b/compiler/testData/diagnostics/tests/evaluate/divisionByZero.txt
@@ -12,7 +12,7 @@ internal val a9: kotlin.Int
 internal val b1: kotlin.Byte
 Ann() internal val b2: kotlin.Int = 1
 
-internal final annotation class Ann : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class Ann : kotlin.Annotation {
     public constructor Ann(/*0*/ i: kotlin.Int)
     internal final val i: kotlin.Int
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
diff --git a/compiler/testData/diagnostics/tests/extensions/extensionMemberInClassObject.kt b/compiler/testData/diagnostics/tests/extensions/extensionMemberInClassObject.kt
index 6c7b9b17d6a..71fd0ed04cb 100644
--- a/compiler/testData/diagnostics/tests/extensions/extensionMemberInClassObject.kt
+++ b/compiler/testData/diagnostics/tests/extensions/extensionMemberInClassObject.kt
@@ -9,7 +9,7 @@ class Foo {
 }
 
 fun main(args: Array<String>) {
-    <!TYPE_INFERENCE_TYPE_CONSTRUCTOR_MISMATCH!>with<!>("", <!TYPE_MISMATCH!>{
+    <!TYPE_INFERENCE_PARAMETER_CONSTRAINT_ERROR!>with<!>("", <!TYPE_MISMATCH!>{
         Foo.<!MISSING_RECEIVER, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>findByName<!>("")
     }<!>)
 }
diff --git a/compiler/testData/diagnostics/tests/functionAsExpression/Common.txt b/compiler/testData/diagnostics/tests/functionAsExpression/Common.txt
index 850048ccdce..08042e068ce 100644
--- a/compiler/testData/diagnostics/tests/functionAsExpression/Common.txt
+++ b/compiler/testData/diagnostics/tests/functionAsExpression/Common.txt
@@ -18,7 +18,7 @@ internal final class A {
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
 }
 
-internal final annotation class ann : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class ann : kotlin.Annotation {
     public constructor ann(/*0*/ name: kotlin.String)
     internal final val name: kotlin.String
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
diff --git a/compiler/testData/diagnostics/tests/functionAsExpression/WithoutBody.txt b/compiler/testData/diagnostics/tests/functionAsExpression/WithoutBody.txt
index d0260cb3578..2dbb32eea0c 100644
--- a/compiler/testData/diagnostics/tests/functionAsExpression/WithoutBody.txt
+++ b/compiler/testData/diagnostics/tests/functionAsExpression/WithoutBody.txt
@@ -4,7 +4,7 @@ internal val bas: () -> kotlin.Unit
 internal fun bar(/*0*/ a: kotlin.Any): () -> kotlin.Unit
 internal fun outer(): kotlin.Unit
 
-internal final annotation class ann : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class ann : kotlin.Annotation {
     public constructor ann()
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
     public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
diff --git a/compiler/testData/diagnostics/tests/inference/commonSystem/boundOnNullableVariable.kt b/compiler/testData/diagnostics/tests/inference/commonSystem/boundOnNullableVariable.kt
new file mode 100644
index 00000000000..72afc526eaf
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/inference/commonSystem/boundOnNullableVariable.kt
@@ -0,0 +1,6 @@
+fun <T: Any> test(f: (T) -> T?) {
+    doFun(f.ext())
+}
+
+fun <E : Any> Function1<E, E?>.ext(): Function0<E?> = throw Exception()
+fun <R : Any> doFun(f: () -> R?) = f
diff --git a/compiler/testData/diagnostics/tests/inference/commonSystem/boundOnNullableVariable.txt b/compiler/testData/diagnostics/tests/inference/commonSystem/boundOnNullableVariable.txt
new file mode 100644
index 00000000000..e1ca5592c90
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/inference/commonSystem/boundOnNullableVariable.txt
@@ -0,0 +1,5 @@
+package
+
+internal fun </*0*/ R : kotlin.Any> doFun(/*0*/ f: () -> R?): () -> R?
+internal fun </*0*/ T : kotlin.Any> test(/*0*/ f: (T) -> T?): kotlin.Unit
+internal fun </*0*/ E : kotlin.Any> ((E) -> E?).ext(): () -> E?
diff --git a/compiler/testData/diagnostics/tests/inference/commonSystem/dontCaptureTypeVariable.kt b/compiler/testData/diagnostics/tests/inference/commonSystem/dontCaptureTypeVariable.kt
new file mode 100644
index 00000000000..56b7f5657a7
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/inference/commonSystem/dontCaptureTypeVariable.kt
@@ -0,0 +1,11 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+import java.util.*
+
+fun test(list: ArrayList<Int>, comparatorFun: (Int, Int) -> Int) {
+    sort(list, Comparator(comparatorFun))
+}
+
+
+public fun <E> sort(list: List<E>, c: Comparator<in E>) {
+}
diff --git a/compiler/testData/diagnostics/tests/inference/commonSystem/dontCaptureTypeVariable.txt b/compiler/testData/diagnostics/tests/inference/commonSystem/dontCaptureTypeVariable.txt
new file mode 100644
index 00000000000..6085ec7dd70
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/inference/commonSystem/dontCaptureTypeVariable.txt
@@ -0,0 +1,4 @@
+package
+
+public fun </*0*/ E> sort(/*0*/ list: kotlin.List<E>, /*1*/ c: java.util.Comparator<in E>): kotlin.Unit
+internal fun test(/*0*/ list: java.util.ArrayList<kotlin.Int>, /*1*/ comparatorFun: (kotlin.Int, kotlin.Int) -> kotlin.Int): kotlin.Unit
diff --git a/compiler/testData/diagnostics/tests/inference/commonSystem/fixVariablesInRightOrder.kt b/compiler/testData/diagnostics/tests/inference/commonSystem/fixVariablesInRightOrder.kt
new file mode 100644
index 00000000000..72673750ba9
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/inference/commonSystem/fixVariablesInRightOrder.kt
@@ -0,0 +1,17 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+class GenericClass<out T>
+
+public fun <K, V> GenericClass<Map<K, V>>.foo() {}
+
+public fun bar<T>(t: T, ext: GenericClass<T>.() -> Unit) {}
+
+fun test() {
+    bar(mapOf(2 to 3)) { foo() }
+}
+
+// from library
+class Pair<out A, out B>
+fun <K, V> mapOf(keyValuePair: Pair<K, V>): Map<K, V> = throw Exception()
+fun <A, B> A.to(that: B): Pair<A, B> = throw Exception()
+
diff --git a/compiler/testData/diagnostics/tests/inference/commonSystem/fixVariablesInRightOrder.txt b/compiler/testData/diagnostics/tests/inference/commonSystem/fixVariablesInRightOrder.txt
new file mode 100644
index 00000000000..2f49bcdfb65
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/inference/commonSystem/fixVariablesInRightOrder.txt
@@ -0,0 +1,21 @@
+package
+
+public fun </*0*/ T> bar(/*0*/ t: T, /*1*/ ext: GenericClass<T>.() -> kotlin.Unit): kotlin.Unit
+internal fun </*0*/ K, /*1*/ V> mapOf(/*0*/ keyValuePair: Pair<K, V>): kotlin.Map<K, V>
+internal fun test(): kotlin.Unit
+public fun </*0*/ K, /*1*/ V> GenericClass<kotlin.Map<K, V>>.foo(): kotlin.Unit
+internal fun </*0*/ A, /*1*/ B> A.to(/*0*/ that: B): Pair<A, B>
+
+internal final class GenericClass</*0*/ out T> {
+    public constructor GenericClass</*0*/ out T>()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+internal final class Pair</*0*/ out A, /*1*/ out B> {
+    public constructor Pair</*0*/ out A, /*1*/ out B>()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
diff --git a/compiler/testData/diagnostics/tests/inference/commonSystem/genericCandidateInGenericClass.kt b/compiler/testData/diagnostics/tests/inference/commonSystem/genericCandidateInGenericClass.kt
new file mode 100644
index 00000000000..3acf44efad9
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/inference/commonSystem/genericCandidateInGenericClass.kt
@@ -0,0 +1,9 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+class GenericClass<out T>(val value: T) {
+    public fun foo<P>(extension: T.() -> P) {}
+}
+
+public fun <E> GenericClass<List<E>>.bar() {
+    foo( { listIterator() })
+}
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/inference/commonSystem/genericCandidateInGenericClass.txt b/compiler/testData/diagnostics/tests/inference/commonSystem/genericCandidateInGenericClass.txt
new file mode 100644
index 00000000000..b0c56b38ada
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/inference/commonSystem/genericCandidateInGenericClass.txt
@@ -0,0 +1,12 @@
+package
+
+public fun </*0*/ E> GenericClass<kotlin.List<E>>.bar(): kotlin.Unit
+
+internal final class GenericClass</*0*/ out T> {
+    public constructor GenericClass</*0*/ out T>(/*0*/ value: T)
+    internal final val value: T
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public final fun </*0*/ P> foo(/*0*/ extension: T.() -> P): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
diff --git a/compiler/testData/diagnostics/tests/inference/commonSystem/inferenceWithUpperBoundsInLambda.kt b/compiler/testData/diagnostics/tests/inference/commonSystem/inferenceWithUpperBoundsInLambda.kt
new file mode 100644
index 00000000000..7ab48bdff17
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/inference/commonSystem/inferenceWithUpperBoundsInLambda.kt
@@ -0,0 +1,13 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+import java.util.*
+
+interface Foo
+class Bar<B : Foo>(val list: MutableList<B>) {}
+
+fun <F : Foo> test(map: MutableMap<String, Bar<F>>) {
+
+    map.getOrPut1("", { Bar(ArrayList()) })
+}
+
+fun <K, V> MutableMap<K, V>.getOrPut1(key: K, defaultValue: () -> V): V = throw Exception()
diff --git a/compiler/testData/diagnostics/tests/inference/commonSystem/inferenceWithUpperBoundsInLambda.txt b/compiler/testData/diagnostics/tests/inference/commonSystem/inferenceWithUpperBoundsInLambda.txt
new file mode 100644
index 00000000000..be4b7ba4273
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/inference/commonSystem/inferenceWithUpperBoundsInLambda.txt
@@ -0,0 +1,18 @@
+package
+
+internal fun </*0*/ F : Foo> test(/*0*/ map: kotlin.MutableMap<kotlin.String, Bar<F>>): kotlin.Unit
+internal fun </*0*/ K, /*1*/ V> kotlin.MutableMap<K, V>.getOrPut1(/*0*/ key: K, /*1*/ defaultValue: () -> V): V
+
+internal final class Bar</*0*/ B : Foo> {
+    public constructor Bar</*0*/ B : Foo>(/*0*/ list: kotlin.MutableList<B>)
+    internal final val list: kotlin.MutableList<B>
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+internal interface Foo {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
diff --git a/compiler/testData/diagnostics/tests/inference/commonSystem/kt3372toCollection.kt b/compiler/testData/diagnostics/tests/inference/commonSystem/kt3372toCollection.kt
new file mode 100644
index 00000000000..ea1f2c3b8de
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/inference/commonSystem/kt3372toCollection.kt
@@ -0,0 +1,12 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+// !CHECK_TYPE
+// KT-3372 Use upper bound in type argument inference
+
+import java.util.HashSet
+
+fun <T, C: MutableCollection<T>> Iterable<T>.toCollection(result: C) : C = throw Exception()
+
+fun test(list: List<Int>) {
+    val set = list.toCollection(HashSet())
+    set checkType { _<HashSet<Int>>() }
+}
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/inference/commonSystem/kt3372toCollection.txt b/compiler/testData/diagnostics/tests/inference/commonSystem/kt3372toCollection.txt
new file mode 100644
index 00000000000..2f6681972e4
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/inference/commonSystem/kt3372toCollection.txt
@@ -0,0 +1,4 @@
+package
+
+internal fun test(/*0*/ list: kotlin.List<kotlin.Int>): kotlin.Unit
+internal fun </*0*/ T, /*1*/ C : kotlin.MutableCollection<T>> kotlin.Iterable<T>.toCollection(/*0*/ result: C): C
diff --git a/compiler/testData/diagnostics/tests/inference/commonSystem/nestedLambdas.kt b/compiler/testData/diagnostics/tests/inference/commonSystem/nestedLambdas.kt
new file mode 100644
index 00000000000..636000acb4c
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/inference/commonSystem/nestedLambdas.kt
@@ -0,0 +1,10 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+// !CHECK_TYPE
+
+fun <T, R> Collection<T>.map(transform : (T) -> R) : List<R> = throw Exception()
+
+fun test(list: List<List<Int>>) {
+
+    val list1 = list.map { it.map { "$it" } }
+    list1 checkType { _<List<List<String>>>() }
+}
diff --git a/compiler/testData/diagnostics/tests/inference/commonSystem/nestedLambdas.txt b/compiler/testData/diagnostics/tests/inference/commonSystem/nestedLambdas.txt
new file mode 100644
index 00000000000..225cd969604
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/inference/commonSystem/nestedLambdas.txt
@@ -0,0 +1,4 @@
+package
+
+internal fun test(/*0*/ list: kotlin.List<kotlin.List<kotlin.Int>>): kotlin.Unit
+internal fun </*0*/ T, /*1*/ R> kotlin.Collection<T>.map(/*0*/ transform: (T) -> R): kotlin.List<R>
diff --git a/compiler/testData/diagnostics/tests/inference/commonSystem/theSameFunctionInArgs.kt b/compiler/testData/diagnostics/tests/inference/commonSystem/theSameFunctionInArgs.kt
new file mode 100644
index 00000000000..65b81903685
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/inference/commonSystem/theSameFunctionInArgs.kt
@@ -0,0 +1,8 @@
+// !CHECK_TYPE
+
+fun <T> arrayOf(vararg t : T) : Array<T> = t as Array<T>
+
+fun test() {
+    val array = arrayOf(arrayOf(1))
+    array checkType { _<Array<Array<Int>>>() }
+}
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/inference/commonSystem/theSameFunctionInArgs.txt b/compiler/testData/diagnostics/tests/inference/commonSystem/theSameFunctionInArgs.txt
new file mode 100644
index 00000000000..e4c746ca220
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/inference/commonSystem/theSameFunctionInArgs.txt
@@ -0,0 +1,4 @@
+package
+
+internal fun </*0*/ T> arrayOf(/*0*/ vararg t: T /*kotlin.Array<out T>*/): kotlin.Array<T>
+internal fun test(): kotlin.Unit
diff --git a/compiler/testData/diagnostics/tests/inference/constraints/kt6320.kt b/compiler/testData/diagnostics/tests/inference/constraints/kt6320.kt
index aa90703e00a..fd2b06233bc 100644
--- a/compiler/testData/diagnostics/tests/inference/constraints/kt6320.kt
+++ b/compiler/testData/diagnostics/tests/inference/constraints/kt6320.kt
@@ -15,6 +15,6 @@ class C<X, Z, Y : X>
 
 class D<X, Z, Y : X>(<!UNUSED_PARAMETER!>foo<!>: C<X, Z, Y>) {
     fun test(a: C<Y, Y, Y>) {
-        val d: D<X, Y, Y> = <!TYPE_MISMATCH!>D(a)<!>
+        val d: D<X, Y, Y> = <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>D<!>(a)
     }
 }
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/inference/constraints/notNullConstraintOnNullableType.kt b/compiler/testData/diagnostics/tests/inference/constraints/notNullConstraintOnNullableType.kt
index ebb32733fdf..723967042de 100644
--- a/compiler/testData/diagnostics/tests/inference/constraints/notNullConstraintOnNullableType.kt
+++ b/compiler/testData/diagnostics/tests/inference/constraints/notNullConstraintOnNullableType.kt
@@ -17,8 +17,8 @@ fun test(out: Out<Int>, i: In<Int>, inv: A<Int>) {
     r checkType { _<Int>() }
 
     // T? <: Int => error
-    doIn(<!TYPE_MISMATCH!>i<!>)
+    <!TYPE_INFERENCE_INCORPORATION_ERROR!>doIn<!>(<!TYPE_MISMATCH!>i<!>)
 
     // T? >: Int => error
-    doA(<!TYPE_MISMATCH!>inv<!>)
+    <!TYPE_INFERENCE_INCORPORATION_ERROR!>doA<!>(<!TYPE_MISMATCH!>inv<!>)
 }
diff --git a/compiler/testData/diagnostics/tests/inference/immutableArrayList.kt b/compiler/testData/diagnostics/tests/inference/immutableArrayList.kt
index db6c4843960..6b8be3fbbdb 100644
--- a/compiler/testData/diagnostics/tests/inference/immutableArrayList.kt
+++ b/compiler/testData/diagnostics/tests/inference/immutableArrayList.kt
@@ -12,6 +12,6 @@ import p.J.*
 
 class Foo<T>: Sub<T> {
     fun foo(): Super<T> {
-        return <!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>Foo<!>()
+        return Foo()
     }
 }
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/inference/regressions/kt2057.kt b/compiler/testData/diagnostics/tests/inference/regressions/kt2057.kt
new file mode 100644
index 00000000000..9f6cf54e955
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/inference/regressions/kt2057.kt
@@ -0,0 +1,11 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+import java.util.ArrayList
+
+fun <T> foo(a : T, b : Collection<T>, c : Int) {
+}
+
+fun arrayListOf<T>(vararg values: T): ArrayList<T> = throw Exception("$values")
+
+val bar = foo("", arrayListOf(),<!SYNTAX!><!> )
+val bar2 = foo<String>("", arrayListOf(),<!SYNTAX!><!> )
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/inference/regressions/kt2057.txt b/compiler/testData/diagnostics/tests/inference/regressions/kt2057.txt
new file mode 100644
index 00000000000..451227671c1
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/inference/regressions/kt2057.txt
@@ -0,0 +1,6 @@
+package
+
+internal val bar: kotlin.Unit
+internal val bar2: kotlin.Unit
+internal fun </*0*/ T> arrayListOf(/*0*/ vararg values: T /*kotlin.Array<out T>*/): java.util.ArrayList<T>
+internal fun </*0*/ T> foo(/*0*/ a: T, /*1*/ b: kotlin.Collection<T>, /*2*/ c: kotlin.Int): kotlin.Unit
diff --git a/compiler/testData/diagnostics/tests/inference/regressions/kt2200.kt b/compiler/testData/diagnostics/tests/inference/regressions/kt2200.kt
index ba518ebc253..d3e473eedb8 100644
--- a/compiler/testData/diagnostics/tests/inference/regressions/kt2200.kt
+++ b/compiler/testData/diagnostics/tests/inference/regressions/kt2200.kt
@@ -4,7 +4,7 @@
 package n
 
 fun main(args: Array<String>) {
-    val <!UNUSED_VARIABLE!>a<!> = array(<!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>array<!>())
+    val <!UNUSED_VARIABLE!>a<!> = <!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>array<!>(<!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>array<!>())
     val <!UNUSED_VARIABLE!>a0<!> : Array<Array<Int>> = array(array())
     val a1 = array(array<Int>())
     checkSubtype<Array<Array<Int>>>(a1)
diff --git a/compiler/testData/diagnostics/tests/inference/regressions/kt2588.kt b/compiler/testData/diagnostics/tests/inference/regressions/kt2588.kt
new file mode 100644
index 00000000000..504f5f7909f
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/inference/regressions/kt2588.kt
@@ -0,0 +1,18 @@
+// !DIAGNOSTICS: -UNUSED_VARIABLE
+//T-2588 Allow to specify exact super type (expected) in inference if many
+
+import java.util.HashSet
+
+class MyClass<T>()
+
+interface A
+interface D
+class B : A, D
+class C : A, D
+
+fun hashSetOf<T>(vararg values: T): HashSet<T> = throw Exception("$values")
+
+fun foo(b: MyClass<B>, c: MyClass<C>) {
+    val set1 : Set<MyClass<out D>> = hashSetOf(b, c) //type inference expected type mismatch
+    val set2  = hashSetOf(b, c) //Set<MyClass<out Any>> is inferred
+}
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/inference/regressions/kt2588.txt b/compiler/testData/diagnostics/tests/inference/regressions/kt2588.txt
new file mode 100644
index 00000000000..8efcc0c878e
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/inference/regressions/kt2588.txt
@@ -0,0 +1,37 @@
+package
+
+internal fun foo(/*0*/ b: MyClass<B>, /*1*/ c: MyClass<C>): kotlin.Unit
+internal fun </*0*/ T> hashSetOf(/*0*/ vararg values: T /*kotlin.Array<out T>*/): java.util.HashSet<T>
+
+internal interface A {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+internal final class B : A, D {
+    public constructor B()
+    public open override /*2*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*2*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*2*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+internal final class C : A, D {
+    public constructor C()
+    public open override /*2*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*2*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*2*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+internal interface D {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+internal final class MyClass</*0*/ T> {
+    public constructor MyClass</*0*/ T>()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
diff --git a/compiler/testData/diagnostics/tests/inference/regressions/kt2754.kt b/compiler/testData/diagnostics/tests/inference/regressions/kt2754.kt
new file mode 100644
index 00000000000..6b5394796c3
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/inference/regressions/kt2754.kt
@@ -0,0 +1,28 @@
+// !CHECK_TYPE
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+// T is the immutable type
+interface Builder<out T> {
+    fun build(): T
+}
+
+// T is the immutable type, U is the builder
+interface Copyable<out T, out U : Builder<T>> {
+    fun builder(): U
+}
+
+fun <T : Copyable<T, U>, U : Builder<T>> T.copy(fn: U.() -> Unit): T = throw Exception()
+
+open class Foo(val x: Int, val y: Int) : Copyable<Foo, Foo.FooBuilder> {
+    override fun builder(): FooBuilder = FooBuilder(x, y)
+
+    open class FooBuilder(var x: Int, var y: Int): Builder<Foo> {
+        override fun build(): Foo = Foo(x, y)
+    }
+}
+
+fun test() {
+    val foo1 = Foo(x = 1, y = 2)
+    val foo2 = foo1.copy { y = 3 } // this doesn't work
+    foo2 checkType { _<Foo>() }
+}
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/inference/regressions/kt2754.txt b/compiler/testData/diagnostics/tests/inference/regressions/kt2754.txt
new file mode 100644
index 00000000000..507f19c225e
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/inference/regressions/kt2754.txt
@@ -0,0 +1,38 @@
+package
+
+internal fun test(): kotlin.Unit
+internal fun </*0*/ T : Copyable<T, U>, /*1*/ U : Builder<T>> T.copy(/*0*/ fn: U.() -> kotlin.Unit): T
+
+internal interface Builder</*0*/ out T> {
+    internal abstract fun build(): T
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+internal interface Copyable</*0*/ out T, /*1*/ out U : Builder<T>> {
+    internal abstract fun builder(): U
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+internal open class Foo : Copyable<Foo, Foo.FooBuilder> {
+    public constructor Foo(/*0*/ x: kotlin.Int, /*1*/ y: kotlin.Int)
+    internal final val x: kotlin.Int
+    internal final val y: kotlin.Int
+    internal open override /*1*/ fun builder(): Foo.FooBuilder
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    internal open class FooBuilder : Builder<Foo> {
+        public constructor FooBuilder(/*0*/ x: kotlin.Int, /*1*/ y: kotlin.Int)
+        internal final var x: kotlin.Int
+        internal final var y: kotlin.Int
+        internal open override /*1*/ fun build(): Foo
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+}
diff --git a/compiler/testData/diagnostics/tests/inference/regressions/kt3496.kt b/compiler/testData/diagnostics/tests/inference/regressions/kt3496.kt
new file mode 100644
index 00000000000..5180621417f
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/inference/regressions/kt3496.kt
@@ -0,0 +1,9 @@
+// !DIAGNOSTICS: -UNUSED_VARIABLE
+// KT-3496 Type inference bug on y[""]
+
+class B<T> {
+    fun <S> x (y: B<Iterable<S>>) {
+        val z: S = y[""] // does not work with [], but works with .get()
+    }
+    fun <S> get(s : String): S = throw Exception()
+}
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/inference/regressions/kt3496.txt b/compiler/testData/diagnostics/tests/inference/regressions/kt3496.txt
new file mode 100644
index 00000000000..c404da8b297
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/inference/regressions/kt3496.txt
@@ -0,0 +1,10 @@
+package
+
+internal final class B</*0*/ T> {
+    public constructor B</*0*/ T>()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    internal final fun </*0*/ S> get(/*0*/ s: kotlin.String): S
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    internal final fun </*0*/ S> x(/*0*/ y: B<kotlin.Iterable<S>>): kotlin.Unit
+}
diff --git a/compiler/testData/diagnostics/tests/inference/regressions/kt3496_2.kt b/compiler/testData/diagnostics/tests/inference/regressions/kt3496_2.kt
new file mode 100644
index 00000000000..19716e3ba80
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/inference/regressions/kt3496_2.kt
@@ -0,0 +1,11 @@
+// !CHECK_TYPE
+// !DIAGNOSTICS: -UNUSED_VARIABLE
+
+import java.util.ArrayList
+
+class F<T> {
+    fun <T, V> x (y: F<ArrayList<T>>, w: ArrayList<V>) {
+        val z: ArrayList<T> = y["", w]
+    }
+}
+fun <V, T> Any.get(s: String, w: ArrayList<V>): ArrayList<T> = throw Exception()
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/inference/regressions/kt3496_2.txt b/compiler/testData/diagnostics/tests/inference/regressions/kt3496_2.txt
new file mode 100644
index 00000000000..9439ea910a7
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/inference/regressions/kt3496_2.txt
@@ -0,0 +1,11 @@
+package
+
+internal fun </*0*/ V, /*1*/ T> kotlin.Any.get(/*0*/ s: kotlin.String, /*1*/ w: java.util.ArrayList<V>): java.util.ArrayList<T>
+
+internal final class F</*0*/ T> {
+    public constructor F</*0*/ T>()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    internal final fun </*0*/ T, /*1*/ V> x(/*0*/ y: F<java.util.ArrayList<T>>, /*1*/ w: java.util.ArrayList<V>): kotlin.Unit
+}
diff --git a/compiler/testData/diagnostics/tests/inference/regressions/kt3559.kt b/compiler/testData/diagnostics/tests/inference/regressions/kt3559.kt
new file mode 100644
index 00000000000..4cd430d0752
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/inference/regressions/kt3559.kt
@@ -0,0 +1,10 @@
+// KT-3559 Strange inference failure error message
+
+public inline fun <T:Any, R> let(subj: T?, body: (T) -> R): R<!BASE_WITH_NULLABLE_UPPER_BOUND!>?<!> {
+    return if (subj != null) body(<!DEBUG_INFO_SMARTCAST!>subj<!>) else null
+}
+
+
+fun test(s: String?): String? {
+    return let(s) {s} // Reports: "Inference failed. Expected jet.String? but found jet.String?"
+}
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/inference/regressions/kt3559.txt b/compiler/testData/diagnostics/tests/inference/regressions/kt3559.txt
new file mode 100644
index 00000000000..dd9e3b06ea9
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/inference/regressions/kt3559.txt
@@ -0,0 +1,4 @@
+package
+
+kotlin.inline() public fun </*0*/ T : kotlin.Any, /*1*/ R> let(/*0*/ subj: T?, /*1*/ body: (T) -> R): R?
+internal fun test(/*0*/ s: kotlin.String?): kotlin.String?
diff --git a/compiler/testData/diagnostics/tests/inference/regressions/kt4420.kt b/compiler/testData/diagnostics/tests/inference/regressions/kt4420.kt
new file mode 100644
index 00000000000..031c92f9445
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/inference/regressions/kt4420.kt
@@ -0,0 +1,10 @@
+// !CHECK_TYPE
+//KT-4420 Type inference with type projections
+
+class Foo<T>
+fun <T> Foo<T>.bar(): T = throw Exception()
+
+fun main(args: Array<String>) {
+    val f: Foo<out String> = Foo()
+    f.bar() checkType { _<String>() }
+}
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/inference/regressions/kt4420.txt b/compiler/testData/diagnostics/tests/inference/regressions/kt4420.txt
new file mode 100644
index 00000000000..7f1125d18ed
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/inference/regressions/kt4420.txt
@@ -0,0 +1,11 @@
+package
+
+internal fun main(/*0*/ args: kotlin.Array<kotlin.String>): kotlin.Unit
+internal fun </*0*/ T> Foo<T>.bar(): T
+
+internal final class Foo</*0*/ T> {
+    public constructor Foo</*0*/ T>()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
diff --git a/compiler/testData/diagnostics/tests/inference/regressions/kt8132.kt b/compiler/testData/diagnostics/tests/inference/regressions/kt8132.kt
new file mode 100644
index 00000000000..03aa63118db
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/inference/regressions/kt8132.kt
@@ -0,0 +1,11 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+// KT-8132 Can't omit lambda parameter types
+
+fun <T> test(foo: List<T>): T {
+    return if (true)
+        throw IllegalStateException()
+    else
+        foo.reduce { left, right -> left } // error: inferred type T is not subtype Nothing
+}
+
+fun <S, T: S> Iterable<T>.reduce(operation: (S, T) -> S): S = throw Exception()
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/inference/regressions/kt8132.txt b/compiler/testData/diagnostics/tests/inference/regressions/kt8132.txt
new file mode 100644
index 00000000000..4a0ea42f804
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/inference/regressions/kt8132.txt
@@ -0,0 +1,4 @@
+package
+
+internal fun </*0*/ T> test(/*0*/ foo: kotlin.List<T>): T
+internal fun </*0*/ S, /*1*/ T : S> kotlin.Iterable<T>.reduce(/*0*/ operation: (S, T) -> S): S
diff --git a/compiler/testData/diagnostics/tests/inference/reportingImprovements/FunctionPlaceholder.kt b/compiler/testData/diagnostics/tests/inference/reportingImprovements/FunctionPlaceholder.kt
index 7ad420b84b1..39486a0a4b9 100644
--- a/compiler/testData/diagnostics/tests/inference/reportingImprovements/FunctionPlaceholder.kt
+++ b/compiler/testData/diagnostics/tests/inference/reportingImprovements/FunctionPlaceholder.kt
@@ -6,9 +6,9 @@ fun <T, R> foo(a: A<T, R>) = a
 fun <T, R> bar(f: (T) -> R) = f
 
 fun test() {
-    <!TYPE_INFERENCE_TYPE_CONSTRUCTOR_MISMATCH!>foo<!> <!TYPE_MISMATCH!>{ <!UNRESOLVED_REFERENCE!>it<!> }<!>
-    <!TYPE_INFERENCE_TYPE_CONSTRUCTOR_MISMATCH!>foo<!> <!TYPE_MISMATCH!>{ <!CANNOT_INFER_PARAMETER_TYPE!>x<!> -> <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>x<!>}<!>
-    <!TYPE_INFERENCE_TYPE_CONSTRUCTOR_MISMATCH!>foo<!> <!TYPE_MISMATCH!>{ x: Int -> x}<!>
+    <!TYPE_INFERENCE_PARAMETER_CONSTRAINT_ERROR!>foo<!> <!TYPE_MISMATCH!>{ <!UNRESOLVED_REFERENCE!>it<!> }<!>
+    <!TYPE_INFERENCE_PARAMETER_CONSTRAINT_ERROR!>foo<!> <!TYPE_MISMATCH!>{ <!CANNOT_INFER_PARAMETER_TYPE!>x<!> -> <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>x<!>}<!>
+    <!TYPE_INFERENCE_PARAMETER_CONSTRAINT_ERROR!>foo<!> <!TYPE_MISMATCH!>{ x: Int -> x}<!>
 
     <!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>bar<!> { <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>it<!> <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>+<!> 1 }
     <!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>bar<!> { <!CANNOT_INFER_PARAMETER_TYPE!>x<!> -> <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>x<!> <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>+<!> 1}
diff --git a/compiler/testData/diagnostics/tests/inference/substitutions/delegationAndInference.kt b/compiler/testData/diagnostics/tests/inference/substitutions/delegationAndInference.kt
new file mode 100644
index 00000000000..d0cad0fb02a
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/inference/substitutions/delegationAndInference.kt
@@ -0,0 +1,12 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+class A(val map: MutableMap<String, CharSequence>) {
+
+    var a: String by map.withDefault1 { "foo" }
+}
+
+fun <G> MutableMap<in String, in G>.get(thisRef: Any?, property: PropertyMetadata): G = throw Exception()
+
+fun <S> MutableMap<in String, in S>.set(thisRef: Any?, property: PropertyMetadata, value: S) {}
+
+fun <K, V> MutableMap<K, V>.withDefault1(default: (key: K) -> V): MutableMap<K, V> = this
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/inference/substitutions/delegationAndInference.txt b/compiler/testData/diagnostics/tests/inference/substitutions/delegationAndInference.txt
new file mode 100644
index 00000000000..2faa56775f4
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/inference/substitutions/delegationAndInference.txt
@@ -0,0 +1,14 @@
+package
+
+internal fun </*0*/ G> kotlin.MutableMap<in kotlin.String, in G>.get(/*0*/ thisRef: kotlin.Any?, /*1*/ property: kotlin.PropertyMetadata): G
+internal fun </*0*/ S> kotlin.MutableMap<in kotlin.String, in S>.set(/*0*/ thisRef: kotlin.Any?, /*1*/ property: kotlin.PropertyMetadata, /*2*/ value: S): kotlin.Unit
+internal fun </*0*/ K, /*1*/ V> kotlin.MutableMap<K, V>.withDefault1(/*0*/ default: (K) -> V): kotlin.MutableMap<K, V>
+
+internal final class A {
+    public constructor A(/*0*/ map: kotlin.MutableMap<kotlin.String, kotlin.CharSequence>)
+    internal final var a: kotlin.String
+    internal final val map: kotlin.MutableMap<kotlin.String, kotlin.CharSequence>
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
diff --git a/compiler/testData/diagnostics/tests/inference/typeConstructorMismatch.kt b/compiler/testData/diagnostics/tests/inference/typeConstructorMismatch.kt
index 37f11cb1236..82e2ca5519e 100644
--- a/compiler/testData/diagnostics/tests/inference/typeConstructorMismatch.kt
+++ b/compiler/testData/diagnostics/tests/inference/typeConstructorMismatch.kt
@@ -4,9 +4,9 @@ package typeConstructorMismatch
 import java.util.*
 
 fun test(set: Set<String>) {
-    <!TYPE_INFERENCE_TYPE_CONSTRUCTOR_MISMATCH!>elemAndList<!>("2", <!TYPE_MISMATCH!>set<!>)
+    <!TYPE_INFERENCE_PARAMETER_CONSTRAINT_ERROR!>elemAndList<!>("2", <!TYPE_MISMATCH!>set<!>)
 
-    "".<!TYPE_INFERENCE_TYPE_CONSTRUCTOR_MISMATCH!>elemAndListWithReceiver<!>("", <!TYPE_MISMATCH!>set<!>)
+    "".<!TYPE_INFERENCE_PARAMETER_CONSTRAINT_ERROR!>elemAndListWithReceiver<!>("", <!TYPE_MISMATCH!>set<!>)
 }
 
 fun <R> elemAndList(r: R, <!UNUSED_PARAMETER!>t<!>: List<R>): R = r
diff --git a/compiler/testData/diagnostics/tests/inference/upperBounds/conflictingSubstitutionsFromUpperBound.kt b/compiler/testData/diagnostics/tests/inference/upperBounds/conflictingSubstitutionsFromUpperBound.kt
index 091243b2b07..0fe2041a8e8 100644
--- a/compiler/testData/diagnostics/tests/inference/upperBounds/conflictingSubstitutionsFromUpperBound.kt
+++ b/compiler/testData/diagnostics/tests/inference/upperBounds/conflictingSubstitutionsFromUpperBound.kt
@@ -7,6 +7,6 @@ fun <T, C: Collection<T>> convert(src: Collection<T>, dest: C): C = throw Except
 
 fun test(l: List<Int>) {
     //todo should be inferred
-    val r = <!TYPE_INFERENCE_UPPER_BOUND_VIOLATED!>convert<!>(l, <!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>HashSet<!>())
-    checkSubtype<Int>(<!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>r<!>)
+    val r = convert(l, HashSet())
+    r checkType { _<HashSet<Int>>() }
 }
diff --git a/compiler/testData/diagnostics/tests/inference/upperBounds/doNotInferFromBoundsOnly.kt b/compiler/testData/diagnostics/tests/inference/upperBounds/doNotInferFromBoundsOnly.kt
index 1e5cd3be0e3..775f12ec20c 100644
--- a/compiler/testData/diagnostics/tests/inference/upperBounds/doNotInferFromBoundsOnly.kt
+++ b/compiler/testData/diagnostics/tests/inference/upperBounds/doNotInferFromBoundsOnly.kt
@@ -29,8 +29,7 @@ fun test3() {
 fun <T, R: T> emptyStrangeMap1(t: T): Map<T, R> = throw Exception("$t")
 
 fun test4() {
-    //todo we may infer 'Int' for 'R' here
-    <!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>emptyStrangeMap1<!>(1)
+    emptyStrangeMap1(1)
 }
 
 //--------------
@@ -38,8 +37,7 @@ fun test4() {
 fun <T: A, R: T> emptyStrangeMap2(t: T): Map<T, R> where R: A = throw Exception("$t")
 
 fun test5(a: A) {
-    //todo we may infer 'A' for 'R' here
-    <!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>emptyStrangeMap2<!>(a)
+    emptyStrangeMap2(a)
 }
 
 //--------------
diff --git a/compiler/testData/diagnostics/tests/inner/classesInClassObjectHeader.txt b/compiler/testData/diagnostics/tests/inner/classesInClassObjectHeader.txt
index 3da9ff2e581..9d1f545c42f 100644
--- a/compiler/testData/diagnostics/tests/inner/classesInClassObjectHeader.txt
+++ b/compiler/testData/diagnostics/tests/inner/classesInClassObjectHeader.txt
@@ -13,7 +13,7 @@ internal final class Test {
         public open override /*2*/ /*fake_override*/ fun toString(): kotlin.String
     }
 
-    internal final annotation class InnerAnnotation : kotlin.Annotation {
+    kotlin.annotation.annotation() internal final class InnerAnnotation : kotlin.Annotation {
         public constructor InnerAnnotation()
         public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
         public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
diff --git a/compiler/testData/diagnostics/tests/inner/illegalModifier.txt b/compiler/testData/diagnostics/tests/inner/illegalModifier.txt
index ddfca693e0c..722225dc574 100644
--- a/compiler/testData/diagnostics/tests/inner/illegalModifier.txt
+++ b/compiler/testData/diagnostics/tests/inner/illegalModifier.txt
@@ -71,7 +71,7 @@ internal final class D {
         public final /*synthesized*/ fun values(): kotlin.Array<D.R>
     }
 
-    internal final annotation class S : kotlin.Annotation {
+    kotlin.annotation.annotation() internal final class S : kotlin.Annotation {
         public constructor S()
         public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
         public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
diff --git a/compiler/testData/diagnostics/tests/inner/selfAnnotationForClassObject.txt b/compiler/testData/diagnostics/tests/inner/selfAnnotationForClassObject.txt
index 0ade0d0df69..ecdb25a2d37 100644
--- a/compiler/testData/diagnostics/tests/inner/selfAnnotationForClassObject.txt
+++ b/compiler/testData/diagnostics/tests/inner/selfAnnotationForClassObject.txt
@@ -12,7 +12,7 @@ internal final class Test {
         public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
         public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
 
-        internal final annotation class ClassObjectAnnotation : kotlin.Annotation {
+        kotlin.annotation.annotation() internal final class ClassObjectAnnotation : kotlin.Annotation {
             public constructor ClassObjectAnnotation()
             public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
             public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
@@ -20,7 +20,7 @@ internal final class Test {
         }
     }
 
-    internal final annotation class NestedAnnotation : kotlin.Annotation {
+    kotlin.annotation.annotation() internal final class NestedAnnotation : kotlin.Annotation {
         public constructor NestedAnnotation()
         public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
         public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
diff --git a/compiler/testData/diagnostics/tests/j+k/GenericsInSupertypes.txt b/compiler/testData/diagnostics/tests/j+k/GenericsInSupertypes.txt
index 0d49eb4bc2f..28af01cb5e6 100644
--- a/compiler/testData/diagnostics/tests/j+k/GenericsInSupertypes.txt
+++ b/compiler/testData/diagnostics/tests/j+k/GenericsInSupertypes.txt
@@ -5,41 +5,41 @@ internal abstract class AL : java.util.ArrayList<p.P> {
     invisible_fake final override /*1*/ /*fake_override*/ var elementData: kotlin.Array<(out) kotlin.Any!>!
     protected/*protected and package*/ final override /*1*/ /*fake_override*/ var modCount: kotlin.Int
     invisible_fake final override /*1*/ /*fake_override*/ var size: kotlin.Int
-    public open override /*1*/ /*fake_override*/ fun add(/*0*/ index: kotlin.Int, /*1*/ element: p.P!): kotlin.Unit
-    public open override /*1*/ /*fake_override*/ fun add(/*0*/ e: p.P!): kotlin.Boolean
-    public open override /*1*/ /*fake_override*/ fun addAll(/*0*/ c: (kotlin.MutableCollection<out p.P!>..kotlin.Collection<p.P!>?)): kotlin.Boolean
-    public open override /*1*/ /*fake_override*/ fun addAll(/*0*/ index: kotlin.Int, /*1*/ c: (kotlin.MutableCollection<out p.P!>..kotlin.Collection<p.P!>?)): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun add(/*0*/ index: kotlin.Int, /*1*/ element: p.P): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun add(/*0*/ e: p.P): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun addAll(/*0*/ c: kotlin.Collection<p.P>): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun addAll(/*0*/ index: kotlin.Int, /*1*/ c: kotlin.Collection<p.P>): kotlin.Boolean
     invisible_fake open override /*1*/ /*fake_override*/ fun batchRemove(/*0*/ p0: kotlin.(Mutable)Collection<*>!, /*1*/ p1: kotlin.Boolean): kotlin.Boolean
     public open override /*1*/ /*fake_override*/ fun clear(): kotlin.Unit
-    public open override /*1*/ /*fake_override*/ fun clone(): kotlin.Any!
-    public open override /*1*/ /*fake_override*/ fun contains(/*0*/ o: kotlin.Any!): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun clone(): kotlin.Any
+    public open override /*1*/ /*fake_override*/ fun contains(/*0*/ o: kotlin.Any?): kotlin.Boolean
     public open override /*1*/ /*fake_override*/ fun containsAll(/*0*/ c: kotlin.Collection<kotlin.Any?>): kotlin.Boolean
     invisible_fake open override /*1*/ /*fake_override*/ fun elementData(/*0*/ p0: kotlin.Int): p.P!
     public open override /*1*/ /*fake_override*/ fun ensureCapacity(/*0*/ p0: kotlin.Int): kotlin.Unit
     invisible_fake open override /*1*/ /*fake_override*/ fun ensureCapacityInternal(/*0*/ p0: kotlin.Int): kotlin.Unit
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
     invisible_fake open override /*1*/ /*fake_override*/ fun fastRemove(/*0*/ p0: kotlin.Int): kotlin.Unit
-    public open override /*1*/ /*fake_override*/ fun get(/*0*/ index: kotlin.Int): p.P!
+    public open override /*1*/ /*fake_override*/ fun get(/*0*/ index: kotlin.Int): p.P
     invisible_fake open override /*1*/ /*fake_override*/ fun grow(/*0*/ p0: kotlin.Int): kotlin.Unit
     public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
-    public open override /*1*/ /*fake_override*/ fun indexOf(/*0*/ o: kotlin.Any!): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun indexOf(/*0*/ o: kotlin.Any?): kotlin.Int
     public open override /*1*/ /*fake_override*/ fun isEmpty(): kotlin.Boolean
-    public open override /*1*/ /*fake_override*/ fun iterator(): kotlin.(Mutable)Iterator<p.P!>!
-    public open override /*1*/ /*fake_override*/ fun lastIndexOf(/*0*/ o: kotlin.Any!): kotlin.Int
-    public open override /*1*/ /*fake_override*/ fun listIterator(): kotlin.(Mutable)ListIterator<p.P!>!
-    public open override /*1*/ /*fake_override*/ fun listIterator(/*0*/ index: kotlin.Int): kotlin.(Mutable)ListIterator<p.P!>!
+    public open override /*1*/ /*fake_override*/ fun iterator(): kotlin.MutableIterator<p.P>
+    public open override /*1*/ /*fake_override*/ fun lastIndexOf(/*0*/ o: kotlin.Any?): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun listIterator(): kotlin.MutableListIterator<p.P>
+    public open override /*1*/ /*fake_override*/ fun listIterator(/*0*/ index: kotlin.Int): kotlin.MutableListIterator<p.P>
     invisible_fake open override /*1*/ /*fake_override*/ fun outOfBoundsMsg(/*0*/ p0: kotlin.Int): kotlin.String!
     invisible_fake open override /*1*/ /*fake_override*/ fun rangeCheck(/*0*/ p0: kotlin.Int): kotlin.Unit
     invisible_fake open override /*1*/ /*fake_override*/ fun rangeCheckForAdd(/*0*/ p0: kotlin.Int): kotlin.Unit
     invisible_fake open override /*1*/ /*fake_override*/ fun readObject(/*0*/ p0: java.io.ObjectInputStream!): 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): p.P!
-    public open override /*1*/ /*fake_override*/ fun removeAll(/*0*/ c: kotlin.(Mutable)Collection<*>!): kotlin.Boolean
+    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): p.P
+    public open override /*1*/ /*fake_override*/ fun removeAll(/*0*/ c: kotlin.Collection<*>): kotlin.Boolean
     protected/*protected and package*/ open override /*1*/ /*fake_override*/ fun removeRange(/*0*/ p0: kotlin.Int, /*1*/ p1: kotlin.Int): kotlin.Unit
-    public open override /*1*/ /*fake_override*/ fun retainAll(/*0*/ c: kotlin.(Mutable)Collection<*>!): kotlin.Boolean
-    public open override /*1*/ /*fake_override*/ fun set(/*0*/ index: kotlin.Int, /*1*/ element: p.P!): p.P!
+    public open override /*1*/ /*fake_override*/ fun retainAll(/*0*/ c: kotlin.Collection<*>): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun set(/*0*/ index: kotlin.Int, /*1*/ element: p.P): p.P
     public open override /*1*/ /*fake_override*/ fun size(): kotlin.Int
-    public open override /*1*/ /*fake_override*/ fun subList(/*0*/ fromIndex: kotlin.Int, /*1*/ toIndex: kotlin.Int): kotlin.(Mutable)List<p.P!>!
+    public open override /*1*/ /*fake_override*/ fun subList(/*0*/ fromIndex: kotlin.Int, /*1*/ toIndex: kotlin.Int): kotlin.MutableList<p.P>
     public open override /*1*/ /*fake_override*/ fun toArray(): kotlin.Array<(out) kotlin.Any!>!
     public open override /*1*/ /*fake_override*/ fun </*0*/ T> toArray(/*0*/ p0: kotlin.Array<(out) T!>!): kotlin.Array<(out) T!>!
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
@@ -50,7 +50,7 @@ internal abstract class AL : java.util.ArrayList<p.P> {
 internal abstract class K : p.C<p.P> {
     public constructor K()
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
-    public open override /*1*/ /*fake_override*/ fun foo(/*0*/ p: p.A<p.P!>!): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun foo(/*0*/ p: p.A<p.P!>): kotlin.Unit
     public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
 }
@@ -67,7 +67,7 @@ package p {
     public open class B</*0*/ TB> : p.A<TB!> {
         public constructor B</*0*/ TB>()
         public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
-        public/*package*/ open override /*1*/ fun foo(/*0*/ p: p.A<TB!>!): kotlin.Unit
+        public/*package*/ open override /*1*/ fun foo(/*0*/ p: p.A<TB!>): kotlin.Unit
         public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
         public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
     }
@@ -75,7 +75,7 @@ package p {
     public open class C</*0*/ TC> : p.B<TC!>, p.A<TC!> {
         public constructor C</*0*/ TC>()
         public open override /*2*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
-        public open override /*2*/ /*fake_override*/ fun foo(/*0*/ p: p.A<TC!>!): kotlin.Unit
+        public open override /*2*/ /*fake_override*/ fun foo(/*0*/ p: p.A<TC!>): kotlin.Unit
         public open override /*2*/ /*fake_override*/ fun hashCode(): kotlin.Int
         public open override /*2*/ /*fake_override*/ fun toString(): kotlin.String
     }
diff --git a/compiler/testData/diagnostics/tests/j+k/SupertypeArgumentsNullability-NotNull-SpecialTypes.kt b/compiler/testData/diagnostics/tests/j+k/SupertypeArgumentsNullability-NotNull-SpecialTypes.kt
index 205bc4f0ca3..52fc47305f0 100644
--- a/compiler/testData/diagnostics/tests/j+k/SupertypeArgumentsNullability-NotNull-SpecialTypes.kt
+++ b/compiler/testData/diagnostics/tests/j+k/SupertypeArgumentsNullability-NotNull-SpecialTypes.kt
@@ -19,6 +19,5 @@ public class Y extends X<String> {
 
 fun main() {
     checkSubtype<Any>(Y().fooN())
-    Y().barN(null);
+    Y().barN(<!NULL_FOR_NONNULL_TYPE!>null<!>);
 }
-
diff --git a/compiler/testData/diagnostics/tests/j+k/SupertypeArgumentsNullability-NotNull-SpecialTypes.txt b/compiler/testData/diagnostics/tests/j+k/SupertypeArgumentsNullability-NotNull-SpecialTypes.txt
index ac3d083dfb6..8a73fb1f86b 100644
--- a/compiler/testData/diagnostics/tests/j+k/SupertypeArgumentsNullability-NotNull-SpecialTypes.txt
+++ b/compiler/testData/diagnostics/tests/j+k/SupertypeArgumentsNullability-NotNull-SpecialTypes.txt
@@ -11,18 +11,18 @@ public open class A {
 
 public open class X</*0*/ T> {
     public constructor X</*0*/ T>()
-    public/*package*/ open fun barN(/*0*/ org.jetbrains.annotations.NotNull() a: T!): kotlin.Unit
+    public/*package*/ open fun barN(/*0*/ org.jetbrains.annotations.NotNull() a: T): kotlin.Unit
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
-    org.jetbrains.annotations.NotNull() public/*package*/ open fun fooN(): T!
+    org.jetbrains.annotations.NotNull() public/*package*/ open fun fooN(): T
     public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
 }
 
 public open class Y : X<kotlin.String!> {
     public constructor Y()
-    public/*package*/ open override /*1*/ /*fake_override*/ fun barN(/*0*/ org.jetbrains.annotations.NotNull() a: kotlin.String!): kotlin.Unit
+    public/*package*/ open override /*1*/ /*fake_override*/ fun barN(/*0*/ org.jetbrains.annotations.NotNull() a: kotlin.String): kotlin.Unit
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
-    org.jetbrains.annotations.NotNull() public/*package*/ open override /*1*/ /*fake_override*/ fun fooN(): kotlin.String!
+    org.jetbrains.annotations.NotNull() public/*package*/ open override /*1*/ /*fake_override*/ fun fooN(): kotlin.String
     public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
 }
diff --git a/compiler/testData/diagnostics/tests/j+k/SupertypeArgumentsNullability-NotNull-UserTypes.kt b/compiler/testData/diagnostics/tests/j+k/SupertypeArgumentsNullability-NotNull-UserTypes.kt
index 1c9610d9195..2dc98dd7583 100644
--- a/compiler/testData/diagnostics/tests/j+k/SupertypeArgumentsNullability-NotNull-UserTypes.kt
+++ b/compiler/testData/diagnostics/tests/j+k/SupertypeArgumentsNullability-NotNull-UserTypes.kt
@@ -19,6 +19,5 @@ public class Y extends X<A> {
 
 fun main() {
     checkSubtype<Any>(Y().fooN())
-    Y().barN(null);
+    Y().barN(<!NULL_FOR_NONNULL_TYPE!>null<!>);
 }
-
diff --git a/compiler/testData/diagnostics/tests/j+k/SupertypeArgumentsNullability-NotNull-UserTypes.txt b/compiler/testData/diagnostics/tests/j+k/SupertypeArgumentsNullability-NotNull-UserTypes.txt
index 28891f6e92d..af87cc89d5b 100644
--- a/compiler/testData/diagnostics/tests/j+k/SupertypeArgumentsNullability-NotNull-UserTypes.txt
+++ b/compiler/testData/diagnostics/tests/j+k/SupertypeArgumentsNullability-NotNull-UserTypes.txt
@@ -11,18 +11,18 @@ public open class A {
 
 public open class X</*0*/ T> {
     public constructor X</*0*/ T>()
-    public/*package*/ open fun barN(/*0*/ org.jetbrains.annotations.NotNull() a: T!): kotlin.Unit
+    public/*package*/ open fun barN(/*0*/ org.jetbrains.annotations.NotNull() a: T): kotlin.Unit
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
-    org.jetbrains.annotations.NotNull() public/*package*/ open fun fooN(): T!
+    org.jetbrains.annotations.NotNull() public/*package*/ open fun fooN(): T
     public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
 }
 
 public open class Y : X<A!> {
     public constructor Y()
-    public/*package*/ open override /*1*/ /*fake_override*/ fun barN(/*0*/ org.jetbrains.annotations.NotNull() a: A!): kotlin.Unit
+    public/*package*/ open override /*1*/ /*fake_override*/ fun barN(/*0*/ org.jetbrains.annotations.NotNull() a: A): kotlin.Unit
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
-    org.jetbrains.annotations.NotNull() public/*package*/ open override /*1*/ /*fake_override*/ fun fooN(): A!
+    org.jetbrains.annotations.NotNull() public/*package*/ open override /*1*/ /*fake_override*/ fun fooN(): A
     public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
 }
diff --git a/compiler/testData/diagnostics/tests/j+k/computeIfAbsentConcurrent.kt b/compiler/testData/diagnostics/tests/j+k/computeIfAbsentConcurrent.kt
new file mode 100644
index 00000000000..abd047b6ccd
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/j+k/computeIfAbsentConcurrent.kt
@@ -0,0 +1,22 @@
+// FILE: MyFunc.java
+public interface MyFunc<K, V> {
+    V apply(K String);
+}
+
+// FILE: ConcMap.java
+public interface ConcMap<K, V> {
+    V computeIfAbsent(K key, MyFunc<? super K,? extends V> mappingFunction);
+}
+
+// FILE: ConcHashMap.java
+public class ConcHashMap<K, V> implements ConcMap<K, V> {
+    @Override
+    V computeIfAbsent(K key, MyFunc<? super K,? extends V> mappingFunction) { }
+}
+
+// FILE: main.kt
+
+public fun concurrentMap() {
+    val map = ConcHashMap<String, String>()
+    map.computeIfAbsent("") { "" } // here
+}
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/j+k/computeIfAbsentConcurrent.txt b/compiler/testData/diagnostics/tests/j+k/computeIfAbsentConcurrent.txt
new file mode 100644
index 00000000000..e66188e9423
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/j+k/computeIfAbsentConcurrent.txt
@@ -0,0 +1,29 @@
+package
+
+public /*synthesized*/ fun </*0*/ K, /*1*/ V> ConcMap(/*0*/ function: (K!, MyFunc<in K!, out V!>!) -> V!): ConcMap<K, V>
+public /*synthesized*/ fun </*0*/ K, /*1*/ V> MyFunc(/*0*/ function: (K!) -> V!): MyFunc<K, V>
+public fun concurrentMap(): kotlin.Unit
+
+public open class ConcHashMap</*0*/ K, /*1*/ V> : ConcMap<K!, V!> {
+    public constructor ConcHashMap</*0*/ K, /*1*/ V>()
+    java.lang.Override() public/*package*/ final override /*1*/ /*synthesized*/ fun computeIfAbsent(/*0*/ key: K!, /*1*/ mappingFunction: ((K!) -> V!)!): V!
+    java.lang.Override() public/*package*/ open override /*1*/ fun computeIfAbsent(/*0*/ key: K!, /*1*/ mappingFunction: MyFunc<in K!, out V!>!): V!
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public interface ConcMap</*0*/ K, /*1*/ V> {
+    public final /*synthesized*/ fun computeIfAbsent(/*0*/ key: K!, /*1*/ mappingFunction: ((K!) -> V!)!): V!
+    public abstract fun computeIfAbsent(/*0*/ key: K!, /*1*/ mappingFunction: MyFunc<in K!, out V!>!): V!
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public interface MyFunc</*0*/ K, /*1*/ V> {
+    public abstract fun apply(/*0*/ String: K!): V!
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
diff --git a/compiler/testData/diagnostics/tests/j+k/javaStaticImport.txt b/compiler/testData/diagnostics/tests/j+k/javaStaticImport.txt
index 6a1ca31528e..a508a227198 100644
--- a/compiler/testData/diagnostics/tests/j+k/javaStaticImport.txt
+++ b/compiler/testData/diagnostics/tests/j+k/javaStaticImport.txt
@@ -19,7 +19,7 @@ package backend {
             public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
 
             // Static members
-            org.jetbrains.annotations.NotNull() public open fun doSmth(/*0*/ s: kotlin.String!): kotlin.String!
+            org.jetbrains.annotations.NotNull() public open fun doSmth(/*0*/ s: kotlin.String!): kotlin.String
         }
     }
 }
diff --git a/compiler/testData/diagnostics/tests/j+k/kt1730_implementCharSequence.txt b/compiler/testData/diagnostics/tests/j+k/kt1730_implementCharSequence.txt
index 437a3bf71db..8b782e8a748 100644
--- a/compiler/testData/diagnostics/tests/j+k/kt1730_implementCharSequence.txt
+++ b/compiler/testData/diagnostics/tests/j+k/kt1730_implementCharSequence.txt
@@ -6,8 +6,8 @@ public open class C : kotlin.CharSequence {
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
     public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
     java.lang.Override() public open override /*1*/ fun length(): kotlin.Int
-    java.lang.Override() public open override /*1*/ fun subSequence(/*0*/ start: kotlin.Int, /*1*/ end: kotlin.Int): kotlin.CharSequence!
-    java.lang.Override() public open override /*1*/ fun toString(): kotlin.String!
+    java.lang.Override() public open override /*1*/ fun subSequence(/*0*/ start: kotlin.Int, /*1*/ end: kotlin.Int): kotlin.CharSequence
+    java.lang.Override() public open override /*1*/ fun toString(): kotlin.String
 }
 
 internal final class T : C {
@@ -16,6 +16,6 @@ internal final class T : C {
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
     public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
     java.lang.Override() public open override /*1*/ /*fake_override*/ fun length(): kotlin.Int
-    java.lang.Override() public open override /*1*/ /*fake_override*/ fun subSequence(/*0*/ start: kotlin.Int, /*1*/ end: kotlin.Int): kotlin.CharSequence!
-    java.lang.Override() public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String!
+    java.lang.Override() public open override /*1*/ /*fake_override*/ fun subSequence(/*0*/ start: kotlin.Int, /*1*/ end: kotlin.Int): kotlin.CharSequence
+    java.lang.Override() public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
 }
diff --git a/compiler/testData/diagnostics/tests/j+k/overrideWithSamAndTypeParameter.kt b/compiler/testData/diagnostics/tests/j+k/overrideWithSamAndTypeParameter.kt
new file mode 100644
index 00000000000..8ce4c73cbd9
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/j+k/overrideWithSamAndTypeParameter.kt
@@ -0,0 +1,22 @@
+// FILE: MyFunc.java
+
+public interface MyFunc {
+    String apply(String x);
+}
+
+// FILE: A.java
+public interface A<K> {
+    K foo(K key, MyFunc f);
+}
+
+// FILE: B.java
+public class B<E> implements A<E> {
+    @Override
+    public E foo(E key, MyFunc f) {return null;}
+}
+
+// FILE: main.kt
+
+fun main() {
+    B<String>().foo("") { "" }
+}
diff --git a/compiler/testData/diagnostics/tests/j+k/overrideWithSamAndTypeParameter.txt b/compiler/testData/diagnostics/tests/j+k/overrideWithSamAndTypeParameter.txt
new file mode 100644
index 00000000000..fb416b164fe
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/j+k/overrideWithSamAndTypeParameter.txt
@@ -0,0 +1,29 @@
+package
+
+public /*synthesized*/ fun </*0*/ K> A(/*0*/ function: (K!, MyFunc!) -> K!): A<K>
+public /*synthesized*/ fun MyFunc(/*0*/ function: (kotlin.String!) -> kotlin.String!): MyFunc
+internal fun main(): kotlin.Unit
+
+public interface A</*0*/ K> {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public final /*synthesized*/ fun foo(/*0*/ key: K!, /*1*/ f: ((kotlin.String!) -> kotlin.String!)!): K!
+    public abstract fun foo(/*0*/ key: K!, /*1*/ f: MyFunc!): K!
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public open class B</*0*/ E> : A<E!> {
+    public constructor B</*0*/ E>()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    java.lang.Override() public final override /*1*/ /*synthesized*/ fun foo(/*0*/ key: E!, /*1*/ f: ((kotlin.String!) -> kotlin.String!)!): E!
+    java.lang.Override() public open override /*1*/ fun foo(/*0*/ key: E!, /*1*/ f: MyFunc!): E!
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public interface MyFunc {
+    public abstract fun apply(/*0*/ x: kotlin.String!): kotlin.String!
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
diff --git a/compiler/testData/diagnostics/tests/j+k/types/arrayList.kt b/compiler/testData/diagnostics/tests/j+k/types/arrayList.kt
new file mode 100644
index 00000000000..6e405cc393e
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/j+k/types/arrayList.kt
@@ -0,0 +1,15 @@
+// FILE: k.kt
+
+interface ML<T> {
+    public fun foo(): MutableList<T>
+}
+
+class K : J<String>(), ML<String>
+
+// FILE: J.java
+
+import java.util.*;
+
+class J<T> extends ML<T> {
+    public List<T> foo() { return null; }
+}
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/j+k/types/arrayList.txt b/compiler/testData/diagnostics/tests/j+k/types/arrayList.txt
new file mode 100644
index 00000000000..793d26b1e99
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/j+k/types/arrayList.txt
@@ -0,0 +1,24 @@
+package
+
+public/*package*/ open class J</*0*/ T> : ML<T!> {
+    public/*package*/ constructor J</*0*/ T>()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ fun foo(): kotlin.MutableList<T!>
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+internal final class K : J<kotlin.String>, ML<kotlin.String> {
+    public constructor K()
+    public open override /*2*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*2*/ /*fake_override*/ fun foo(): kotlin.MutableList<kotlin.String>
+    public open override /*2*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*2*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+internal interface ML</*0*/ T> {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public abstract fun foo(): kotlin.MutableList<T>
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
diff --git a/compiler/testData/diagnostics/tests/j+k/types/returnCollection.kt b/compiler/testData/diagnostics/tests/j+k/types/returnCollection.kt
new file mode 100644
index 00000000000..4ead28c1794
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/j+k/types/returnCollection.kt
@@ -0,0 +1,13 @@
+// FILE: k.kt
+
+interface K {
+    fun foo(): List<String>
+}
+
+// FILE: J.java
+
+import java.util.*;
+
+interface J extends K {
+    List<String> foo();
+}
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/j+k/types/returnCollection.txt b/compiler/testData/diagnostics/tests/j+k/types/returnCollection.txt
new file mode 100644
index 00000000000..198fd3c2834
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/j+k/types/returnCollection.txt
@@ -0,0 +1,17 @@
+package
+
+public/*package*/ /*synthesized*/ fun J(/*0*/ function: () -> kotlin.(Mutable)List<kotlin.String!>!): J
+
+public/*package*/ interface J : K {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public abstract override /*1*/ fun foo(): kotlin.List<kotlin.String>
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+internal interface K {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    internal abstract fun foo(): kotlin.List<kotlin.String>
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
diff --git a/compiler/testData/diagnostics/tests/j+k/types/shapeMismatchInCovariantPosition.kt b/compiler/testData/diagnostics/tests/j+k/types/shapeMismatchInCovariantPosition.kt
new file mode 100644
index 00000000000..84c8934b225
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/j+k/types/shapeMismatchInCovariantPosition.kt
@@ -0,0 +1,19 @@
+// FILE: k.kt
+
+interface G<T>
+interface SubG : G<String>
+
+interface K {
+    fun foo(): G<String>
+    fun bar(): G<String>?
+}
+
+// FILE: J.java
+
+import java.util.*;
+
+interface J extends K {
+    SubG foo();
+    SubG bar();
+    SubG baz();
+}
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/j+k/types/shapeMismatchInCovariantPosition.txt b/compiler/testData/diagnostics/tests/j+k/types/shapeMismatchInCovariantPosition.txt
new file mode 100644
index 00000000000..36ae41d1de9
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/j+k/types/shapeMismatchInCovariantPosition.txt
@@ -0,0 +1,30 @@
+package
+
+internal interface G</*0*/ T> {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public/*package*/ interface J : K {
+    public abstract override /*1*/ fun bar(): SubG?
+    public abstract fun baz(): SubG!
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public abstract override /*1*/ fun foo(): SubG
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+internal interface K {
+    internal abstract fun bar(): G<kotlin.String>?
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    internal abstract fun foo(): G<kotlin.String>
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+internal interface SubG : G<kotlin.String> {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
diff --git a/compiler/testData/diagnostics/tests/j+k/types/shapeMismatchInCovariantPositionGeneric.kt b/compiler/testData/diagnostics/tests/j+k/types/shapeMismatchInCovariantPositionGeneric.kt
new file mode 100644
index 00000000000..2ab572dca5a
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/j+k/types/shapeMismatchInCovariantPositionGeneric.kt
@@ -0,0 +1,19 @@
+// FILE: k.kt
+
+interface G<T>
+interface SubG<A, B> : G<String>
+
+interface K<KT> {
+    fun foo(): G<KT>
+    fun bar(): G<KT>?
+}
+
+// FILE: J.java
+
+import java.util.*;
+
+interface J extends K<String> {
+    SubG<String, G<String>> foo();
+    SubG<String, G<String>> bar();
+    SubG<String, G<String>> baz();
+}
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/j+k/types/shapeMismatchInCovariantPositionGeneric.txt b/compiler/testData/diagnostics/tests/j+k/types/shapeMismatchInCovariantPositionGeneric.txt
new file mode 100644
index 00000000000..84f01f74142
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/j+k/types/shapeMismatchInCovariantPositionGeneric.txt
@@ -0,0 +1,30 @@
+package
+
+internal interface G</*0*/ T> {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public/*package*/ interface J : K<kotlin.String!> {
+    public abstract override /*1*/ fun bar(): SubG<kotlin.String!, G<kotlin.String!>!>?
+    public abstract fun baz(): SubG<kotlin.String!, G<kotlin.String!>!>!
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public abstract override /*1*/ fun foo(): SubG<kotlin.String!, G<kotlin.String!>!>
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+internal interface K</*0*/ KT> {
+    internal abstract fun bar(): G<KT>?
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    internal abstract fun foo(): G<KT>
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+internal interface SubG</*0*/ A, /*1*/ B> : G<kotlin.String> {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
diff --git a/compiler/testData/diagnostics/tests/j+k/types/typeParameter.kt b/compiler/testData/diagnostics/tests/j+k/types/typeParameter.kt
new file mode 100644
index 00000000000..550b69b506d
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/j+k/types/typeParameter.kt
@@ -0,0 +1,11 @@
+// FILE: k.kt
+
+interface K {
+    fun <T> foo(t: T)
+}
+
+// FILE: J.java
+
+interface J extends K {
+    <T> void foo(T t);
+}
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/j+k/types/typeParameter.txt b/compiler/testData/diagnostics/tests/j+k/types/typeParameter.txt
new file mode 100644
index 00000000000..d96e7b10deb
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/j+k/types/typeParameter.txt
@@ -0,0 +1,15 @@
+package
+
+public/*package*/ interface J : K {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public abstract override /*1*/ fun </*0*/ T> foo(/*0*/ t: T): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+internal interface K {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    internal abstract fun </*0*/ T> foo(/*0*/ t: T): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
diff --git a/compiler/testData/diagnostics/tests/modifiers/IllegalModifiers.kt b/compiler/testData/diagnostics/tests/modifiers/IllegalModifiers.kt
index d6c6f91412f..f4f0706f2eb 100644
--- a/compiler/testData/diagnostics/tests/modifiers/IllegalModifiers.kt
+++ b/compiler/testData/diagnostics/tests/modifiers/IllegalModifiers.kt
@@ -83,9 +83,9 @@ abstract class IllegalModifiers6() {
     <!ILLEGAL_MODIFIER!>open<!> init {}
     <!ILLEGAL_MODIFIER!>final<!> init {}
 
-    <!ILLEGAL_MODIFIER!>public<!> annotated init {}
+    <!ILLEGAL_MODIFIER!>public<!> <!WRONG_ANNOTATION_TARGET!>annotated<!> init {}
 
-    <!ILLEGAL_MODIFIER!>private<!> <!NOT_AN_ANNOTATION_CLASS!>IllegalModifiers6()<!> init {}
+    <!ILLEGAL_MODIFIER!>private<!> <!NOT_AN_ANNOTATION_CLASS, WRONG_ANNOTATION_TARGET!>IllegalModifiers6()<!> init {}
 }
 
 // strange inappropriate modifiers usages
@@ -97,7 +97,7 @@ abstract class IllegalModifiers6() {
 class IllegalModifiers7() {
     <!ILLEGAL_ENUM_ANNOTATION!>enum<!>
     <!ILLEGAL_MODIFIER!>inner<!>
-    <!ILLEGAL_ANNOTATION_KEYWORD!>annotation<!>
+    <!WRONG_ANNOTATION_TARGET!>annotation<!>
     <!ILLEGAL_MODIFIER!>out<!>
     <!ILLEGAL_MODIFIER!>in<!>
     <!ILLEGAL_MODIFIER!>vararg<!>
@@ -105,7 +105,7 @@ class IllegalModifiers7() {
     val x = 1
     <!ILLEGAL_ENUM_ANNOTATION!>enum<!>
     <!ILLEGAL_MODIFIER!>inner<!>
-    <!ILLEGAL_ANNOTATION_KEYWORD!>annotation<!>
+    <!WRONG_ANNOTATION_TARGET!>annotation<!>
     <!ILLEGAL_MODIFIER!>out<!>
     <!ILLEGAL_MODIFIER!>in<!>
     <!ILLEGAL_MODIFIER!>vararg<!>
@@ -119,7 +119,7 @@ class IllegalModifiers8 {
     <!ILLEGAL_ENUM_ANNOTATION!>enum<!>
     <!ILLEGAL_MODIFIER, REDUNDANT_MODIFIER, REDUNDANT_MODIFIER, INCOMPATIBLE_MODIFIERS!>open<!>
     <!ILLEGAL_MODIFIER!>inner<!>
-    <!ILLEGAL_ANNOTATION_KEYWORD!>annotation<!>
+    <!WRONG_ANNOTATION_TARGET!>annotation<!>
     <!ILLEGAL_MODIFIER!>override<!>
     <!ILLEGAL_MODIFIER!>out<!>
     <!ILLEGAL_MODIFIER!>in<!>
@@ -143,7 +143,7 @@ class IllegalModifiers10
 <!ILLEGAL_ENUM_ANNOTATION!>enum<!>
 <!ILLEGAL_MODIFIER, REDUNDANT_MODIFIER, REDUNDANT_MODIFIER, INCOMPATIBLE_MODIFIERS!>open<!>
 <!ILLEGAL_MODIFIER!>inner<!>
-<!ILLEGAL_ANNOTATION_KEYWORD!>annotation<!>
+<!WRONG_ANNOTATION_TARGET!>annotation<!>
 <!ILLEGAL_MODIFIER!>override<!>
 <!ILLEGAL_MODIFIER!>out<!>
 <!ILLEGAL_MODIFIER!>in<!>
diff --git a/compiler/testData/diagnostics/tests/modifiers/IllegalModifiers.txt b/compiler/testData/diagnostics/tests/modifiers/IllegalModifiers.txt
index bb0511c48c6..c0302f33667 100644
--- a/compiler/testData/diagnostics/tests/modifiers/IllegalModifiers.txt
+++ b/compiler/testData/diagnostics/tests/modifiers/IllegalModifiers.txt
@@ -45,7 +45,7 @@ package illegal_modifiers {
     }
 
     internal final class IllegalModifiers10 {
-        public constructor IllegalModifiers10()
+        kotlin.annotation.annotation() public constructor IllegalModifiers10()
         public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
         public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
         public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
@@ -100,15 +100,15 @@ package illegal_modifiers {
 
     internal open class IllegalModifiers7 {
         public constructor IllegalModifiers7()
-        internal final val x: kotlin.Int = 1
+        kotlin.annotation.annotation() internal final val x: kotlin.Int = 1
         public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
-        internal final fun foo(): kotlin.Unit
+        kotlin.annotation.annotation() internal final fun foo(): kotlin.Unit
         public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
         public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
     }
 
     internal final class IllegalModifiers8 {
-        public constructor IllegalModifiers8()
+        kotlin.annotation.annotation() public constructor IllegalModifiers8()
         public constructor IllegalModifiers8(/*0*/ x: kotlin.Int)
         public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
         public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
@@ -138,7 +138,7 @@ package illegal_modifiers {
         public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
     }
 
-    internal final annotation class annotated : kotlin.Annotation {
+    kotlin.annotation.annotation() internal final class annotated : kotlin.Annotation {
         public constructor annotated(/*0*/ text: kotlin.String = ...)
         internal final val text: kotlin.String
         public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
diff --git a/compiler/testData/diagnostics/tests/modifiers/primaryConstructorMissingKeyword.txt b/compiler/testData/diagnostics/tests/modifiers/primaryConstructorMissingKeyword.txt
index 48fa3a24d61..08b73867132 100644
--- a/compiler/testData/diagnostics/tests/modifiers/primaryConstructorMissingKeyword.txt
+++ b/compiler/testData/diagnostics/tests/modifiers/primaryConstructorMissingKeyword.txt
@@ -9,7 +9,7 @@ internal final class A {
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
 
     internal final inner class B {
-        Ann(x = IntegerValueType(2)) public constructor B(/*0*/ y: kotlin.Int)
+        Ann(x = 2) public constructor B(/*0*/ y: kotlin.Int)
         internal final val y: kotlin.Int
         public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
         public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
@@ -17,7 +17,7 @@ internal final class A {
     }
 }
 
-internal final annotation class Ann : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class Ann : kotlin.Annotation {
     public constructor Ann(/*0*/ x: kotlin.Int = ...)
     internal final val x: kotlin.Int
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
diff --git a/compiler/testData/diagnostics/tests/multimodule/varargConflict.kt b/compiler/testData/diagnostics/tests/multimodule/varargConflict.kt
new file mode 100644
index 00000000000..0631d24ad78
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/multimodule/varargConflict.kt
@@ -0,0 +1,26 @@
+// !DIAGNOSTICS: -UNUSED_VARIABLE -UNUSED_PARAMETER
+// MODULE: m1
+// FILE: a.kt
+
+package p
+
+public fun foo(a: Int) {}
+public fun foo(vararg values: Int) {}
+
+// MODULE: m2
+// FILE: b.kt
+
+package p
+
+public fun foo(a: Int) {}
+public fun foo(vararg values: Int) {}
+
+// MODULE: m3(m1, m2)
+// FILE: c.kt
+package m
+
+import p.foo
+
+fun main() {
+    foo(12)
+}
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/multimodule/varargConflict.txt b/compiler/testData/diagnostics/tests/multimodule/varargConflict.txt
new file mode 100644
index 00000000000..148397c48a3
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/multimodule/varargConflict.txt
@@ -0,0 +1,33 @@
+// -- Module: <m1> --
+package
+
+package p {
+    public fun foo(/*0*/ a: kotlin.Int): kotlin.Unit
+    public fun foo(/*0*/ vararg values: kotlin.Int /*kotlin.IntArray*/): kotlin.Unit
+}
+
+
+// -- Module: <m2> --
+package
+
+package p {
+    public fun foo(/*0*/ a: kotlin.Int): kotlin.Unit
+    public fun foo(/*0*/ vararg values: kotlin.Int /*kotlin.IntArray*/): kotlin.Unit
+}
+
+
+// -- Module: <m3> --
+package
+
+package m {
+    internal fun main(): kotlin.Unit
+}
+
+package p {
+    public fun foo(/*0*/ a: kotlin.Int): kotlin.Unit
+    public fun foo(/*0*/ a: kotlin.Int): kotlin.Unit
+    public fun foo(/*0*/ vararg values: kotlin.Int /*kotlin.IntArray*/): kotlin.Unit
+    public fun foo(/*0*/ vararg values: kotlin.Int /*kotlin.IntArray*/): kotlin.Unit
+}
+
+
diff --git a/compiler/testData/diagnostics/tests/namedArguments/allowForJavaAnnotation.txt b/compiler/testData/diagnostics/tests/namedArguments/allowForJavaAnnotation.txt
index a732ee60232..ef1414b9a56 100644
--- a/compiler/testData/diagnostics/tests/namedArguments/allowForJavaAnnotation.txt
+++ b/compiler/testData/diagnostics/tests/namedArguments/allowForJavaAnnotation.txt
@@ -1,8 +1,8 @@
 package
 
-A(x = IntegerValueType(1), y = "2") internal fun test(): kotlin.Unit
+A(x = 1, y = "2") internal fun test(): kotlin.Unit
 
-public final annotation class A : kotlin.Annotation {
+public final class A : kotlin.Annotation {
     public constructor A(/*0*/ x: kotlin.Int, /*1*/ y: kotlin.String)
     public final val x: kotlin.Int
     public final val y: kotlin.String
diff --git a/compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/kt1270.kt b/compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/kt1270.kt
index 3b0a1227122..7f56511c759 100644
--- a/compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/kt1270.kt
+++ b/compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/kt1270.kt
@@ -5,7 +5,7 @@ package kt1270
 
 fun foo() {
     val sc = java.util.HashMap<String, SomeClass>()[""]
-    val value = sc.value
+    val value = sc<!UNSAFE_CALL!>.<!>value
 }
 
 private class SomeClass() {
diff --git a/compiler/testData/diagnostics/tests/numbers/numbersInSimpleConstraints.kt b/compiler/testData/diagnostics/tests/numbers/numbersInSimpleConstraints.kt
index a80068ed652..7831173206c 100644
--- a/compiler/testData/diagnostics/tests/numbers/numbersInSimpleConstraints.kt
+++ b/compiler/testData/diagnostics/tests/numbers/numbersInSimpleConstraints.kt
@@ -28,7 +28,7 @@ fun test() {
 
     other(<!CONSTANT_EXPECTED_TYPE_MISMATCH!>11<!>)
 
-    <!TYPE_INFERENCE_TYPE_CONSTRUCTOR_MISMATCH!>otherGeneric<!>(<!CONSTANT_EXPECTED_TYPE_MISMATCH!>1<!>)
+    <!TYPE_INFERENCE_PARAMETER_CONSTRAINT_ERROR!>otherGeneric<!>(<!CONSTANT_EXPECTED_TYPE_MISMATCH!>1<!>)
 
     val r = either(1, "")
     r checkType { _<Comparable<*>>() }
diff --git a/compiler/testData/diagnostics/tests/operatorsOverloading/assignmentOperationsCheckReturnType.kt b/compiler/testData/diagnostics/tests/operatorsOverloading/assignmentOperationsCheckReturnType.kt
index 1f29d7de724..209820a1ced 100644
--- a/compiler/testData/diagnostics/tests/operatorsOverloading/assignmentOperationsCheckReturnType.kt
+++ b/compiler/testData/diagnostics/tests/operatorsOverloading/assignmentOperationsCheckReturnType.kt
@@ -1,12 +1,12 @@
 fun intBinEq() {
     var x = 0
-    x <!DEPRECATED_SYMBOL_WITH_MESSAGE!>+=<!> 'a'
+    x <!NONE_APPLICABLE!>+=<!> 'a'
     x += 1.toByte()
     x += 1.toShort()
     <!TYPE_MISMATCH!>x += 1L<!>
     <!TYPE_MISMATCH!>x += 1f<!>
     <!TYPE_MISMATCH!>x += 1.0<!>
-    x <!DEPRECATED_SYMBOL_WITH_MESSAGE!>*=<!> 'a'
+    x <!NONE_APPLICABLE!>*=<!> 'a'
     x *= 1.toByte()
     x *= 1.toShort()
     <!TYPE_MISMATCH!>x *= 1L<!>
@@ -16,14 +16,14 @@ fun intBinEq() {
 
 fun shortBinEq() {
     var x = 0.toShort()
-    <!TYPE_MISMATCH!>x <!DEPRECATED_SYMBOL_WITH_MESSAGE!>+=<!> 'a'<!>
+    x <!NONE_APPLICABLE!>+=<!> 'a'
     <!TYPE_MISMATCH!>x += 1.toByte()<!>
     <!TYPE_MISMATCH!>x += 1.toShort()<!>
     <!TYPE_MISMATCH!>x += 1L<!>
     <!TYPE_MISMATCH!>x += 1f<!>
     <!TYPE_MISMATCH!>x += 1.0<!>
 
-    <!TYPE_MISMATCH!>x <!DEPRECATED_SYMBOL_WITH_MESSAGE!>*=<!> 'a'<!>
+    x <!NONE_APPLICABLE!>*=<!> 'a'
     <!TYPE_MISMATCH!>x *= 1.toByte()<!>
     <!TYPE_MISMATCH!>x *= 1.toShort()<!>
     <!TYPE_MISMATCH!>x *= 1L<!>
diff --git a/compiler/testData/diagnostics/tests/platformTypes/inference.kt b/compiler/testData/diagnostics/tests/platformTypes/inference.kt
index a5fc0a7ff4d..f6818460b8b 100644
--- a/compiler/testData/diagnostics/tests/platformTypes/inference.kt
+++ b/compiler/testData/diagnostics/tests/platformTypes/inference.kt
@@ -16,11 +16,10 @@ public class HS<T> extends Base<T> {}
 
 import foo.*;
 
-import java.util.HashSet
 fun <T, C: Base<T>> convert(src: HS<T>, dest: C): C = throw Exception("$src $dest")
 
 fun test(l: HS<Int>) {
     //todo should be inferred
-    val r = <!TYPE_INFERENCE_UPPER_BOUND_VIOLATED!>convert<!>(l, <!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>HS<!>())
-    checkSubtype<Int>(<!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>r<!>)
+    val r = convert(l, HS())
+    r checkType { _<HS<Int>>() }
 }
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/platformTypes/methodCall/multipleExactBoundsNullable.kt b/compiler/testData/diagnostics/tests/platformTypes/methodCall/multipleExactBoundsNullable.kt
index 72cd6adfb41..60141117617 100644
--- a/compiler/testData/diagnostics/tests/platformTypes/methodCall/multipleExactBoundsNullable.kt
+++ b/compiler/testData/diagnostics/tests/platformTypes/methodCall/multipleExactBoundsNullable.kt
@@ -1,4 +1,16 @@
-import java.util.HashMap
+// FILE: MyMap.java
+
+import java.util.AbstractMap;
+import java.util.Set;
+
+class MyMap<K, V> extends AbstractMap<K, V> {
+    @Override
+    public Set<Entry<K, V>> entrySet() {
+        return null;
+    }
+}
+
+// FILE: main.kt
 
 interface ResolverForProject<M1> {
     val exposeM: M1 get() = null!!
@@ -13,8 +25,8 @@ interface WithFoo {
     fun foo()
 }
 
-fun <M2: WithFoo> foo(delegateResolver: ResolverForProject<M2?>): ResolverForProject<M2> {
-    val descriptorByModule = HashMap<M2, String>()
+fun <M2: WithFoo> foo(delegateResolver: ResolverForProject<M2?>): ResolverForProject<M2?> {
+    val descriptorByModule = MyMap<M2, String>()
     val result = ResolverForProjectImpl(descriptorByModule, delegateResolver)
     result.exposeM.foo() // M is not M2?
     result.exposeM?.foo() // no warning, M is not M2, hense M is M2!
@@ -22,5 +34,5 @@ fun <M2: WithFoo> foo(delegateResolver: ResolverForProject<M2?>): ResolverForPro
     return ResolverForProjectImpl(descriptorByModule, delegateResolver) // another bound check
 }
 
-// HashMap<M2, String> :< Map<M, String> => M = M2!
+// MyMap<M2, String> :< Map<M, String> => M = M2!
 // RFP<M2?> :< RFP<M> => M = M2?
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/platformTypes/methodCall/multipleExactBoundsNullable.txt b/compiler/testData/diagnostics/tests/platformTypes/methodCall/multipleExactBoundsNullable.txt
index dbc14f5d9b7..381ec125c74 100644
--- a/compiler/testData/diagnostics/tests/platformTypes/methodCall/multipleExactBoundsNullable.txt
+++ b/compiler/testData/diagnostics/tests/platformTypes/methodCall/multipleExactBoundsNullable.txt
@@ -1,6 +1,28 @@
 package
 
-internal fun </*0*/ M2 : WithFoo> foo(/*0*/ delegateResolver: ResolverForProject<M2?>): ResolverForProject<M2>
+internal fun </*0*/ M2 : WithFoo> foo(/*0*/ delegateResolver: ResolverForProject<M2?>): ResolverForProject<M2?>
+
+public/*package*/ open class MyMap</*0*/ K, /*1*/ V> : java.util.AbstractMap<K!, V!> {
+    public/*package*/ constructor MyMap</*0*/ K, /*1*/ V>()
+    invisible_fake final override /*1*/ /*fake_override*/ var keySet: kotlin.(Mutable)Set<K!>!
+    invisible_fake final override /*1*/ /*fake_override*/ var values: kotlin.(Mutable)Collection<V!>!
+    public open override /*1*/ /*fake_override*/ fun clear(): kotlin.Unit
+    protected/*protected and package*/ open override /*1*/ /*fake_override*/ fun clone(): kotlin.Any!
+    public open override /*1*/ /*fake_override*/ fun containsKey(/*0*/ key: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun containsValue(/*0*/ value: kotlin.Any?): kotlin.Boolean
+    java.lang.Override() public open override /*1*/ fun entrySet(): kotlin.MutableSet<kotlin.MutableMap.MutableEntry<K!, V!>>
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun get(/*0*/ key: kotlin.Any?): V?
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun isEmpty(): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun keySet(): kotlin.MutableSet<K!>
+    public open override /*1*/ /*fake_override*/ fun put(/*0*/ key: K!, /*1*/ value: V!): V?
+    public open override /*1*/ /*fake_override*/ fun putAll(/*0*/ m: kotlin.Map<out K!, V!>): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun remove(/*0*/ key: kotlin.Any?): V?
+    public open override /*1*/ /*fake_override*/ fun size(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    public open override /*1*/ /*fake_override*/ fun values(): kotlin.MutableCollection<V!>
+}
 
 internal interface ResolverForProject</*0*/ M1> {
     internal open val exposeM: M1
diff --git a/compiler/testData/diagnostics/tests/platformTypes/methodCall/singleton.kt b/compiler/testData/diagnostics/tests/platformTypes/methodCall/singleton.kt
index 6505d5bf312..d03b13d7efd 100644
--- a/compiler/testData/diagnostics/tests/platformTypes/methodCall/singleton.kt
+++ b/compiler/testData/diagnostics/tests/platformTypes/methodCall/singleton.kt
@@ -4,6 +4,6 @@ interface Foo
 
 fun test() {
     var nullable: Foo? = null
-    val foo: Collection<Foo> = <!TYPE_MISMATCH!>java.util.Collections.singleton(nullable)<!>
+    val foo: Collection<Foo> = java.util.Collections.<!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>singleton<!>(nullable)
     val foo1: Collection<Foo> = java.util.Collections.singleton(nullable!!)
 }
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/arithmetic.kt b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/arithmetic.kt
index 43aa5abd3d0..92006839405 100644
--- a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/arithmetic.kt
+++ b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/arithmetic.kt
@@ -1,5 +1,4 @@
-// FILE: p/J.java
-package p;
+// FILE: J.java
 
 import org.jetbrains.annotations.*;
 
@@ -13,8 +12,6 @@ public class J {
 
 // FILE: k.kt
 
-import p.*
-
 fun test() {
     // @NotNull platform type
     var platformNN = J.staticNN
@@ -24,35 +21,35 @@ fun test() {
     var platformJ = J.staticJ
 
     +platformNN
-    +<!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>platformN<!>
+    <!UNSAFE_CALL!>+<!>platformN
     +platformJ
 
     ++platformNN
-    ++<!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>platformN<!>
+    <!UNSAFE_CALL!>++<!>platformN
     ++platformJ
 
     platformNN++
-    <!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>platformN<!>++
+    platformN<!UNSAFE_CALL!>++<!>
     platformJ++
 
     1 + platformNN
-    1 + <!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>platformN<!>
+    1 <!NONE_APPLICABLE!>+<!> platformN
     1 + platformJ
 
     platformNN + 1
-    <!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>platformN<!> + 1
+    platformN <!UNSAFE_INFIX_CALL!>+<!> 1
     platformJ + 1
 
     1 plus platformNN
-    1 plus <!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>platformN<!>
+    1 <!NONE_APPLICABLE!>plus<!> platformN
     1 plus platformJ
 
     platformNN plus 1
-    <!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>platformN<!> plus 1
+    platformN <!UNSAFE_INFIX_CALL!>plus<!> 1
     platformJ plus 1
 
     platformNN += 1
-    <!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>platformN<!> += 1
+    platformN <!UNSAFE_INFIX_CALL!>+=<!> 1
     platformJ += 1
 }
 
diff --git a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/arithmetic.txt b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/arithmetic.txt
index b8def46715c..70ddc963fab 100644
--- a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/arithmetic.txt
+++ b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/arithmetic.txt
@@ -1,3 +1,15 @@
 package
 
 internal fun test(): kotlin.Unit
+
+public open class J {
+    public constructor J()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    // Static members
+    public final var staticJ: kotlin.Int!
+    org.jetbrains.annotations.Nullable() public final var staticN: kotlin.Int?
+    org.jetbrains.annotations.NotNull() public final var staticNN: kotlin.Int
+}
diff --git a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/array.kt b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/array.kt
index 2dce002aff8..acf93ae0567 100644
--- a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/array.kt
+++ b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/array.kt
@@ -1,5 +1,4 @@
-// FILE: p/J.java
-package p;
+// FILE: J.java
 
 import org.jetbrains.annotations.*;
 
@@ -13,8 +12,6 @@ public class J {
 
 // FILE: k.kt
 
-import p.*
-
 fun test() {
     // @NotNull platform type
     val platformNN = J.staticNN
@@ -24,11 +21,11 @@ fun test() {
     val platformJ = J.staticJ
 
     platformNN[0]
-    <!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>platformN<!>[0]
+    <!UNSAFE_CALL!>platformN[0]<!>
     platformJ[0]
 
     platformNN[0] = 1
-    <!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>platformN<!>[0]  = 1
+    <!UNSAFE_CALL!>platformN[0]<!>  = 1
     platformJ[0]  = 1
 }
 
diff --git a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/array.txt b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/array.txt
index b8def46715c..75a3de97607 100644
--- a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/array.txt
+++ b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/array.txt
@@ -1,3 +1,15 @@
 package
 
 internal fun test(): kotlin.Unit
+
+public open class J {
+    public constructor J()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    // Static members
+    public final var staticJ: kotlin.Array<(out) kotlin.Int!>!
+    org.jetbrains.annotations.Nullable() public final var staticN: kotlin.Array<(out) kotlin.Int!>?
+    org.jetbrains.annotations.NotNull() public final var staticNN: kotlin.Array<(out) kotlin.Int!>
+}
diff --git a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/assignToVar.kt b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/assignToVar.kt
index 600db661622..712431e8132 100644
--- a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/assignToVar.kt
+++ b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/assignToVar.kt
@@ -1,5 +1,4 @@
-// FILE: p/J.java
-package p;
+// FILE: J.java
 
 import org.jetbrains.annotations.*;
 
@@ -13,14 +12,12 @@ public class J {
 
 // FILE: k.kt
 
-import p.*
-
 var v: J = J()
 var n: J? = J()
 
 fun test() {
     v = J.staticNN
-    v = <!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>J.staticN<!>
+    v = <!TYPE_MISMATCH!>J.staticN<!>
     v = J.staticJ
 
     n = J.staticNN
diff --git a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/assignToVar.txt b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/assignToVar.txt
index b258b62a31a..1e4d0befe73 100644
--- a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/assignToVar.txt
+++ b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/assignToVar.txt
@@ -1,5 +1,17 @@
 package
 
-internal var n: p.J?
-internal var v: p.J
+internal var n: J?
+internal var v: J
 internal fun test(): kotlin.Unit
+
+public open class J {
+    public constructor J()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    // Static members
+    public final var staticJ: J!
+    org.jetbrains.annotations.Nullable() public final var staticN: J?
+    org.jetbrains.annotations.NotNull() public final var staticNN: J
+}
diff --git a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/conditions.kt b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/conditions.kt
index 4e875c499b7..4f322c6cd65 100644
--- a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/conditions.kt
+++ b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/conditions.kt
@@ -1,6 +1,5 @@
 // !DIAGNOSTICS: -UNUSED_EXPRESSION
-// FILE: p/J.java
-package p;
+// FILE: J.java
 
 import org.jetbrains.annotations.*;
 
@@ -14,8 +13,6 @@ public class J {
 
 // FILE: k.kt
 
-import p.*
-
 fun test() {
     // @NotNull platform type
     val platformNN = J.staticNN
@@ -25,26 +22,26 @@ fun test() {
     val platformJ = J.staticJ
 
     if (platformNN) {}
-    if (<!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>platformN<!>) {}
+    if (<!TYPE_MISMATCH, TYPE_MISMATCH_IN_CONDITION!>platformN<!>) {}
     if (platformJ) {}
 
     while (platformNN) {}
-    while (<!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>platformN<!>) {}
+    while (<!TYPE_MISMATCH, TYPE_MISMATCH_IN_CONDITION!>platformN<!>) {}
     while (platformJ) {}
 
     do {} while (platformNN)
-    do {} while (<!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>platformN<!>)
+    do {} while (<!TYPE_MISMATCH, TYPE_MISMATCH_IN_CONDITION!>platformN<!>)
     do {} while (platformJ)
 
     platformNN && false
-    <!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>platformN<!> && false
+    <!TYPE_MISMATCH!>platformN<!> && false
     platformJ && false
 
     platformNN || false
-    <!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>platformN<!> || false
+    <!TYPE_MISMATCH!>platformN<!> || false
     platformJ || false
 
     !platformNN
-    !<!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>platformN<!>
+    <!UNSAFE_CALL!>!<!>platformN
     !platformJ
 }
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/conditions.txt b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/conditions.txt
index b8def46715c..3febba97fa0 100644
--- a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/conditions.txt
+++ b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/conditions.txt
@@ -1,3 +1,15 @@
 package
 
 internal fun test(): kotlin.Unit
+
+public open class J {
+    public constructor J()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    // Static members
+    public final var staticJ: kotlin.Boolean!
+    org.jetbrains.annotations.Nullable() public final var staticN: kotlin.Boolean?
+    org.jetbrains.annotations.NotNull() public final var staticNN: kotlin.Boolean
+}
diff --git a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/dataFlowInfo.kt b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/dataFlowInfo.kt
index eb1fd9521cd..bb8ff0a9c87 100644
--- a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/dataFlowInfo.kt
+++ b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/dataFlowInfo.kt
@@ -1,6 +1,5 @@
 // !DIAGNOSTICS: -UNUSED_PARAMETER
-// FILE: p/J.java
-package p;
+// FILE: J.java
 
 import org.jetbrains.annotations.*;
 
@@ -13,21 +12,19 @@ public class J {
 
 // FILE: k.kt
 
-import p.*
-
 fun test() {
     val n = J.staticN
-    foo(<!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>n<!>)
-    J.staticNN = <!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>n<!>
+    foo(<!TYPE_MISMATCH!>n<!>)
+    J.staticNN = <!TYPE_MISMATCH!>n<!>
     if (n != null) {
-        foo(n)
-        J.staticNN = n
+        foo(<!DEBUG_INFO_SMARTCAST!>n<!>)
+        J.staticNN = <!DEBUG_INFO_SMARTCAST!>n<!>
     }
 
     val x: J? = null
-    J.staticNN = <!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>x<!>
+    J.staticNN = <!TYPE_MISMATCH!>x<!>
     if (x != null) {
-        J.staticNN = x
+        J.staticNN = <!DEBUG_INFO_SMARTCAST!>x<!>
     }
 }
 
diff --git a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/dataFlowInfo.txt b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/dataFlowInfo.txt
index 7719efbbb09..62c2956663a 100644
--- a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/dataFlowInfo.txt
+++ b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/dataFlowInfo.txt
@@ -1,4 +1,15 @@
 package
 
-internal fun foo(/*0*/ j: p.J): kotlin.Unit
+internal fun foo(/*0*/ j: J): kotlin.Unit
 internal fun test(): kotlin.Unit
+
+public open class J {
+    public constructor J()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    // Static members
+    org.jetbrains.annotations.Nullable() public final var staticN: J?
+    org.jetbrains.annotations.NotNull() public final var staticNN: J
+}
diff --git a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/defaultParameters.kt b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/defaultParameters.kt
index b9cbbe9a057..4c6d2fc62aa 100644
--- a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/defaultParameters.kt
+++ b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/defaultParameters.kt
@@ -1,6 +1,5 @@
 // !DIAGNOSTICS: -UNUSED_PARAMETER
-// FILE: p/J.java
-package p;
+// FILE: J.java
 
 import org.jetbrains.annotations.*;
 
@@ -14,8 +13,6 @@ public class J {
 
 // FILE: k.kt
 
-import p.*
-
 fun test() {
     // @NotNull platform type
     val platformNN = J.staticNN
@@ -24,7 +21,7 @@ fun test() {
     // platform type with no annotation
     val platformJ = J.staticJ
 
-    fun foo(p: J = platformNN, p1: J = <!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>platformN<!>, p2: J = platformJ) {}
+    fun foo(p: J = platformNN, p1: J = <!TYPE_MISMATCH!>platformN<!>, p2: J = platformJ) {}
 
     fun foo1(p: J? = platformNN, p1: J? = platformN, p2: J? = platformJ) {}
 }
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/defaultParameters.txt b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/defaultParameters.txt
index b8def46715c..337b583c502 100644
--- a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/defaultParameters.txt
+++ b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/defaultParameters.txt
@@ -1,3 +1,15 @@
 package
 
 internal fun test(): kotlin.Unit
+
+public open class J {
+    public constructor J()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    // Static members
+    public final var staticJ: J!
+    org.jetbrains.annotations.Nullable() public final var staticN: J?
+    org.jetbrains.annotations.NotNull() public final var staticNN: J
+}
diff --git a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/delegatedProperties.kt b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/delegatedProperties.kt
index 19bf516c533..129ee20826e 100644
--- a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/delegatedProperties.kt
+++ b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/delegatedProperties.kt
@@ -1,5 +1,4 @@
-// FILE: p/J.java
-package p;
+// FILE: J.java
 
 import org.jetbrains.annotations.*;
 
@@ -19,8 +18,6 @@ public class J {
 
 // FILE: k.kt
 
-import p.*
-
 var A by J.staticNN
-var B by <!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS, NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>J.staticN<!>
+var B by <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE, DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE!>J.staticN<!>
 var C by J.staticJ
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/delegatedProperties.txt b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/delegatedProperties.txt
index be11c83820c..8861f67a667 100644
--- a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/delegatedProperties.txt
+++ b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/delegatedProperties.txt
@@ -1,5 +1,25 @@
 package
 
 internal var A: kotlin.String!
-internal var B: kotlin.String!
+internal var B: [ERROR : Type from delegate]
 internal var C: kotlin.String!
+
+public open class J {
+    public constructor J()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    public interface DP {
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public abstract fun get(/*0*/ a: kotlin.Any!, /*1*/ b: kotlin.Any!): kotlin.String!
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public abstract fun set(/*0*/ a: kotlin.Any!, /*1*/ b: kotlin.Any!, /*2*/ c: kotlin.Any!): kotlin.String!
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    // Static members
+    public final var staticJ: J.DP!
+    org.jetbrains.annotations.Nullable() public final var staticN: J.DP?
+    org.jetbrains.annotations.NotNull() public final var staticNN: J.DP
+}
diff --git a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/delegation.kt b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/delegation.kt
index 38f22824d4b..5970a02c277 100644
--- a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/delegation.kt
+++ b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/delegation.kt
@@ -1,5 +1,4 @@
-// FILE: p/J.java
-package p;
+// FILE: J.java
 
 import org.jetbrains.annotations.*;
 import java.util.*;
@@ -14,8 +13,6 @@ public class J {
 
 // FILE: k.kt
 
-import p.*
-
 class A : List<String> by J.staticNN
-class B : List<String> by <!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>J.staticN<!>
+class B : List<String> by <!TYPE_MISMATCH!>J.staticN<!>
 class C : List<String> by J.staticJ
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/delegation.txt b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/delegation.txt
index 8088400d541..113e6c04242 100644
--- a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/delegation.txt
+++ b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/delegation.txt
@@ -53,3 +53,15 @@ internal final class C : kotlin.List<kotlin.String> {
     public open override /*1*/ /*delegation*/ fun subList(/*0*/ fromIndex: kotlin.Int, /*1*/ toIndex: kotlin.Int): kotlin.List<kotlin.String>
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
 }
+
+public open class J {
+    public constructor J()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    // Static members
+    public final var staticJ: kotlin.(Mutable)List<kotlin.String!>!
+    org.jetbrains.annotations.Nullable() public final var staticN: kotlin.(Mutable)List<kotlin.String!>?
+    org.jetbrains.annotations.NotNull() public final var staticNN: kotlin.(Mutable)List<kotlin.String!>
+}
diff --git a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/derefenceExtension.kt b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/derefenceExtension.kt
index 0c61dbac4c3..03812dbf1ba 100644
--- a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/derefenceExtension.kt
+++ b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/derefenceExtension.kt
@@ -1,7 +1,6 @@
 // !DIAGNOSTICS: -UNUSED_PARAMETER
 
-// FILE: p/J.java
-package p;
+// FILE: J.java
 
 import org.jetbrains.annotations.*;
 
@@ -15,8 +14,6 @@ public class J {
 
 // FILE: k.kt
 
-import p.*
-
 fun test() {
     // @NotNull platform type
     val platformNN = J.staticNN
@@ -26,14 +23,14 @@ fun test() {
     val platformJ = J.staticJ
 
     platformNN.foo()
-    <!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>platformN<!>.foo()
+    platformN<!UNSAFE_CALL!>.<!>foo()
     platformJ.foo()
 
     with(platformNN) {
         foo()
     }
     with(platformN) {
-        <!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>foo<!>()
+        <!UNSAFE_CALL!>foo<!>()
     }
     with(platformJ) {
         foo()
diff --git a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/derefenceExtension.txt b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/derefenceExtension.txt
index e909556b47c..9291b06c1bd 100644
--- a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/derefenceExtension.txt
+++ b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/derefenceExtension.txt
@@ -2,5 +2,17 @@ package
 
 internal fun test(): kotlin.Unit
 internal fun </*0*/ T> with(/*0*/ t: T, /*1*/ f: T.() -> kotlin.Unit): kotlin.Unit
-internal fun p.J?.bar(): kotlin.Unit
-internal fun p.J.foo(): kotlin.Unit
+internal fun J?.bar(): kotlin.Unit
+internal fun J.foo(): kotlin.Unit
+
+public open class J {
+    public constructor J()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    // Static members
+    public final var staticJ: J!
+    org.jetbrains.annotations.Nullable() public final var staticN: J?
+    org.jetbrains.annotations.NotNull() public final var staticNN: J
+}
diff --git a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/derefenceMember.kt b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/derefenceMember.kt
index 0ccc1a0b2fc..a62b4e4c2fb 100644
--- a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/derefenceMember.kt
+++ b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/derefenceMember.kt
@@ -1,7 +1,6 @@
 // !DIAGNOSTICS: -UNUSED_PARAMETER
 
-// FILE: p/J.java
-package p;
+// FILE: J.java
 
 import org.jetbrains.annotations.*;
 
@@ -17,8 +16,6 @@ public class J {
 
 // FILE: k.kt
 
-import p.*
-
 fun test() {
     // @NotNull platform type
     val platformNN = J.staticNN
@@ -28,14 +25,14 @@ fun test() {
     val platformJ = J.staticJ
 
     platformNN.foo()
-    <!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>platformN<!>.foo()
+    platformN<!UNSAFE_CALL!>.<!>foo()
     platformJ.foo()
 
     with(platformNN) {
         foo()
     }
     with(platformN) {
-        <!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>foo<!>()
+        <!UNSAFE_CALL!>foo<!>()
     }
     with(platformJ) {
         foo()
diff --git a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/derefenceMember.txt b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/derefenceMember.txt
index 7e19ffea500..5b7f1851a98 100644
--- a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/derefenceMember.txt
+++ b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/derefenceMember.txt
@@ -2,3 +2,16 @@ package
 
 internal fun test(): kotlin.Unit
 internal fun </*0*/ T> with(/*0*/ t: T, /*1*/ f: T.() -> kotlin.Unit): kotlin.Unit
+
+public open class J {
+    public constructor J()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open fun foo(): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    // Static members
+    public final var staticJ: J!
+    org.jetbrains.annotations.Nullable() public final var staticN: J?
+    org.jetbrains.annotations.NotNull() public final var staticNN: J
+}
diff --git a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/elvis.kt b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/elvis.kt
index 7ec695beb29..6dcd4b4aeaa 100644
--- a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/elvis.kt
+++ b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/elvis.kt
@@ -1,7 +1,6 @@
 // !DIAGNOSTICS: -UNUSED_VARIABLE -SENSELESS_COMPARISON
 
-// FILE: p/J.java
-package p;
+// FILE: J.java
 
 import org.jetbrains.annotations.*;
 
@@ -15,8 +14,6 @@ public class J {
 
 // FILE: k.kt
 
-import p.*
-
 fun test() {
     // @NotNull platform type
     val platformNN = J.staticNN
diff --git a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/elvis.txt b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/elvis.txt
index b8def46715c..337b583c502 100644
--- a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/elvis.txt
+++ b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/elvis.txt
@@ -1,3 +1,15 @@
 package
 
 internal fun test(): kotlin.Unit
+
+public open class J {
+    public constructor J()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    // Static members
+    public final var staticJ: J!
+    org.jetbrains.annotations.Nullable() public final var staticN: J?
+    org.jetbrains.annotations.NotNull() public final var staticNN: J
+}
diff --git a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/expectedType.kt b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/expectedType.kt
index 0cdc5c96fce..9879205a921 100644
--- a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/expectedType.kt
+++ b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/expectedType.kt
@@ -1,7 +1,6 @@
 // !CHECK_TYPE
 
-// FILE: p/J.java
-package p;
+// FILE: J.java
 
 import org.jetbrains.annotations.*;
 
@@ -15,8 +14,6 @@ public class J {
 
 // FILE: k.kt
 
-import p.*
-
 fun test() {
     // @NotNull platform type
     val platformNN = J.staticNN
@@ -26,7 +23,7 @@ fun test() {
     val platformJ = J.staticJ
 
     checkSubtype<J>(platformNN)
-    checkSubtype<J>(<!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>platformN<!>)
+    checkSubtype<J>(<!TYPE_MISMATCH!>platformN<!>)
     checkSubtype<J>(platformJ)
 
     checkSubtype<J?>(platformNN)
diff --git a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/expectedType.txt b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/expectedType.txt
index b8def46715c..337b583c502 100644
--- a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/expectedType.txt
+++ b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/expectedType.txt
@@ -1,3 +1,15 @@
 package
 
 internal fun test(): kotlin.Unit
+
+public open class J {
+    public constructor J()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    // Static members
+    public final var staticJ: J!
+    org.jetbrains.annotations.Nullable() public final var staticN: J?
+    org.jetbrains.annotations.NotNull() public final var staticNN: J
+}
diff --git a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/for.kt b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/for.kt
index bb5589537e6..4dad6907875 100644
--- a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/for.kt
+++ b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/for.kt
@@ -1,5 +1,4 @@
-// FILE: p/J.java
-package p;
+// FILE: J.java
 
 import org.jetbrains.annotations.*;
 import java.util.*;
@@ -14,8 +13,6 @@ public class J {
 
 // FILE: k.kt
 
-import p.*
-
 fun test() {
     // @NotNull platform type
     val platformNN = J.staticNN
@@ -25,7 +22,7 @@ fun test() {
     val platformJ = J.staticJ
 
     for (x in platformNN) {}
-    for (x in <!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>platformN<!>) {}
+    for (x in <!ITERATOR_MISSING!>platformN<!>) {}
     for (x in platformJ) {}
 }
 
diff --git a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/for.txt b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/for.txt
index b8def46715c..fa7da09107d 100644
--- a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/for.txt
+++ b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/for.txt
@@ -1,3 +1,15 @@
 package
 
 internal fun test(): kotlin.Unit
+
+public open class J {
+    public constructor J()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    // Static members
+    public final var staticJ: kotlin.(Mutable)List<kotlin.String!>!
+    org.jetbrains.annotations.Nullable() public final var staticN: kotlin.(Mutable)List<kotlin.String!>?
+    org.jetbrains.annotations.NotNull() public final var staticNN: kotlin.(Mutable)List<kotlin.String!>
+}
diff --git a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/functionArguments.kt b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/functionArguments.kt
index dcca95d883d..824731bebdb 100644
--- a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/functionArguments.kt
+++ b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/functionArguments.kt
@@ -1,6 +1,5 @@
 // !DIAGNOSTICS: -UNUSED_PARAMETER
-// FILE: p/J.java
-package p;
+// FILE: J.java
 
 import org.jetbrains.annotations.*;
 
@@ -14,11 +13,9 @@ public class J {
 
 // FILE: k.kt
 
-import p.*
-
 fun test() {
     foo(J.staticNN)
-    foo(<!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>J.staticN<!>)
+    foo(<!TYPE_MISMATCH!>J.staticN<!>)
     foo(J.staticJ)
 
     bar(J.staticNN)
diff --git a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/functionArguments.txt b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/functionArguments.txt
index febe9fdde72..594f4dd052f 100644
--- a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/functionArguments.txt
+++ b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/functionArguments.txt
@@ -1,5 +1,17 @@
 package
 
-internal fun bar(/*0*/ j: p.J?): kotlin.Unit
-internal fun foo(/*0*/ j: p.J): kotlin.Unit
+internal fun bar(/*0*/ j: J?): kotlin.Unit
+internal fun foo(/*0*/ j: J): kotlin.Unit
 internal fun test(): kotlin.Unit
+
+public open class J {
+    public constructor J()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    // Static members
+    public final var staticJ: J!
+    org.jetbrains.annotations.Nullable() public final var staticN: J?
+    org.jetbrains.annotations.NotNull() public final var staticNN: J
+}
diff --git a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/inferenceInConditionals.kt b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/inferenceInConditionals.kt
index 2028b23d1f4..a35af95498a 100644
--- a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/inferenceInConditionals.kt
+++ b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/inferenceInConditionals.kt
@@ -1,6 +1,4 @@
-// FILE: p/J.java
-
-package p;
+// FILE: J.java
 
 import org.jetbrains.annotations.*;
 import java.util.*;
@@ -15,8 +13,6 @@ public class J {
 
 // FILE: k.kt
 
-import p.*
-
 fun safeCall(c: J?) {
   c?.nn()?.length()
 }
diff --git a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/inferenceInConditionals.txt b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/inferenceInConditionals.txt
index 3cd68f13413..0e614823af9 100644
--- a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/inferenceInConditionals.txt
+++ b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/inferenceInConditionals.txt
@@ -1,5 +1,14 @@
 package
 
-internal fun elvis(/*0*/ c: p.J): kotlin.Any?
-internal fun ifelse(/*0*/ c: p.J): kotlin.Any?
-internal fun safeCall(/*0*/ c: p.J?): kotlin.Unit
+internal fun elvis(/*0*/ c: J): kotlin.Any?
+internal fun ifelse(/*0*/ c: J): kotlin.Any?
+internal fun safeCall(/*0*/ c: J?): kotlin.Unit
+
+public open class J {
+    public constructor J()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    org.jetbrains.annotations.Nullable() public open fun n(): kotlin.(Mutable)List<kotlin.String!>?
+    org.jetbrains.annotations.NotNull() public open fun nn(): kotlin.String
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
diff --git a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/invoke.kt b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/invoke.kt
index d7fdcac56eb..951251b949f 100644
--- a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/invoke.kt
+++ b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/invoke.kt
@@ -1,5 +1,4 @@
-// FILE: p/J.java
-package p;
+// FILE: J.java
 
 import org.jetbrains.annotations.*;
 
@@ -17,11 +16,9 @@ public class J {
 
 // FILE: k.kt
 
-import p.*
-
 fun test() {
     J.staticNN()
-    J.<!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>staticN<!>()
+    J.<!UNSAFE_CALL!>staticN<!>()
     J.staticJ()
 }
 
diff --git a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/invoke.txt b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/invoke.txt
index b8def46715c..2c0af6f063f 100644
--- a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/invoke.txt
+++ b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/invoke.txt
@@ -1,3 +1,23 @@
 package
 
 internal fun test(): kotlin.Unit
+
+public open class J {
+    public constructor J()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    public interface Invoke {
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public abstract fun invoke(): kotlin.Unit
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    // Static members
+    public final var staticJ: J.Invoke!
+    org.jetbrains.annotations.Nullable() public final var staticN: J.Invoke?
+    org.jetbrains.annotations.NotNull() public final var staticNN: J.Invoke
+    public final /*synthesized*/ fun Invoke(/*0*/ function: () -> kotlin.Unit): J.Invoke
+}
diff --git a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/kt6829.kt b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/kt6829.kt
index 21129c3c083..04c35b7a7ba 100644
--- a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/kt6829.kt
+++ b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/kt6829.kt
@@ -2,8 +2,7 @@
 
 // KT-6829 False warning on map to @Nullable
 
-// FILE: p/J.java
-package p;
+// FILE: J.java
 
 import org.jetbrains.annotations.*;
 
@@ -15,11 +14,9 @@ public class J {
 
 // FILE: k.kt
 
-import p.*
-
 fun foo(collection: Collection<J>) {
     val mapped = collection.map { it.method() }
-    <!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>mapped[0]<!>.length()
+    mapped[0]<!UNSAFE_CALL!>.<!>length()
 }
 
 public fun <T, R> Iterable<T>.map(transform: (T) -> R): List<R> {
diff --git a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/kt6829.txt b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/kt6829.txt
index 066df5f85b8..4498b5ea58e 100644
--- a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/kt6829.txt
+++ b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/kt6829.txt
@@ -1,4 +1,12 @@
 package
 
-internal fun foo(/*0*/ collection: kotlin.Collection<p.J>): kotlin.Unit
+internal fun foo(/*0*/ collection: kotlin.Collection<J>): kotlin.Unit
 public fun </*0*/ T, /*1*/ R> kotlin.Iterable<T>.map(/*0*/ transform: (T) -> R): kotlin.List<R>
+
+public open class J {
+    public constructor J()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    org.jetbrains.annotations.Nullable() public open fun method(): kotlin.String?
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
diff --git a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/multiDeclaration.kt b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/multiDeclaration.kt
index c7ddde2a2b6..996ce6fc410 100644
--- a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/multiDeclaration.kt
+++ b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/multiDeclaration.kt
@@ -1,6 +1,5 @@
 // !DIAGNOSTICS: -UNUSED_VARIABLE
-// FILE: p/J.java
-package p;
+// FILE: J.java
 
 import org.jetbrains.annotations.*;
 
@@ -19,8 +18,6 @@ public class J {
 
 // FILE: k.kt
 
-import p.*
-
 fun test() {
     // @NotNull platform type
     val platformNN = J.staticNN
@@ -30,7 +27,7 @@ fun test() {
     val platformJ = J.staticJ
 
     val (a1, b1) = platformNN
-    val (a2, b2) = <!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS, NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>platformN<!>
+    val (a2, b2) = <!COMPONENT_FUNCTION_MISSING, COMPONENT_FUNCTION_MISSING!>platformN<!>
     val (a3, b3) = platformJ
 }
 
diff --git a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/multiDeclaration.txt b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/multiDeclaration.txt
index b8def46715c..5c7644e6642 100644
--- a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/multiDeclaration.txt
+++ b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/multiDeclaration.txt
@@ -1,3 +1,23 @@
 package
 
 internal fun test(): kotlin.Unit
+
+public open class J {
+    public constructor J()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    public interface Multi {
+        public abstract fun component1(): kotlin.String!
+        public abstract fun component2(): kotlin.String!
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    // Static members
+    public final var staticJ: J.Multi!
+    org.jetbrains.annotations.Nullable() public final var staticN: J.Multi?
+    org.jetbrains.annotations.NotNull() public final var staticNN: J.Multi
+}
diff --git a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/notNullAfterSafeCall.kt b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/notNullAfterSafeCall.kt
index 47bd945635a..420dc45a990 100644
--- a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/notNullAfterSafeCall.kt
+++ b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/notNullAfterSafeCall.kt
@@ -1,6 +1,4 @@
-// FILE: p/J.java
-
-package p;
+// FILE: J.java
 
 import org.jetbrains.annotations.*;
 
@@ -10,8 +8,6 @@ public class J {
 
 // FILE: k.kt
 
-import p.J
-
 fun test(j: J?) {
     val s = j?.nn()
     if (s != null) {
diff --git a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/notNullAfterSafeCall.txt b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/notNullAfterSafeCall.txt
index 4811fa11f1a..ecb6bc198c1 100644
--- a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/notNullAfterSafeCall.txt
+++ b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/notNullAfterSafeCall.txt
@@ -1,3 +1,11 @@
 package
 
-internal fun test(/*0*/ j: p.J?): kotlin.Unit
+internal fun test(/*0*/ j: J?): kotlin.Unit
+
+public open class J {
+    public constructor J()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    org.jetbrains.annotations.NotNull() public open fun nn(): kotlin.String
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
diff --git a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/notNullAssertion.kt b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/notNullAssertion.kt
index 8d882af3213..75a31645695 100644
--- a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/notNullAssertion.kt
+++ b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/notNullAssertion.kt
@@ -1,7 +1,6 @@
 // !DIAGNOSTICS: -UNUSED_EXPRESSION -SENSELESS_COMPARISON -UNUSED_PARAMETER
 
-// FILE: p/J.java
-package p;
+// FILE: J.java
 
 import org.jetbrains.annotations.*;
 
@@ -15,8 +14,6 @@ public class J {
 
 // FILE: k.kt
 
-import p.*
-
 fun test() {
     // @NotNull platform type
     val platformNN = J.staticNN
diff --git a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/notNullAssertion.txt b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/notNullAssertion.txt
index b8def46715c..337b583c502 100644
--- a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/notNullAssertion.txt
+++ b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/notNullAssertion.txt
@@ -1,3 +1,15 @@
 package
 
 internal fun test(): kotlin.Unit
+
+public open class J {
+    public constructor J()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    // Static members
+    public final var staticJ: J!
+    org.jetbrains.annotations.Nullable() public final var staticN: J?
+    org.jetbrains.annotations.NotNull() public final var staticNN: J
+}
diff --git a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/notNullAssertionInCall.kt b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/notNullAssertionInCall.kt
index 42d5c782d80..7c4f02a8cd2 100644
--- a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/notNullAssertionInCall.kt
+++ b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/notNullAssertionInCall.kt
@@ -1,7 +1,6 @@
 // !DIAGNOSTICS: -UNUSED_PARAMETER
 
-// FILE: p/J.java
-package p;
+// FILE: J.java
 
 import org.jetbrains.annotations.*;
 
@@ -12,8 +11,6 @@ public class J {
 
 // FILE: k.kt
 
-import p.*
-
 fun test() {
     // @NotNull platform type
     val platformNN = J.staticNN
diff --git a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/notNullAssertionInCall.txt b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/notNullAssertionInCall.txt
index 79f259ce9cb..344c25b69e4 100644
--- a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/notNullAssertionInCall.txt
+++ b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/notNullAssertionInCall.txt
@@ -10,3 +10,13 @@ internal final class Bar {
     internal final fun invoke(/*0*/ a: kotlin.Any): kotlin.Unit
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
 }
+
+public open class J {
+    public constructor J()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    // Static members
+    org.jetbrains.annotations.NotNull() public final var staticNN: J
+}
diff --git a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/notNullTypeMarkedWithNullableAnnotation.kt b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/notNullTypeMarkedWithNullableAnnotation.kt
index 2c396a46367..40515b7c858 100644
--- a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/notNullTypeMarkedWithNullableAnnotation.kt
+++ b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/notNullTypeMarkedWithNullableAnnotation.kt
@@ -1,6 +1,4 @@
-// FILE: p/J.java
-
-package p;
+// FILE: J.java
 
 import org.jetbrains.annotations.*;
 import java.util.*;
@@ -12,8 +10,6 @@ public class J {
 
 // FILE: k.kt
 
-import p.*
-
 fun list(j: J): Any {
     val a = j.n()!!
 
diff --git a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/notNullTypeMarkedWithNullableAnnotation.txt b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/notNullTypeMarkedWithNullableAnnotation.txt
index 8059f2c7f76..f362d5abae8 100644
--- a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/notNullTypeMarkedWithNullableAnnotation.txt
+++ b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/notNullTypeMarkedWithNullableAnnotation.txt
@@ -1,3 +1,11 @@
 package
 
-internal fun list(/*0*/ j: p.J): kotlin.Any
+internal fun list(/*0*/ j: J): kotlin.Any
+
+public open class J {
+    public constructor J()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    org.jetbrains.annotations.Nullable() public open fun n(): kotlin.(Mutable)List<kotlin.String!>?
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
diff --git a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/passToJava.kt b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/passToJava.kt
index 89f3a61f6f2..95aa5173dce 100644
--- a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/passToJava.kt
+++ b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/passToJava.kt
@@ -1,5 +1,4 @@
-// FILE: p/J.java
-package p;
+// FILE: J.java
 
 import org.jetbrains.annotations.*;
 
@@ -26,8 +25,6 @@ public class J {
 
 // FILE: k.kt
 
-import p.*
-
 fun test(n: J?, nn: J) {
     // @NotNull platform type
     val platformNN = J.staticNN
@@ -36,8 +33,8 @@ fun test(n: J?, nn: J) {
     // platform type with no annotation
     val platformJ = J.staticJ
 
-    J.staticNN = <!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>n<!>
-    J.staticNN = <!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>platformN<!>
+    J.staticNN = <!TYPE_MISMATCH!>n<!>
+    J.staticNN = <!TYPE_MISMATCH!>platformN<!>
     J.staticNN = nn
     J.staticNN = platformNN
     J.staticNN = platformJ
@@ -56,12 +53,12 @@ fun test(n: J?, nn: J) {
 
     J.staticSet(nn, nn, nn)
     J.staticSet(platformNN, platformNN, platformNN)
-    J.staticSet(<!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>n<!>, n, n)
-    J.staticSet(<!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>platformN<!>, platformN, platformN)
+    J.staticSet(<!TYPE_MISMATCH!>n<!>, n, n)
+    J.staticSet(<!TYPE_MISMATCH!>platformN<!>, platformN, platformN)
     J.staticSet(platformJ, platformJ, platformJ)
 
-    J().nn = <!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>n<!>
-    J().nn = <!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>platformN<!>
+    J().nn = <!TYPE_MISMATCH!>n<!>
+    J().nn = <!TYPE_MISMATCH!>platformN<!>
     J().nn = nn
     J().nn = platformNN
     J().nn = platformJ
@@ -80,13 +77,13 @@ fun test(n: J?, nn: J) {
 
     J().set(nn, nn, nn)
     J().set(platformNN, platformNN, platformNN)
-    J().set(<!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>n<!>, n, n)
-    J().set(<!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>platformN<!>, platformN, platformN)
+    J().set(<!TYPE_MISMATCH!>n<!>, n, n)
+    J().set(<!TYPE_MISMATCH!>platformN<!>, platformN, platformN)
     J().set(platformJ, platformJ, platformJ)
 
     J(nn, nn, nn)
     J(platformNN, platformNN, platformNN)
-    J(<!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>n<!>, n, n)
-    J(<!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>platformN<!>, platformN, platformN)
+    <!NONE_APPLICABLE!>J<!>(n, n, n)
+    <!NONE_APPLICABLE!>J<!>(platformN, platformN, platformN)
     J(platformJ, platformJ, platformJ)
 }
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/passToJava.txt b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/passToJava.txt
index 468c30694dc..1167bc6af33 100644
--- a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/passToJava.txt
+++ b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/passToJava.txt
@@ -1,3 +1,21 @@
 package
 
-internal fun test(/*0*/ n: p.J?, /*1*/ nn: p.J): kotlin.Unit
+internal fun test(/*0*/ n: J?, /*1*/ nn: J): kotlin.Unit
+
+public open class J {
+    public constructor J()
+    public constructor J(/*0*/ org.jetbrains.annotations.NotNull() nn: J, /*1*/ org.jetbrains.annotations.Nullable() n: J?, /*2*/ j: J!)
+    public final var j: J!
+    org.jetbrains.annotations.Nullable() public final var n: J?
+    org.jetbrains.annotations.NotNull() public final var nn: J
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open fun set(/*0*/ org.jetbrains.annotations.NotNull() nn: J, /*1*/ org.jetbrains.annotations.Nullable() n: J?, /*2*/ j: J!): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    // Static members
+    public final var staticJ: J!
+    org.jetbrains.annotations.Nullable() public final var staticN: J?
+    org.jetbrains.annotations.NotNull() public final var staticNN: J
+    public open fun staticSet(/*0*/ org.jetbrains.annotations.NotNull() nn: J, /*1*/ org.jetbrains.annotations.Nullable() n: J?, /*2*/ j: J!): kotlin.Unit
+}
diff --git a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/primitiveArray.kt b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/primitiveArray.kt
index 84a3c69f789..63d41a2ccb6 100644
--- a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/primitiveArray.kt
+++ b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/primitiveArray.kt
@@ -1,5 +1,4 @@
-// FILE: p/J.java
-package p;
+// FILE: J.java
 
 import org.jetbrains.annotations.*;
 
@@ -13,8 +12,6 @@ public class J {
 
 // FILE: k.kt
 
-import p.*
-
 fun test() {
     // @NotNull platform type
     val platformNN = J.staticNN
@@ -24,11 +21,11 @@ fun test() {
     val platformJ = J.staticJ
 
     platformNN[0]
-    <!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>platformN<!>[0]
+    <!UNSAFE_CALL!>platformN[0]<!>
     platformJ[0]
 
     platformNN[0] = 1
-    <!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>platformN<!>[0]  = 1
+    <!UNSAFE_CALL!>platformN[0]<!>  = 1
     platformJ[0]  = 1
 }
 
diff --git a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/primitiveArray.txt b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/primitiveArray.txt
index b8def46715c..549e6a94cdc 100644
--- a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/primitiveArray.txt
+++ b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/primitiveArray.txt
@@ -1,3 +1,15 @@
 package
 
 internal fun test(): kotlin.Unit
+
+public open class J {
+    public constructor J()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    // Static members
+    public final var staticJ: kotlin.IntArray!
+    org.jetbrains.annotations.Nullable() public final var staticN: kotlin.IntArray?
+    org.jetbrains.annotations.NotNull() public final var staticNN: kotlin.IntArray
+}
diff --git a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/safeCall.kt b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/safeCall.kt
index 9c20b759ae9..0e3cb21c2fe 100644
--- a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/safeCall.kt
+++ b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/safeCall.kt
@@ -1,7 +1,6 @@
 // !DIAGNOSTICS: -SENSELESS_COMPARISON
 
-// FILE: p/J.java
-package p;
+// FILE: J.java
 
 import org.jetbrains.annotations.*;
 
@@ -17,8 +16,6 @@ public class J {
 
 // FILE: k.kt
 
-import p.*
-
 fun test() {
     // @NotNull platform type
     val platformNN = J.staticNN
diff --git a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/safeCall.txt b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/safeCall.txt
index b8def46715c..7b24a77511a 100644
--- a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/safeCall.txt
+++ b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/safeCall.txt
@@ -1,3 +1,16 @@
 package
 
 internal fun test(): kotlin.Unit
+
+public open class J {
+    public constructor J()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open fun foo(): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    // Static members
+    public final var staticJ: J!
+    org.jetbrains.annotations.Nullable() public final var staticN: J?
+    org.jetbrains.annotations.NotNull() public final var staticNN: J
+}
diff --git a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/senselessComparisonEquals.kt b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/senselessComparisonEquals.kt
index 468ff5c4959..3e16583b802 100644
--- a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/senselessComparisonEquals.kt
+++ b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/senselessComparisonEquals.kt
@@ -1,7 +1,6 @@
 // !DIAGNOSTICS: -UNUSED_EXPRESSION
 
-// FILE: p/J.java
-package p;
+// FILE: J.java
 
 import org.jetbrains.annotations.*;
 
@@ -15,8 +14,6 @@ public class J {
 
 // FILE: k.kt
 
-import p.*
-
 fun test() {
     // @NotNull platform type
     val platformNN = J.staticNN
diff --git a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/senselessComparisonEquals.txt b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/senselessComparisonEquals.txt
index b8def46715c..337b583c502 100644
--- a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/senselessComparisonEquals.txt
+++ b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/senselessComparisonEquals.txt
@@ -1,3 +1,15 @@
 package
 
 internal fun test(): kotlin.Unit
+
+public open class J {
+    public constructor J()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    // Static members
+    public final var staticJ: J!
+    org.jetbrains.annotations.Nullable() public final var staticN: J?
+    org.jetbrains.annotations.NotNull() public final var staticNN: J
+}
diff --git a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/senselessComparisonIdentityEquals.kt b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/senselessComparisonIdentityEquals.kt
index 6cab5d050bd..ee64b8d261e 100644
--- a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/senselessComparisonIdentityEquals.kt
+++ b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/senselessComparisonIdentityEquals.kt
@@ -1,7 +1,6 @@
 // !DIAGNOSTICS: -UNUSED_EXPRESSION
 
-// FILE: p/J.java
-package p;
+// FILE: J.java
 
 import org.jetbrains.annotations.*;
 
@@ -15,8 +14,6 @@ public class J {
 
 // FILE: k.kt
 
-import p.*
-
 fun test() {
     // @NotNull platform type
     val platformNN = J.staticNN
diff --git a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/senselessComparisonIdentityEquals.txt b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/senselessComparisonIdentityEquals.txt
index b8def46715c..337b583c502 100644
--- a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/senselessComparisonIdentityEquals.txt
+++ b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/senselessComparisonIdentityEquals.txt
@@ -1,3 +1,15 @@
 package
 
 internal fun test(): kotlin.Unit
+
+public open class J {
+    public constructor J()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    // Static members
+    public final var staticJ: J!
+    org.jetbrains.annotations.Nullable() public final var staticN: J?
+    org.jetbrains.annotations.NotNull() public final var staticNN: J
+}
diff --git a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/throw.kt b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/throw.kt
index 9d74d623335..df4f6c14145 100644
--- a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/throw.kt
+++ b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/throw.kt
@@ -1,5 +1,4 @@
-// FILE: p/J.java
-package p;
+// FILE: J.java
 
 import org.jetbrains.annotations.*;
 
@@ -13,14 +12,12 @@ public class J {
 
 // FILE: k.kt
 
-import p.*
-
 fun test() {
     throw J.staticNN
 }
 
 fun test1() {
-    throw <!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>J.staticN<!>
+    throw <!TYPE_MISMATCH!>J.staticN<!>
 }
 
 fun test2() {
diff --git a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/throw.txt b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/throw.txt
index 324eef14d41..35fa850f446 100644
--- a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/throw.txt
+++ b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/throw.txt
@@ -3,3 +3,15 @@ package
 internal fun test(): kotlin.Unit
 internal fun test1(): kotlin.Unit
 internal fun test2(): kotlin.Unit
+
+public open class J {
+    public constructor J()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    // Static members
+    public final var staticJ: java.lang.Exception!
+    org.jetbrains.annotations.Nullable() public final var staticN: java.lang.Exception?
+    org.jetbrains.annotations.NotNull() public final var staticNN: java.lang.Exception
+}
diff --git a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/uselessElvisInCall.kt b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/uselessElvisInCall.kt
index 230514a1596..ab1f846dcbf 100644
--- a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/uselessElvisInCall.kt
+++ b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/uselessElvisInCall.kt
@@ -1,7 +1,6 @@
 // !DIAGNOSTICS: -UNUSED_PARAMETER
 
-// FILE: p/J.java
-package p;
+// FILE: J.java
 
 import org.jetbrains.annotations.*;
 
@@ -12,8 +11,6 @@ public class J {
 
 // FILE: k.kt
 
-import p.*
-
 fun test() {
     // @NotNull platform type
     val platformNN = J.staticNN
diff --git a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/uselessElvisInCall.txt b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/uselessElvisInCall.txt
index 79f259ce9cb..344c25b69e4 100644
--- a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/uselessElvisInCall.txt
+++ b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/uselessElvisInCall.txt
@@ -10,3 +10,13 @@ internal final class Bar {
     internal final fun invoke(/*0*/ a: kotlin.Any): kotlin.Unit
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
 }
+
+public open class J {
+    public constructor J()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    // Static members
+    org.jetbrains.annotations.NotNull() public final var staticNN: J
+}
diff --git a/compiler/testData/diagnostics/tests/platformTypes/supertypeTypeArguments.txt b/compiler/testData/diagnostics/tests/platformTypes/supertypeTypeArguments.txt
index f8e286d2825..fe79b88083d 100644
--- a/compiler/testData/diagnostics/tests/platformTypes/supertypeTypeArguments.txt
+++ b/compiler/testData/diagnostics/tests/platformTypes/supertypeTypeArguments.txt
@@ -29,12 +29,12 @@ internal final class HashMapEx</*0*/ K, /*1*/ V> : java.util.HashMap<K, V>, ExtM
     invisible_fake open override /*1*/ /*fake_override*/ fun addEntry(/*0*/ p0: kotlin.Int, /*1*/ p1: K!, /*2*/ p2: V!, /*3*/ p3: kotlin.Int): kotlin.Unit
     invisible_fake open override /*1*/ /*fake_override*/ fun capacity(): kotlin.Int
     public open override /*1*/ /*fake_override*/ fun clear(): kotlin.Unit
-    public open override /*1*/ /*fake_override*/ fun clone(): kotlin.Any!
+    public open override /*1*/ /*fake_override*/ fun clone(): kotlin.Any
     public open override /*2*/ /*fake_override*/ fun containsKey(/*0*/ key: kotlin.Any?): kotlin.Boolean
     invisible_fake open override /*1*/ /*fake_override*/ fun containsNullValue(): kotlin.Boolean
     public open override /*2*/ /*fake_override*/ fun containsValue(/*0*/ value: kotlin.Any?): kotlin.Boolean
     invisible_fake open override /*1*/ /*fake_override*/ fun createEntry(/*0*/ p0: kotlin.Int, /*1*/ p1: K!, /*2*/ p2: V!, /*3*/ p3: kotlin.Int): kotlin.Unit
-    public open override /*2*/ /*fake_override*/ fun entrySet(): kotlin.Set<kotlin.Map.Entry<K, V>>
+    public open override /*2*/ /*fake_override*/ fun entrySet(): kotlin.MutableSet<kotlin.MutableMap.MutableEntry<K, V>>
     invisible_fake open override /*1*/ /*fake_override*/ fun entrySet0(): kotlin.(Mutable)Set<kotlin.(Mutable)Map.(Mutable)Entry<K!, V!>!>!
     public open override /*2*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
     public open override /*2*/ /*fake_override*/ fun get(/*0*/ key: kotlin.Any?): V?
@@ -44,24 +44,24 @@ internal final class HashMapEx</*0*/ K, /*1*/ V> : java.util.HashMap<K, V>, ExtM
     public open override /*2*/ /*fake_override*/ fun hashCode(): kotlin.Int
     invisible_fake open override /*1*/ /*fake_override*/ fun init(): kotlin.Unit
     public open override /*2*/ /*fake_override*/ fun isEmpty(): kotlin.Boolean
-    public open override /*2*/ /*fake_override*/ fun keySet(): kotlin.Set<K>
+    public open override /*2*/ /*fake_override*/ fun keySet(): kotlin.MutableSet<K>
     invisible_fake open override /*1*/ /*fake_override*/ fun loadFactor(): kotlin.Float
     invisible_fake open override /*1*/ /*fake_override*/ fun newEntryIterator(): kotlin.(Mutable)Iterator<kotlin.(Mutable)Map.(Mutable)Entry<K!, V!>!>!
     invisible_fake open override /*1*/ /*fake_override*/ fun newKeyIterator(): kotlin.(Mutable)Iterator<K!>!
     invisible_fake open override /*1*/ /*fake_override*/ fun newValueIterator(): kotlin.(Mutable)Iterator<V!>!
-    public open override /*1*/ /*fake_override*/ fun put(/*0*/ key: K!, /*1*/ value: V!): V!
-    public open override /*1*/ /*fake_override*/ fun putAll(/*0*/ m: (kotlin.MutableMap<out K!, out V!>..kotlin.Map<out K!, V!>?)): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun put(/*0*/ key: K, /*1*/ value: V): V?
+    public open override /*1*/ /*fake_override*/ fun putAll(/*0*/ m: kotlin.Map<out K, V>): kotlin.Unit
     invisible_fake open override /*1*/ /*fake_override*/ fun putAllForCreate(/*0*/ p0: (kotlin.MutableMap<out K!, out V!>..kotlin.Map<out K!, V!>?)): kotlin.Unit
     invisible_fake open override /*1*/ /*fake_override*/ fun putForCreate(/*0*/ p0: K!, /*1*/ p1: V!): kotlin.Unit
     invisible_fake open override /*1*/ /*fake_override*/ fun putForNullKey(/*0*/ p0: V!): V!
     invisible_fake open override /*1*/ /*fake_override*/ fun readObject(/*0*/ p0: java.io.ObjectInputStream!): kotlin.Unit
-    public open override /*1*/ /*fake_override*/ fun remove(/*0*/ key: kotlin.Any!): V!
+    public open override /*1*/ /*fake_override*/ fun remove(/*0*/ key: kotlin.Any?): V?
     invisible_fake final override /*1*/ /*fake_override*/ fun removeEntryForKey(/*0*/ p0: kotlin.Any!): java.util.HashMap.Entry<K!, V!>!
     invisible_fake final override /*1*/ /*fake_override*/ fun removeMapping(/*0*/ p0: kotlin.Any!): java.util.HashMap.Entry<K!, V!>!
     invisible_fake open override /*1*/ /*fake_override*/ fun resize(/*0*/ p0: kotlin.Int): kotlin.Unit
     public open override /*2*/ /*fake_override*/ fun size(): kotlin.Int
     public open override /*2*/ /*fake_override*/ fun toString(): kotlin.String
     invisible_fake open override /*1*/ /*fake_override*/ fun transfer(/*0*/ p0: kotlin.Array<(out) java.util.HashMap.Entry<*, *>!>!, /*1*/ p1: kotlin.Boolean): kotlin.Unit
-    public open override /*2*/ /*fake_override*/ fun values(): kotlin.Collection<V>
+    public open override /*2*/ /*fake_override*/ fun values(): kotlin.MutableCollection<V>
     invisible_fake open override /*1*/ /*fake_override*/ fun writeObject(/*0*/ p0: java.io.ObjectOutputStream!): kotlin.Unit
 }
diff --git a/compiler/testData/diagnostics/tests/platformTypes/typeEnhancement/annotatedTypeArguments.kt b/compiler/testData/diagnostics/tests/platformTypes/typeEnhancement/annotatedTypeArguments.kt
new file mode 100644
index 00000000000..b2a46d6ba21
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/platformTypes/typeEnhancement/annotatedTypeArguments.kt
@@ -0,0 +1,38 @@
+// FILE: AnnotatedTypeArguments.java
+
+import org.jetbrains.annotations.*;
+
+interface P<X, Y> {}
+interface L<T> {}
+interface S<T> {}
+
+class AnnotatedTypeArguments {
+
+    class A {
+        L<P<L<String>, S<?>>> foo(L<P<L<String>, S<?>>> x) {return null;}
+    }
+
+    class B extends A {
+        // some complicated type tree
+        // return type and argument's type differ only by nullability of outermost type
+        @Nullable
+        L<P<@NotNull L<@Nullable String>, @NotNull S<?>>> foo(@NotNull L<P<@NotNull L<@Nullable String>, @NotNull S<?>>> x) {return null;}
+    }
+
+    class C extends B {
+        // signature should be the same as in A
+        L<P<L<String>, S<?>>> foo(L<P<L<String>, S<?>>> x) {return null;}
+    }
+
+    class D1 extends C {
+        // signature should be the same as in A, but annotated String-type should be platform
+        L<P<L<@NotNull String>, S<?>>> foo(L<P<L<@NotNull String>, S<?>>> x) {return null;}
+    }
+
+    class D2 extends C {
+        // return type refined to not-nullable
+        // argument type here same as in A except outermost type (it becomes flexible because of conflict)
+        @NotNull
+        L<P<L<String>, S<?>>> foo(@Nullable L<P<L<String>, S<?>>> x) {return null;}
+    }
+}
diff --git a/compiler/testData/diagnostics/tests/platformTypes/typeEnhancement/annotatedTypeArguments.txt b/compiler/testData/diagnostics/tests/platformTypes/typeEnhancement/annotatedTypeArguments.txt
new file mode 100644
index 00000000000..e5833bf45e6
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/platformTypes/typeEnhancement/annotatedTypeArguments.txt
@@ -0,0 +1,48 @@
+package 
+
+public/*package*/ open class AnnotatedTypeArguments {
+    public/*package*/ constructor AnnotatedTypeArguments()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    public/*package*/ open inner class A {
+        public/*package*/ constructor A()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public/*package*/ open fun foo(/*0*/ x: L<P<L<kotlin.String!>!, S<*>!>!>!): L<P<L<kotlin.String!>!, S<*>!>!>!
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    public/*package*/ open inner class B : AnnotatedTypeArguments.A {
+        public/*package*/ constructor B()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        org.jetbrains.annotations.Nullable() public/*package*/ open override /*1*/ fun foo(/*0*/ org.jetbrains.annotations.NotNull() x: L<P<L<kotlin.String?>, S<*>>!>): L<P<L<kotlin.String?>, S<*>>!>?
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    public/*package*/ open inner class C : AnnotatedTypeArguments.B {
+        public/*package*/ constructor C()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public/*package*/ open override /*1*/ fun foo(/*0*/ x: L<P<L<kotlin.String?>, S<*>>!>): L<P<L<kotlin.String?>, S<*>>!>?
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    public/*package*/ open inner class D1 : AnnotatedTypeArguments.C {
+        public/*package*/ constructor D1()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public/*package*/ open override /*1*/ fun foo(/*0*/ x: L<P<L<kotlin.String!>, S<*>>!>): L<P<L<kotlin.String!>, S<*>>!>?
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    public/*package*/ open inner class D2 : AnnotatedTypeArguments.C {
+        public/*package*/ constructor D2()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        org.jetbrains.annotations.NotNull() public/*package*/ open override /*1*/ fun foo(/*0*/ org.jetbrains.annotations.Nullable() x: L<P<L<kotlin.String?>, S<*>>!>!): L<P<L<kotlin.String?>, S<*>>!>
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+}
diff --git a/compiler/testData/diagnostics/tests/platformTypes/typeEnhancement/methodWithTypeParameter.kt b/compiler/testData/diagnostics/tests/platformTypes/typeEnhancement/methodWithTypeParameter.kt
new file mode 100644
index 00000000000..b676019d8fb
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/platformTypes/typeEnhancement/methodWithTypeParameter.kt
@@ -0,0 +1,51 @@
+// FILE: Outer.java
+
+import org.jetbrains.annotations.*;
+
+interface X<T> {}
+interface Y<T> {}
+
+class Outer {
+    class A {
+        <K, V> V foo(K x) { return null; }
+
+        <T> X<T> bar(Y<T> x) { return null; }
+    }
+
+    class B extends A {
+        // OK, non-platform types
+        @Override
+        <T1, T2> @NotNull T2 foo(@Nullable T1 x) { return null; }
+
+        // Parameter type is fully non-flexible (OK)
+        // Return type is `X<R!>?`.
+        // The reason is that we do not treat it as equal to return type of A.bar because they are base on different type parameters,
+        // so type enhancing happens only for outermost type.
+        // TODO: We should properly compare equality with specific local equality axioms (as when calculating overriden descriptors)
+        @Override
+        <R> @Nullable X<@Nullable R> bar(@NotNull Y<@NotNull R> x) { return null; }
+    }
+
+    class C extends B {
+        // OK, non-platform types
+        @Override
+        <I, J> J foo(I x) { return null; }
+
+        // Parameter type is fully non-flexible (OK)
+        // Return type is `X<R!>?`, same is in B
+        @Override
+        <E> X<E> bar(Y<E> x) { return null; }
+    }
+
+    class D extends C {
+        // Return type is not-nullable, covariantly overridden, OK
+        // Parameter type is flexible, because of conflict with supertype, OK
+        @Override
+        @NotNull
+        <U, W> W foo(@Nullable U x) { return null; }
+
+
+        @Override
+        <F> @NotNull X<@NotNull F> bar(@Nullable Y<@Nullable F> x) { return null; }
+    }
+}
diff --git a/compiler/testData/diagnostics/tests/platformTypes/typeEnhancement/methodWithTypeParameter.txt b/compiler/testData/diagnostics/tests/platformTypes/typeEnhancement/methodWithTypeParameter.txt
new file mode 100644
index 00000000000..1621e611eb6
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/platformTypes/typeEnhancement/methodWithTypeParameter.txt
@@ -0,0 +1,44 @@
+package
+
+public/*package*/ open class Outer {
+    public/*package*/ constructor Outer()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    public/*package*/ open inner class A {
+        public/*package*/ constructor A()
+        public/*package*/ open fun </*0*/ T> bar(/*0*/ x: Y<T!>!): X<T!>!
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public/*package*/ open fun </*0*/ K, /*1*/ V> foo(/*0*/ x: K!): V!
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    public/*package*/ open inner class B : Outer.A {
+        public/*package*/ constructor B()
+        java.lang.Override() public/*package*/ open override /*1*/ fun </*0*/ R> bar(/*0*/ org.jetbrains.annotations.NotNull() x: Y<R>): X<R!>?
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        java.lang.Override() public/*package*/ open override /*1*/ fun </*0*/ T1, /*1*/ T2> foo(/*0*/ org.jetbrains.annotations.Nullable() x: T1?): T2
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    public/*package*/ open inner class C : Outer.B {
+        public/*package*/ constructor C()
+        java.lang.Override() public/*package*/ open override /*1*/ fun </*0*/ E> bar(/*0*/ x: Y<E>): X<E!>?
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        java.lang.Override() public/*package*/ open override /*1*/ fun </*0*/ I, /*1*/ J> foo(/*0*/ x: I?): J
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    public/*package*/ open inner class D : Outer.C {
+        public/*package*/ constructor D()
+        java.lang.Override() public/*package*/ open override /*1*/ fun </*0*/ F> bar(/*0*/ org.jetbrains.annotations.Nullable() x: Y<F!>!): X<F!>
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        java.lang.Override() org.jetbrains.annotations.NotNull() public/*package*/ open override /*1*/ fun </*0*/ U, /*1*/ W> foo(/*0*/ org.jetbrains.annotations.Nullable() x: U?): W
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+}
diff --git a/compiler/testData/diagnostics/tests/platformTypes/typeEnhancement/overriddenExtensions.kt b/compiler/testData/diagnostics/tests/platformTypes/typeEnhancement/overriddenExtensions.kt
new file mode 100644
index 00000000000..1cff51ea18f
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/platformTypes/typeEnhancement/overriddenExtensions.kt
@@ -0,0 +1,63 @@
+// FILE: A.kt
+open class A {
+    open fun String.foo(y: String?): Int = 1
+    open fun String?.bar(y: String): Int = 1
+}
+
+class E : B1() {
+    fun baz() {
+        val x: String? = ""
+
+        x<!UNSAFE_CALL!>.<!>foo(x)
+        x<!UNSAFE_CALL!>.<!>foo("")
+        x.bar(<!TYPE_MISMATCH!>x<!>)
+        x.bar("")
+    }
+
+    override fun String.foo(y: String?): Int = 1
+    override fun String?.bar(y: String): Int = 1
+}
+
+// FILE: B.java
+import org.jetbrains.annotations.*;
+
+// Just inherit enhanced types
+class B extends A {
+    @Override
+    int foo(String x, String y);
+    @Override
+    int bar(String x, String y);
+}
+
+// FILE: B1.java
+import org.jetbrains.annotations.*;
+
+// Just inherit enhanced types (annotations without conflicts)
+class B1 extends A {
+    @Override
+    int foo(@NotNull String x, String y);
+    @Override
+    int bar(@Nullable String x, String y);
+}
+
+// FILE: C.java
+import org.jetbrains.annotations.*;
+
+// Conflicting annotations. Everything is flexible
+class C extends A {
+    @Override
+    int foo(@Nullable String x, @NotNull String y);
+    @Override
+    int bar(@NotNull String x, @Nullable String y);
+}
+
+// FILE: D.java
+import org.jetbrains.annotations.*;
+
+// Just inherit enhanced types (annotations without conflicts)
+class D extends B {
+    @Override
+    int foo(@Nullable String x, @Nullable String y);
+    @Override
+    int bar(@NotNull String x, @NotNull String y);
+}
diff --git a/compiler/testData/diagnostics/tests/platformTypes/typeEnhancement/overriddenExtensions.txt b/compiler/testData/diagnostics/tests/platformTypes/typeEnhancement/overriddenExtensions.txt
new file mode 100644
index 00000000000..1813968a443
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/platformTypes/typeEnhancement/overriddenExtensions.txt
@@ -0,0 +1,56 @@
+package
+
+internal open class A {
+    public constructor A()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    internal open fun kotlin.String?.bar(/*0*/ y: kotlin.String): kotlin.Int
+    internal open fun kotlin.String.foo(/*0*/ y: kotlin.String?): kotlin.Int
+}
+
+public/*package*/ open class B : A {
+    public/*package*/ constructor B()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    java.lang.Override() public/*package*/ open override /*1*/ fun kotlin.String?.bar(/*0*/ y: kotlin.String): kotlin.Int
+    java.lang.Override() public/*package*/ open override /*1*/ fun kotlin.String.foo(/*0*/ y: kotlin.String?): kotlin.Int
+}
+
+public/*package*/ open class B1 : A {
+    public/*package*/ constructor B1()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    java.lang.Override() public/*package*/ open override /*1*/ fun kotlin.String?.bar(/*0*/ y: kotlin.String): kotlin.Int
+    java.lang.Override() public/*package*/ open override /*1*/ fun kotlin.String.foo(/*0*/ y: kotlin.String?): kotlin.Int
+}
+
+public/*package*/ open class C : A {
+    public/*package*/ constructor C()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    java.lang.Override() public/*package*/ open override /*1*/ fun kotlin.String!.bar(/*0*/ org.jetbrains.annotations.Nullable() y: kotlin.String!): kotlin.Int
+    java.lang.Override() public/*package*/ open override /*1*/ fun kotlin.String!.foo(/*0*/ org.jetbrains.annotations.NotNull() y: kotlin.String!): kotlin.Int
+}
+
+public/*package*/ open class D : B {
+    public/*package*/ constructor D()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    java.lang.Override() public/*package*/ open override /*1*/ fun kotlin.String!.bar(/*0*/ org.jetbrains.annotations.NotNull() y: kotlin.String): kotlin.Int
+    java.lang.Override() public/*package*/ open override /*1*/ fun kotlin.String!.foo(/*0*/ org.jetbrains.annotations.Nullable() y: kotlin.String?): kotlin.Int
+}
+
+internal final class E : B1 {
+    public constructor E()
+    internal final fun baz(): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    internal open override /*1*/ fun kotlin.String?.bar(/*0*/ y: kotlin.String): kotlin.Int
+    internal open override /*1*/ fun kotlin.String.foo(/*0*/ y: kotlin.String?): kotlin.Int
+}
diff --git a/compiler/testData/diagnostics/tests/platformTypes/typeEnhancement/returnTypeDifferentConstructor.kt b/compiler/testData/diagnostics/tests/platformTypes/typeEnhancement/returnTypeDifferentConstructor.kt
new file mode 100644
index 00000000000..c96a266a34f
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/platformTypes/typeEnhancement/returnTypeDifferentConstructor.kt
@@ -0,0 +1,37 @@
+// FILE: Outer.java
+
+import org.jetbrains.annotations.*;
+
+interface Base<T> {}
+interface Derived<E> extends Base<E> {}
+
+class Outer {
+    class A {
+        @Nullable Base<@NotNull String> foo() { return null; }
+    }
+
+    class B extends A {
+        @Override
+        Base<String> foo() {}
+    }
+
+    class C extends A {
+        @Override
+        @NotNull Base<String> foo() {}
+    }
+
+    class D extends A {
+        @Override
+        Derived<String> foo() {}
+    }
+
+    class E extends A {
+        @Override
+        @NotNull Derived<String> foo() {}
+    }
+
+    class F extends A {
+        @Override
+        @NotNull Derived<@NotNull String> foo() {}
+    }
+}
diff --git a/compiler/testData/diagnostics/tests/platformTypes/typeEnhancement/returnTypeDifferentConstructor.txt b/compiler/testData/diagnostics/tests/platformTypes/typeEnhancement/returnTypeDifferentConstructor.txt
new file mode 100644
index 00000000000..3de4b6bfdcd
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/platformTypes/typeEnhancement/returnTypeDifferentConstructor.txt
@@ -0,0 +1,56 @@
+package
+
+public/*package*/ open class Outer {
+    public/*package*/ constructor Outer()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    public/*package*/ open inner class A {
+        public/*package*/ constructor A()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        org.jetbrains.annotations.Nullable() public/*package*/ open fun foo(): Base<kotlin.String>?
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    public/*package*/ open inner class B : Outer.A {
+        public/*package*/ constructor B()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        java.lang.Override() public/*package*/ open override /*1*/ fun foo(): Base<kotlin.String>?
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    public/*package*/ open inner class C : Outer.A {
+        public/*package*/ constructor C()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        java.lang.Override() org.jetbrains.annotations.NotNull() public/*package*/ open override /*1*/ fun foo(): Base<kotlin.String>
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    public/*package*/ open inner class D : Outer.A {
+        public/*package*/ constructor D()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        java.lang.Override() public/*package*/ open override /*1*/ fun foo(): Derived<kotlin.String!>?
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    public/*package*/ open inner class E : Outer.A {
+        public/*package*/ constructor E()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        java.lang.Override() org.jetbrains.annotations.NotNull() public/*package*/ open override /*1*/ fun foo(): Derived<kotlin.String!>
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    public/*package*/ open inner class F : Outer.A {
+        public/*package*/ constructor F()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        java.lang.Override() org.jetbrains.annotations.NotNull() public/*package*/ open override /*1*/ fun foo(): Derived<kotlin.String!>
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+}
diff --git a/compiler/testData/diagnostics/tests/platformTypes/typeEnhancement/returnTypeOverrideInKotlin.kt b/compiler/testData/diagnostics/tests/platformTypes/typeEnhancement/returnTypeOverrideInKotlin.kt
new file mode 100644
index 00000000000..a010f31db7c
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/platformTypes/typeEnhancement/returnTypeOverrideInKotlin.kt
@@ -0,0 +1,31 @@
+// FILE: A.java
+
+import org.jetbrains.annotations.*;
+
+public class A {
+    @Nullable Base<@NotNull String> foo() { return null; }
+}
+
+// FILE: a.kt
+
+interface Base<T> {}
+interface Derived<E> : Base<E> {}
+
+fun bar1(): Derived<String> = null!!
+fun bar2(): Derived<String?> = null!!
+
+class B : A() {
+    override fun foo(): Base<String> { return bar1(); }
+}
+
+class C1 : A() {
+    override fun foo(): Derived<String> { return bar1(); }
+}
+
+class C2 : A() {
+    override fun foo(): Derived<String>? { return bar1(); }
+}
+
+class C3 : A() {
+    override fun foo(): <!RETURN_TYPE_MISMATCH_ON_OVERRIDE!>Derived<String?><!> { return bar2(); }
+}
diff --git a/compiler/testData/diagnostics/tests/platformTypes/typeEnhancement/returnTypeOverrideInKotlin.txt b/compiler/testData/diagnostics/tests/platformTypes/typeEnhancement/returnTypeOverrideInKotlin.txt
new file mode 100644
index 00000000000..e5613b2f150
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/platformTypes/typeEnhancement/returnTypeOverrideInKotlin.txt
@@ -0,0 +1,56 @@
+package
+
+internal fun bar1(): Derived<kotlin.String>
+internal fun bar2(): Derived<kotlin.String?>
+
+public open class A {
+    public constructor A()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    org.jetbrains.annotations.Nullable() public/*package*/ open fun foo(): Base<kotlin.String>?
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+internal final class B : A {
+    public constructor B()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    internal open override /*1*/ fun foo(): Base<kotlin.String>
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+internal interface Base</*0*/ T> {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+internal final class C1 : A {
+    public constructor C1()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    internal open override /*1*/ fun foo(): Derived<kotlin.String>
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+internal final class C2 : A {
+    public constructor C2()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    internal open override /*1*/ fun foo(): Derived<kotlin.String>?
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+internal final class C3 : A {
+    public constructor C3()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    internal open override /*1*/ fun foo(): Derived<kotlin.String?>
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+internal interface Derived</*0*/ E> : Base<E> {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
diff --git a/compiler/testData/diagnostics/tests/platformTypes/typeEnhancement/saveAnnotationAfterSubstitution.kt b/compiler/testData/diagnostics/tests/platformTypes/typeEnhancement/saveAnnotationAfterSubstitution.kt
new file mode 100644
index 00000000000..33bdd9ca0f1
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/platformTypes/typeEnhancement/saveAnnotationAfterSubstitution.kt
@@ -0,0 +1,47 @@
+// FILE: A.java
+
+import org.jetbrains.annotations.*;
+
+interface A<T> {
+    void foo(@NotNull T x, @Nullable T y);
+}
+
+// FILE: B1.java
+
+// contains fake_override fun foo(/*0*/ org.jetbrains.annotations.NotNull() x: kotlin.String, /*1*/ org.jetbrains.annotations.Nullable() y: kotlin.String?)
+interface B1 extends A<String> {}
+
+// FILE: B2.java
+import org.jetbrains.annotations.*;
+
+interface B2 extends A<String> {
+    // Ok, consistent override
+    // override fun foo(/*0*/ org.jetbrains.annotations.NotNull() x: kotlin.String, /*1*/ org.jetbrains.annotations.Nullable() y: kotlin.String?)
+    void foo(@NotNull String x, @Nullable String y);
+}
+
+// FILE: B3.java
+import org.jetbrains.annotations.*;
+
+interface B3 extends A<String> {
+    // inconsistent override, second parameter type is platform
+    // TODO: first one should be platform too, but it's not because when substituting T -> String!,
+    // value parameter type becomes platform and it can be overridden with @NotNull String.
+    // Conceptual problem: we can use type parameter as T?, but there is no way to specify same semantics as in Java `@NotNull T`.
+
+    // override /*1*/ fun foo(/*0*/ org.jetbrains.annotations.Nullable() x: kotlin.String?, /*1*/ org.jetbrains.annotations.NotNull() y: kotlin.String!): kotlin.Unit
+    void foo(@Nullable String x, @NotNull String y);
+}
+
+// FILE: main.kt
+
+// fake_override fun foo(/*0*/ org.jetbrains.annotations.NotNull() x: kotlin.String, /*1*/ org.jetbrains.annotations.Nullable() y: kotlin.String?): kotlin.Unit
+interface C1 : A<String>
+
+// fake_override fun foo(/*0*/ org.jetbrains.annotations.NotNull() x: kotlin.String?, /*1*/ org.jetbrains.annotations.Nullable() y: kotlin.String?): kotlin.Unit
+interface C2 : A<String?>
+
+interface C3 : B1 {
+    // inconsistent override
+    <!NOTHING_TO_OVERRIDE!>override<!> fun foo(x: String?, y: String?);
+}
diff --git a/compiler/testData/diagnostics/tests/platformTypes/typeEnhancement/saveAnnotationAfterSubstitution.txt b/compiler/testData/diagnostics/tests/platformTypes/typeEnhancement/saveAnnotationAfterSubstitution.txt
new file mode 100644
index 00000000000..a9a6a6124a4
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/platformTypes/typeEnhancement/saveAnnotationAfterSubstitution.txt
@@ -0,0 +1,56 @@
+package
+
+public/*package*/ /*synthesized*/ fun </*0*/ T> A(/*0*/ function: (T!, T!) -> kotlin.Unit): A<T>
+public/*package*/ /*synthesized*/ fun B1(/*0*/ function: (kotlin.String!, kotlin.String?) -> kotlin.Unit): B1
+public/*package*/ /*synthesized*/ fun B2(/*0*/ function: (kotlin.String!, kotlin.String!) -> kotlin.Unit): B2
+public/*package*/ /*synthesized*/ fun B3(/*0*/ function: (kotlin.String!, kotlin.String!) -> kotlin.Unit): B3
+
+public/*package*/ interface A</*0*/ T> {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public abstract fun foo(/*0*/ org.jetbrains.annotations.NotNull() x: T, /*1*/ org.jetbrains.annotations.Nullable() y: T?): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public/*package*/ interface B1 : A<kotlin.String!> {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public abstract override /*1*/ /*fake_override*/ fun foo(/*0*/ org.jetbrains.annotations.NotNull() x: kotlin.String, /*1*/ org.jetbrains.annotations.Nullable() y: kotlin.String?): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public/*package*/ interface B2 : A<kotlin.String!> {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public abstract override /*1*/ fun foo(/*0*/ org.jetbrains.annotations.NotNull() x: kotlin.String, /*1*/ org.jetbrains.annotations.Nullable() y: kotlin.String?): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public/*package*/ interface B3 : A<kotlin.String!> {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public abstract override /*1*/ fun foo(/*0*/ org.jetbrains.annotations.Nullable() x: kotlin.String?, /*1*/ org.jetbrains.annotations.NotNull() y: kotlin.String!): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+internal interface C1 : A<kotlin.String> {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public abstract override /*1*/ /*fake_override*/ fun foo(/*0*/ org.jetbrains.annotations.NotNull() x: kotlin.String, /*1*/ org.jetbrains.annotations.Nullable() y: kotlin.String?): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+internal interface C2 : A<kotlin.String?> {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public abstract override /*1*/ /*fake_override*/ fun foo(/*0*/ org.jetbrains.annotations.NotNull() x: kotlin.String?, /*1*/ org.jetbrains.annotations.Nullable() y: kotlin.String?): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+internal interface C3 : B1 {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public abstract override /*1*/ /*fake_override*/ fun foo(/*0*/ org.jetbrains.annotations.NotNull() x: kotlin.String, /*1*/ org.jetbrains.annotations.Nullable() y: kotlin.String?): kotlin.Unit
+    internal abstract fun foo(/*0*/ x: kotlin.String?, /*1*/ y: kotlin.String?): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
diff --git a/compiler/testData/diagnostics/tests/platformTypes/typeEnhancement/supertypeDifferentParameterNullability.kt b/compiler/testData/diagnostics/tests/platformTypes/typeEnhancement/supertypeDifferentParameterNullability.kt
new file mode 100644
index 00000000000..1d50f6f48ce
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/platformTypes/typeEnhancement/supertypeDifferentParameterNullability.kt
@@ -0,0 +1,33 @@
+// FILE: A.java
+import org.jetbrains.annotations.*;
+
+interface A {
+    void foo(@Nullable String x);
+}
+
+// FILE: B.java
+import org.jetbrains.annotations.*;
+
+interface B {
+    void foo(@NotNull String x);
+}
+
+// FILE: C.kt
+
+<!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>class C1<!> : A, B {
+    <!ACCIDENTAL_OVERRIDE!>override fun foo(x: String)<!> {}
+}
+
+<!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>class C2<!> : A, B {
+    <!ACCIDENTAL_OVERRIDE!>override fun foo(x: String?)<!> {}
+}
+
+interface <!ACCIDENTAL_OVERRIDE!>I<!> : A, B
+
+<!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>class C3<!> : I {
+    <!ACCIDENTAL_OVERRIDE!>override fun foo(x: String)<!> {}
+}
+
+<!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>class C4<!> : I {
+    <!ACCIDENTAL_OVERRIDE!>override fun foo(x: String?)<!> {}
+}
diff --git a/compiler/testData/diagnostics/tests/platformTypes/typeEnhancement/supertypeDifferentParameterNullability.txt b/compiler/testData/diagnostics/tests/platformTypes/typeEnhancement/supertypeDifferentParameterNullability.txt
new file mode 100644
index 00000000000..2c6055689b2
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/platformTypes/typeEnhancement/supertypeDifferentParameterNullability.txt
@@ -0,0 +1,62 @@
+package
+
+public/*package*/ /*synthesized*/ fun A(/*0*/ function: (kotlin.String!) -> kotlin.Unit): A
+public/*package*/ /*synthesized*/ fun B(/*0*/ function: (kotlin.String!) -> kotlin.Unit): B
+
+public/*package*/ interface A {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public abstract fun foo(/*0*/ org.jetbrains.annotations.Nullable() x: kotlin.String?): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public/*package*/ interface B {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public abstract fun foo(/*0*/ org.jetbrains.annotations.NotNull() x: kotlin.String): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+internal final class C1 : A, B {
+    public constructor C1()
+    public open override /*2*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ fun foo(/*0*/ x: kotlin.String): kotlin.Unit
+    public abstract override /*1*/ /*fake_override*/ fun foo(/*0*/ org.jetbrains.annotations.Nullable() x: kotlin.String?): kotlin.Unit
+    public open override /*2*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*2*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+internal final class C2 : A, B {
+    public constructor C2()
+    public open override /*2*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public abstract override /*1*/ /*fake_override*/ fun foo(/*0*/ org.jetbrains.annotations.NotNull() x: kotlin.String): kotlin.Unit
+    public open override /*1*/ fun foo(/*0*/ x: kotlin.String?): kotlin.Unit
+    public open override /*2*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*2*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+internal final class C3 : I {
+    public constructor C3()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ fun foo(/*0*/ x: kotlin.String): kotlin.Unit
+    public abstract override /*1*/ /*fake_override*/ fun foo(/*0*/ org.jetbrains.annotations.Nullable() x: kotlin.String?): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+internal final class C4 : I {
+    public constructor C4()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public abstract override /*1*/ /*fake_override*/ fun foo(/*0*/ org.jetbrains.annotations.NotNull() x: kotlin.String): kotlin.Unit
+    public open override /*1*/ fun foo(/*0*/ x: kotlin.String?): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+internal interface I : A, B {
+    public open override /*2*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public abstract override /*1*/ /*fake_override*/ fun foo(/*0*/ org.jetbrains.annotations.NotNull() x: kotlin.String): kotlin.Unit
+    public abstract override /*1*/ /*fake_override*/ fun foo(/*0*/ org.jetbrains.annotations.Nullable() x: kotlin.String?): kotlin.Unit
+    public open override /*2*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*2*/ /*fake_override*/ fun toString(): kotlin.String
+}
diff --git a/compiler/testData/diagnostics/tests/platformTypes/typeEnhancement/supertypeDifferentReturnNullability.kt b/compiler/testData/diagnostics/tests/platformTypes/typeEnhancement/supertypeDifferentReturnNullability.kt
new file mode 100644
index 00000000000..fbc8c65470a
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/platformTypes/typeEnhancement/supertypeDifferentReturnNullability.kt
@@ -0,0 +1,35 @@
+// FILE: A.java
+import org.jetbrains.annotations.*;
+
+interface A {
+    @Nullable
+    String foo();
+}
+
+// FILE: B.java
+import org.jetbrains.annotations.*;
+
+interface B {
+    @NotNull
+    String foo();
+}
+
+// FILE: C.kt
+
+class C1 : A, B {
+    override fun foo(): <!RETURN_TYPE_MISMATCH_ON_OVERRIDE!>String?<!> = ""
+}
+
+class C2 : A, B {
+    override fun foo(): String = ""
+}
+
+interface I : A, B
+
+class C3 : I {
+    override fun foo(): <!RETURN_TYPE_MISMATCH_ON_OVERRIDE!>String?<!> = ""
+}
+
+class C4 : I {
+    override fun foo(): String = ""
+}
diff --git a/compiler/testData/diagnostics/tests/platformTypes/typeEnhancement/supertypeDifferentReturnNullability.txt b/compiler/testData/diagnostics/tests/platformTypes/typeEnhancement/supertypeDifferentReturnNullability.txt
new file mode 100644
index 00000000000..20e5b74578a
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/platformTypes/typeEnhancement/supertypeDifferentReturnNullability.txt
@@ -0,0 +1,57 @@
+package
+
+public/*package*/ /*synthesized*/ fun A(/*0*/ function: () -> kotlin.String!): A
+public/*package*/ /*synthesized*/ fun B(/*0*/ function: () -> kotlin.String!): B
+
+public/*package*/ interface A {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    org.jetbrains.annotations.Nullable() public abstract fun foo(): kotlin.String?
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public/*package*/ interface B {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    org.jetbrains.annotations.NotNull() public abstract fun foo(): kotlin.String
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+internal final class C1 : A, B {
+    public constructor C1()
+    public open override /*2*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*2*/ fun foo(): kotlin.String?
+    public open override /*2*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*2*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+internal final class C2 : A, B {
+    public constructor C2()
+    public open override /*2*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*2*/ fun foo(): kotlin.String
+    public open override /*2*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*2*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+internal final class C3 : I {
+    public constructor C3()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ fun foo(): kotlin.String?
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+internal final class C4 : I {
+    public constructor C4()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ fun foo(): kotlin.String
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+internal interface I : A, B {
+    public open override /*2*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    org.jetbrains.annotations.NotNull() public abstract override /*2*/ /*fake_override*/ fun foo(): kotlin.String
+    public open override /*2*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*2*/ /*fake_override*/ fun toString(): kotlin.String
+}
diff --git a/compiler/testData/diagnostics/tests/recovery/namelessToplevelDeclarations.txt b/compiler/testData/diagnostics/tests/recovery/namelessToplevelDeclarations.txt
index 3ab980b59b1..b36af47c889 100644
--- a/compiler/testData/diagnostics/tests/recovery/namelessToplevelDeclarations.txt
+++ b/compiler/testData/diagnostics/tests/recovery/namelessToplevelDeclarations.txt
@@ -30,7 +30,7 @@ internal final enum class <no name provided> : kotlin.Enum<<no name provided>> {
     public final /*synthesized*/ fun values(): kotlin.Array<<no name provided>>
 }
 
-internal final annotation class <no name provided> : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class <no name provided> : kotlin.Annotation {
     public constructor <no name provided>()
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
     public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
diff --git a/compiler/testData/diagnostics/tests/reflection/noReflectionInClassPath.kt b/compiler/testData/diagnostics/tests/reflection/noReflectionInClassPath.kt
new file mode 100644
index 00000000000..2e37aa21352
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/reflection/noReflectionInClassPath.kt
@@ -0,0 +1,21 @@
+import kotlin.reflect.*
+
+class Foo(val prop: Any) {
+    fun func() {}
+}
+
+fun n01() = Foo::prop
+fun n02() = Foo::func
+fun n03() = Foo::class
+fun n04(p: KProperty0<Int>) = p.get()
+fun n05(p: KMutableProperty0<String>) = p.set("")
+fun n06(p: KProperty0<Int>) = p.get()
+fun n07(p: KFunction<String>) = p.name
+fun n08(p: KProperty1<String, Int>) = p[""]
+fun n09(p: KProperty2<String, String, Int>) = p["", ""]
+fun n10() = (Foo::func).invoke(Foo(""))
+fun n11() = (Foo::func)(Foo(""))
+
+fun y01() = Foo::prop.<!NO_REFLECTION_IN_CLASS_PATH!>getter<!>
+fun y02() = Foo::class.<!NO_REFLECTION_IN_CLASS_PATH!>properties<!>
+fun y03() = Foo::class.<!NO_REFLECTION_IN_CLASS_PATH!>simpleName<!>
diff --git a/compiler/testData/diagnostics/tests/reflection/noReflectionInClassPath.txt b/compiler/testData/diagnostics/tests/reflection/noReflectionInClassPath.txt
new file mode 100644
index 00000000000..6b6d957333b
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/reflection/noReflectionInClassPath.txt
@@ -0,0 +1,25 @@
+package
+
+internal fun n01(): kotlin.reflect.KProperty1<Foo, kotlin.Any>
+internal fun n02(): kotlin.reflect.KFunction1<Foo, kotlin.Unit>
+internal fun n03(): kotlin.reflect.KClass<Foo>
+internal fun n04(/*0*/ p: kotlin.reflect.KProperty0<kotlin.Int>): kotlin.Int
+internal fun n05(/*0*/ p: kotlin.reflect.KMutableProperty0<kotlin.String>): kotlin.Unit
+internal fun n06(/*0*/ p: kotlin.reflect.KProperty0<kotlin.Int>): kotlin.Int
+internal fun n07(/*0*/ p: kotlin.reflect.KFunction<kotlin.String>): kotlin.String
+internal fun n08(/*0*/ p: kotlin.reflect.KProperty1<kotlin.String, kotlin.Int>): kotlin.Int
+internal fun n09(/*0*/ p: kotlin.reflect.KProperty2<kotlin.String, kotlin.String, kotlin.Int>): kotlin.Int
+internal fun n10(): kotlin.Unit
+internal fun n11(): kotlin.Unit
+internal fun y01(): kotlin.reflect.KProperty1.Getter<Foo, kotlin.Any>
+internal fun y02(): kotlin.Collection<kotlin.reflect.KProperty1<Foo, *>>
+internal fun y03(): kotlin.String?
+
+internal final class Foo {
+    public constructor Foo(/*0*/ prop: kotlin.Any)
+    internal final val prop: kotlin.Any
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    internal final fun func(): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
diff --git a/compiler/testData/diagnostics/tests/regressions/intchar.kt b/compiler/testData/diagnostics/tests/regressions/intchar.kt
new file mode 100644
index 00000000000..edfb8c134cb
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/regressions/intchar.kt
@@ -0,0 +1 @@
+val x: Char = '1'.plus(1)
diff --git a/compiler/testData/diagnostics/tests/regressions/intchar.txt b/compiler/testData/diagnostics/tests/regressions/intchar.txt
new file mode 100644
index 00000000000..2f0f30574f6
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/regressions/intchar.txt
@@ -0,0 +1,3 @@
+package
+
+internal val x: kotlin.Char = \u0032 ('2')
diff --git a/compiler/testData/diagnostics/tests/regressions/itselfAsUpperBoundLocal.kt b/compiler/testData/diagnostics/tests/regressions/itselfAsUpperBoundLocal.kt
index 353988510c3..35af733335a 100644
--- a/compiler/testData/diagnostics/tests/regressions/itselfAsUpperBoundLocal.kt
+++ b/compiler/testData/diagnostics/tests/regressions/itselfAsUpperBoundLocal.kt
@@ -1,4 +1,4 @@
 fun bar() {
     fun <T: <!CYCLIC_GENERIC_UPPER_BOUND!>T?<!>> foo() {}
-    foo()
+    <!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>()
 }
diff --git a/compiler/testData/diagnostics/tests/regressions/kt1639-JFrame.txt b/compiler/testData/diagnostics/tests/regressions/kt1639-JFrame.txt
index c78ad5184f8..6463448f65c 100644
--- a/compiler/testData/diagnostics/tests/regressions/kt1639-JFrame.txt
+++ b/compiler/testData/diagnostics/tests/regressions/kt1639-JFrame.txt
@@ -645,7 +645,7 @@ package test {
         invisible_fake final override /*1*/ /*fake_override*/ fun toBack_NoClientCode(): kotlin.Unit
         public open override /*1*/ /*fake_override*/ fun toFront(): kotlin.Unit
         invisible_fake final override /*1*/ /*fake_override*/ fun toFront_NoClientCode(): kotlin.Unit
-        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String!
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
         public open override /*1*/ /*fake_override*/ fun transferFocus(): kotlin.Unit
         invisible_fake open override /*1*/ /*fake_override*/ fun transferFocus(/*0*/ p0: kotlin.Boolean): kotlin.Boolean
         public open override /*1*/ /*fake_override*/ fun transferFocusBackward(): kotlin.Unit
diff --git a/compiler/testData/diagnostics/tests/regressions/kt588.txt b/compiler/testData/diagnostics/tests/regressions/kt588.txt
index a6169143ac2..2cb6a33a6f2 100644
--- a/compiler/testData/diagnostics/tests/regressions/kt588.txt
+++ b/compiler/testData/diagnostics/tests/regressions/kt588.txt
@@ -69,7 +69,7 @@ internal final class Test : java.lang.Thread {
     invisible_fake open override /*1*/ /*fake_override*/ fun stop0(/*0*/ p0: kotlin.Any!): kotlin.Unit
     kotlin.deprecated(value = "Deprecated in Java") public final override /*1*/ /*fake_override*/ fun suspend(): kotlin.Unit
     invisible_fake open override /*1*/ /*fake_override*/ fun suspend0(): kotlin.Unit
-    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String!
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
 
     public companion object Companion {
         private constructor Companion()
diff --git a/compiler/testData/diagnostics/tests/resolve/ambiguityWithTwoCorrespondingFunctionTypes.kt b/compiler/testData/diagnostics/tests/resolve/ambiguityWithTwoCorrespondingFunctionTypes.kt
new file mode 100644
index 00000000000..984dbdb2c74
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/resolve/ambiguityWithTwoCorrespondingFunctionTypes.kt
@@ -0,0 +1,11 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+fun foo(a: Any, f: ()->Int) = f()
+fun foo(a: Any, f: (Any)->Int) = f(a)
+fun foo(i: Int, f: Int.()->Int) = i.f()
+
+fun test1() {
+    <!OVERLOAD_RESOLUTION_AMBIGUITY!>foo<!>(1) { ->
+        <!NO_THIS!>this<!>
+    }
+}
diff --git a/compiler/testData/diagnostics/tests/resolve/ambiguityWithTwoCorrespondingFunctionTypes.txt b/compiler/testData/diagnostics/tests/resolve/ambiguityWithTwoCorrespondingFunctionTypes.txt
new file mode 100644
index 00000000000..8fc9fe6c93c
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/resolve/ambiguityWithTwoCorrespondingFunctionTypes.txt
@@ -0,0 +1,6 @@
+package
+
+internal fun foo(/*0*/ a: kotlin.Any, /*1*/ f: () -> kotlin.Int): kotlin.Int
+internal fun foo(/*0*/ a: kotlin.Any, /*1*/ f: (kotlin.Any) -> kotlin.Int): kotlin.Int
+internal fun foo(/*0*/ i: kotlin.Int, /*1*/ f: kotlin.Int.() -> kotlin.Int): kotlin.Int
+internal fun test1(): kotlin.Unit
diff --git a/compiler/testData/diagnostics/tests/resolve/inferenceInLinkedLambdas.kt b/compiler/testData/diagnostics/tests/resolve/inferenceInLinkedLambdas.kt
new file mode 100644
index 00000000000..b6e7f1bc6dd
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/resolve/inferenceInLinkedLambdas.kt
@@ -0,0 +1,8 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+// !CHECK_TYPE
+
+fun <T, R> foo(first: () -> T, second: (T) -> R): R = throw Exception()
+fun test() {
+    val r = foo( { 4 }, { "${it + 1}" } )
+    r checkType { _<String>() }
+}
diff --git a/compiler/testData/diagnostics/tests/resolve/inferenceInLinkedLambdas.txt b/compiler/testData/diagnostics/tests/resolve/inferenceInLinkedLambdas.txt
new file mode 100644
index 00000000000..452f937be9e
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/resolve/inferenceInLinkedLambdas.txt
@@ -0,0 +1,4 @@
+package
+
+internal fun </*0*/ T, /*1*/ R> foo(/*0*/ first: () -> T, /*1*/ second: (T) -> R): R
+internal fun test(): kotlin.Unit
diff --git a/compiler/testData/diagnostics/tests/resolve/inferenceInLinkedLambdasDependentOnExpectedType.kt b/compiler/testData/diagnostics/tests/resolve/inferenceInLinkedLambdasDependentOnExpectedType.kt
new file mode 100644
index 00000000000..6c2ba39d404
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/resolve/inferenceInLinkedLambdasDependentOnExpectedType.kt
@@ -0,0 +1,7 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+fun <T> foo(f: () -> Collection<T>, p: (T) -> Boolean): Collection<T> = throw Exception()
+
+fun emptyList<T>(): List<T> = throw Exception()
+
+fun test(): Collection<Int> = foo({ emptyList<Int>() }, { x -> x > 0 })
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/resolve/inferenceInLinkedLambdasDependentOnExpectedType.txt b/compiler/testData/diagnostics/tests/resolve/inferenceInLinkedLambdasDependentOnExpectedType.txt
new file mode 100644
index 00000000000..3ddf0a9d9ab
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/resolve/inferenceInLinkedLambdasDependentOnExpectedType.txt
@@ -0,0 +1,5 @@
+package
+
+internal fun </*0*/ T> emptyList(): kotlin.List<T>
+internal fun </*0*/ T> foo(/*0*/ f: () -> kotlin.Collection<T>, /*1*/ p: (T) -> kotlin.Boolean): kotlin.Collection<T>
+internal fun test(): kotlin.Collection<kotlin.Int>
diff --git a/compiler/testData/diagnostics/tests/resolve/nestedCalls/kt7597.kt b/compiler/testData/diagnostics/tests/resolve/nestedCalls/kt7597.kt
index 9d8aac8a083..9e8cb9218b1 100644
--- a/compiler/testData/diagnostics/tests/resolve/nestedCalls/kt7597.kt
+++ b/compiler/testData/diagnostics/tests/resolve/nestedCalls/kt7597.kt
@@ -1,10 +1,8 @@
-// !CHECK_TYPE
-
 interface Inv<I>
 
 fun <S, T: S> Inv<T>.reduce2(): S = null!!
 
 fun test(a: Inv<Int>): Int {
-    val b = 1 <!OVERLOAD_RESOLUTION_AMBIGUITY!>+<!> a.reduce2()
-    return <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>b<!>
+    val b = 1 + a.reduce2()
+    return b
 }
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/resolve/nestedCalls/twoTypeParameters.kt b/compiler/testData/diagnostics/tests/resolve/nestedCalls/twoTypeParameters.kt
index ab81fa1efc1..298efdc4e3d 100644
--- a/compiler/testData/diagnostics/tests/resolve/nestedCalls/twoTypeParameters.kt
+++ b/compiler/testData/diagnostics/tests/resolve/nestedCalls/twoTypeParameters.kt
@@ -6,7 +6,12 @@ fun <D, E : D> List<ResolutionTask<D, E>>.bar(t: ResolutionTask<D, E>) = t
 
 public class ResolutionTaskHolder<F, G : F> {
     fun test(candidate: ResolutionCandidate<F>, tasks: MutableList<ResolutionTask<F, G>>) {
-        tasks.bar(ResolutionTask(candidate))
+        tasks.bar(ResolutionTask<F, G>(candidate))
+        tasks.add(ResolutionTask<F, G>(candidate))
+
+        //todo the problem is the type of ResolutionTask is inferred as ResolutionTask<F, F> too early
+        tasks.<!TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS!>bar<!>(ResolutionTask(candidate))
+        tasks.<!NONE_APPLICABLE!>add<!>(ResolutionTask(candidate))
     }
 }
 
diff --git a/compiler/testData/diagnostics/tests/resolve/resolveAnnotatedLambdaArgument.kt b/compiler/testData/diagnostics/tests/resolve/resolveAnnotatedLambdaArgument.kt
index 2425a866945..78a2967dd2d 100644
--- a/compiler/testData/diagnostics/tests/resolve/resolveAnnotatedLambdaArgument.kt
+++ b/compiler/testData/diagnostics/tests/resolve/resolveAnnotatedLambdaArgument.kt
@@ -1,5 +1,6 @@
 // !DIAGNOSTICS: -UNUSED_PARAMETER
-annotation class Ann
+target(AnnotationTarget.EXPRESSION)
+annotation(repeatable = true) class Ann
 
 fun <T> bar(block: (T) -> Int) {}
 
diff --git a/compiler/testData/diagnostics/tests/resolve/resolveAnnotatedLambdaArgument.txt b/compiler/testData/diagnostics/tests/resolve/resolveAnnotatedLambdaArgument.txt
index 07a4482db96..ee455a37a64 100644
--- a/compiler/testData/diagnostics/tests/resolve/resolveAnnotatedLambdaArgument.txt
+++ b/compiler/testData/diagnostics/tests/resolve/resolveAnnotatedLambdaArgument.txt
@@ -3,7 +3,7 @@ package
 internal fun </*0*/ T> bar(/*0*/ block: (T) -> kotlin.Int): kotlin.Unit
 internal fun foo(): kotlin.Unit
 
-internal final annotation class Ann : kotlin.Annotation {
+kotlin.annotation.target(allowedTargets = {AnnotationTarget.EXPRESSION}) kotlin.annotation.annotation(repeatable = true) internal final class Ann : kotlin.Annotation {
     public constructor Ann()
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
     public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
diff --git a/compiler/testData/diagnostics/tests/resolve/resolveWithSpecifiedFunctionLiteralWithId.kt b/compiler/testData/diagnostics/tests/resolve/resolveWithSpecifiedFunctionLiteralWithId.kt
index bb0bd0b58f5..ad2dc2764be 100644
--- a/compiler/testData/diagnostics/tests/resolve/resolveWithSpecifiedFunctionLiteralWithId.kt
+++ b/compiler/testData/diagnostics/tests/resolve/resolveWithSpecifiedFunctionLiteralWithId.kt
@@ -10,26 +10,26 @@ fun foo(s: String, a: Any) = s + a
 fun foo(a: Any, s: String) = s + a
 fun foo(i: Int, j: Int) = i + j
 fun foo(a: Any, i: Int) = "$a$i"
-fun foo(f: (Int)->Int, i: Int) = f(i)
-fun foo(f: (String)->Int, s: String) = f(s)
-fun foo(f: (Any)->Int, a: Any) = f(a)
-fun foo(s: String, f: (String)->Int) = f(s)
-fun foo(a: Any, f: (Any)->Int) = f(a)
+fun foo(f: (Int) -> Int, i: Int) = f(i)
+fun foo(f: (String) -> Int, s: String) = f(s)
+fun foo(f: (Any) -> Int, a: Any) = f(a)
+fun foo(s: String, f: (String) -> Int) = f(s)
+fun foo(a: Any, f: (Any) -> Int) = f(a)
 //appropriate function
-fun foo(i: Int, f: (Int)->Int) = f(i)
+fun foo(i: Int, f: (Int) -> Int) = f(i)
 
 fun id<T>(t: T) = t
 
 fun test() {
-    foo(1, id { <!DEPRECATED_LAMBDA_SYNTAX!>(x1: Int):Int<!> ->
-        foo(2, id { <!DEPRECATED_LAMBDA_SYNTAX!>(x2: Int): Int<!> ->
-            foo(3, id { <!DEPRECATED_LAMBDA_SYNTAX!>(x3: Int): Int<!> ->
-                foo(4, id { <!DEPRECATED_LAMBDA_SYNTAX!>(x4: Int): Int<!> ->
-                    foo(5, id { <!DEPRECATED_LAMBDA_SYNTAX!>(x5: Int): Int<!> ->
-                        x1 + x2 + x3 + x4 + x5 + A.iii
-                    })
-                })
-            })
-        })
-    })
+    foo(1, id(fun(x1: Int) =
+          foo(2, id(fun(x2: Int) =
+                foo(3, id(fun(x3: Int) =
+                      foo(4, id(fun(x4: Int) =
+                            foo(5, id(fun(x5: Int) =
+                                  x1 + x2 + x3 + x4 + x5 + A.iii
+                            ))
+                      ))
+                ))
+          ))
+    ))
 }
diff --git a/compiler/testData/diagnostics/tests/scopes/visibility2.txt b/compiler/testData/diagnostics/tests/scopes/visibility2.txt
index db6469ade5f..05bfe99c825 100644
--- a/compiler/testData/diagnostics/tests/scopes/visibility2.txt
+++ b/compiler/testData/diagnostics/tests/scopes/visibility2.txt
@@ -36,41 +36,41 @@ package b {
         invisible_fake final override /*1*/ /*fake_override*/ var elementData: kotlin.Array<(out) kotlin.Any!>!
         protected/*protected and package*/ final override /*1*/ /*fake_override*/ var modCount: kotlin.Int
         invisible_fake final override /*1*/ /*fake_override*/ var size: kotlin.Int
-        public open override /*1*/ /*fake_override*/ fun add(/*0*/ e: java.lang.Integer!): kotlin.Boolean
-        public open override /*1*/ /*fake_override*/ fun add(/*0*/ index: kotlin.Int, /*1*/ element: java.lang.Integer!): kotlin.Unit
-        public open override /*1*/ /*fake_override*/ fun addAll(/*0*/ c: (kotlin.MutableCollection<out java.lang.Integer!>..kotlin.Collection<java.lang.Integer!>?)): kotlin.Boolean
-        public open override /*1*/ /*fake_override*/ fun addAll(/*0*/ index: kotlin.Int, /*1*/ c: (kotlin.MutableCollection<out java.lang.Integer!>..kotlin.Collection<java.lang.Integer!>?)): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun add(/*0*/ e: java.lang.Integer): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun add(/*0*/ index: kotlin.Int, /*1*/ element: java.lang.Integer): kotlin.Unit
+        public open override /*1*/ /*fake_override*/ fun addAll(/*0*/ c: kotlin.Collection<java.lang.Integer>): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun addAll(/*0*/ index: kotlin.Int, /*1*/ c: kotlin.Collection<java.lang.Integer>): kotlin.Boolean
         invisible_fake open override /*1*/ /*fake_override*/ fun batchRemove(/*0*/ p0: kotlin.(Mutable)Collection<*>!, /*1*/ p1: kotlin.Boolean): kotlin.Boolean
         public open override /*1*/ /*fake_override*/ fun clear(): kotlin.Unit
-        public open override /*1*/ /*fake_override*/ fun clone(): kotlin.Any!
-        public open override /*1*/ /*fake_override*/ fun contains(/*0*/ o: kotlin.Any!): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun clone(): kotlin.Any
+        public open override /*1*/ /*fake_override*/ fun contains(/*0*/ o: kotlin.Any?): kotlin.Boolean
         public open override /*1*/ /*fake_override*/ fun containsAll(/*0*/ c: kotlin.Collection<kotlin.Any?>): kotlin.Boolean
         invisible_fake open override /*1*/ /*fake_override*/ fun elementData(/*0*/ p0: kotlin.Int): java.lang.Integer!
         public open override /*1*/ /*fake_override*/ fun ensureCapacity(/*0*/ p0: kotlin.Int): kotlin.Unit
         invisible_fake open override /*1*/ /*fake_override*/ fun ensureCapacityInternal(/*0*/ p0: kotlin.Int): kotlin.Unit
         public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
         invisible_fake open override /*1*/ /*fake_override*/ fun fastRemove(/*0*/ p0: kotlin.Int): kotlin.Unit
-        public open override /*1*/ /*fake_override*/ fun get(/*0*/ index: kotlin.Int): java.lang.Integer!
+        public open override /*1*/ /*fake_override*/ fun get(/*0*/ index: kotlin.Int): java.lang.Integer
         invisible_fake open override /*1*/ /*fake_override*/ fun grow(/*0*/ p0: kotlin.Int): kotlin.Unit
         public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
-        public open override /*1*/ /*fake_override*/ fun indexOf(/*0*/ o: kotlin.Any!): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun indexOf(/*0*/ o: kotlin.Any?): kotlin.Int
         public open override /*1*/ /*fake_override*/ fun isEmpty(): kotlin.Boolean
-        public open override /*1*/ /*fake_override*/ fun iterator(): kotlin.(Mutable)Iterator<java.lang.Integer!>!
-        public open override /*1*/ /*fake_override*/ fun lastIndexOf(/*0*/ o: kotlin.Any!): kotlin.Int
-        public open override /*1*/ /*fake_override*/ fun listIterator(): kotlin.(Mutable)ListIterator<java.lang.Integer!>!
-        public open override /*1*/ /*fake_override*/ fun listIterator(/*0*/ index: kotlin.Int): kotlin.(Mutable)ListIterator<java.lang.Integer!>!
+        public open override /*1*/ /*fake_override*/ fun iterator(): kotlin.MutableIterator<java.lang.Integer>
+        public open override /*1*/ /*fake_override*/ fun lastIndexOf(/*0*/ o: kotlin.Any?): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun listIterator(): kotlin.MutableListIterator<java.lang.Integer>
+        public open override /*1*/ /*fake_override*/ fun listIterator(/*0*/ index: kotlin.Int): kotlin.MutableListIterator<java.lang.Integer>
         invisible_fake open override /*1*/ /*fake_override*/ fun outOfBoundsMsg(/*0*/ p0: kotlin.Int): kotlin.String!
         invisible_fake open override /*1*/ /*fake_override*/ fun rangeCheck(/*0*/ p0: kotlin.Int): kotlin.Unit
         invisible_fake open override /*1*/ /*fake_override*/ fun rangeCheckForAdd(/*0*/ p0: kotlin.Int): kotlin.Unit
         invisible_fake open override /*1*/ /*fake_override*/ fun readObject(/*0*/ p0: java.io.ObjectInputStream!): 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): java.lang.Integer!
-        public open override /*1*/ /*fake_override*/ fun removeAll(/*0*/ c: kotlin.(Mutable)Collection<*>!): kotlin.Boolean
+        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): java.lang.Integer
+        public open override /*1*/ /*fake_override*/ fun removeAll(/*0*/ c: kotlin.Collection<*>): kotlin.Boolean
         protected/*protected and package*/ open override /*1*/ /*fake_override*/ fun removeRange(/*0*/ p0: kotlin.Int, /*1*/ p1: kotlin.Int): kotlin.Unit
-        public open override /*1*/ /*fake_override*/ fun retainAll(/*0*/ c: kotlin.(Mutable)Collection<*>!): kotlin.Boolean
-        public open override /*1*/ /*fake_override*/ fun set(/*0*/ index: kotlin.Int, /*1*/ element: java.lang.Integer!): java.lang.Integer!
+        public open override /*1*/ /*fake_override*/ fun retainAll(/*0*/ c: kotlin.Collection<*>): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun set(/*0*/ index: kotlin.Int, /*1*/ element: java.lang.Integer): java.lang.Integer
         public open override /*1*/ /*fake_override*/ fun size(): kotlin.Int
-        public open override /*1*/ /*fake_override*/ fun subList(/*0*/ fromIndex: kotlin.Int, /*1*/ toIndex: kotlin.Int): kotlin.(Mutable)List<java.lang.Integer!>!
+        public open override /*1*/ /*fake_override*/ fun subList(/*0*/ fromIndex: kotlin.Int, /*1*/ toIndex: kotlin.Int): kotlin.MutableList<java.lang.Integer>
         public open override /*1*/ /*fake_override*/ fun toArray(): kotlin.Array<(out) kotlin.Any!>!
         public open override /*1*/ /*fake_override*/ fun </*0*/ T> toArray(/*0*/ p0: kotlin.Array<(out) T!>!): kotlin.Array<(out) T!>!
         public open override /*1*/ fun toString(): kotlin.String
diff --git a/compiler/testData/diagnostics/tests/secondaryConstructors/ctrsAnnotationResolve.txt b/compiler/testData/diagnostics/tests/secondaryConstructors/ctrsAnnotationResolve.txt
index fe82d9818f9..d2331f93dbd 100644
--- a/compiler/testData/diagnostics/tests/secondaryConstructors/ctrsAnnotationResolve.txt
+++ b/compiler/testData/diagnostics/tests/secondaryConstructors/ctrsAnnotationResolve.txt
@@ -3,20 +3,20 @@ package
 internal final class A {
     Ann1() public constructor A()
     Ann2() public constructor A(/*0*/ x1: kotlin.Int)
-    Ann2(x = IntegerValueType(2)) public constructor A(/*0*/ x1: kotlin.Int, /*1*/ x2: kotlin.Int)
+    Ann2(x = 2) public constructor A(/*0*/ x1: kotlin.Int, /*1*/ x2: kotlin.Int)
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
     public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
 }
 
-internal final annotation class Ann1 : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class Ann1 : kotlin.Annotation {
     public constructor Ann1()
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
     public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
 }
 
-internal final annotation class Ann2 : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class Ann2 : kotlin.Annotation {
     public constructor Ann2(/*0*/ x: kotlin.Int)
     internal final val x: kotlin.Int
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
diff --git a/compiler/testData/diagnostics/tests/smartCasts/inference/kt1275.kt b/compiler/testData/diagnostics/tests/smartCasts/inference/kt1275.kt
new file mode 100644
index 00000000000..d3a519cc2d0
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/smartCasts/inference/kt1275.kt
@@ -0,0 +1,11 @@
+// !CHECK_TYPE
+
+fun foo(s : String?, b : Boolean) {
+    if (s == null) return
+
+    val s1 = if (b) "" else <!DEBUG_INFO_SMARTCAST!>s<!>
+    s1 checkType { _<String>() }
+
+    val s2 = s
+    <!DEBUG_INFO_SMARTCAST!>s2<!> checkType { _<String>() }
+}
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/smartCasts/inference/kt1275.txt b/compiler/testData/diagnostics/tests/smartCasts/inference/kt1275.txt
new file mode 100644
index 00000000000..420da32d346
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/smartCasts/inference/kt1275.txt
@@ -0,0 +1,3 @@
+package
+
+internal fun foo(/*0*/ s: kotlin.String?, /*1*/ b: kotlin.Boolean): kotlin.Unit
diff --git a/compiler/testData/diagnostics/tests/subtyping/findClosestCorrespondingSupertype.kt b/compiler/testData/diagnostics/tests/subtyping/findClosestCorrespondingSupertype.kt
new file mode 100644
index 00000000000..a0123248f44
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/subtyping/findClosestCorrespondingSupertype.kt
@@ -0,0 +1,10 @@
+// !DIAGNOSTICS: -UNUSED_VARIABLE
+
+interface X<T>
+interface A: X<String>
+interface B : <!INCONSISTENT_TYPE_PARAMETER_VALUES!>A, X<Int><!>
+
+fun foo(x: B) {
+    // Checks that when checking subtypes we search closes corresponding constructor (e.g. with BFS)
+    val y: X<Int> = x
+}
diff --git a/compiler/testData/diagnostics/tests/subtyping/findClosestCorrespondingSupertype.txt b/compiler/testData/diagnostics/tests/subtyping/findClosestCorrespondingSupertype.txt
new file mode 100644
index 00000000000..f0dfc7c8267
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/subtyping/findClosestCorrespondingSupertype.txt
@@ -0,0 +1,21 @@
+package
+
+internal fun foo(/*0*/ x: B): kotlin.Unit
+
+internal interface A : X<kotlin.String> {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+internal interface B : A, X<kotlin.Int> {
+    public open override /*2*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*2*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*2*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+internal interface X</*0*/ T> {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
diff --git a/compiler/testData/diagnostics/tests/subtyping/kt-1457.txt b/compiler/testData/diagnostics/tests/subtyping/kt-1457.txt
index 49c11b0035e..6a2b7303465 100644
--- a/compiler/testData/diagnostics/tests/subtyping/kt-1457.txt
+++ b/compiler/testData/diagnostics/tests/subtyping/kt-1457.txt
@@ -7,41 +7,41 @@ internal final class MyListOfPairs</*0*/ T> : java.util.ArrayList<Pair<T, T>> {
     invisible_fake final override /*1*/ /*fake_override*/ var elementData: kotlin.Array<(out) kotlin.Any!>!
     protected/*protected and package*/ final override /*1*/ /*fake_override*/ var modCount: kotlin.Int
     invisible_fake final override /*1*/ /*fake_override*/ var size: kotlin.Int
-    public open override /*1*/ /*fake_override*/ fun add(/*0*/ e: Pair<T, T>!): kotlin.Boolean
-    public open override /*1*/ /*fake_override*/ fun add(/*0*/ index: kotlin.Int, /*1*/ element: Pair<T, T>!): kotlin.Unit
-    public open override /*1*/ /*fake_override*/ fun addAll(/*0*/ c: (kotlin.MutableCollection<out Pair<T, T>!>..kotlin.Collection<Pair<T, T>!>?)): kotlin.Boolean
-    public open override /*1*/ /*fake_override*/ fun addAll(/*0*/ index: kotlin.Int, /*1*/ c: (kotlin.MutableCollection<out Pair<T, T>!>..kotlin.Collection<Pair<T, T>!>?)): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun add(/*0*/ e: Pair<T, T>): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun add(/*0*/ index: kotlin.Int, /*1*/ element: Pair<T, T>): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun addAll(/*0*/ c: kotlin.Collection<Pair<T, T>>): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun addAll(/*0*/ index: kotlin.Int, /*1*/ c: kotlin.Collection<Pair<T, T>>): kotlin.Boolean
     invisible_fake open override /*1*/ /*fake_override*/ fun batchRemove(/*0*/ p0: kotlin.(Mutable)Collection<*>!, /*1*/ p1: kotlin.Boolean): kotlin.Boolean
     public open override /*1*/ /*fake_override*/ fun clear(): kotlin.Unit
-    public open override /*1*/ /*fake_override*/ fun clone(): kotlin.Any!
-    public open override /*1*/ /*fake_override*/ fun contains(/*0*/ o: kotlin.Any!): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun clone(): kotlin.Any
+    public open override /*1*/ /*fake_override*/ fun contains(/*0*/ o: kotlin.Any?): kotlin.Boolean
     public open override /*1*/ /*fake_override*/ fun containsAll(/*0*/ c: kotlin.Collection<kotlin.Any?>): kotlin.Boolean
     invisible_fake open override /*1*/ /*fake_override*/ fun elementData(/*0*/ p0: kotlin.Int): Pair<T, T>!
     public open override /*1*/ /*fake_override*/ fun ensureCapacity(/*0*/ p0: kotlin.Int): kotlin.Unit
     invisible_fake open override /*1*/ /*fake_override*/ fun ensureCapacityInternal(/*0*/ p0: kotlin.Int): kotlin.Unit
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
     invisible_fake open override /*1*/ /*fake_override*/ fun fastRemove(/*0*/ p0: kotlin.Int): kotlin.Unit
-    public open override /*1*/ /*fake_override*/ fun get(/*0*/ index: kotlin.Int): Pair<T, T>!
+    public open override /*1*/ /*fake_override*/ fun get(/*0*/ index: kotlin.Int): Pair<T, T>
     invisible_fake open override /*1*/ /*fake_override*/ fun grow(/*0*/ p0: kotlin.Int): kotlin.Unit
     public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
-    public open override /*1*/ /*fake_override*/ fun indexOf(/*0*/ o: kotlin.Any!): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun indexOf(/*0*/ o: kotlin.Any?): kotlin.Int
     public open override /*1*/ /*fake_override*/ fun isEmpty(): kotlin.Boolean
-    public open override /*1*/ /*fake_override*/ fun iterator(): kotlin.(Mutable)Iterator<Pair<T, T>!>!
-    public open override /*1*/ /*fake_override*/ fun lastIndexOf(/*0*/ o: kotlin.Any!): kotlin.Int
-    public open override /*1*/ /*fake_override*/ fun listIterator(): kotlin.(Mutable)ListIterator<Pair<T, T>!>!
-    public open override /*1*/ /*fake_override*/ fun listIterator(/*0*/ index: kotlin.Int): kotlin.(Mutable)ListIterator<Pair<T, T>!>!
+    public open override /*1*/ /*fake_override*/ fun iterator(): kotlin.MutableIterator<Pair<T, T>>
+    public open override /*1*/ /*fake_override*/ fun lastIndexOf(/*0*/ o: kotlin.Any?): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun listIterator(): kotlin.MutableListIterator<Pair<T, T>>
+    public open override /*1*/ /*fake_override*/ fun listIterator(/*0*/ index: kotlin.Int): kotlin.MutableListIterator<Pair<T, T>>
     invisible_fake open override /*1*/ /*fake_override*/ fun outOfBoundsMsg(/*0*/ p0: kotlin.Int): kotlin.String!
     invisible_fake open override /*1*/ /*fake_override*/ fun rangeCheck(/*0*/ p0: kotlin.Int): kotlin.Unit
     invisible_fake open override /*1*/ /*fake_override*/ fun rangeCheckForAdd(/*0*/ p0: kotlin.Int): kotlin.Unit
     invisible_fake open override /*1*/ /*fake_override*/ fun readObject(/*0*/ p0: java.io.ObjectInputStream!): 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): Pair<T, T>!
-    public open override /*1*/ /*fake_override*/ fun removeAll(/*0*/ c: kotlin.(Mutable)Collection<*>!): kotlin.Boolean
+    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): Pair<T, T>
+    public open override /*1*/ /*fake_override*/ fun removeAll(/*0*/ c: kotlin.Collection<*>): kotlin.Boolean
     protected/*protected and package*/ open override /*1*/ /*fake_override*/ fun removeRange(/*0*/ p0: kotlin.Int, /*1*/ p1: kotlin.Int): kotlin.Unit
-    public open override /*1*/ /*fake_override*/ fun retainAll(/*0*/ c: kotlin.(Mutable)Collection<*>!): kotlin.Boolean
-    public open override /*1*/ /*fake_override*/ fun set(/*0*/ index: kotlin.Int, /*1*/ element: Pair<T, T>!): Pair<T, T>!
+    public open override /*1*/ /*fake_override*/ fun retainAll(/*0*/ c: kotlin.Collection<*>): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun set(/*0*/ index: kotlin.Int, /*1*/ element: Pair<T, T>): Pair<T, T>
     public open override /*1*/ /*fake_override*/ fun size(): kotlin.Int
-    public open override /*1*/ /*fake_override*/ fun subList(/*0*/ fromIndex: kotlin.Int, /*1*/ toIndex: kotlin.Int): kotlin.(Mutable)List<Pair<T, T>!>!
+    public open override /*1*/ /*fake_override*/ fun subList(/*0*/ fromIndex: kotlin.Int, /*1*/ toIndex: kotlin.Int): kotlin.MutableList<Pair<T, T>>
     public open override /*1*/ /*fake_override*/ fun toArray(): kotlin.Array<(out) kotlin.Any!>!
     public open override /*1*/ /*fake_override*/ fun </*0*/ T> toArray(/*0*/ p0: kotlin.Array<(out) T!>!): kotlin.Array<(out) T!>!
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
diff --git a/compiler/testData/diagnostics/tests/syntheticExtensions/AbbreviationName.kt b/compiler/testData/diagnostics/tests/syntheticExtensions/AbbreviationName.kt
new file mode 100644
index 00000000000..2c812f9d52b
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/syntheticExtensions/AbbreviationName.kt
@@ -0,0 +1,20 @@
+// FILE: KotlinFile.kt
+fun foo(javaClass: JavaClass) {
+    javaClass.url = javaClass.url + "/"
+    javaClass.htmlFile += "1"
+
+    javaClass.<!UNRESOLVED_REFERENCE!>URL<!>
+    javaClass.<!UNRESOLVED_REFERENCE!>uRL<!>
+    javaClass.<!UNRESOLVED_REFERENCE!>HTMLFile<!>
+    javaClass.<!UNRESOLVED_REFERENCE!>hTMLFile<!>
+    javaClass.<!UNRESOLVED_REFERENCE!>htmlfile<!>
+}
+
+// FILE: JavaClass.java
+public class JavaClass {
+    public String getURL() { return true; }
+    public void setURL(String value) { }
+
+    public String getHTMLFile() { return true; }
+    public void setHTMLFile(String value) { }
+}
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/syntheticExtensions/AbbreviationName.txt b/compiler/testData/diagnostics/tests/syntheticExtensions/AbbreviationName.txt
new file mode 100644
index 00000000000..6d50ee24342
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/syntheticExtensions/AbbreviationName.txt
@@ -0,0 +1,14 @@
+package
+
+internal fun foo(/*0*/ javaClass: JavaClass): kotlin.Unit
+
+public open class JavaClass {
+    public constructor JavaClass()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open fun getHTMLFile(): kotlin.String!
+    public open fun getURL(): kotlin.String!
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open fun setHTMLFile(/*0*/ value: kotlin.String!): kotlin.Unit
+    public open fun setURL(/*0*/ value: kotlin.String!): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
diff --git a/compiler/testData/diagnostics/tests/syntheticExtensions/Bases.kt b/compiler/testData/diagnostics/tests/syntheticExtensions/Bases.kt
new file mode 100644
index 00000000000..2ea41e308b1
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/syntheticExtensions/Bases.kt
@@ -0,0 +1,31 @@
+// FILE: KotlinFile.kt
+open class KotlinClass1 : JavaClass1() {
+    public fun getSomethingKotlin1(): Int = 1
+}
+
+class KotlinClass2 : JavaClass2() {
+    public fun getSomethingKotlin2(): Int = 1
+}
+
+fun foo(k: KotlinClass2) {
+    useInt(k.getSomething1())
+    useInt(k.something1)
+    useInt(k.getSomething2())
+    useInt(k.something2)
+    useInt(k.getSomethingKotlin1())
+    useInt(k.getSomethingKotlin2())
+    k.<!UNRESOLVED_REFERENCE!>somethingKotlin1<!>
+    k.<!UNRESOLVED_REFERENCE!>somethingKotlin2<!>
+}
+
+fun useInt(<!UNUSED_PARAMETER!>i<!>: Int) {}
+
+// FILE: JavaClass1.java
+public class JavaClass1 {
+    public int getSomething1() { return 1; }
+}
+
+// FILE: JavaClass2.java
+public class JavaClass2 extends KotlinClass1 {
+    public int getSomething2() { return 1; }
+}
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/syntheticExtensions/Bases.txt b/compiler/testData/diagnostics/tests/syntheticExtensions/Bases.txt
new file mode 100644
index 00000000000..2681c9cc870
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/syntheticExtensions/Bases.txt
@@ -0,0 +1,42 @@
+package
+
+internal fun foo(/*0*/ k: KotlinClass2): kotlin.Unit
+internal fun useInt(/*0*/ i: kotlin.Int): kotlin.Unit
+
+public open class JavaClass1 {
+    public constructor JavaClass1()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open fun getSomething1(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public open class JavaClass2 : KotlinClass1 {
+    public constructor JavaClass2()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun getSomething1(): kotlin.Int
+    public open fun getSomething2(): kotlin.Int
+    public final override /*1*/ /*fake_override*/ fun getSomethingKotlin1(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+internal open class KotlinClass1 : JavaClass1 {
+    public constructor KotlinClass1()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun getSomething1(): kotlin.Int
+    public final fun getSomethingKotlin1(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+internal final class KotlinClass2 : JavaClass2 {
+    public constructor KotlinClass2()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun getSomething1(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun getSomething2(): kotlin.Int
+    public final override /*1*/ /*fake_override*/ fun getSomethingKotlin1(): kotlin.Int
+    public final fun getSomethingKotlin2(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
diff --git a/compiler/testData/diagnostics/tests/syntheticExtensions/CompiledClass.kt b/compiler/testData/diagnostics/tests/syntheticExtensions/CompiledClass.kt
new file mode 100644
index 00000000000..07e822a3ee7
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/syntheticExtensions/CompiledClass.kt
@@ -0,0 +1,6 @@
+// FILE: KotlinFile.kt
+import java.io.File
+
+fun foo(file: File) {
+    file.absolutePath.length()
+}
diff --git a/compiler/testData/diagnostics/tests/syntheticExtensions/CompiledClass.txt b/compiler/testData/diagnostics/tests/syntheticExtensions/CompiledClass.txt
new file mode 100644
index 00000000000..736b22b85f4
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/syntheticExtensions/CompiledClass.txt
@@ -0,0 +1,3 @@
+package
+
+internal fun foo(/*0*/ file: java.io.File): kotlin.Unit
diff --git a/compiler/testData/diagnostics/tests/syntheticExtensions/FalseGetters.kt b/compiler/testData/diagnostics/tests/syntheticExtensions/FalseGetters.kt
new file mode 100644
index 00000000000..859abe3f688
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/syntheticExtensions/FalseGetters.kt
@@ -0,0 +1,21 @@
+// FILE: KotlinFile.kt
+fun foo(javaClass: JavaClass) {
+    javaClass.<!UNRESOLVED_REFERENCE!>something1<!>
+    javaClass.<!UNRESOLVED_REFERENCE!>something2<!>
+    javaClass.<!UNRESOLVED_REFERENCE!>somethingStatic<!>
+    javaClass.<!UNRESOLVED_REFERENCE!>somethingVoid<!>
+    javaClass.<!UNRESOLVED_REFERENCE!>ter<!>
+}
+
+// FILE: JavaClass.java
+public class JavaClass {
+    public int getSomething1(int p) { return p; }
+
+    public <T> T getSomething2() { return null; }
+
+    public static int getSomethingStatic() { return 1; }
+
+    public void getSomethingVoid() { }
+
+    public int getter() { return 1; }
+}
diff --git a/compiler/testData/diagnostics/tests/syntheticExtensions/FalseGetters.txt b/compiler/testData/diagnostics/tests/syntheticExtensions/FalseGetters.txt
new file mode 100644
index 00000000000..808b3d6d7a4
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/syntheticExtensions/FalseGetters.txt
@@ -0,0 +1,17 @@
+package
+
+internal fun foo(/*0*/ javaClass: JavaClass): kotlin.Unit
+
+public open class JavaClass {
+    public constructor JavaClass()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open fun getSomething1(/*0*/ p: kotlin.Int): kotlin.Int
+    public open fun </*0*/ T> getSomething2(): T!
+    public open fun getSomethingVoid(): kotlin.Unit
+    public open fun getter(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    // Static members
+    public open fun getSomethingStatic(): kotlin.Int
+}
diff --git a/compiler/testData/diagnostics/tests/syntheticExtensions/FalseSetters.kt b/compiler/testData/diagnostics/tests/syntheticExtensions/FalseSetters.kt
new file mode 100644
index 00000000000..1c46a2c1073
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/syntheticExtensions/FalseSetters.kt
@@ -0,0 +1,30 @@
+// FILE: KotlinFile.kt
+fun foo(javaClass: JavaClass) {
+    <!VAL_REASSIGNMENT!>javaClass.something1<!>++
+    <!VAL_REASSIGNMENT!>javaClass.something2<!>++
+    <!VAL_REASSIGNMENT!>javaClass.something3<!>++
+    <!VAL_REASSIGNMENT!>javaClass.something4<!>++
+    <!VAL_REASSIGNMENT!>javaClass.something5<!>++
+    <!VAL_REASSIGNMENT!>javaClass.something6<!> = null
+}
+
+// FILE: JavaClass.java
+public class JavaClass {
+    public int getSomething1() { return 1; }
+    public void setSomething1(int value, char c) { }
+
+    public int getSomething2() { return 1; }
+    public void setSomething2(String value) { }
+
+    public int getSomething3() { return 1; }
+    public int setSomething3(int value) { return value; }
+
+    public int getSomething4() { return 1; }
+    public <T> void setSomething4(int value) { return value; }
+
+    public int getSomething5() { return 1; }
+    public static void setSomething5(int value) { }
+
+    public int[] getSomething6() { return null; }
+    public void setSomething6(int... value) { }
+}
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/syntheticExtensions/FalseSetters.txt b/compiler/testData/diagnostics/tests/syntheticExtensions/FalseSetters.txt
new file mode 100644
index 00000000000..9493dc52099
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/syntheticExtensions/FalseSetters.txt
@@ -0,0 +1,24 @@
+package
+
+internal fun foo(/*0*/ javaClass: JavaClass): kotlin.Unit
+
+public open class JavaClass {
+    public constructor JavaClass()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open fun getSomething1(): kotlin.Int
+    public open fun getSomething2(): kotlin.Int
+    public open fun getSomething3(): kotlin.Int
+    public open fun getSomething4(): kotlin.Int
+    public open fun getSomething5(): kotlin.Int
+    public open fun getSomething6(): kotlin.IntArray!
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open fun setSomething1(/*0*/ value: kotlin.Int, /*1*/ c: kotlin.Char): kotlin.Unit
+    public open fun setSomething2(/*0*/ value: kotlin.String!): kotlin.Unit
+    public open fun setSomething3(/*0*/ value: kotlin.Int): kotlin.Int
+    public open fun </*0*/ T> setSomething4(/*0*/ value: kotlin.Int): kotlin.Unit
+    public open fun setSomething6(/*0*/ vararg value: kotlin.Int /*kotlin.IntArray!*/): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    // Static members
+    public open fun setSomething5(/*0*/ value: kotlin.Int): kotlin.Unit
+}
diff --git a/compiler/testData/diagnostics/tests/syntheticExtensions/FromTwoBases.kt b/compiler/testData/diagnostics/tests/syntheticExtensions/FromTwoBases.kt
new file mode 100644
index 00000000000..d329ecc0d80
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/syntheticExtensions/FromTwoBases.kt
@@ -0,0 +1,19 @@
+// FILE: KotlinFile.kt
+
+interface C : A, B
+
+fun foo(c: C) {
+    c.setSomething(c.getSomething() + 1)
+    c.something++
+}
+
+// FILE: A.java
+public interface A {
+    int getSomething();
+}
+
+// FILE: B.java
+public interface B {
+    int getSomething();
+    void setSomething(int value);
+}
diff --git a/compiler/testData/diagnostics/tests/syntheticExtensions/FromTwoBases.txt b/compiler/testData/diagnostics/tests/syntheticExtensions/FromTwoBases.txt
new file mode 100644
index 00000000000..658ddecc2a3
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/syntheticExtensions/FromTwoBases.txt
@@ -0,0 +1,27 @@
+package
+
+public /*synthesized*/ fun A(/*0*/ function: () -> kotlin.Int): A
+internal fun foo(/*0*/ c: C): kotlin.Unit
+
+public interface A {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public abstract fun getSomething(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public interface B {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public abstract fun getSomething(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public abstract fun setSomething(/*0*/ value: kotlin.Int): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+internal interface C : A, B {
+    public open override /*2*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public abstract override /*2*/ /*fake_override*/ fun getSomething(): kotlin.Int
+    public open override /*2*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public abstract override /*1*/ /*fake_override*/ fun setSomething(/*0*/ value: kotlin.Int): kotlin.Unit
+    public open override /*2*/ /*fake_override*/ fun toString(): kotlin.String
+}
diff --git a/compiler/testData/diagnostics/tests/syntheticExtensions/GenericClass.kt b/compiler/testData/diagnostics/tests/syntheticExtensions/GenericClass.kt
new file mode 100644
index 00000000000..71a600c59a2
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/syntheticExtensions/GenericClass.kt
@@ -0,0 +1,10 @@
+// FILE: KotlinFile.kt
+fun foo(javaClass: JavaClass<String>) {
+    javaClass.something += "x"
+}
+
+// FILE: JavaClass.java
+public class JavaClass<T> {
+    public T getSomething() { return null; }
+    public void setSomething(T value) { }
+}
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/syntheticExtensions/GenericClass.txt b/compiler/testData/diagnostics/tests/syntheticExtensions/GenericClass.txt
new file mode 100644
index 00000000000..7f43ca97e8a
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/syntheticExtensions/GenericClass.txt
@@ -0,0 +1,12 @@
+package
+
+internal fun foo(/*0*/ javaClass: JavaClass<kotlin.String>): kotlin.Unit
+
+public open class JavaClass</*0*/ T> {
+    public constructor JavaClass</*0*/ T>()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open fun getSomething(): T!
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open fun setSomething(/*0*/ value: T!): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
diff --git a/compiler/testData/diagnostics/tests/syntheticExtensions/Getter.kt b/compiler/testData/diagnostics/tests/syntheticExtensions/Getter.kt
new file mode 100644
index 00000000000..314f895def1
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/syntheticExtensions/Getter.kt
@@ -0,0 +1,20 @@
+// FILE: KotlinFile.kt
+class KotlinClass {
+    public fun getSomething(): Int = 1
+}
+
+fun foo(javaClass: JavaClass, kotlinClass: KotlinClass) {
+    useInt(javaClass.getSomething())
+    useInt(javaClass.something)
+    <!VAL_REASSIGNMENT!>javaClass.something<!> = 1
+    javaClass.<!UNRESOLVED_REFERENCE!>Something<!>
+    useInt(kotlinClass.getSomething())
+    kotlinClass.<!UNRESOLVED_REFERENCE!>something<!>
+}
+
+fun useInt(<!UNUSED_PARAMETER!>i<!>: Int) {}
+
+// FILE: JavaClass.java
+public class JavaClass {
+    public int getSomething() { return 1; }
+}
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/syntheticExtensions/Getter.txt b/compiler/testData/diagnostics/tests/syntheticExtensions/Getter.txt
new file mode 100644
index 00000000000..f82412dce00
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/syntheticExtensions/Getter.txt
@@ -0,0 +1,20 @@
+package
+
+internal fun foo(/*0*/ javaClass: JavaClass, /*1*/ kotlinClass: KotlinClass): kotlin.Unit
+internal fun useInt(/*0*/ i: kotlin.Int): kotlin.Unit
+
+public open class JavaClass {
+    public constructor JavaClass()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open fun getSomething(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+internal final class KotlinClass {
+    public constructor KotlinClass()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public final fun getSomething(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
diff --git a/compiler/testData/diagnostics/tests/syntheticExtensions/GetterAndSetter.kt b/compiler/testData/diagnostics/tests/syntheticExtensions/GetterAndSetter.kt
new file mode 100644
index 00000000000..c26c6947cd1
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/syntheticExtensions/GetterAndSetter.kt
@@ -0,0 +1,10 @@
+// FILE: KotlinFile.kt
+fun foo(javaClass: JavaClass) {
+    javaClass.something++
+}
+
+// FILE: JavaClass.java
+public class JavaClass {
+    public int getSomething() { return 1; }
+    public void setSomething(int value) { }
+}
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/syntheticExtensions/GetterAndSetter.txt b/compiler/testData/diagnostics/tests/syntheticExtensions/GetterAndSetter.txt
new file mode 100644
index 00000000000..b45913cb221
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/syntheticExtensions/GetterAndSetter.txt
@@ -0,0 +1,12 @@
+package
+
+internal fun foo(/*0*/ javaClass: JavaClass): kotlin.Unit
+
+public open class JavaClass {
+    public constructor JavaClass()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open fun getSomething(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open fun setSomething(/*0*/ value: kotlin.Int): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
diff --git a/compiler/testData/diagnostics/tests/syntheticExtensions/ImplicitReceiver.kt b/compiler/testData/diagnostics/tests/syntheticExtensions/ImplicitReceiver.kt
new file mode 100644
index 00000000000..f8aa9d9af1c
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/syntheticExtensions/ImplicitReceiver.kt
@@ -0,0 +1,12 @@
+// FILE: KotlinFile.kt
+fun JavaClass.foo() {
+    useInt(getSomething())
+    useInt(something)
+}
+
+fun useInt(<!UNUSED_PARAMETER!>i<!>: Int) {}
+
+// FILE: JavaClass.java
+public class JavaClass {
+    public int getSomething() { return 1; }
+}
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/syntheticExtensions/ImplicitReceiver.txt b/compiler/testData/diagnostics/tests/syntheticExtensions/ImplicitReceiver.txt
new file mode 100644
index 00000000000..31708c4748a
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/syntheticExtensions/ImplicitReceiver.txt
@@ -0,0 +1,12 @@
+package
+
+internal fun useInt(/*0*/ i: kotlin.Int): kotlin.Unit
+internal fun JavaClass.foo(): kotlin.Unit
+
+public open class JavaClass {
+    public constructor JavaClass()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open fun getSomething(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
diff --git a/compiler/testData/diagnostics/tests/syntheticExtensions/IsNaming.kt b/compiler/testData/diagnostics/tests/syntheticExtensions/IsNaming.kt
new file mode 100644
index 00000000000..45eb42ecf0a
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/syntheticExtensions/IsNaming.kt
@@ -0,0 +1,30 @@
+// FILE: KotlinFile.kt
+fun foo(javaClass: JavaClass) {
+    javaClass.isSomething = !javaClass.isSomething
+    javaClass.isSomething2 = !javaClass.isSomething2
+
+    javaClass.<!UNRESOLVED_REFERENCE!>something<!>
+    javaClass.<!FUNCTION_CALL_EXPECTED!>isSomethingWrong<!>
+    javaClass.<!UNRESOLVED_REFERENCE!>somethingWrong<!>
+}
+
+// FILE: JavaClass.java
+public class JavaClass {
+    public boolean isSomething() {
+        return true;
+    }
+
+    public void setSomething(boolean value) {
+    }
+
+    public boolean getIsSomething2() {
+        return true;
+    }
+
+    public void setIsSomething2(boolean value) {
+    }
+
+    public int isSomethingWrong() {
+        return 1;
+    }
+}
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/syntheticExtensions/IsNaming.txt b/compiler/testData/diagnostics/tests/syntheticExtensions/IsNaming.txt
new file mode 100644
index 00000000000..93bde185b5b
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/syntheticExtensions/IsNaming.txt
@@ -0,0 +1,15 @@
+package
+
+internal fun foo(/*0*/ javaClass: JavaClass): kotlin.Unit
+
+public open class JavaClass {
+    public constructor JavaClass()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open fun getIsSomething2(): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open fun isSomething(): kotlin.Boolean
+    public open fun isSomethingWrong(): kotlin.Int
+    public open fun setIsSomething2(/*0*/ value: kotlin.Boolean): kotlin.Unit
+    public open fun setSomething(/*0*/ value: kotlin.Boolean): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
diff --git a/compiler/testData/diagnostics/tests/syntheticExtensions/JavaOverridesKotlin.kt b/compiler/testData/diagnostics/tests/syntheticExtensions/JavaOverridesKotlin.kt
new file mode 100644
index 00000000000..ca18c9b15bc
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/syntheticExtensions/JavaOverridesKotlin.kt
@@ -0,0 +1,29 @@
+// FILE: KotlinFile.kt
+open class KotlinClass {
+    public open fun getSomething1(): Int = 1
+
+    public open fun setSomething2(value: Int) {}
+}
+
+fun foo(javaClass: JavaClass) {
+    useInt(javaClass.getSomething1())
+    useInt(javaClass.<!UNRESOLVED_REFERENCE!>something1<!>)
+
+    javaClass.setSomething2(javaClass.getSomething2() + 1)
+    javaClass.something2 = javaClass.something2 + 1
+}
+
+fun useInt(<!UNUSED_PARAMETER!>i<!>: Int) {}
+
+// FILE: JavaClass.java
+public class JavaClass extends KotlinClass implements JavaInterface {
+    public int getSomething1() { return 1; }
+
+    public int getSomething2() { return 1; }
+    public void setSomething2(int value) {}
+}
+
+// FILE: JavaInterface.java
+public class JavaInterface {
+    int getSomething2();
+}
diff --git a/compiler/testData/diagnostics/tests/syntheticExtensions/JavaOverridesKotlin.txt b/compiler/testData/diagnostics/tests/syntheticExtensions/JavaOverridesKotlin.txt
new file mode 100644
index 00000000000..85484900fc5
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/syntheticExtensions/JavaOverridesKotlin.txt
@@ -0,0 +1,31 @@
+package
+
+internal fun foo(/*0*/ javaClass: JavaClass): kotlin.Unit
+internal fun useInt(/*0*/ i: kotlin.Int): kotlin.Unit
+
+public open class JavaClass : KotlinClass, JavaInterface {
+    public constructor JavaClass()
+    public open override /*2*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ fun getSomething1(): kotlin.Int
+    public open override /*1*/ fun getSomething2(): kotlin.Int
+    public open override /*2*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ fun setSomething2(/*0*/ value: kotlin.Int): kotlin.Unit
+    public open override /*2*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public open class JavaInterface {
+    public constructor JavaInterface()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public/*package*/ open fun getSomething2(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+internal open class KotlinClass {
+    public constructor KotlinClass()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open fun getSomething1(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open fun setSomething2(/*0*/ value: kotlin.Int): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
diff --git a/compiler/testData/diagnostics/tests/syntheticExtensions/KotlinOverridesJava.kt b/compiler/testData/diagnostics/tests/syntheticExtensions/KotlinOverridesJava.kt
new file mode 100644
index 00000000000..bbebad6f852
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/syntheticExtensions/KotlinOverridesJava.kt
@@ -0,0 +1,52 @@
+// FILE: KotlinFile.kt
+abstract class KotlinClass : JavaClass(), KotlinInterface, JavaInterface {
+    override fun getSomething1(): Int = 1
+    override fun getSomething3(): String = ""
+    override fun setSomething4(value: String) {}
+    override fun getSomething5(): String = ""
+}
+
+interface KotlinInterface {
+    public fun getSomething1(): Int
+    public fun getSomething4(): String
+}
+
+fun foo(k: KotlinClass) {
+    useInt(k.getSomething1())
+    useInt(k.something1)
+
+    useInt(k.getSomething2())
+    useInt(k.something2)
+
+    useString(k.getSomething3())
+    useString(k.something3)
+
+    k.setSomething4("")
+    k.something4 += ""
+    k.setSomething4(<!NULL_FOR_NONNULL_TYPE!>null<!>)
+    k.something4 = null
+
+    useString(k.getSomething5())
+    useString(k.something5)
+    k.setSomething5(1)
+    k.something5 = <!CONSTANT_EXPECTED_TYPE_MISMATCH!>1<!>
+}
+
+fun useInt(<!UNUSED_PARAMETER!>i<!>: Int) {}
+fun useString(<!UNUSED_PARAMETER!>i<!>: String) {}
+
+// FILE: JavaClass.java
+public class JavaClass {
+    public int getSomething1() { return 1; }
+    public int getSomething2() { return 1; }
+    public Object getSomething3() { return null; }
+}
+
+// FILE: JavaInterface.java
+public interface JavaInterface {
+    String getSomething4();
+    void setSomething4(String value);
+
+    Object getSomething5();
+    void setSomething5(Object value);
+}
diff --git a/compiler/testData/diagnostics/tests/syntheticExtensions/KotlinOverridesJava.txt b/compiler/testData/diagnostics/tests/syntheticExtensions/KotlinOverridesJava.txt
new file mode 100644
index 00000000000..a48f3c46a49
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/syntheticExtensions/KotlinOverridesJava.txt
@@ -0,0 +1,47 @@
+package
+
+internal fun foo(/*0*/ k: KotlinClass): kotlin.Unit
+internal fun useInt(/*0*/ i: kotlin.Int): kotlin.Unit
+internal fun useString(/*0*/ i: kotlin.String): kotlin.Unit
+
+public open class JavaClass {
+    public constructor JavaClass()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open fun getSomething1(): kotlin.Int
+    public open fun getSomething2(): kotlin.Int
+    public open fun getSomething3(): kotlin.Any!
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public interface JavaInterface {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public abstract fun getSomething4(): kotlin.String!
+    public abstract fun getSomething5(): kotlin.Any!
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public abstract fun setSomething4(/*0*/ value: kotlin.String!): kotlin.Unit
+    public abstract fun setSomething5(/*0*/ value: kotlin.Any!): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+internal abstract class KotlinClass : JavaClass, KotlinInterface, JavaInterface {
+    public constructor KotlinClass()
+    public open override /*3*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*2*/ fun getSomething1(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun getSomething2(): kotlin.Int
+    public open override /*1*/ fun getSomething3(): kotlin.String
+    public abstract override /*2*/ /*fake_override*/ fun getSomething4(): kotlin.String!
+    public open override /*1*/ fun getSomething5(): kotlin.String
+    public open override /*3*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ fun setSomething4(/*0*/ value: kotlin.String): kotlin.Unit
+    public abstract override /*1*/ /*fake_override*/ fun setSomething5(/*0*/ value: kotlin.Any!): kotlin.Unit
+    public open override /*3*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+internal interface KotlinInterface {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public abstract fun getSomething1(): kotlin.Int
+    public abstract fun getSomething4(): kotlin.String
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
diff --git a/compiler/testData/diagnostics/tests/syntheticExtensions/KotlinOverridesJava2.kt b/compiler/testData/diagnostics/tests/syntheticExtensions/KotlinOverridesJava2.kt
new file mode 100644
index 00000000000..fadda63cd94
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/syntheticExtensions/KotlinOverridesJava2.kt
@@ -0,0 +1,25 @@
+// FILE: KotlinFile.kt
+abstract class KotlinClass : JavaInterface1, JavaInterface2 {
+    override fun getSomething(): String = ""
+}
+
+fun foo(k: KotlinClass) {
+    useString(k.getSomething())
+    useString(k.something)
+    if (<!SENSELESS_COMPARISON!>k.something == null<!>) return
+
+    k.setSomething(1)
+    <!VAL_REASSIGNMENT!>k.something<!> = <!CONSTANT_EXPECTED_TYPE_MISMATCH!>1<!>
+}
+
+fun useString(<!UNUSED_PARAMETER!>i<!>: String) {}
+
+// FILE: JavaInterface1.java
+public interface JavaInterface1 {
+    String getSomething();
+}
+
+// FILE: JavaInterface2.java
+public interface JavaInterface2 {
+    void setSomething(int value);
+}
diff --git a/compiler/testData/diagnostics/tests/syntheticExtensions/KotlinOverridesJava2.txt b/compiler/testData/diagnostics/tests/syntheticExtensions/KotlinOverridesJava2.txt
new file mode 100644
index 00000000000..50f76abf47e
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/syntheticExtensions/KotlinOverridesJava2.txt
@@ -0,0 +1,29 @@
+package
+
+public /*synthesized*/ fun JavaInterface1(/*0*/ function: () -> kotlin.String!): JavaInterface1
+public /*synthesized*/ fun JavaInterface2(/*0*/ function: (kotlin.Int) -> kotlin.Unit): JavaInterface2
+internal fun foo(/*0*/ k: KotlinClass): kotlin.Unit
+internal fun useString(/*0*/ i: kotlin.String): kotlin.Unit
+
+public interface JavaInterface1 {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public abstract fun getSomething(): kotlin.String!
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public interface JavaInterface2 {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public abstract fun setSomething(/*0*/ value: kotlin.Int): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+internal abstract class KotlinClass : JavaInterface1, JavaInterface2 {
+    public constructor KotlinClass()
+    public open override /*2*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ fun getSomething(): kotlin.String
+    public open override /*2*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public abstract override /*1*/ /*fake_override*/ fun setSomething(/*0*/ value: kotlin.Int): kotlin.Unit
+    public open override /*2*/ /*fake_override*/ fun toString(): kotlin.String
+}
diff --git a/compiler/testData/diagnostics/tests/syntheticExtensions/KotlinOverridesJava3.kt b/compiler/testData/diagnostics/tests/syntheticExtensions/KotlinOverridesJava3.kt
new file mode 100644
index 00000000000..568078acfd3
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/syntheticExtensions/KotlinOverridesJava3.kt
@@ -0,0 +1,25 @@
+// FILE: KotlinFile.kt
+abstract class KotlinClass : JavaInterface1, JavaInterface2 {
+    override fun getSomething(): String = ""
+}
+
+fun foo(k: KotlinClass) {
+    useString(k.getSomething())
+    useString(k.something)
+    if (<!SENSELESS_COMPARISON!>k.something == null<!>) return
+
+    k.setSomething("")
+    k.something = ""
+}
+
+fun useString(<!UNUSED_PARAMETER!>i<!>: String) {}
+
+// FILE: JavaInterface1.java
+public interface JavaInterface1 {
+    String getSomething();
+}
+
+// FILE: JavaInterface2.java
+public interface JavaInterface2 {
+    void setSomething(String value);
+}
diff --git a/compiler/testData/diagnostics/tests/syntheticExtensions/KotlinOverridesJava3.txt b/compiler/testData/diagnostics/tests/syntheticExtensions/KotlinOverridesJava3.txt
new file mode 100644
index 00000000000..dab991a8dcf
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/syntheticExtensions/KotlinOverridesJava3.txt
@@ -0,0 +1,29 @@
+package
+
+public /*synthesized*/ fun JavaInterface1(/*0*/ function: () -> kotlin.String!): JavaInterface1
+public /*synthesized*/ fun JavaInterface2(/*0*/ function: (kotlin.String!) -> kotlin.Unit): JavaInterface2
+internal fun foo(/*0*/ k: KotlinClass): kotlin.Unit
+internal fun useString(/*0*/ i: kotlin.String): kotlin.Unit
+
+public interface JavaInterface1 {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public abstract fun getSomething(): kotlin.String!
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public interface JavaInterface2 {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public abstract fun setSomething(/*0*/ value: kotlin.String!): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+internal abstract class KotlinClass : JavaInterface1, JavaInterface2 {
+    public constructor KotlinClass()
+    public open override /*2*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ fun getSomething(): kotlin.String
+    public open override /*2*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public abstract override /*1*/ /*fake_override*/ fun setSomething(/*0*/ value: kotlin.String!): kotlin.Unit
+    public open override /*2*/ /*fake_override*/ fun toString(): kotlin.String
+}
diff --git a/compiler/testData/diagnostics/tests/syntheticExtensions/KotlinOverridesJava4.kt b/compiler/testData/diagnostics/tests/syntheticExtensions/KotlinOverridesJava4.kt
new file mode 100644
index 00000000000..ef65896c7cb
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/syntheticExtensions/KotlinOverridesJava4.kt
@@ -0,0 +1,28 @@
+// FILE: KotlinFile.kt
+abstract class KotlinClass : JavaInterface3 {
+    override fun getSomething(): String = ""
+}
+
+fun foo(k: KotlinClass) {
+    useString(k.getSomething())
+    useString(k.something)
+    if (<!SENSELESS_COMPARISON!>k.something == null<!>) return
+
+    k.setSomething("")
+    k.something = ""
+}
+
+fun useString(<!UNUSED_PARAMETER!>i<!>: String) {}
+
+// FILE: JavaInterface1.java
+public interface JavaInterface1 {
+    String getSomething();
+}
+
+// FILE: JavaInterface2.java
+public interface JavaInterface2 {
+    void setSomething(String value);
+}
+
+// FILE: JavaInterface3.java
+public interface JavaInterface3 extends JavaInterface1, JavaInterface2 {}
diff --git a/compiler/testData/diagnostics/tests/syntheticExtensions/KotlinOverridesJava4.txt b/compiler/testData/diagnostics/tests/syntheticExtensions/KotlinOverridesJava4.txt
new file mode 100644
index 00000000000..4d1dff211de
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/syntheticExtensions/KotlinOverridesJava4.txt
@@ -0,0 +1,37 @@
+package
+
+public /*synthesized*/ fun JavaInterface1(/*0*/ function: () -> kotlin.String!): JavaInterface1
+public /*synthesized*/ fun JavaInterface2(/*0*/ function: (kotlin.String!) -> kotlin.Unit): JavaInterface2
+internal fun foo(/*0*/ k: KotlinClass): kotlin.Unit
+internal fun useString(/*0*/ i: kotlin.String): kotlin.Unit
+
+public interface JavaInterface1 {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public abstract fun getSomething(): kotlin.String!
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public interface JavaInterface2 {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public abstract fun setSomething(/*0*/ value: kotlin.String!): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public interface JavaInterface3 : JavaInterface1, JavaInterface2 {
+    public open override /*2*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public abstract override /*1*/ /*fake_override*/ fun getSomething(): kotlin.String!
+    public open override /*2*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public abstract override /*1*/ /*fake_override*/ fun setSomething(/*0*/ value: kotlin.String!): kotlin.Unit
+    public open override /*2*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+internal abstract class KotlinClass : JavaInterface3 {
+    public constructor KotlinClass()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ fun getSomething(): kotlin.String
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public abstract override /*1*/ /*fake_override*/ fun setSomething(/*0*/ value: kotlin.String!): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
diff --git a/compiler/testData/diagnostics/tests/syntheticExtensions/KotlinOverridesJava5.kt b/compiler/testData/diagnostics/tests/syntheticExtensions/KotlinOverridesJava5.kt
new file mode 100644
index 00000000000..69e516b4abc
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/syntheticExtensions/KotlinOverridesJava5.kt
@@ -0,0 +1,29 @@
+// FILE: KotlinFile.kt
+abstract class KotlinClass : JavaInterface3 {
+    override fun getSomething(): String = ""
+}
+
+fun foo(k: KotlinClass) {
+    useString(k.getSomething())
+    useString(k.something)
+    if (<!SENSELESS_COMPARISON!>k.something == null<!>) return
+
+    k.setSomething("")
+    k.something = ""
+}
+
+fun useString(<!UNUSED_PARAMETER!>i<!>: String) {}
+
+// FILE: JavaInterface1.java
+public interface JavaInterface1 {
+    String getSomething();
+}
+
+// FILE: JavaInterface2.java
+public interface JavaInterface2 {
+    String getSomething();
+    void setSomething(String value);
+}
+
+// FILE: JavaInterface3.java
+public interface JavaInterface3 extends JavaInterface1, JavaInterface2 {}
diff --git a/compiler/testData/diagnostics/tests/syntheticExtensions/KotlinOverridesJava5.txt b/compiler/testData/diagnostics/tests/syntheticExtensions/KotlinOverridesJava5.txt
new file mode 100644
index 00000000000..7f113511b9c
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/syntheticExtensions/KotlinOverridesJava5.txt
@@ -0,0 +1,37 @@
+package
+
+public /*synthesized*/ fun JavaInterface1(/*0*/ function: () -> kotlin.String!): JavaInterface1
+internal fun foo(/*0*/ k: KotlinClass): kotlin.Unit
+internal fun useString(/*0*/ i: kotlin.String): kotlin.Unit
+
+public interface JavaInterface1 {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public abstract fun getSomething(): kotlin.String!
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public interface JavaInterface2 {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public abstract fun getSomething(): kotlin.String!
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public abstract fun setSomething(/*0*/ value: kotlin.String!): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public interface JavaInterface3 : JavaInterface1, JavaInterface2 {
+    public open override /*2*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public abstract override /*2*/ /*fake_override*/ fun getSomething(): kotlin.String!
+    public open override /*2*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public abstract override /*1*/ /*fake_override*/ fun setSomething(/*0*/ value: kotlin.String!): kotlin.Unit
+    public open override /*2*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+internal abstract class KotlinClass : JavaInterface3 {
+    public constructor KotlinClass()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ fun getSomething(): kotlin.String
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public abstract override /*1*/ /*fake_override*/ fun setSomething(/*0*/ value: kotlin.String!): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
diff --git a/compiler/testData/diagnostics/tests/syntheticExtensions/OnlyPublic.kt b/compiler/testData/diagnostics/tests/syntheticExtensions/OnlyPublic.kt
new file mode 100644
index 00000000000..9bcc925eb27
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/syntheticExtensions/OnlyPublic.kt
@@ -0,0 +1,18 @@
+// FILE: KotlinFile.kt
+fun foo(javaClass: JavaClass) {
+    javaClass.somethingPublic
+    javaClass.<!UNRESOLVED_REFERENCE!>somethingProtected<!>
+    javaClass.<!UNRESOLVED_REFERENCE!>somethingPrivate<!>
+    javaClass.<!UNRESOLVED_REFERENCE!>somethingPackage<!>
+    <!VAL_REASSIGNMENT!>javaClass.somethingPublic<!> = 1
+}
+
+// FILE: JavaClass.java
+public class JavaClass {
+    public int getSomethingPublic() { return 1; }
+    protected int getSomethingProtected() { return 1; }
+    private int getSomethingPrivate() { return 1; }
+    int getSomethingPackage() { return 1; }
+
+    protected void setSomethingPublic(int value) {}
+}
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/syntheticExtensions/OnlyPublic.txt b/compiler/testData/diagnostics/tests/syntheticExtensions/OnlyPublic.txt
new file mode 100644
index 00000000000..cbb81bad348
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/syntheticExtensions/OnlyPublic.txt
@@ -0,0 +1,15 @@
+package
+
+internal fun foo(/*0*/ javaClass: JavaClass): kotlin.Unit
+
+public open class JavaClass {
+    public constructor JavaClass()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public/*package*/ open fun getSomethingPackage(): kotlin.Int
+    private open fun getSomethingPrivate(): kotlin.Int
+    protected/*protected and package*/ open fun getSomethingProtected(): kotlin.Int
+    public open fun getSomethingPublic(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    protected/*protected and package*/ open fun setSomethingPublic(/*0*/ value: kotlin.Int): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
diff --git a/compiler/testData/diagnostics/tests/syntheticExtensions/OverrideGetterOnly.kt b/compiler/testData/diagnostics/tests/syntheticExtensions/OverrideGetterOnly.kt
new file mode 100644
index 00000000000..c8e14d5333b
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/syntheticExtensions/OverrideGetterOnly.kt
@@ -0,0 +1,22 @@
+// FILE: KotlinFile.kt
+
+fun foo(o: JavaClass2) {
+    useString(o.something)
+    o.something = ""
+    o.setSomething(1)
+    o.something = <!CONSTANT_EXPECTED_TYPE_MISMATCH!>1<!> // we generate extension property for JavaClass2 with more specific type
+    o.something += "1"
+}
+
+fun useString(<!UNUSED_PARAMETER!>i<!>: String) {}
+
+// FILE: JavaClass1.java
+public class JavaClass1 {
+    public Object getSomething() { return null; }
+    public void setSomething(Object value) { }
+}
+
+// FILE: JavaClass2.java
+public class JavaClass2 extends JavaClass1 {
+    public String getSomething() { return ""; }
+}
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/syntheticExtensions/OverrideGetterOnly.txt b/compiler/testData/diagnostics/tests/syntheticExtensions/OverrideGetterOnly.txt
new file mode 100644
index 00000000000..d49adc526da
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/syntheticExtensions/OverrideGetterOnly.txt
@@ -0,0 +1,22 @@
+package
+
+internal fun foo(/*0*/ o: JavaClass2): kotlin.Unit
+internal fun useString(/*0*/ i: kotlin.String): kotlin.Unit
+
+public open class JavaClass1 {
+    public constructor JavaClass1()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open fun getSomething(): kotlin.Any!
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open fun setSomething(/*0*/ value: kotlin.Any!): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public open class JavaClass2 : JavaClass1 {
+    public constructor JavaClass2()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ fun getSomething(): kotlin.String!
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun setSomething(/*0*/ value: kotlin.Any!): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
diff --git a/compiler/testData/diagnostics/tests/syntheticExtensions/SetterOnly.kt b/compiler/testData/diagnostics/tests/syntheticExtensions/SetterOnly.kt
new file mode 100644
index 00000000000..9d3bef5eabe
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/syntheticExtensions/SetterOnly.kt
@@ -0,0 +1,9 @@
+// FILE: KotlinFile.kt
+fun foo(javaClass: JavaClass) {
+    javaClass.<!UNRESOLVED_REFERENCE!>something<!> = 1
+}
+
+// FILE: JavaClass.java
+public class JavaClass {
+    public void setSomething(int value) { }
+}
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/syntheticExtensions/SetterOnly.txt b/compiler/testData/diagnostics/tests/syntheticExtensions/SetterOnly.txt
new file mode 100644
index 00000000000..f22704ef214
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/syntheticExtensions/SetterOnly.txt
@@ -0,0 +1,11 @@
+package
+
+internal fun foo(/*0*/ javaClass: JavaClass): kotlin.Unit
+
+public open class JavaClass {
+    public constructor JavaClass()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open fun setSomething(/*0*/ value: kotlin.Int): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
diff --git a/compiler/testData/diagnostics/tests/syntheticExtensions/SmartCast.kt b/compiler/testData/diagnostics/tests/syntheticExtensions/SmartCast.kt
new file mode 100644
index 00000000000..6dff2b630a1
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/syntheticExtensions/SmartCast.kt
@@ -0,0 +1,28 @@
+// FILE: KotlinFile.kt
+fun foo(o: JavaInterface2): Int {
+    if (o is JavaClass) {
+        <!DEBUG_INFO_SMARTCAST!>o<!>.something++
+        return <!DEBUG_INFO_SMARTCAST!>o<!>.x + o.something2
+    }
+    return 0
+}
+
+// FILE: JavaClass.java
+public abstract class JavaClass extends BaseClass implements JavaInterface {
+    public int getSomething() { return 1; }
+    public void setSomething(int value) { }
+}
+
+// FILE: BaseClass.java
+public abstract class BaseClass implements JavaInterface {
+}
+
+// FILE: JavaInterface.java
+public interface JavaInterface {
+    int getX();
+}
+
+// FILE: JavaInterface2.java
+public interface JavaInterface2 {
+    int getSomething2();
+}
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/syntheticExtensions/SmartCast.txt b/compiler/testData/diagnostics/tests/syntheticExtensions/SmartCast.txt
new file mode 100644
index 00000000000..7100c3e7725
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/syntheticExtensions/SmartCast.txt
@@ -0,0 +1,37 @@
+package
+
+public /*synthesized*/ fun JavaInterface(/*0*/ function: () -> kotlin.Int): JavaInterface
+public /*synthesized*/ fun JavaInterface2(/*0*/ function: () -> kotlin.Int): JavaInterface2
+internal fun foo(/*0*/ o: JavaInterface2): kotlin.Int
+
+public abstract class BaseClass : JavaInterface {
+    public constructor BaseClass()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public abstract override /*1*/ /*fake_override*/ fun getX(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public abstract class JavaClass : BaseClass, JavaInterface {
+    public constructor JavaClass()
+    public open override /*2*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open fun getSomething(): kotlin.Int
+    public abstract override /*2*/ /*fake_override*/ fun getX(): kotlin.Int
+    public open override /*2*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open fun setSomething(/*0*/ value: kotlin.Int): kotlin.Unit
+    public open override /*2*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public interface JavaInterface {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public abstract fun getX(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public interface JavaInterface2 {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public abstract fun getSomething2(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
diff --git a/compiler/testData/diagnostics/tests/syntheticExtensions/SmartCastImplicitReceiver.kt b/compiler/testData/diagnostics/tests/syntheticExtensions/SmartCastImplicitReceiver.kt
new file mode 100644
index 00000000000..7da8bd686ca
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/syntheticExtensions/SmartCastImplicitReceiver.kt
@@ -0,0 +1,23 @@
+// FILE: KotlinFile.kt
+fun Any.foo(): Int {
+    if (this is JavaClass) {
+        something++
+        return x
+    }
+    return 0
+}
+
+// FILE: JavaClass.java
+public abstract class JavaClass extends BaseClass implements JavaInterface {
+    public int getSomething() { return 1; }
+    public void setSomething(int value) { }
+}
+
+// FILE: BaseClass.java
+public abstract class BaseClass implements JavaInterface {
+}
+
+// FILE: JavaInterface.java
+public interface JavaInterface {
+    int getX();
+}
diff --git a/compiler/testData/diagnostics/tests/syntheticExtensions/SmartCastImplicitReceiver.txt b/compiler/testData/diagnostics/tests/syntheticExtensions/SmartCastImplicitReceiver.txt
new file mode 100644
index 00000000000..fb712c02c73
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/syntheticExtensions/SmartCastImplicitReceiver.txt
@@ -0,0 +1,29 @@
+package
+
+public /*synthesized*/ fun JavaInterface(/*0*/ function: () -> kotlin.Int): JavaInterface
+internal fun kotlin.Any.foo(): kotlin.Int
+
+public abstract class BaseClass : JavaInterface {
+    public constructor BaseClass()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public abstract override /*1*/ /*fake_override*/ fun getX(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public abstract class JavaClass : BaseClass, JavaInterface {
+    public constructor JavaClass()
+    public open override /*2*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open fun getSomething(): kotlin.Int
+    public abstract override /*2*/ /*fake_override*/ fun getX(): kotlin.Int
+    public open override /*2*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open fun setSomething(/*0*/ value: kotlin.Int): kotlin.Unit
+    public open override /*2*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public interface JavaInterface {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public abstract fun getX(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
diff --git a/compiler/testData/diagnostics/tests/syntheticExtensions/TypeParameterReceiver.kt b/compiler/testData/diagnostics/tests/syntheticExtensions/TypeParameterReceiver.kt
new file mode 100644
index 00000000000..c106a07c6da
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/syntheticExtensions/TypeParameterReceiver.kt
@@ -0,0 +1,16 @@
+// FILE: KotlinFile.kt
+
+fun <T: B> foo(t: T) {
+    t.setSomething(t.getSomething() + 1)
+    t.something++
+}
+
+// FILE: A.java
+public interface A {
+    int getSomething();
+}
+
+// FILE: B.java
+public interface B extends A {
+    void setSomething(int value);
+}
diff --git a/compiler/testData/diagnostics/tests/syntheticExtensions/TypeParameterReceiver.txt b/compiler/testData/diagnostics/tests/syntheticExtensions/TypeParameterReceiver.txt
new file mode 100644
index 00000000000..f2de8f0142f
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/syntheticExtensions/TypeParameterReceiver.txt
@@ -0,0 +1,19 @@
+package
+
+public /*synthesized*/ fun A(/*0*/ function: () -> kotlin.Int): A
+internal fun </*0*/ T : B> foo(/*0*/ t: T): kotlin.Unit
+
+public interface A {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public abstract fun getSomething(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public interface B : A {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public abstract override /*1*/ /*fake_override*/ fun getSomething(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public abstract fun setSomething(/*0*/ value: kotlin.Int): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
diff --git a/compiler/testData/diagnostics/tests/when/AnnotatedWhenStatement.txt b/compiler/testData/diagnostics/tests/when/AnnotatedWhenStatement.txt
index a1a550e49f0..996fffb1cc4 100644
--- a/compiler/testData/diagnostics/tests/when/AnnotatedWhenStatement.txt
+++ b/compiler/testData/diagnostics/tests/when/AnnotatedWhenStatement.txt
@@ -2,7 +2,7 @@ package
 
 internal fun foo(/*0*/ a: kotlin.Int): kotlin.Unit
 
-internal final annotation class ann : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class ann : kotlin.Annotation {
     public constructor ann()
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
     public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
diff --git a/compiler/testData/diagnostics/tests/when/ExhaustivePlatformEnumAnnotated.txt b/compiler/testData/diagnostics/tests/when/ExhaustivePlatformEnumAnnotated.txt
index 0f5c9acb5f8..a8a18e3895f 100644
--- a/compiler/testData/diagnostics/tests/when/ExhaustivePlatformEnumAnnotated.txt
+++ b/compiler/testData/diagnostics/tests/when/ExhaustivePlatformEnumAnnotated.txt
@@ -32,7 +32,7 @@ public final enum class J : kotlin.Enum<J!> {
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
 
     // Static members
-    org.jetbrains.annotations.NotNull() public open fun create(): J!
+    org.jetbrains.annotations.NotNull() public open fun create(): J
     public final /*synthesized*/ fun valueOf(/*0*/ value: kotlin.String): J
     public final /*synthesized*/ fun values(): kotlin.Array<J>
 }
diff --git a/compiler/testData/diagnostics/testsWithStdLib/annotations/ClassObjectAnnotatedWithItsKClass.txt b/compiler/testData/diagnostics/testsWithStdLib/annotations/ClassObjectAnnotatedWithItsKClass.txt
index b6f5edd1e9b..06cd552887e 100644
--- a/compiler/testData/diagnostics/testsWithStdLib/annotations/ClassObjectAnnotatedWithItsKClass.txt
+++ b/compiler/testData/diagnostics/testsWithStdLib/annotations/ClassObjectAnnotatedWithItsKClass.txt
@@ -2,7 +2,7 @@ package
 
 package test {
 
-    internal final annotation class AnnClass : kotlin.Annotation {
+    kotlin.annotation.annotation() internal final class AnnClass : kotlin.Annotation {
         public constructor AnnClass(/*0*/ a: kotlin.reflect.KClass<*>)
         internal final val a: kotlin.reflect.KClass<*>
         public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
diff --git a/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationClassMethodCall.txt b/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationClassMethodCall.txt
index cb1cabf4374..abd04a4380c 100644
--- a/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationClassMethodCall.txt
+++ b/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationClassMethodCall.txt
@@ -3,7 +3,7 @@ package
 internal fun foo(/*0*/ ann: A): kotlin.Unit
 internal fun A.bar(): kotlin.Unit
 
-public final annotation class A : kotlin.Annotation {
+public final class A : kotlin.Annotation {
     public constructor A(/*0*/ value: kotlin.String, /*1*/ arg: kotlin.Int)
     public final val arg: kotlin.Int
     public final val value: kotlin.String
@@ -14,7 +14,7 @@ public final annotation class A : kotlin.Annotation {
     public abstract fun value(): kotlin.String
 }
 
-A(arg = IntegerValueType(1), value = "a") internal final class MyClass {
+A(arg = 1, value = "a") internal final class MyClass {
     public constructor MyClass()
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
     public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
diff --git a/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameterMustBeConstant/array.txt b/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameterMustBeConstant/array.txt
index db00d009415..559b318378d 100644
--- a/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameterMustBeConstant/array.txt
+++ b/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameterMustBeConstant/array.txt
@@ -6,7 +6,7 @@ internal val i3: kotlin.Int
 internal val iAnn: Ann
 internal fun foo(): kotlin.Int
 
-internal final annotation class Ann : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class Ann : kotlin.Annotation {
     public constructor Ann(/*0*/ i: kotlin.IntArray)
     internal final val i: kotlin.IntArray
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
@@ -14,7 +14,7 @@ internal final annotation class Ann : kotlin.Annotation {
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
 }
 
-internal final annotation class AnnAnn : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class AnnAnn : kotlin.Annotation {
     public constructor AnnAnn(/*0*/ i: kotlin.Array<Ann>)
     internal final val i: kotlin.Array<Ann>
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
@@ -29,7 +29,7 @@ Ann(i = {}) Ann(i = {1}) Ann(i = {}) Ann(i = {1}) Ann(i = {{1}}) internal final
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
 }
 
-AnnAnn(i = {Ann(i = {IntegerValueType(1)})}) AnnAnn(i = {}) internal final class TestAnn {
+AnnAnn(i = {Ann(i = {1})}) AnnAnn(i = {}) internal final class TestAnn {
     public constructor TestAnn()
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
     public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
diff --git a/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameterMustBeConstant/simple.txt b/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameterMustBeConstant/simple.txt
index fa1d18de8ab..c97995c25ea 100644
--- a/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameterMustBeConstant/simple.txt
+++ b/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameterMustBeConstant/simple.txt
@@ -6,7 +6,7 @@ internal val ia: kotlin.IntArray
 internal val sa: kotlin.Array<kotlin.String>
 internal fun foo(): kotlin.Int
 
-internal final annotation class Ann : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class Ann : kotlin.Annotation {
     public constructor Ann(/*0*/ i: kotlin.Int)
     internal final val i: kotlin.Int
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
@@ -14,14 +14,14 @@ internal final annotation class Ann : kotlin.Annotation {
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
 }
 
-internal final annotation class Ann2 : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class Ann2 : kotlin.Annotation {
     public constructor Ann2()
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
     public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
 }
 
-internal final annotation class AnnIA : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class AnnIA : kotlin.Annotation {
     public constructor AnnIA(/*0*/ ia: kotlin.IntArray)
     internal final val ia: kotlin.IntArray
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
@@ -29,7 +29,7 @@ internal final annotation class AnnIA : kotlin.Annotation {
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
 }
 
-internal final annotation class AnnSA : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class AnnSA : kotlin.Annotation {
     public constructor AnnSA(/*0*/ sa: kotlin.Array<kotlin.String>)
     internal final val sa: kotlin.Array<kotlin.String>
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
diff --git a/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameterMustBeConstant/vararg.txt b/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameterMustBeConstant/vararg.txt
index 6e2588a7779..6621e28bf33 100644
--- a/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameterMustBeConstant/vararg.txt
+++ b/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameterMustBeConstant/vararg.txt
@@ -6,7 +6,7 @@ internal val i3: kotlin.Int
 internal val iAnn: Ann
 internal fun foo(): kotlin.Int
 
-internal final annotation class Ann : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class Ann : kotlin.Annotation {
     public constructor Ann(/*0*/ vararg i: kotlin.Int /*kotlin.IntArray*/)
     internal final val i: kotlin.IntArray
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
@@ -14,7 +14,7 @@ internal final annotation class Ann : kotlin.Annotation {
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
 }
 
-internal final annotation class AnnAnn : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class AnnAnn : kotlin.Annotation {
     public constructor AnnAnn(/*0*/ vararg i: Ann /*kotlin.Array<out Ann>*/)
     internal final val i: kotlin.Array<out Ann>
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
@@ -29,7 +29,7 @@ Ann(i = {}) Ann(i = {1}) Ann(i = {}) Ann(i = {1}) Ann(i = {}) Ann(i = {1}) Ann(i
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
 }
 
-AnnAnn(i = {Ann(i = {IntegerValueType(1)})}) AnnAnn(i = {}) internal final class TestAnn {
+AnnAnn(i = {Ann(i = {1})}) AnnAnn(i = {}) internal final class TestAnn {
     public constructor TestAnn()
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
     public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
diff --git a/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameters/orderWithValue.txt b/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameters/orderWithValue.txt
index 8eb4cc4a5cc..41bc6d8a4e3 100644
--- a/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameters/orderWithValue.txt
+++ b/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameters/orderWithValue.txt
@@ -1,6 +1,6 @@
 package
 
-public final annotation class A : kotlin.Annotation {
+public final class A : kotlin.Annotation {
     public constructor A(/*0*/ value: kotlin.String, /*1*/ b: kotlin.Double, /*2*/ x1: kotlin.reflect.KClass<*>, /*3*/ a: kotlin.Int, /*4*/ x: kotlin.reflect.KClass<*>, /*5*/ x2: kotlin.reflect.KClass<*>)
     public final val a: kotlin.Int
     public final val b: kotlin.Double
diff --git a/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameters/orderWithoutValue.txt b/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameters/orderWithoutValue.txt
index df8f9fb54aa..6a068e6b817 100644
--- a/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameters/orderWithoutValue.txt
+++ b/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameters/orderWithoutValue.txt
@@ -1,6 +1,6 @@
 package
 
-public final annotation class A : kotlin.Annotation {
+public final class A : kotlin.Annotation {
     public constructor A(/*0*/ b: kotlin.Double, /*1*/ x1: kotlin.reflect.KClass<*>, /*2*/ a: kotlin.Int, /*3*/ x: kotlin.reflect.KClass<*>, /*4*/ x2: kotlin.reflect.KClass<*>)
     public final val a: kotlin.Int
     public final val b: kotlin.Double
diff --git a/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameters/valueArray.txt b/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameters/valueArray.txt
index c5af1272f2e..a69cf471c73 100644
--- a/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameters/valueArray.txt
+++ b/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameters/valueArray.txt
@@ -1,15 +1,15 @@
 package
 
-A(value = {"1", "2", "3"}, y = IntegerValueType(1)) internal fun test1(): kotlin.Unit
-A(value = {"4"}, y = IntegerValueType(2)) internal fun test2(): kotlin.Unit
-A(value = {{"5", "6"}, "7"}, y = IntegerValueType(3)) internal fun test3(): kotlin.Unit
-A(value = {"1", "2", "3"}, x = kotlin.String::class, y = IntegerValueType(4)) internal fun test4(): kotlin.Unit
-A(value = {"4"}, y = IntegerValueType(5)) internal fun test5(): kotlin.Unit
-A(value = {{"5", "6"}, "7"}, x = kotlin.Any::class, y = IntegerValueType(6)) internal fun test6(): kotlin.Unit
-A(value = {}, y = IntegerValueType(7)) internal fun test7(): kotlin.Unit
+A(value = {"1", "2", "3"}, y = 1) internal fun test1(): kotlin.Unit
+A(value = {"4"}, y = 2) internal fun test2(): kotlin.Unit
+A(value = {{"5", "6"}, "7"}, y = 3) internal fun test3(): kotlin.Unit
+A(value = {"1", "2", "3"}, x = kotlin.String::class, y = 4) internal fun test4(): kotlin.Unit
+A(value = {"4"}, y = 5) internal fun test5(): kotlin.Unit
+A(value = {{"5", "6"}, "7"}, x = kotlin.Any::class, y = 6) internal fun test6(): kotlin.Unit
+A(value = {}, y = 7) internal fun test7(): kotlin.Unit
 A(value = {"8", "9", "10"}) internal fun test8(): kotlin.Unit
 
-public final annotation class A : kotlin.Annotation {
+public final class A : kotlin.Annotation {
     public constructor A(/*0*/ vararg value: kotlin.String /*kotlin.Array<out kotlin.String>*/, /*1*/ x: kotlin.reflect.KClass<*> = ..., /*2*/ y: kotlin.Int)
     public final val value: kotlin.Array<kotlin.String>
     public final val x: kotlin.reflect.KClass<*>
diff --git a/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameters/valueArrayAndOtherDefault.txt b/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameters/valueArrayAndOtherDefault.txt
index 3a0f8acfd92..607954a26f4 100644
--- a/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameters/valueArrayAndOtherDefault.txt
+++ b/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameters/valueArrayAndOtherDefault.txt
@@ -1,18 +1,18 @@
 package
 
 A(value = {"1", "2", "3"}) internal fun test1(): kotlin.Unit
-A(value = {"5", "6"}, x = kotlin.Any::class, y = IntegerValueType(3)) internal fun test10(): kotlin.Unit
-A(value = {"5", "6", "7"}, x = kotlin.Any::class, y = IntegerValueType(3)) internal fun test11(): kotlin.Unit
+A(value = {"5", "6"}, x = kotlin.Any::class, y = 3) internal fun test10(): kotlin.Unit
+A(value = {"5", "6", "7"}, x = kotlin.Any::class, y = 3) internal fun test11(): kotlin.Unit
 A(value = {"4"}) internal fun test2(): kotlin.Unit
 A(value = {{"5", "6"}, "7"}) internal fun test3(): kotlin.Unit
 A(value = {"1", "2", "3"}, x = kotlin.String::class) internal fun test4(): kotlin.Unit
-A(value = {"4"}, y = IntegerValueType(2)) internal fun test5(): kotlin.Unit
-A(value = {{"5", "6"}, "7"}, x = kotlin.Any::class, y = IntegerValueType(3)) internal fun test6(): kotlin.Unit
+A(value = {"4"}, y = 2) internal fun test5(): kotlin.Unit
+A(value = {{"5", "6"}, "7"}, x = kotlin.Any::class, y = 3) internal fun test6(): kotlin.Unit
 A(value = {}) internal fun test7(): kotlin.Unit
 A(value = {}) internal fun test8(): kotlin.Unit
-A(value = {}, x = kotlin.Any::class, y = IntegerValueType(3)) internal fun test9(): kotlin.Unit
+A(value = {}, x = kotlin.Any::class, y = 3) internal fun test9(): kotlin.Unit
 
-public final annotation class A : kotlin.Annotation {
+public final class A : kotlin.Annotation {
     public constructor A(/*0*/ vararg value: kotlin.String /*kotlin.Array<out kotlin.String>*/, /*1*/ x: kotlin.reflect.KClass<*> = ..., /*2*/ y: kotlin.Int = ...)
     public final val value: kotlin.Array<kotlin.String>
     public final val x: kotlin.reflect.KClass<*>
diff --git a/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameters/valueArrayOnly.txt b/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameters/valueArrayOnly.txt
index bc2cf56de7a..c8b06abd6c4 100644
--- a/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameters/valueArrayOnly.txt
+++ b/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameters/valueArrayOnly.txt
@@ -6,7 +6,7 @@ A(value = {{"5", "6"}, "7"}) internal fun test3(): kotlin.Unit
 A(value = {}) internal fun test4(): kotlin.Unit
 A(value = {}) internal fun test5(): kotlin.Unit
 
-public final annotation class A : kotlin.Annotation {
+public final class A : kotlin.Annotation {
     public constructor A(/*0*/ vararg value: kotlin.String /*kotlin.Array<out kotlin.String>*/)
     public final val value: kotlin.Array<kotlin.String>
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
diff --git a/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameters/valueArrayWithDefault.txt b/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameters/valueArrayWithDefault.txt
index ffaeaa870ba..ab13f0ae3e1 100644
--- a/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameters/valueArrayWithDefault.txt
+++ b/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameters/valueArrayWithDefault.txt
@@ -6,7 +6,7 @@ A(value = {{"5", "6"}, "7"}) internal fun test3(): kotlin.Unit
 A() internal fun test4(): kotlin.Unit
 A() internal fun test5(): kotlin.Unit
 
-public final annotation class A : kotlin.Annotation {
+public final class A : kotlin.Annotation {
     public constructor A(/*0*/ vararg value: kotlin.String /*kotlin.Array<out kotlin.String>*/ = ...)
     public final val value: kotlin.Array<kotlin.String>
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
diff --git a/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationWithVarargParameter/javaAnnotationWithVarargArgument.txt b/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationWithVarargParameter/javaAnnotationWithVarargArgument.txt
index 8493cb21b51..dac73b98869 100644
--- a/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationWithVarargParameter/javaAnnotationWithVarargArgument.txt
+++ b/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationWithVarargParameter/javaAnnotationWithVarargArgument.txt
@@ -1,8 +1,8 @@
 package
 
-A(value = {IntegerValueType(1), "b"}) internal fun test(): kotlin.Unit
+A(value = {1, "b"}) internal fun test(): kotlin.Unit
 
-public final annotation class A : kotlin.Annotation {
+public final class A : kotlin.Annotation {
     public constructor A(/*0*/ vararg value: kotlin.String /*kotlin.Array<out kotlin.String>*/)
     public final val value: kotlin.Array<kotlin.String>
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
diff --git a/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationWithVarargParameter/kotlinAnnotationWithVarargArgument.txt b/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationWithVarargParameter/kotlinAnnotationWithVarargArgument.txt
index b721ac4d876..5974a3c30b3 100644
--- a/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationWithVarargParameter/kotlinAnnotationWithVarargArgument.txt
+++ b/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationWithVarargParameter/kotlinAnnotationWithVarargArgument.txt
@@ -1,8 +1,8 @@
 package
 
-B(args = {IntegerValueType(1), "b"}) internal fun test(): kotlin.Unit
+B(args = {1, "b"}) internal fun test(): kotlin.Unit
 
-internal final annotation class B : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class B : kotlin.Annotation {
     public constructor B(/*0*/ vararg args: kotlin.String /*kotlin.Array<out kotlin.String>*/)
     internal final val args: kotlin.Array<out kotlin.String>
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
diff --git a/compiler/testData/diagnostics/testsWithStdLib/annotations/defaultValueMustBeConstant.txt b/compiler/testData/diagnostics/testsWithStdLib/annotations/defaultValueMustBeConstant.txt
index 811b3654351..bc66b807956 100644
--- a/compiler/testData/diagnostics/testsWithStdLib/annotations/defaultValueMustBeConstant.txt
+++ b/compiler/testData/diagnostics/testsWithStdLib/annotations/defaultValueMustBeConstant.txt
@@ -5,7 +5,7 @@ internal val nonConst: kotlin.Int
 internal val nonConstKClass: kotlin.reflect.KClass<kotlin.String>
 internal fun foo(): kotlin.Int
 
-internal final annotation class InvalidAnn : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class InvalidAnn : kotlin.Annotation {
     public constructor InvalidAnn(/*0*/ p1: kotlin.Int = ..., /*1*/ p2: kotlin.Int = ..., /*2*/ p3: kotlin.reflect.KClass<*> = ...)
     internal final val p1: kotlin.Int
     internal final val p2: kotlin.Int
@@ -15,7 +15,7 @@ internal final annotation class InvalidAnn : kotlin.Annotation {
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
 }
 
-internal final annotation class ValidAnn : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class ValidAnn : kotlin.Annotation {
     public constructor ValidAnn(/*0*/ p1: kotlin.Int = ..., /*1*/ p2: kotlin.String = ..., /*2*/ p3: kotlin.reflect.KClass<*> = ..., /*3*/ p4: kotlin.IntArray = ..., /*4*/ p5: kotlin.Array<kotlin.String> = ..., /*5*/ p6: kotlin.Array<kotlin.reflect.KClass<*>> = ...)
     internal final val p1: kotlin.Int
     internal final val p2: kotlin.String
diff --git a/compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter/annotationAsArgument.txt b/compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter/annotationAsArgument.txt
index 12130f57a1f..2c4ea8df39b 100644
--- a/compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter/annotationAsArgument.txt
+++ b/compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter/annotationAsArgument.txt
@@ -1,6 +1,6 @@
 package
 
-public final annotation class A : kotlin.Annotation {
+public final class A : kotlin.Annotation {
     public constructor A(/*0*/ arg: kotlin.reflect.KClass<*> = ..., /*1*/ x: kotlin.Int = ..., /*2*/ b: B)
     public final val arg: kotlin.reflect.KClass<*>
     public final val b: B
@@ -13,7 +13,7 @@ public final annotation class A : kotlin.Annotation {
     public abstract fun x(): kotlin.Int
 }
 
-public final annotation class B : kotlin.Annotation {
+public final class B : kotlin.Annotation {
     public constructor B(/*0*/ arg: kotlin.reflect.KClass<*> = ..., /*1*/ y: kotlin.Int = ...)
     public final val arg: kotlin.reflect.KClass<*>
     public final val y: kotlin.Int
@@ -24,14 +24,14 @@ public final annotation class B : kotlin.Annotation {
     public abstract fun y(): kotlin.Int
 }
 
-A(arg = kotlin.String::class, b = B(y = IntegerValueType(1))) internal final class MyClass1 {
+A(arg = kotlin.String::class, b = B(y = 1)) internal final class MyClass1 {
     public constructor MyClass1()
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
     public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
 }
 
-A(b = B(y = IntegerValueType(3))) internal final class MyClass2 {
+A(b = B(y = 3)) internal final class MyClass2 {
     public constructor MyClass2()
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
     public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
diff --git a/compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter/arg.txt b/compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter/arg.txt
index e4717d047f2..e6bc9ffc1e1 100644
--- a/compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter/arg.txt
+++ b/compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter/arg.txt
@@ -1,6 +1,6 @@
 package
 
-public final annotation class A : kotlin.Annotation {
+public final class A : kotlin.Annotation {
     public constructor A(/*0*/ arg: kotlin.reflect.KClass<*>)
     public final val arg: kotlin.reflect.KClass<*>
     public abstract fun arg(): kotlin.reflect.KClass<*>
diff --git a/compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter/argAndOtherDefault.txt b/compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter/argAndOtherDefault.txt
index 4f2666750ec..3395985b2b7 100644
--- a/compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter/argAndOtherDefault.txt
+++ b/compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter/argAndOtherDefault.txt
@@ -1,6 +1,6 @@
 package
 
-public final annotation class A : kotlin.Annotation {
+public final class A : kotlin.Annotation {
     public constructor A(/*0*/ arg: kotlin.reflect.KClass<*>, /*1*/ x: kotlin.Int = ...)
     public final val arg: kotlin.reflect.KClass<*>
     public final val x: kotlin.Int
@@ -18,7 +18,7 @@ A(arg = kotlin.String::class) internal final class MyClass1 {
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
 }
 
-A(arg = kotlin.String::class, x = IntegerValueType(2)) internal final class MyClass2 {
+A(arg = kotlin.String::class, x = 2) internal final class MyClass2 {
     public constructor MyClass2()
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
     public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
diff --git a/compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter/argArray.txt b/compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter/argArray.txt
index ad9fc65193e..29b347d1df1 100644
--- a/compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter/argArray.txt
+++ b/compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter/argArray.txt
@@ -1,6 +1,6 @@
 package
 
-public final annotation class A : kotlin.Annotation {
+public final class A : kotlin.Annotation {
     public constructor A(/*0*/ arg: kotlin.Array<kotlin.reflect.KClass<*>>)
     public final val arg: kotlin.Array<kotlin.reflect.KClass<*>>
     public abstract fun arg(): kotlin.Array<kotlin.reflect.KClass<*>>
diff --git a/compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter/argWithDefault.txt b/compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter/argWithDefault.txt
index dfe18e08c97..364ad61d6b7 100644
--- a/compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter/argWithDefault.txt
+++ b/compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter/argWithDefault.txt
@@ -1,6 +1,6 @@
 package
 
-public final annotation class A : kotlin.Annotation {
+public final class A : kotlin.Annotation {
     public constructor A(/*0*/ arg: kotlin.reflect.KClass<*> = ...)
     public final val arg: kotlin.reflect.KClass<*>
     public abstract fun arg(): kotlin.reflect.KClass<*>
diff --git a/compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter/argWithDefaultAndOther.txt b/compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter/argWithDefaultAndOther.txt
index 4585128b24c..117f5e6ccb0 100644
--- a/compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter/argWithDefaultAndOther.txt
+++ b/compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter/argWithDefaultAndOther.txt
@@ -1,6 +1,6 @@
 package
 
-public final annotation class A : kotlin.Annotation {
+public final class A : kotlin.Annotation {
     public constructor A(/*0*/ arg: kotlin.reflect.KClass<*> = ..., /*1*/ x: kotlin.Int)
     public final val arg: kotlin.reflect.KClass<*>
     public final val x: kotlin.Int
@@ -11,14 +11,14 @@ public final annotation class A : kotlin.Annotation {
     public abstract fun x(): kotlin.Int
 }
 
-A(arg = kotlin.String::class, x = IntegerValueType(4)) internal final class MyClass2 {
+A(arg = kotlin.String::class, x = 4) internal final class MyClass2 {
     public constructor MyClass2()
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
     public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
 }
 
-A(x = IntegerValueType(5)) internal final class MyClass3 {
+A(x = 5) internal final class MyClass3 {
     public constructor MyClass3()
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
     public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
diff --git a/compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter/twoArgs.txt b/compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter/twoArgs.txt
index cf23b3bef0b..ee6386f2a0b 100644
--- a/compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter/twoArgs.txt
+++ b/compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter/twoArgs.txt
@@ -1,6 +1,6 @@
 package
 
-public final annotation class A : kotlin.Annotation {
+public final class A : kotlin.Annotation {
     public constructor A(/*0*/ arg1: kotlin.reflect.KClass<*>, /*1*/ arg2: kotlin.reflect.KClass<*>)
     public final val arg1: kotlin.reflect.KClass<*>
     public final val arg2: kotlin.reflect.KClass<*>
diff --git a/compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter/value.txt b/compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter/value.txt
index ce33baa7cb8..75ad0c7ba9d 100644
--- a/compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter/value.txt
+++ b/compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter/value.txt
@@ -1,6 +1,6 @@
 package
 
-public final annotation class A : kotlin.Annotation {
+public final class A : kotlin.Annotation {
     public constructor A(/*0*/ value: kotlin.reflect.KClass<*>)
     public final val value: kotlin.reflect.KClass<*>
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
diff --git a/compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter/valueAndOtherDefault.txt b/compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter/valueAndOtherDefault.txt
index 8a7894a5aea..bb937f10a14 100644
--- a/compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter/valueAndOtherDefault.txt
+++ b/compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter/valueAndOtherDefault.txt
@@ -1,6 +1,6 @@
 package
 
-public final annotation class A : kotlin.Annotation {
+public final class A : kotlin.Annotation {
     public constructor A(/*0*/ value: kotlin.reflect.KClass<*>, /*1*/ x: kotlin.Int = ...)
     public final val value: kotlin.reflect.KClass<*>
     public final val x: kotlin.Int
@@ -25,14 +25,14 @@ A(value = kotlin.String::class) internal final class MyClass2 {
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
 }
 
-A(value = kotlin.String::class, x = IntegerValueType(2)) internal final class MyClass3 {
+A(value = kotlin.String::class, x = 2) internal final class MyClass3 {
     public constructor MyClass3()
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
     public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
 }
 
-A(value = kotlin.String::class, x = IntegerValueType(4)) internal final class MyClass4 {
+A(value = kotlin.String::class, x = 4) internal final class MyClass4 {
     public constructor MyClass4()
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
     public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
diff --git a/compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter/valueArray.txt b/compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter/valueArray.txt
index 404b8943c43..d3f68330c80 100644
--- a/compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter/valueArray.txt
+++ b/compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter/valueArray.txt
@@ -1,6 +1,6 @@
 package
 
-public final annotation class A : kotlin.Annotation {
+public final class A : kotlin.Annotation {
     public constructor A(/*0*/ vararg value: kotlin.reflect.KClass<*> /*kotlin.Array<out kotlin.reflect.KClass<*>>*/)
     public final val value: kotlin.Array<kotlin.reflect.KClass<*>>
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
diff --git a/compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter/valueWithDefault.txt b/compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter/valueWithDefault.txt
index b2d4e88c8c1..8f230970148 100644
--- a/compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter/valueWithDefault.txt
+++ b/compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter/valueWithDefault.txt
@@ -1,6 +1,6 @@
 package
 
-public final annotation class A : kotlin.Annotation {
+public final class A : kotlin.Annotation {
     public constructor A(/*0*/ value: kotlin.reflect.KClass<*> = ...)
     public final val value: kotlin.reflect.KClass<*>
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
diff --git a/compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter/valueWithDefaultAndOther.txt b/compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter/valueWithDefaultAndOther.txt
index 72d973e8303..d46c0049dc5 100644
--- a/compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter/valueWithDefaultAndOther.txt
+++ b/compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter/valueWithDefaultAndOther.txt
@@ -1,6 +1,6 @@
 package
 
-public final annotation class A : kotlin.Annotation {
+public final class A : kotlin.Annotation {
     public constructor A(/*0*/ value: kotlin.reflect.KClass<*> = ..., /*1*/ x: kotlin.Int)
     public final val value: kotlin.reflect.KClass<*>
     public final val x: kotlin.Int
@@ -11,21 +11,21 @@ public final annotation class A : kotlin.Annotation {
     public abstract fun x(): kotlin.Int
 }
 
-A(value = kotlin.String::class, x = IntegerValueType(2)) internal final class MyClass1 {
+A(value = kotlin.String::class, x = 2) internal final class MyClass1 {
     public constructor MyClass1()
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
     public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
 }
 
-A(value = kotlin.String::class, x = IntegerValueType(4)) internal final class MyClass2 {
+A(value = kotlin.String::class, x = 4) internal final class MyClass2 {
     public constructor MyClass2()
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
     public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
 }
 
-A(x = IntegerValueType(5)) internal final class MyClass3 {
+A(x = 5) internal final class MyClass3 {
     public constructor MyClass3()
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
     public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
diff --git a/compiler/testData/diagnostics/testsWithStdLib/annotations/kClass/kClassArrayInAnnotationsInVariance.txt b/compiler/testData/diagnostics/testsWithStdLib/annotations/kClass/kClassArrayInAnnotationsInVariance.txt
index a6765ac3675..5c140838c73 100644
--- a/compiler/testData/diagnostics/testsWithStdLib/annotations/kClass/kClassArrayInAnnotationsInVariance.txt
+++ b/compiler/testData/diagnostics/testsWithStdLib/annotations/kClass/kClassArrayInAnnotationsInVariance.txt
@@ -7,7 +7,7 @@ internal open class A {
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
 }
 
-internal final annotation class Ann1 : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class Ann1 : kotlin.Annotation {
     public constructor Ann1(/*0*/ arg: kotlin.Array<kotlin.reflect.KClass<in A>>)
     internal final val arg: kotlin.Array<kotlin.reflect.KClass<in A>>
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
@@ -15,7 +15,7 @@ internal final annotation class Ann1 : kotlin.Annotation {
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
 }
 
-internal final annotation class Ann2 : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class Ann2 : kotlin.Annotation {
     public constructor Ann2(/*0*/ arg: kotlin.Array<kotlin.reflect.KClass<in B1>>)
     internal final val arg: kotlin.Array<kotlin.reflect.KClass<in B1>>
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
diff --git a/compiler/testData/diagnostics/testsWithStdLib/annotations/kClass/kClassArrayInAnnotationsOutVariance.txt b/compiler/testData/diagnostics/testsWithStdLib/annotations/kClass/kClassArrayInAnnotationsOutVariance.txt
index c0ec82f6272..4d041ec83e7 100644
--- a/compiler/testData/diagnostics/testsWithStdLib/annotations/kClass/kClassArrayInAnnotationsOutVariance.txt
+++ b/compiler/testData/diagnostics/testsWithStdLib/annotations/kClass/kClassArrayInAnnotationsOutVariance.txt
@@ -7,7 +7,7 @@ internal open class A {
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
 }
 
-internal final annotation class Ann1 : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class Ann1 : kotlin.Annotation {
     public constructor Ann1(/*0*/ arg: kotlin.Array<kotlin.reflect.KClass<out A>>)
     internal final val arg: kotlin.Array<kotlin.reflect.KClass<out A>>
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
@@ -15,7 +15,7 @@ internal final annotation class Ann1 : kotlin.Annotation {
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
 }
 
-internal final annotation class Ann2 : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class Ann2 : kotlin.Annotation {
     public constructor Ann2(/*0*/ arg: kotlin.Array<kotlin.reflect.KClass<out B1>>)
     internal final val arg: kotlin.Array<kotlin.reflect.KClass<out B1>>
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
diff --git a/compiler/testData/diagnostics/testsWithStdLib/annotations/kClass/kClassInAnnotation.txt b/compiler/testData/diagnostics/testsWithStdLib/annotations/kClass/kClassInAnnotation.txt
index e40b008836d..c35e04678e9 100644
--- a/compiler/testData/diagnostics/testsWithStdLib/annotations/kClass/kClassInAnnotation.txt
+++ b/compiler/testData/diagnostics/testsWithStdLib/annotations/kClass/kClassInAnnotation.txt
@@ -16,7 +16,7 @@ internal final class A2 {
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
 }
 
-internal final annotation class Ann1 : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class Ann1 : kotlin.Annotation {
     public constructor Ann1(/*0*/ arg: kotlin.reflect.KClass<*>)
     internal final val arg: kotlin.reflect.KClass<*>
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
@@ -24,7 +24,7 @@ internal final annotation class Ann1 : kotlin.Annotation {
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
 }
 
-internal final annotation class Ann2 : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class Ann2 : kotlin.Annotation {
     public constructor Ann2(/*0*/ vararg arg: kotlin.reflect.KClass<*> /*kotlin.Array<out kotlin.reflect.KClass<*>>*/)
     internal final val arg: kotlin.Array<out kotlin.reflect.KClass<*>>
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
@@ -32,7 +32,7 @@ internal final annotation class Ann2 : kotlin.Annotation {
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
 }
 
-internal final annotation class Ann3 : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class Ann3 : kotlin.Annotation {
     public constructor Ann3(/*0*/ arg: kotlin.Array<kotlin.reflect.KClass<*>>)
     internal final val arg: kotlin.Array<kotlin.reflect.KClass<*>>
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
diff --git a/compiler/testData/diagnostics/testsWithStdLib/annotations/kClass/kClassInAnnotationsInVariance.txt b/compiler/testData/diagnostics/testsWithStdLib/annotations/kClass/kClassInAnnotationsInVariance.txt
index 16b953e974c..0a89c9c7ba1 100644
--- a/compiler/testData/diagnostics/testsWithStdLib/annotations/kClass/kClassInAnnotationsInVariance.txt
+++ b/compiler/testData/diagnostics/testsWithStdLib/annotations/kClass/kClassInAnnotationsInVariance.txt
@@ -7,7 +7,7 @@ internal open class A {
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
 }
 
-internal final annotation class Ann1 : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class Ann1 : kotlin.Annotation {
     public constructor Ann1(/*0*/ arg: kotlin.reflect.KClass<in A>)
     internal final val arg: kotlin.reflect.KClass<in A>
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
@@ -15,7 +15,7 @@ internal final annotation class Ann1 : kotlin.Annotation {
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
 }
 
-internal final annotation class Ann2 : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class Ann2 : kotlin.Annotation {
     public constructor Ann2(/*0*/ arg: kotlin.reflect.KClass<in B1>)
     internal final val arg: kotlin.reflect.KClass<in B1>
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
diff --git a/compiler/testData/diagnostics/testsWithStdLib/annotations/kClass/kClassInAnnotationsOutVariance.txt b/compiler/testData/diagnostics/testsWithStdLib/annotations/kClass/kClassInAnnotationsOutVariance.txt
index 69adfb817a3..6aed0440f52 100644
--- a/compiler/testData/diagnostics/testsWithStdLib/annotations/kClass/kClassInAnnotationsOutVariance.txt
+++ b/compiler/testData/diagnostics/testsWithStdLib/annotations/kClass/kClassInAnnotationsOutVariance.txt
@@ -7,7 +7,7 @@ internal open class A {
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
 }
 
-internal final annotation class Ann1 : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class Ann1 : kotlin.Annotation {
     public constructor Ann1(/*0*/ arg: kotlin.reflect.KClass<out A>)
     internal final val arg: kotlin.reflect.KClass<out A>
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
@@ -15,7 +15,7 @@ internal final annotation class Ann1 : kotlin.Annotation {
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
 }
 
-internal final annotation class Ann2 : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class Ann2 : kotlin.Annotation {
     public constructor Ann2(/*0*/ arg: kotlin.reflect.KClass<out B1>)
     internal final val arg: kotlin.reflect.KClass<out B1>
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
diff --git a/compiler/testData/diagnostics/testsWithStdLib/annotations/kClass/kClassInvariantTP.txt b/compiler/testData/diagnostics/testsWithStdLib/annotations/kClass/kClassInvariantTP.txt
index 4b1b1e7b528..9e160a446e1 100644
--- a/compiler/testData/diagnostics/testsWithStdLib/annotations/kClass/kClassInvariantTP.txt
+++ b/compiler/testData/diagnostics/testsWithStdLib/annotations/kClass/kClassInvariantTP.txt
@@ -7,7 +7,7 @@ internal open class A {
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
 }
 
-internal final annotation class Ann1 : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class Ann1 : kotlin.Annotation {
     public constructor Ann1(/*0*/ arg: kotlin.reflect.KClass<A>)
     internal final val arg: kotlin.reflect.KClass<A>
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
@@ -15,7 +15,7 @@ internal final annotation class Ann1 : kotlin.Annotation {
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
 }
 
-internal final annotation class Ann2 : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class Ann2 : kotlin.Annotation {
     public constructor Ann2(/*0*/ arg: kotlin.reflect.KClass<B>)
     internal final val arg: kotlin.reflect.KClass<B>
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
diff --git a/compiler/testData/diagnostics/testsWithStdLib/annotations/kClass/kClassOutArrayInAnnotationsOutVariance.txt b/compiler/testData/diagnostics/testsWithStdLib/annotations/kClass/kClassOutArrayInAnnotationsOutVariance.txt
index 57bb6dcede5..a070f6c89aa 100644
--- a/compiler/testData/diagnostics/testsWithStdLib/annotations/kClass/kClassOutArrayInAnnotationsOutVariance.txt
+++ b/compiler/testData/diagnostics/testsWithStdLib/annotations/kClass/kClassOutArrayInAnnotationsOutVariance.txt
@@ -7,7 +7,7 @@ internal open class A {
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
 }
 
-internal final annotation class Ann1 : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class Ann1 : kotlin.Annotation {
     public constructor Ann1(/*0*/ arg: kotlin.Array<out kotlin.reflect.KClass<out A>>)
     internal final val arg: kotlin.Array<out kotlin.reflect.KClass<out A>>
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
diff --git a/compiler/testData/diagnostics/testsWithStdLib/annotations/prohibitPositionedArgument/kotlinAnnotation.txt b/compiler/testData/diagnostics/testsWithStdLib/annotations/prohibitPositionedArgument/kotlinAnnotation.txt
index c655e78749f..f5aeeece4c0 100644
--- a/compiler/testData/diagnostics/testsWithStdLib/annotations/prohibitPositionedArgument/kotlinAnnotation.txt
+++ b/compiler/testData/diagnostics/testsWithStdLib/annotations/prohibitPositionedArgument/kotlinAnnotation.txt
@@ -1,10 +1,10 @@
 package
 
-Ann(value = "a", x = IntegerValueType(1), y = 1.0.toDouble()) internal fun foo1(): kotlin.Unit
-Ann(value = "b", x = IntegerValueType(2), y = 2.0.toDouble()) internal fun foo2(): kotlin.Unit
-Ann(value = "c", x = IntegerValueType(3), y = 2.0.toDouble()) internal fun foo3(): kotlin.Unit
+Ann(value = "a", x = 1, y = 1.0.toDouble()) internal fun foo1(): kotlin.Unit
+Ann(value = "b", x = 2, y = 2.0.toDouble()) internal fun foo2(): kotlin.Unit
+Ann(value = "c", x = 3, y = 2.0.toDouble()) internal fun foo3(): kotlin.Unit
 
-internal final annotation class Ann : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class Ann : kotlin.Annotation {
     public constructor Ann(/*0*/ x: kotlin.Int, /*1*/ value: kotlin.String, /*2*/ y: kotlin.Double)
     internal final val value: kotlin.String
     internal final val x: kotlin.Int
diff --git a/compiler/testData/diagnostics/testsWithStdLib/annotations/prohibitPositionedArgument/tooManyArgs.txt b/compiler/testData/diagnostics/testsWithStdLib/annotations/prohibitPositionedArgument/tooManyArgs.txt
index 699fa97cffe..208bbf61e93 100644
--- a/compiler/testData/diagnostics/testsWithStdLib/annotations/prohibitPositionedArgument/tooManyArgs.txt
+++ b/compiler/testData/diagnostics/testsWithStdLib/annotations/prohibitPositionedArgument/tooManyArgs.txt
@@ -2,7 +2,7 @@ package
 
 A(a = false, b = 1.0.toDouble(), x = false) internal fun foo1(): kotlin.Unit
 
-public final annotation class A : kotlin.Annotation {
+public final class A : kotlin.Annotation {
     public constructor A(/*0*/ a: kotlin.Int, /*1*/ b: kotlin.Double, /*2*/ x: kotlin.Boolean)
     public final val a: kotlin.Int
     public final val b: kotlin.Double
diff --git a/compiler/testData/diagnostics/testsWithStdLib/annotations/prohibitPositionedArgument/typeMismatch.txt b/compiler/testData/diagnostics/testsWithStdLib/annotations/prohibitPositionedArgument/typeMismatch.txt
index a64bbd54aa0..5822e0e3670 100644
--- a/compiler/testData/diagnostics/testsWithStdLib/annotations/prohibitPositionedArgument/typeMismatch.txt
+++ b/compiler/testData/diagnostics/testsWithStdLib/annotations/prohibitPositionedArgument/typeMismatch.txt
@@ -3,7 +3,7 @@ package
 A(a = false, b = 1.0.toDouble(), x = false) internal fun foo1(): kotlin.Unit
 A(a = 2.0.toDouble(), b = 2.0.toDouble(), x = true) internal fun foo2(): kotlin.Unit
 
-public final annotation class A : kotlin.Annotation {
+public final class A : kotlin.Annotation {
     public constructor A(/*0*/ a: kotlin.Int, /*1*/ b: kotlin.Double, /*2*/ x: kotlin.Boolean)
     public final val a: kotlin.Int
     public final val b: kotlin.Double
diff --git a/compiler/testData/diagnostics/testsWithStdLib/annotations/prohibitPositionedArgument/withValue.txt b/compiler/testData/diagnostics/testsWithStdLib/annotations/prohibitPositionedArgument/withValue.txt
index f4fbbf7c874..74b23d2864c 100644
--- a/compiler/testData/diagnostics/testsWithStdLib/annotations/prohibitPositionedArgument/withValue.txt
+++ b/compiler/testData/diagnostics/testsWithStdLib/annotations/prohibitPositionedArgument/withValue.txt
@@ -1,11 +1,11 @@
 package
 
-A(a = IntegerValueType(1), b = 1.0.toDouble(), value = "v1", x = false) internal fun foo1(): kotlin.Unit
-A(a = IntegerValueType(2), b = 2.0.toDouble(), value = "v2", x = true) internal fun foo2(): kotlin.Unit
-A(a = IntegerValueType(4), b = 3.0.toDouble(), value = "v2", x = true) internal fun foo3(): kotlin.Unit
-A(a = IntegerValueType(4), b = 3.0.toDouble(), value = "v2", x = true) internal fun foo4(): kotlin.Unit
+A(a = 1, b = 1.0.toDouble(), value = "v1", x = false) internal fun foo1(): kotlin.Unit
+A(a = 2, b = 2.0.toDouble(), value = "v2", x = true) internal fun foo2(): kotlin.Unit
+A(a = 4, b = 3.0.toDouble(), value = "v2", x = true) internal fun foo3(): kotlin.Unit
+A(a = 4, b = 3.0.toDouble(), value = "v2", x = true) internal fun foo4(): kotlin.Unit
 
-public final annotation class A : kotlin.Annotation {
+public final class A : kotlin.Annotation {
     public constructor A(/*0*/ value: kotlin.String, /*1*/ a: kotlin.Int, /*2*/ b: kotlin.Double, /*3*/ x: kotlin.Boolean)
     public final val a: kotlin.Int
     public final val b: kotlin.Double
diff --git a/compiler/testData/diagnostics/testsWithStdLib/annotations/prohibitPositionedArgument/withoutValue.txt b/compiler/testData/diagnostics/testsWithStdLib/annotations/prohibitPositionedArgument/withoutValue.txt
index 6c282e4da72..1eaa96222ef 100644
--- a/compiler/testData/diagnostics/testsWithStdLib/annotations/prohibitPositionedArgument/withoutValue.txt
+++ b/compiler/testData/diagnostics/testsWithStdLib/annotations/prohibitPositionedArgument/withoutValue.txt
@@ -1,10 +1,10 @@
 package
 
-A(a = IntegerValueType(1), b = 1.0.toDouble(), x = false) internal fun foo1(): kotlin.Unit
-A(a = IntegerValueType(2), b = 2.0.toDouble(), x = true) internal fun foo2(): kotlin.Unit
-A(a = IntegerValueType(4), b = 3.0.toDouble(), x = true) internal fun foo3(): kotlin.Unit
+A(a = 1, b = 1.0.toDouble(), x = false) internal fun foo1(): kotlin.Unit
+A(a = 2, b = 2.0.toDouble(), x = true) internal fun foo2(): kotlin.Unit
+A(a = 4, b = 3.0.toDouble(), x = true) internal fun foo3(): kotlin.Unit
 
-public final annotation class A : kotlin.Annotation {
+public final class A : kotlin.Annotation {
     public constructor A(/*0*/ a: kotlin.Int, /*1*/ b: kotlin.Double, /*2*/ x: kotlin.Boolean)
     public final val a: kotlin.Int
     public final val b: kotlin.Double
diff --git a/compiler/testData/diagnostics/testsWithStdLib/annotations/publicField/publicFieldNotOnProperty.kt b/compiler/testData/diagnostics/testsWithStdLib/annotations/publicField/publicFieldNotOnProperty.kt
new file mode 100644
index 00000000000..40e65a437de
--- /dev/null
+++ b/compiler/testData/diagnostics/testsWithStdLib/annotations/publicField/publicFieldNotOnProperty.kt
@@ -0,0 +1,16 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+class C {
+
+    <!INAPPLICABLE_PUBLIC_FIELD!>@kotlin.jvm.publicField<!> constructor(s: String) {
+
+    }
+
+    <!INAPPLICABLE_PUBLIC_FIELD!>@kotlin.jvm.publicField<!> private fun foo(s: String = "OK") {
+
+    }
+}
+
+<!INAPPLICABLE_PUBLIC_FIELD!>@kotlin.jvm.publicField<!>
+fun foo() {
+    <!INAPPLICABLE_PUBLIC_FIELD!>@kotlin.jvm.publicField<!> val <!UNUSED_VARIABLE!>x<!> = "A"
+}
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/testsWithStdLib/annotations/publicField/publicFieldNotOnProperty.txt b/compiler/testData/diagnostics/testsWithStdLib/annotations/publicField/publicFieldNotOnProperty.txt
new file mode 100644
index 00000000000..2cc82a65623
--- /dev/null
+++ b/compiler/testData/diagnostics/testsWithStdLib/annotations/publicField/publicFieldNotOnProperty.txt
@@ -0,0 +1,12 @@
+package 
+
+kotlin.jvm.publicField() internal fun foo(): kotlin.Unit
+
+internal final class C {
+    kotlin.jvm.publicField() public constructor C(/*0*/ s: kotlin.String)
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    kotlin.jvm.publicField() private final fun foo(/*0*/ s: kotlin.String = ...): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
diff --git a/compiler/testData/diagnostics/testsWithStdLib/annotations/publicField/publicFieldOnDelegatedProperty.kt b/compiler/testData/diagnostics/testsWithStdLib/annotations/publicField/publicFieldOnDelegatedProperty.kt
new file mode 100644
index 00000000000..b230058cb9e
--- /dev/null
+++ b/compiler/testData/diagnostics/testsWithStdLib/annotations/publicField/publicFieldOnDelegatedProperty.kt
@@ -0,0 +1,3 @@
+class C {
+    private <!INAPPLICABLE_PUBLIC_FIELD!>@publicField<!> val a: String by lazy { "A" }
+}
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/testsWithStdLib/annotations/publicField/publicFieldOnDelegatedProperty.txt b/compiler/testData/diagnostics/testsWithStdLib/annotations/publicField/publicFieldOnDelegatedProperty.txt
new file mode 100644
index 00000000000..2bffb955537
--- /dev/null
+++ b/compiler/testData/diagnostics/testsWithStdLib/annotations/publicField/publicFieldOnDelegatedProperty.txt
@@ -0,0 +1,9 @@
+package 
+
+internal final class C {
+    public constructor C()
+    kotlin.jvm.publicField() private final val a: kotlin.String
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
diff --git a/compiler/testData/diagnostics/testsWithStdLib/annotations/qualifiedCallValue.txt b/compiler/testData/diagnostics/testsWithStdLib/annotations/qualifiedCallValue.txt
index 55ed1ce17e4..dc2e947c62e 100644
--- a/compiler/testData/diagnostics/testsWithStdLib/annotations/qualifiedCallValue.txt
+++ b/compiler/testData/diagnostics/testsWithStdLib/annotations/qualifiedCallValue.txt
@@ -13,7 +13,7 @@ package a {
                 public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
                 public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
 
-                internal final annotation class IAnn : kotlin.Annotation {
+                kotlin.annotation.annotation() internal final class IAnn : kotlin.Annotation {
                     public constructor IAnn()
                     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
                     public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
@@ -21,7 +21,7 @@ package a {
                 }
             }
 
-            internal final annotation class ann1 : kotlin.Annotation {
+            kotlin.annotation.annotation() internal final class ann1 : kotlin.Annotation {
                 public constructor ann1(/*0*/ p: kotlin.deprecated = ...)
                 internal final val p: kotlin.deprecated
                 public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
@@ -29,7 +29,7 @@ package a {
                 public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
             }
 
-            internal final annotation class ann2 : kotlin.Annotation {
+            kotlin.annotation.annotation() internal final class ann2 : kotlin.Annotation {
                 public constructor ann2(/*0*/ p: a.b.c.ann1 = ...)
                 internal final val p: a.b.c.ann1
                 public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
@@ -37,7 +37,7 @@ package a {
                 public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
             }
 
-            internal final annotation class ann3 : kotlin.Annotation {
+            kotlin.annotation.annotation() internal final class ann3 : kotlin.Annotation {
                 public constructor ann3(/*0*/ p: a.b.c.A.IAnn = ..., /*1*/ p2: a.b.c.A.IAnn = ...)
                 internal final val p: a.b.c.A.IAnn
                 internal final val p2: a.b.c.A.IAnn
@@ -46,7 +46,7 @@ package a {
                 public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
             }
 
-            internal final annotation class annArray : kotlin.Annotation {
+            kotlin.annotation.annotation() internal final class annArray : kotlin.Annotation {
                 public constructor annArray(/*0*/ p: kotlin.Array<kotlin.String> = ...)
                 internal final val p: kotlin.Array<kotlin.String>
                 public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
diff --git a/compiler/testData/diagnostics/testsWithStdLib/functionLiterals/pseudocodeMemoryOverhead.kt b/compiler/testData/diagnostics/testsWithStdLib/functionLiterals/pseudocodeMemoryOverhead.kt
index c4078737066..f6cf29b6555 100644
--- a/compiler/testData/diagnostics/testsWithStdLib/functionLiterals/pseudocodeMemoryOverhead.kt
+++ b/compiler/testData/diagnostics/testsWithStdLib/functionLiterals/pseudocodeMemoryOverhead.kt
@@ -49,10 +49,8 @@ private val unaryOperations: HashMap<UnaryOperationKey<*>, Pair<Function1<Any?,
         unaryOperation(BYTE, "toShort", { a -> a.toShort() }, emptyUnaryFun),
         unaryOperation(BYTE, "toByte", { a -> a.toByte() }, emptyUnaryFun),
         unaryOperation(CHAR, "toInt", { a -> a.toInt() }, emptyUnaryFun),
-        unaryOperation(CHAR, "minus", { a -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>minus<!>() }, emptyUnaryFun),
         unaryOperation(CHAR, "toChar", { a -> a.toChar() }, emptyUnaryFun),
         unaryOperation(CHAR, "toLong", { a -> a.toLong() }, emptyUnaryFun),
-        unaryOperation(CHAR, "plus", { a -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>plus<!>() }, emptyUnaryFun),
         unaryOperation(CHAR, "toFloat", { a -> a.toFloat() }, emptyUnaryFun),
         unaryOperation(CHAR, "toDouble", { a -> a.toDouble() }, emptyUnaryFun),
         unaryOperation(CHAR, "toShort", { a -> a.toShort() }, emptyUnaryFun),
@@ -115,110 +113,66 @@ private val binaryOperations: HashMap<BinaryOperationKey<*, *>, Pair<Function2<A
         binaryOperation(BOOLEAN, BOOLEAN, "and", { a, b -> a.and(b) }, emptyBinaryFun),
         binaryOperation(BOOLEAN, BOOLEAN, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
         binaryOperation(BYTE, BYTE, "minus", { a, b -> a.minus(b) }, { a, b -> a.subtract(b) }),
-        binaryOperation(BYTE, CHAR, "minus", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>minus<!>(b) }, emptyBinaryFun),
         binaryOperation(BYTE, DOUBLE, "minus", { a, b -> a.minus(b) }, emptyBinaryFun),
         binaryOperation(BYTE, FLOAT, "minus", { a, b -> a.minus(b) }, emptyBinaryFun),
         binaryOperation(BYTE, INT, "minus", { a, b -> a.minus(b) }, { a, b -> a.subtract(b) }),
         binaryOperation(BYTE, LONG, "minus", { a, b -> a.minus(b) }, { a, b -> a.subtract(b) }),
         binaryOperation(BYTE, SHORT, "minus", { a, b -> a.minus(b) }, { a, b -> a.subtract(b) }),
         binaryOperation(BYTE, BYTE, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
-        binaryOperation(BYTE, CHAR, "compareTo", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>compareTo<!>(b) }, emptyBinaryFun),
         binaryOperation(BYTE, DOUBLE, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
         binaryOperation(BYTE, FLOAT, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
         binaryOperation(BYTE, INT, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
         binaryOperation(BYTE, LONG, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
         binaryOperation(BYTE, SHORT, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
         binaryOperation(BYTE, BYTE, "plus", { a, b -> a.plus(b) }, { a, b -> a.add(b) }),
-        binaryOperation(BYTE, CHAR, "plus", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>plus<!>(b) }, emptyBinaryFun),
         binaryOperation(BYTE, DOUBLE, "plus", { a, b -> a.plus(b) }, emptyBinaryFun),
         binaryOperation(BYTE, FLOAT, "plus", { a, b -> a.plus(b) }, emptyBinaryFun),
         binaryOperation(BYTE, INT, "plus", { a, b -> a.plus(b) }, { a, b -> a.add(b) }),
         binaryOperation(BYTE, LONG, "plus", { a, b -> a.plus(b) }, { a, b -> a.add(b) }),
         binaryOperation(BYTE, SHORT, "plus", { a, b -> a.plus(b) }, { a, b -> a.add(b) }),
         binaryOperation(BYTE, BYTE, "div", { a, b -> a.div(b) }, { a, b -> a.divide(b) }),
-        binaryOperation(BYTE, CHAR, "div", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>div<!>(b) }, emptyBinaryFun),
         binaryOperation(BYTE, DOUBLE, "div", { a, b -> a.div(b) }, emptyBinaryFun),
         binaryOperation(BYTE, FLOAT, "div", { a, b -> a.div(b) }, emptyBinaryFun),
         binaryOperation(BYTE, INT, "div", { a, b -> a.div(b) }, { a, b -> a.divide(b) }),
         binaryOperation(BYTE, LONG, "div", { a, b -> a.div(b) }, { a, b -> a.divide(b) }),
         binaryOperation(BYTE, SHORT, "div", { a, b -> a.div(b) }, { a, b -> a.divide(b) }),
         binaryOperation(BYTE, BYTE, "mod", { a, b -> a.mod(b) }, { a, b -> a.mod(b) }),
-        binaryOperation(BYTE, CHAR, "mod", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>mod<!>(b) }, emptyBinaryFun),
         binaryOperation(BYTE, DOUBLE, "mod", { a, b -> a.mod(b) }, emptyBinaryFun),
         binaryOperation(BYTE, FLOAT, "mod", { a, b -> a.mod(b) }, emptyBinaryFun),
         binaryOperation(BYTE, INT, "mod", { a, b -> a.mod(b) }, { a, b -> a.mod(b) }),
         binaryOperation(BYTE, LONG, "mod", { a, b -> a.mod(b) }, { a, b -> a.mod(b) }),
         binaryOperation(BYTE, SHORT, "mod", { a, b -> a.mod(b) }, { a, b -> a.mod(b) }),
         binaryOperation(BYTE, BYTE, "times", { a, b -> a.times(b) }, { a, b -> a.multiply(b) }),
-        binaryOperation(BYTE, CHAR, "times", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>times<!>(b) }, emptyBinaryFun),
         binaryOperation(BYTE, DOUBLE, "times", { a, b -> a.times(b) }, emptyBinaryFun),
         binaryOperation(BYTE, FLOAT, "times", { a, b -> a.times(b) }, emptyBinaryFun),
         binaryOperation(BYTE, INT, "times", { a, b -> a.times(b) }, { a, b -> a.multiply(b) }),
         binaryOperation(BYTE, LONG, "times", { a, b -> a.times(b) }, { a, b -> a.multiply(b) }),
         binaryOperation(BYTE, SHORT, "times", { a, b -> a.times(b) }, { a, b -> a.multiply(b) }),
         binaryOperation(BYTE, ANY, "equals", { a, b -> a.equals(b) }, emptyBinaryFun),
-        binaryOperation(CHAR, BYTE, "minus", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>minus<!>(b) }, emptyBinaryFun),
         binaryOperation(CHAR, CHAR, "minus", { a, b -> a.minus(b) }, emptyBinaryFun),
-        binaryOperation(CHAR, DOUBLE, "minus", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>minus<!>(b) }, emptyBinaryFun),
-        binaryOperation(CHAR, FLOAT, "minus", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>minus<!>(b) }, emptyBinaryFun),
-        binaryOperation(CHAR, INT, "minus", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>minus<!>(b) }, emptyBinaryFun),
-        binaryOperation(CHAR, LONG, "minus", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>minus<!>(b) }, emptyBinaryFun),
-        binaryOperation(CHAR, SHORT, "minus", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>minus<!>(b) }, emptyBinaryFun),
-        binaryOperation(CHAR, BYTE, "compareTo", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>compareTo<!>(b) }, emptyBinaryFun),
         binaryOperation(CHAR, CHAR, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
-        binaryOperation(CHAR, DOUBLE, "compareTo", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>compareTo<!>(b) }, emptyBinaryFun),
-        binaryOperation(CHAR, FLOAT, "compareTo", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>compareTo<!>(b) }, emptyBinaryFun),
-        binaryOperation(CHAR, INT, "compareTo", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>compareTo<!>(b) }, emptyBinaryFun),
-        binaryOperation(CHAR, LONG, "compareTo", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>compareTo<!>(b) }, emptyBinaryFun),
-        binaryOperation(CHAR, SHORT, "compareTo", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>compareTo<!>(b) }, emptyBinaryFun),
-        binaryOperation(CHAR, BYTE, "plus", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>plus<!>(b) }, emptyBinaryFun),
-        binaryOperation(CHAR, DOUBLE, "plus", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>plus<!>(b) }, emptyBinaryFun),
-        binaryOperation(CHAR, FLOAT, "plus", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>plus<!>(b) }, emptyBinaryFun),
-        binaryOperation(CHAR, INT, "plus", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>plus<!>(b) }, emptyBinaryFun),
-        binaryOperation(CHAR, LONG, "plus", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>plus<!>(b) }, emptyBinaryFun),
-        binaryOperation(CHAR, SHORT, "plus", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>plus<!>(b) }, emptyBinaryFun),
-        binaryOperation(CHAR, BYTE, "div", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>div<!>(b) }, emptyBinaryFun),
-        binaryOperation(CHAR, DOUBLE, "div", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>div<!>(b) }, emptyBinaryFun),
-        binaryOperation(CHAR, FLOAT, "div", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>div<!>(b) }, emptyBinaryFun),
-        binaryOperation(CHAR, INT, "div", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>div<!>(b) }, emptyBinaryFun),
-        binaryOperation(CHAR, LONG, "div", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>div<!>(b) }, emptyBinaryFun),
-        binaryOperation(CHAR, SHORT, "div", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>div<!>(b) }, emptyBinaryFun),
-        binaryOperation(CHAR, BYTE, "mod", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>mod<!>(b) }, emptyBinaryFun),
-        binaryOperation(CHAR, DOUBLE, "mod", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>mod<!>(b) }, emptyBinaryFun),
-        binaryOperation(CHAR, FLOAT, "mod", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>mod<!>(b) }, emptyBinaryFun),
-        binaryOperation(CHAR, INT, "mod", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>mod<!>(b) }, emptyBinaryFun),
-        binaryOperation(CHAR, LONG, "mod", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>mod<!>(b) }, emptyBinaryFun),
-        binaryOperation(CHAR, SHORT, "mod", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>mod<!>(b) }, emptyBinaryFun),
-        binaryOperation(CHAR, BYTE, "times", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>times<!>(b) }, emptyBinaryFun),
-        binaryOperation(CHAR, DOUBLE, "times", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>times<!>(b) }, emptyBinaryFun),
-        binaryOperation(CHAR, FLOAT, "times", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>times<!>(b) }, emptyBinaryFun),
-        binaryOperation(CHAR, INT, "times", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>times<!>(b) }, emptyBinaryFun),
-        binaryOperation(CHAR, LONG, "times", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>times<!>(b) }, emptyBinaryFun),
-        binaryOperation(CHAR, SHORT, "times", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>times<!>(b) }, emptyBinaryFun),
+        binaryOperation(CHAR, INT, "minus", { a, b -> a.minus(b) }, emptyBinaryFun),
+        binaryOperation(CHAR, INT, "plus", { a, b -> a.plus(b) }, emptyBinaryFun),
         binaryOperation(CHAR, ANY, "equals", { a, b -> a.equals(b) }, emptyBinaryFun),
         binaryOperation(DOUBLE, BYTE, "minus", { a, b -> a.minus(b) }, emptyBinaryFun),
-        binaryOperation(DOUBLE, CHAR, "minus", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>minus<!>(b) }, emptyBinaryFun),
         binaryOperation(DOUBLE, DOUBLE, "minus", { a, b -> a.minus(b) }, emptyBinaryFun),
         binaryOperation(DOUBLE, FLOAT, "minus", { a, b -> a.minus(b) }, emptyBinaryFun),
         binaryOperation(DOUBLE, INT, "minus", { a, b -> a.minus(b) }, emptyBinaryFun),
         binaryOperation(DOUBLE, LONG, "minus", { a, b -> a.minus(b) }, emptyBinaryFun),
         binaryOperation(DOUBLE, SHORT, "minus", { a, b -> a.minus(b) }, emptyBinaryFun),
         binaryOperation(DOUBLE, BYTE, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
-        binaryOperation(DOUBLE, CHAR, "compareTo", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>compareTo<!>(b) }, emptyBinaryFun),
         binaryOperation(DOUBLE, DOUBLE, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
         binaryOperation(DOUBLE, FLOAT, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
         binaryOperation(DOUBLE, INT, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
         binaryOperation(DOUBLE, LONG, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
         binaryOperation(DOUBLE, SHORT, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
         binaryOperation(DOUBLE, BYTE, "plus", { a, b -> a.plus(b) }, emptyBinaryFun),
-        binaryOperation(DOUBLE, CHAR, "plus", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>plus<!>(b) }, emptyBinaryFun),
         binaryOperation(DOUBLE, DOUBLE, "plus", { a, b -> a.plus(b) }, emptyBinaryFun),
         binaryOperation(DOUBLE, FLOAT, "plus", { a, b -> a.plus(b) }, emptyBinaryFun),
         binaryOperation(DOUBLE, INT, "plus", { a, b -> a.plus(b) }, emptyBinaryFun),
         binaryOperation(DOUBLE, LONG, "plus", { a, b -> a.plus(b) }, emptyBinaryFun),
         binaryOperation(DOUBLE, SHORT, "plus", { a, b -> a.plus(b) }, emptyBinaryFun),
         binaryOperation(DOUBLE, BYTE, "div", { a, b -> a.div(b) }, emptyBinaryFun),
-        binaryOperation(DOUBLE, CHAR, "div", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>div<!>(b) }, emptyBinaryFun),
         binaryOperation(DOUBLE, DOUBLE, "div", { a, b -> a.div(b) }, emptyBinaryFun),
         binaryOperation(DOUBLE, FLOAT, "div", { a, b -> a.div(b) }, emptyBinaryFun),
         binaryOperation(DOUBLE, INT, "div", { a, b -> a.div(b) }, emptyBinaryFun),
@@ -231,7 +185,6 @@ private val binaryOperations: HashMap<BinaryOperationKey<*, *>, Pair<Function2<A
         binaryOperation(DOUBLE, LONG, "mod", { a, b -> a.mod(b) }, emptyBinaryFun),
         binaryOperation(DOUBLE, SHORT, "mod", { a, b -> a.mod(b) }, emptyBinaryFun),
         binaryOperation(DOUBLE, BYTE, "times", { a, b -> a.times(b) }, emptyBinaryFun),
-        binaryOperation(DOUBLE, CHAR, "times", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>times<!>(b) }, emptyBinaryFun),
         binaryOperation(DOUBLE, DOUBLE, "times", { a, b -> a.times(b) }, emptyBinaryFun),
         binaryOperation(DOUBLE, FLOAT, "times", { a, b -> a.times(b) }, emptyBinaryFun),
         binaryOperation(DOUBLE, INT, "times", { a, b -> a.times(b) }, emptyBinaryFun),
@@ -239,42 +192,36 @@ private val binaryOperations: HashMap<BinaryOperationKey<*, *>, Pair<Function2<A
         binaryOperation(DOUBLE, SHORT, "times", { a, b -> a.times(b) }, emptyBinaryFun),
         binaryOperation(DOUBLE, ANY, "equals", { a, b -> a.equals(b) }, emptyBinaryFun),
         binaryOperation(FLOAT, BYTE, "minus", { a, b -> a.minus(b) }, emptyBinaryFun),
-        binaryOperation(FLOAT, CHAR, "minus", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>minus<!>(b) }, emptyBinaryFun),
         binaryOperation(FLOAT, DOUBLE, "minus", { a, b -> a.minus(b) }, emptyBinaryFun),
         binaryOperation(FLOAT, FLOAT, "minus", { a, b -> a.minus(b) }, emptyBinaryFun),
         binaryOperation(FLOAT, INT, "minus", { a, b -> a.minus(b) }, emptyBinaryFun),
         binaryOperation(FLOAT, LONG, "minus", { a, b -> a.minus(b) }, emptyBinaryFun),
         binaryOperation(FLOAT, SHORT, "minus", { a, b -> a.minus(b) }, emptyBinaryFun),
         binaryOperation(FLOAT, BYTE, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
-        binaryOperation(FLOAT, CHAR, "compareTo", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>compareTo<!>(b) }, emptyBinaryFun),
         binaryOperation(FLOAT, DOUBLE, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
         binaryOperation(FLOAT, FLOAT, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
         binaryOperation(FLOAT, INT, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
         binaryOperation(FLOAT, LONG, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
         binaryOperation(FLOAT, SHORT, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
         binaryOperation(FLOAT, BYTE, "plus", { a, b -> a.plus(b) }, emptyBinaryFun),
-        binaryOperation(FLOAT, CHAR, "plus", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>plus<!>(b) }, emptyBinaryFun),
         binaryOperation(FLOAT, DOUBLE, "plus", { a, b -> a.plus(b) }, emptyBinaryFun),
         binaryOperation(FLOAT, FLOAT, "plus", { a, b -> a.plus(b) }, emptyBinaryFun),
         binaryOperation(FLOAT, INT, "plus", { a, b -> a.plus(b) }, emptyBinaryFun),
         binaryOperation(FLOAT, LONG, "plus", { a, b -> a.plus(b) }, emptyBinaryFun),
         binaryOperation(FLOAT, SHORT, "plus", { a, b -> a.plus(b) }, emptyBinaryFun),
         binaryOperation(FLOAT, BYTE, "div", { a, b -> a.div(b) }, emptyBinaryFun),
-        binaryOperation(FLOAT, CHAR, "div", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>div<!>(b) }, emptyBinaryFun),
         binaryOperation(FLOAT, DOUBLE, "div", { a, b -> a.div(b) }, emptyBinaryFun),
         binaryOperation(FLOAT, FLOAT, "div", { a, b -> a.div(b) }, emptyBinaryFun),
         binaryOperation(FLOAT, INT, "div", { a, b -> a.div(b) }, emptyBinaryFun),
         binaryOperation(FLOAT, LONG, "div", { a, b -> a.div(b) }, emptyBinaryFun),
         binaryOperation(FLOAT, SHORT, "div", { a, b -> a.div(b) }, emptyBinaryFun),
         binaryOperation(FLOAT, BYTE, "mod", { a, b -> a.mod(b) }, emptyBinaryFun),
-        binaryOperation(FLOAT, CHAR, "mod", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>mod<!>(b) }, emptyBinaryFun),
         binaryOperation(FLOAT, DOUBLE, "mod", { a, b -> a.mod(b) }, emptyBinaryFun),
         binaryOperation(FLOAT, FLOAT, "mod", { a, b -> a.mod(b) }, emptyBinaryFun),
         binaryOperation(FLOAT, INT, "mod", { a, b -> a.mod(b) }, emptyBinaryFun),
         binaryOperation(FLOAT, LONG, "mod", { a, b -> a.mod(b) }, emptyBinaryFun),
         binaryOperation(FLOAT, SHORT, "mod", { a, b -> a.mod(b) }, emptyBinaryFun),
         binaryOperation(FLOAT, BYTE, "times", { a, b -> a.times(b) }, emptyBinaryFun),
-        binaryOperation(FLOAT, CHAR, "times", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>times<!>(b) }, emptyBinaryFun),
         binaryOperation(FLOAT, DOUBLE, "times", { a, b -> a.times(b) }, emptyBinaryFun),
         binaryOperation(FLOAT, FLOAT, "times", { a, b -> a.times(b) }, emptyBinaryFun),
         binaryOperation(FLOAT, INT, "times", { a, b -> a.times(b) }, emptyBinaryFun),
@@ -282,14 +229,12 @@ private val binaryOperations: HashMap<BinaryOperationKey<*, *>, Pair<Function2<A
         binaryOperation(FLOAT, SHORT, "times", { a, b -> a.times(b) }, emptyBinaryFun),
         binaryOperation(FLOAT, ANY, "equals", { a, b -> a.equals(b) }, emptyBinaryFun),
         binaryOperation(INT, BYTE, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
-        binaryOperation(INT, CHAR, "compareTo", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>compareTo<!>(b) }, emptyBinaryFun),
         binaryOperation(INT, DOUBLE, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
         binaryOperation(INT, FLOAT, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
         binaryOperation(INT, INT, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
         binaryOperation(INT, LONG, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
         binaryOperation(INT, SHORT, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
         binaryOperation(INT, BYTE, "plus", { a, b -> a.plus(b) }, { a, b -> a.add(b) }),
-        binaryOperation(INT, CHAR, "plus", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>plus<!>(b) }, emptyBinaryFun),
         binaryOperation(INT, DOUBLE, "plus", { a, b -> a.plus(b) }, emptyBinaryFun),
         binaryOperation(INT, FLOAT, "plus", { a, b -> a.plus(b) }, emptyBinaryFun),
         binaryOperation(INT, INT, "plus", { a, b -> a.plus(b) }, { a, b -> a.add(b) }),
@@ -298,7 +243,6 @@ private val binaryOperations: HashMap<BinaryOperationKey<*, *>, Pair<Function2<A
         binaryOperation(INT, INT, "shl", { a, b -> a.shl(b) }, emptyBinaryFun),
         binaryOperation(INT, INT, "ushr", { a, b -> a.ushr(b) }, emptyBinaryFun),
         binaryOperation(INT, BYTE, "div", { a, b -> a.div(b) }, { a, b -> a.divide(b) }),
-        binaryOperation(INT, CHAR, "div", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>div<!>(b) }, emptyBinaryFun),
         binaryOperation(INT, DOUBLE, "div", { a, b -> a.div(b) }, emptyBinaryFun),
         binaryOperation(INT, FLOAT, "div", { a, b -> a.div(b) }, emptyBinaryFun),
         binaryOperation(INT, INT, "div", { a, b -> a.div(b) }, { a, b -> a.divide(b) }),
@@ -306,14 +250,12 @@ private val binaryOperations: HashMap<BinaryOperationKey<*, *>, Pair<Function2<A
         binaryOperation(INT, SHORT, "div", { a, b -> a.div(b) }, { a, b -> a.divide(b) }),
         binaryOperation(INT, INT, "shr", { a, b -> a.shr(b) }, emptyBinaryFun),
         binaryOperation(INT, BYTE, "mod", { a, b -> a.mod(b) }, { a, b -> a.mod(b) }),
-        binaryOperation(INT, CHAR, "mod", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>mod<!>(b) }, emptyBinaryFun),
         binaryOperation(INT, DOUBLE, "mod", { a, b -> a.mod(b) }, emptyBinaryFun),
         binaryOperation(INT, FLOAT, "mod", { a, b -> a.mod(b) }, emptyBinaryFun),
         binaryOperation(INT, INT, "mod", { a, b -> a.mod(b) }, { a, b -> a.mod(b) }),
         binaryOperation(INT, LONG, "mod", { a, b -> a.mod(b) }, { a, b -> a.mod(b) }),
         binaryOperation(INT, SHORT, "mod", { a, b -> a.mod(b) }, { a, b -> a.mod(b) }),
         binaryOperation(INT, BYTE, "times", { a, b -> a.times(b) }, { a, b -> a.multiply(b) }),
-        binaryOperation(INT, CHAR, "times", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>times<!>(b) }, emptyBinaryFun),
         binaryOperation(INT, DOUBLE, "times", { a, b -> a.times(b) }, emptyBinaryFun),
         binaryOperation(INT, FLOAT, "times", { a, b -> a.times(b) }, emptyBinaryFun),
         binaryOperation(INT, INT, "times", { a, b -> a.times(b) }, { a, b -> a.multiply(b) }),
@@ -321,7 +263,6 @@ private val binaryOperations: HashMap<BinaryOperationKey<*, *>, Pair<Function2<A
         binaryOperation(INT, SHORT, "times", { a, b -> a.times(b) }, { a, b -> a.multiply(b) }),
         binaryOperation(INT, INT, "or", { a, b -> a.or(b) }, { a, b -> a.or(b) }),
         binaryOperation(INT, BYTE, "minus", { a, b -> a.minus(b) }, { a, b -> a.subtract(b) }),
-        binaryOperation(INT, CHAR, "minus", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>minus<!>(b) }, emptyBinaryFun),
         binaryOperation(INT, DOUBLE, "minus", { a, b -> a.minus(b) }, emptyBinaryFun),
         binaryOperation(INT, FLOAT, "minus", { a, b -> a.minus(b) }, emptyBinaryFun),
         binaryOperation(INT, INT, "minus", { a, b -> a.minus(b) }, { a, b -> a.subtract(b) }),
@@ -331,14 +272,12 @@ private val binaryOperations: HashMap<BinaryOperationKey<*, *>, Pair<Function2<A
         binaryOperation(INT, INT, "xor", { a, b -> a.xor(b) }, { a, b -> a.xor(b) }),
         binaryOperation(INT, ANY, "equals", { a, b -> a.equals(b) }, emptyBinaryFun),
         binaryOperation(LONG, BYTE, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
-        binaryOperation(LONG, CHAR, "compareTo", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>compareTo<!>(b) }, emptyBinaryFun),
         binaryOperation(LONG, DOUBLE, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
         binaryOperation(LONG, FLOAT, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
         binaryOperation(LONG, INT, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
         binaryOperation(LONG, LONG, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
         binaryOperation(LONG, SHORT, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
         binaryOperation(LONG, BYTE, "plus", { a, b -> a.plus(b) }, { a, b -> a.add(b) }),
-        binaryOperation(LONG, CHAR, "plus", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>plus<!>(b) }, emptyBinaryFun),
         binaryOperation(LONG, DOUBLE, "plus", { a, b -> a.plus(b) }, emptyBinaryFun),
         binaryOperation(LONG, FLOAT, "plus", { a, b -> a.plus(b) }, emptyBinaryFun),
         binaryOperation(LONG, INT, "plus", { a, b -> a.plus(b) }, { a, b -> a.add(b) }),
@@ -347,7 +286,6 @@ private val binaryOperations: HashMap<BinaryOperationKey<*, *>, Pair<Function2<A
         binaryOperation(LONG, INT, "shl", { a, b -> a.shl(b) }, emptyBinaryFun),
         binaryOperation(LONG, INT, "ushr", { a, b -> a.ushr(b) }, emptyBinaryFun),
         binaryOperation(LONG, BYTE, "div", { a, b -> a.div(b) }, { a, b -> a.divide(b) }),
-        binaryOperation(LONG, CHAR, "div", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>div<!>(b) }, emptyBinaryFun),
         binaryOperation(LONG, DOUBLE, "div", { a, b -> a.div(b) }, emptyBinaryFun),
         binaryOperation(LONG, FLOAT, "div", { a, b -> a.div(b) }, emptyBinaryFun),
         binaryOperation(LONG, INT, "div", { a, b -> a.div(b) }, { a, b -> a.divide(b) }),
@@ -355,14 +293,12 @@ private val binaryOperations: HashMap<BinaryOperationKey<*, *>, Pair<Function2<A
         binaryOperation(LONG, SHORT, "div", { a, b -> a.div(b) }, { a, b -> a.divide(b) }),
         binaryOperation(LONG, INT, "shr", { a, b -> a.shr(b) }, emptyBinaryFun),
         binaryOperation(LONG, BYTE, "mod", { a, b -> a.mod(b) }, { a, b -> a.mod(b) }),
-        binaryOperation(LONG, CHAR, "mod", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>mod<!>(b) }, emptyBinaryFun),
         binaryOperation(LONG, DOUBLE, "mod", { a, b -> a.mod(b) }, emptyBinaryFun),
         binaryOperation(LONG, FLOAT, "mod", { a, b -> a.mod(b) }, emptyBinaryFun),
         binaryOperation(LONG, INT, "mod", { a, b -> a.mod(b) }, { a, b -> a.mod(b) }),
         binaryOperation(LONG, LONG, "mod", { a, b -> a.mod(b) }, { a, b -> a.mod(b) }),
         binaryOperation(LONG, SHORT, "mod", { a, b -> a.mod(b) }, { a, b -> a.mod(b) }),
         binaryOperation(LONG, BYTE, "times", { a, b -> a.times(b) }, { a, b -> a.multiply(b) }),
-        binaryOperation(LONG, CHAR, "times", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>times<!>(b) }, emptyBinaryFun),
         binaryOperation(LONG, DOUBLE, "times", { a, b -> a.times(b) }, emptyBinaryFun),
         binaryOperation(LONG, FLOAT, "times", { a, b -> a.times(b) }, emptyBinaryFun),
         binaryOperation(LONG, INT, "times", { a, b -> a.times(b) }, { a, b -> a.multiply(b) }),
@@ -370,7 +306,6 @@ private val binaryOperations: HashMap<BinaryOperationKey<*, *>, Pair<Function2<A
         binaryOperation(LONG, SHORT, "times", { a, b -> a.times(b) }, { a, b -> a.multiply(b) }),
         binaryOperation(LONG, LONG, "or", { a, b -> a.or(b) }, { a, b -> a.or(b) }),
         binaryOperation(LONG, BYTE, "minus", { a, b -> a.minus(b) }, { a, b -> a.subtract(b) }),
-        binaryOperation(LONG, CHAR, "minus", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>minus<!>(b) }, emptyBinaryFun),
         binaryOperation(LONG, DOUBLE, "minus", { a, b -> a.minus(b) }, emptyBinaryFun),
         binaryOperation(LONG, FLOAT, "minus", { a, b -> a.minus(b) }, emptyBinaryFun),
         binaryOperation(LONG, INT, "minus", { a, b -> a.minus(b) }, { a, b -> a.subtract(b) }),
@@ -380,42 +315,36 @@ private val binaryOperations: HashMap<BinaryOperationKey<*, *>, Pair<Function2<A
         binaryOperation(LONG, LONG, "xor", { a, b -> a.xor(b) }, { a, b -> a.xor(b) }),
         binaryOperation(LONG, ANY, "equals", { a, b -> a.equals(b) }, emptyBinaryFun),
         binaryOperation(SHORT, BYTE, "minus", { a, b -> a.minus(b) }, { a, b -> a.subtract(b) }),
-        binaryOperation(SHORT, CHAR, "minus", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>minus<!>(b) }, emptyBinaryFun),
         binaryOperation(SHORT, DOUBLE, "minus", { a, b -> a.minus(b) }, emptyBinaryFun),
         binaryOperation(SHORT, FLOAT, "minus", { a, b -> a.minus(b) }, emptyBinaryFun),
         binaryOperation(SHORT, INT, "minus", { a, b -> a.minus(b) }, { a, b -> a.subtract(b) }),
         binaryOperation(SHORT, LONG, "minus", { a, b -> a.minus(b) }, { a, b -> a.subtract(b) }),
         binaryOperation(SHORT, SHORT, "minus", { a, b -> a.minus(b) }, { a, b -> a.subtract(b) }),
         binaryOperation(SHORT, BYTE, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
-        binaryOperation(SHORT, CHAR, "compareTo", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>compareTo<!>(b) }, emptyBinaryFun),
         binaryOperation(SHORT, DOUBLE, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
         binaryOperation(SHORT, FLOAT, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
         binaryOperation(SHORT, INT, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
         binaryOperation(SHORT, LONG, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
         binaryOperation(SHORT, SHORT, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
         binaryOperation(SHORT, BYTE, "plus", { a, b -> a.plus(b) }, { a, b -> a.add(b) }),
-        binaryOperation(SHORT, CHAR, "plus", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>plus<!>(b) }, emptyBinaryFun),
         binaryOperation(SHORT, DOUBLE, "plus", { a, b -> a.plus(b) }, emptyBinaryFun),
         binaryOperation(SHORT, FLOAT, "plus", { a, b -> a.plus(b) }, emptyBinaryFun),
         binaryOperation(SHORT, INT, "plus", { a, b -> a.plus(b) }, { a, b -> a.add(b) }),
         binaryOperation(SHORT, LONG, "plus", { a, b -> a.plus(b) }, { a, b -> a.add(b) }),
         binaryOperation(SHORT, SHORT, "plus", { a, b -> a.plus(b) }, { a, b -> a.add(b) }),
         binaryOperation(SHORT, BYTE, "div", { a, b -> a.div(b) }, { a, b -> a.divide(b) }),
-        binaryOperation(SHORT, CHAR, "div", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>div<!>(b) }, emptyBinaryFun),
         binaryOperation(SHORT, DOUBLE, "div", { a, b -> a.div(b) }, emptyBinaryFun),
         binaryOperation(SHORT, FLOAT, "div", { a, b -> a.div(b) }, emptyBinaryFun),
         binaryOperation(SHORT, INT, "div", { a, b -> a.div(b) }, { a, b -> a.divide(b) }),
         binaryOperation(SHORT, LONG, "div", { a, b -> a.div(b) }, { a, b -> a.divide(b) }),
         binaryOperation(SHORT, SHORT, "div", { a, b -> a.div(b) }, { a, b -> a.divide(b) }),
         binaryOperation(SHORT, BYTE, "mod", { a, b -> a.mod(b) }, { a, b -> a.mod(b) }),
-        binaryOperation(SHORT, CHAR, "mod", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>mod<!>(b) }, emptyBinaryFun),
         binaryOperation(SHORT, DOUBLE, "mod", { a, b -> a.mod(b) }, emptyBinaryFun),
         binaryOperation(SHORT, FLOAT, "mod", { a, b -> a.mod(b) }, emptyBinaryFun),
         binaryOperation(SHORT, INT, "mod", { a, b -> a.mod(b) }, { a, b -> a.mod(b) }),
         binaryOperation(SHORT, LONG, "mod", { a, b -> a.mod(b) }, { a, b -> a.mod(b) }),
         binaryOperation(SHORT, SHORT, "mod", { a, b -> a.mod(b) }, { a, b -> a.mod(b) }),
         binaryOperation(SHORT, BYTE, "times", { a, b -> a.times(b) }, { a, b -> a.multiply(b) }),
-        binaryOperation(SHORT, CHAR, "times", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>times<!>(b) }, emptyBinaryFun),
         binaryOperation(SHORT, DOUBLE, "times", { a, b -> a.times(b) }, emptyBinaryFun),
         binaryOperation(SHORT, FLOAT, "times", { a, b -> a.times(b) }, emptyBinaryFun),
         binaryOperation(SHORT, INT, "times", { a, b -> a.times(b) }, { a, b -> a.multiply(b) }),
diff --git a/compiler/testData/diagnostics/testsWithStdLib/inference/kt3458.kt b/compiler/testData/diagnostics/testsWithStdLib/inference/kt3458.kt
new file mode 100644
index 00000000000..03cf7f8b523
--- /dev/null
+++ b/compiler/testData/diagnostics/testsWithStdLib/inference/kt3458.kt
@@ -0,0 +1,9 @@
+// !CHECK_TYPE
+
+import java.io.File
+
+fun test() {
+    val dir = File("dir")
+    val files = dir.listFiles()?.toList() ?: listOf() // error
+    files checkType { _<List<File>>() }
+}
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/testsWithStdLib/inference/kt3458.txt b/compiler/testData/diagnostics/testsWithStdLib/inference/kt3458.txt
new file mode 100644
index 00000000000..b8def46715c
--- /dev/null
+++ b/compiler/testData/diagnostics/testsWithStdLib/inference/kt3458.txt
@@ -0,0 +1,3 @@
+package
+
+internal fun test(): kotlin.Unit
diff --git a/compiler/testData/diagnostics/testsWithStdLib/inference/kt4975.kt b/compiler/testData/diagnostics/testsWithStdLib/inference/kt4975.kt
new file mode 100644
index 00000000000..921a68f7936
--- /dev/null
+++ b/compiler/testData/diagnostics/testsWithStdLib/inference/kt4975.kt
@@ -0,0 +1,10 @@
+// !CHECK_TYPE
+
+fun <T> bar(f: () -> T) : T = f()
+
+fun test(map: MutableMap<Int, Int>) {
+    val r = bar {
+        map[1] = 2
+    }
+    r checkType { _<Unit>() }
+}
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/testsWithStdLib/inference/kt4975.txt b/compiler/testData/diagnostics/testsWithStdLib/inference/kt4975.txt
new file mode 100644
index 00000000000..3eab57374a6
--- /dev/null
+++ b/compiler/testData/diagnostics/testsWithStdLib/inference/kt4975.txt
@@ -0,0 +1,4 @@
+package
+
+internal fun </*0*/ T> bar(/*0*/ f: () -> T): T
+internal fun test(/*0*/ map: kotlin.MutableMap<kotlin.Int, kotlin.Int>): kotlin.Unit
diff --git a/compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/arrayList.kt b/compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/arrayList.kt
new file mode 100644
index 00000000000..b28f1a8c27e
--- /dev/null
+++ b/compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/arrayList.kt
@@ -0,0 +1,22 @@
+// !DIAGNOSTICS: -UNUSED_VARIABLE
+import java.util.*
+
+fun bar(): String? = null
+
+fun foo() {
+    var x = ArrayList<String>()
+    x.<!NONE_APPLICABLE!>add<!>(null)
+    x.<!NONE_APPLICABLE!>add<!>(bar())
+    x.add("")
+
+    x[0] = <!NULL_FOR_NONNULL_TYPE!>null<!>
+    x[0] = <!TYPE_MISMATCH!>bar()<!>
+    x[0] = ""
+
+    val b1: MutableList<String?> = <!TYPE_MISMATCH!>x<!>
+    val b2: MutableList<String> = x
+    val b3: List<String?> = x
+
+    val b4: Collection<String?> = x
+    val b6: MutableCollection<String?> = <!TYPE_MISMATCH!>x<!>
+}
diff --git a/compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/arrayList.txt b/compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/arrayList.txt
new file mode 100644
index 00000000000..dd1f7a31060
--- /dev/null
+++ b/compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/arrayList.txt
@@ -0,0 +1,4 @@
+package
+
+internal fun bar(): kotlin.String?
+internal fun foo(): kotlin.Unit
diff --git a/compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/arrayListNullable.kt b/compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/arrayListNullable.kt
new file mode 100644
index 00000000000..fad8fa935c2
--- /dev/null
+++ b/compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/arrayListNullable.kt
@@ -0,0 +1,22 @@
+// !DIAGNOSTICS: -UNUSED_VARIABLE
+import java.util.*
+
+fun bar(): String? = null
+
+fun foo() {
+    var x = ArrayList<String?>()
+    x.add(null)
+    x.add(bar())
+    x.add("")
+
+    x[0] = null
+    x[0] = bar()
+    x[0] = ""
+
+    val b1: MutableList<String?> = x
+    val b2: MutableList<String> = <!TYPE_MISMATCH!>x<!>
+    val b3: List<String?> = x
+
+    val b4: Collection<String?> = x
+    val b6: MutableCollection<String?> = x
+}
diff --git a/compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/arrayListNullable.txt b/compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/arrayListNullable.txt
new file mode 100644
index 00000000000..dd1f7a31060
--- /dev/null
+++ b/compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/arrayListNullable.txt
@@ -0,0 +1,4 @@
+package
+
+internal fun bar(): kotlin.String?
+internal fun foo(): kotlin.Unit
diff --git a/compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/customClassMutableCollection.kt b/compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/customClassMutableCollection.kt
new file mode 100644
index 00000000000..b67883babd4
--- /dev/null
+++ b/compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/customClassMutableCollection.kt
@@ -0,0 +1,31 @@
+// !DIAGNOSTICS: -UNUSED_VARIABLE
+
+import java.util.*
+
+// FILE: A.java
+@kotlin.jvm.PurelyImplements("kotlin.MutableCollection")
+class A<T> extends AbstractCollection<T> {
+    @Override
+    public Iterator<T> iterator() {
+        return null;
+    }
+
+    @Override
+    public int size() {
+        return 0;
+    }
+}
+
+// FILE: b.kt
+
+fun bar(): String? = null
+
+fun foo() {
+    var x = A<String>()
+    x.add(<!NULL_FOR_NONNULL_TYPE!>null<!>)
+    x.add(<!TYPE_MISMATCH!>bar()<!>)
+    x.add("")
+
+    val b1: Collection<String?> = x
+    val b2: MutableCollection<String?> = <!TYPE_MISMATCH!>x<!>
+}
diff --git a/compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/customClassMutableCollection.txt b/compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/customClassMutableCollection.txt
new file mode 100644
index 00000000000..c8966bb576a
--- /dev/null
+++ b/compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/customClassMutableCollection.txt
@@ -0,0 +1,24 @@
+package
+
+internal fun bar(): kotlin.String?
+internal fun foo(): kotlin.Unit
+
+kotlin.jvm.PurelyImplements(value = "kotlin.MutableCollection") public/*package*/ open class A</*0*/ T> : java.util.AbstractCollection<T!>, kotlin.MutableCollection<T> {
+    public/*package*/ constructor A</*0*/ T>()
+    public open override /*2*/ /*fake_override*/ fun add(/*0*/ e: T): kotlin.Boolean
+    public open override /*2*/ /*fake_override*/ fun addAll(/*0*/ c: kotlin.Collection<T>): kotlin.Boolean
+    public open override /*2*/ /*fake_override*/ fun clear(): kotlin.Unit
+    public open override /*2*/ /*fake_override*/ fun contains(/*0*/ o: kotlin.Any?): kotlin.Boolean
+    public open override /*2*/ /*fake_override*/ fun containsAll(/*0*/ c: kotlin.Collection<kotlin.Any?>): kotlin.Boolean
+    public open override /*2*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*2*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*2*/ /*fake_override*/ fun isEmpty(): kotlin.Boolean
+    java.lang.Override() public open override /*2*/ fun iterator(): kotlin.MutableIterator<T>
+    public open override /*2*/ /*fake_override*/ fun remove(/*0*/ o: kotlin.Any?): kotlin.Boolean
+    public open override /*2*/ /*fake_override*/ fun removeAll(/*0*/ c: kotlin.Collection<kotlin.Any?>): kotlin.Boolean
+    public open override /*2*/ /*fake_override*/ fun retainAll(/*0*/ c: kotlin.Collection<kotlin.Any?>): kotlin.Boolean
+    java.lang.Override() public open override /*2*/ fun size(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toArray(): kotlin.Array<(out) kotlin.Any!>!
+    public open override /*1*/ /*fake_override*/ fun </*0*/ T> toArray(/*0*/ p0: kotlin.Array<(out) T!>!): kotlin.Array<(out) T!>!
+    public open override /*2*/ /*fake_override*/ fun toString(): kotlin.String
+}
diff --git a/compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/customClassMutableList.kt b/compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/customClassMutableList.kt
new file mode 100644
index 00000000000..31e3c57ad0f
--- /dev/null
+++ b/compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/customClassMutableList.kt
@@ -0,0 +1,39 @@
+// !DIAGNOSTICS: -UNUSED_VARIABLE
+
+import java.util.*
+
+// FILE: A.java
+@kotlin.jvm.PurelyImplements("kotlin.MutableList")
+class A<T> extends AbstractList<T> {
+    @Override
+    public T get(int index) {
+        return null;
+    }
+
+    @Override
+    public int size() {
+        return 0;
+    }
+}
+
+// FILE: b.kt
+
+fun bar(): String? = null
+
+fun foo() {
+    var x = A<String>()
+    x.<!NONE_APPLICABLE!>add<!>(null)
+    x.<!NONE_APPLICABLE!>add<!>(bar())
+    x.add("")
+
+    x[0] = <!NULL_FOR_NONNULL_TYPE!>null<!>
+    x[0] = <!TYPE_MISMATCH!>bar()<!>
+    x[0] = ""
+
+    val b1: MutableList<String?> = <!TYPE_MISMATCH!>x<!>
+    val b2: MutableList<String> = x
+    val b3: List<String?> = x
+
+    val b4: Collection<String?> = x
+    val b6: MutableCollection<String?> = <!TYPE_MISMATCH!>x<!>
+}
diff --git a/compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/customClassMutableList.txt b/compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/customClassMutableList.txt
new file mode 100644
index 00000000000..41c160f2daf
--- /dev/null
+++ b/compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/customClassMutableList.txt
@@ -0,0 +1,38 @@
+package
+
+internal fun bar(): kotlin.String?
+internal fun foo(): kotlin.Unit
+
+kotlin.jvm.PurelyImplements(value = "kotlin.MutableList") public/*package*/ open class A</*0*/ T> : java.util.AbstractList<T!>, kotlin.MutableList<T> {
+    public/*package*/ constructor A</*0*/ T>()
+    protected/*protected and package*/ final override /*1*/ /*fake_override*/ var modCount: kotlin.Int
+    public open override /*2*/ /*fake_override*/ fun add(/*0*/ e: T): kotlin.Boolean
+    public open override /*2*/ /*fake_override*/ fun add(/*0*/ index: kotlin.Int, /*1*/ element: T): kotlin.Unit
+    public open override /*2*/ /*fake_override*/ fun addAll(/*0*/ c: kotlin.Collection<T>): kotlin.Boolean
+    public open override /*2*/ /*fake_override*/ fun addAll(/*0*/ index: kotlin.Int, /*1*/ c: kotlin.Collection<T>): kotlin.Boolean
+    public open override /*2*/ /*fake_override*/ fun clear(): kotlin.Unit
+    public open override /*2*/ /*fake_override*/ fun contains(/*0*/ o: kotlin.Any?): kotlin.Boolean
+    public open override /*2*/ /*fake_override*/ fun containsAll(/*0*/ c: kotlin.Collection<kotlin.Any?>): kotlin.Boolean
+    public open override /*2*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    java.lang.Override() public open override /*2*/ fun get(/*0*/ index: kotlin.Int): T
+    public open override /*2*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*2*/ /*fake_override*/ fun indexOf(/*0*/ o: kotlin.Any?): kotlin.Int
+    public open override /*2*/ /*fake_override*/ fun isEmpty(): kotlin.Boolean
+    public open override /*2*/ /*fake_override*/ fun iterator(): kotlin.MutableIterator<T>
+    public open override /*2*/ /*fake_override*/ fun lastIndexOf(/*0*/ o: kotlin.Any?): kotlin.Int
+    public open override /*2*/ /*fake_override*/ fun listIterator(): kotlin.MutableListIterator<T>
+    public open override /*2*/ /*fake_override*/ fun listIterator(/*0*/ index: kotlin.Int): kotlin.MutableListIterator<T>
+    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 /*2*/ /*fake_override*/ fun remove(/*0*/ o: kotlin.Any?): kotlin.Boolean
+    public open override /*2*/ /*fake_override*/ fun remove(/*0*/ index: kotlin.Int): T
+    public open override /*2*/ /*fake_override*/ fun removeAll(/*0*/ c: kotlin.Collection<kotlin.Any?>): kotlin.Boolean
+    protected/*protected and package*/ open override /*1*/ /*fake_override*/ fun removeRange(/*0*/ p0: kotlin.Int, /*1*/ p1: kotlin.Int): kotlin.Unit
+    public open override /*2*/ /*fake_override*/ fun retainAll(/*0*/ c: kotlin.Collection<kotlin.Any?>): kotlin.Boolean
+    public open override /*2*/ /*fake_override*/ fun set(/*0*/ index: kotlin.Int, /*1*/ element: T): T
+    java.lang.Override() public open override /*2*/ fun size(): kotlin.Int
+    public open override /*2*/ /*fake_override*/ fun subList(/*0*/ fromIndex: kotlin.Int, /*1*/ toIndex: kotlin.Int): kotlin.MutableList<T>
+    public open override /*1*/ /*fake_override*/ fun toArray(): kotlin.Array<(out) kotlin.Any!>!
+    public open override /*1*/ /*fake_override*/ fun </*0*/ T> toArray(/*0*/ p0: kotlin.Array<(out) T!>!): kotlin.Array<(out) T!>!
+    public open override /*2*/ /*fake_override*/ fun toString(): kotlin.String
+}
diff --git a/compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/maps.kt b/compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/maps.kt
new file mode 100644
index 00000000000..8cb8a523cf8
--- /dev/null
+++ b/compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/maps.kt
@@ -0,0 +1,78 @@
+// !DIAGNOSTICS: -UNUSED_VARIABLE
+import java.util.*
+import java.util.concurrent.*
+
+fun bar(): String? = null
+val nullableInt: Int? = null
+
+fun hashMapTest() {
+    var x: HashMap<String, Int> = HashMap<String, Int>()
+    x.put(<!NULL_FOR_NONNULL_TYPE!>null<!>, <!NULL_FOR_NONNULL_TYPE!>null<!>)
+    x.put("", <!NULL_FOR_NONNULL_TYPE!>null<!>)
+    x.put(<!TYPE_MISMATCH!>bar()<!>, 1)
+    x.put("", 1)
+
+    <!TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS!>x[null]<!> = 1
+    <!TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS!>x[bar()]<!> = 1
+    <!TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS!>x[""]<!> = nullableInt
+    x[""] = 1
+
+    val b1: MutableMap<String, Int?> = <!TYPE_MISMATCH!>x<!>
+    val b2: MutableMap<String, Int> = x
+    val b3: Map<String?, Int> = <!TYPE_MISMATCH!>x<!>
+    val b4: Map<String?, Int?> = <!TYPE_MISMATCH!>x<!>
+    val b5: Map<String, Int?> = x
+
+    val b6: Int = <!TYPE_MISMATCH!>x[""]<!>
+    val b7: Int = <!TYPE_MISMATCH!>x.get("")<!>
+
+    val b8: Int? = x.get("")
+}
+
+fun treeMapTest() {
+    var x: TreeMap<String, Int> = TreeMap<String, Int>()
+    x.put(<!NULL_FOR_NONNULL_TYPE!>null<!>, <!NULL_FOR_NONNULL_TYPE!>null<!>)
+    x.put("", <!NULL_FOR_NONNULL_TYPE!>null<!>)
+    x.put(<!TYPE_MISMATCH!>bar()<!>, 1)
+    x.put("", 1)
+
+    <!TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS!>x[null]<!> = 1
+    <!TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS!>x[bar()]<!> = 1
+    <!TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS!>x[""]<!> = nullableInt
+    x[""] = 1
+
+    val b1: MutableMap<String, Int?> = <!TYPE_MISMATCH!>x<!>
+    val b2: MutableMap<String, Int> = x
+    val b3: Map<String?, Int> = <!TYPE_MISMATCH!>x<!>
+    val b4: Map<String?, Int?> = <!TYPE_MISMATCH!>x<!>
+    val b5: Map<String, Int?> = x
+
+    val b6: Int = <!TYPE_MISMATCH!>x[""]<!>
+    val b7: Int = <!TYPE_MISMATCH!>x.get("")<!>
+
+    val b8: Int? = x.get("")
+}
+
+fun concurrentHashMapTest() {
+    var x: ConcurrentHashMap<String, Int> = ConcurrentHashMap<String, Int>()
+    x.put(<!NULL_FOR_NONNULL_TYPE!>null<!>, <!NULL_FOR_NONNULL_TYPE!>null<!>)
+    x.put("", <!NULL_FOR_NONNULL_TYPE!>null<!>)
+    x.put(<!TYPE_MISMATCH!>bar()<!>, 1)
+    x.put("", 1)
+
+    <!TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS!>x[null]<!> = 1
+    <!TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS!>x[bar()]<!> = 1
+    <!TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS!>x[""]<!> = nullableInt
+    x[""] = 1
+
+    val b1: MutableMap<String, Int?> = <!TYPE_MISMATCH!>x<!>
+    val b2: MutableMap<String, Int> = x
+    val b3: Map<String?, Int> = <!TYPE_MISMATCH!>x<!>
+    val b4: Map<String?, Int?> = <!TYPE_MISMATCH!>x<!>
+    val b5: Map<String, Int?> = x
+
+    val b6: Int = <!TYPE_MISMATCH!>x[""]<!>
+    val b7: Int = <!TYPE_MISMATCH!>x.get("")<!>
+
+    val b8: Int? = x.get("")
+}
diff --git a/compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/maps.txt b/compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/maps.txt
new file mode 100644
index 00000000000..3b7d946afb4
--- /dev/null
+++ b/compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/maps.txt
@@ -0,0 +1,7 @@
+package
+
+internal val nullableInt: kotlin.Int? = null
+internal fun bar(): kotlin.String?
+internal fun concurrentHashMapTest(): kotlin.Unit
+internal fun hashMapTest(): kotlin.Unit
+internal fun treeMapTest(): kotlin.Unit
diff --git a/compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/mapsWithNullableKey.kt b/compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/mapsWithNullableKey.kt
new file mode 100644
index 00000000000..cbf06958749
--- /dev/null
+++ b/compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/mapsWithNullableKey.kt
@@ -0,0 +1,54 @@
+// !DIAGNOSTICS: -UNUSED_VARIABLE
+import java.util.*
+
+fun bar(): String? = null
+val nullableInt: Int? = null
+
+fun hashMapTest() {
+    var x: HashMap<String?, Int> = HashMap<String?, Int>()
+    x.put(null, <!NULL_FOR_NONNULL_TYPE!>null<!>)
+    x.put("", <!NULL_FOR_NONNULL_TYPE!>null<!>)
+    x.put(bar(), 1)
+    x.put("", 1)
+
+    x[null] = 1
+    x[bar()] = 1
+    <!TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS!>x[""]<!> = nullableInt
+    x[""] = 1
+
+    val b1: MutableMap<String?, Int?> = <!TYPE_MISMATCH!>x<!>
+    val b2: MutableMap<String?, Int> = x
+    val b3: Map<String?, Int> = x
+    val b4: Map<String?, Int?> = x
+    val b5: Map<String, Int?> = <!TYPE_MISMATCH!>x<!>
+
+    val b6: Int = <!TYPE_MISMATCH!>x[""]<!>
+    val b7: Int = <!TYPE_MISMATCH!>x[null]<!>
+    val b8: Int = <!TYPE_MISMATCH!>x.get("")<!>
+
+    val b9: Int? = x.get("")
+}
+
+fun treeMapTest() {
+    var x: TreeMap<String?, Int> = TreeMap<String?, Int>()
+    x.put(null, <!NULL_FOR_NONNULL_TYPE!>null<!>)
+    x.put("", <!NULL_FOR_NONNULL_TYPE!>null<!>)
+    x.put(bar(), 1)
+    x.put("", 1)
+
+    x[null] = 1
+    x[bar()] = 1
+    <!TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS!>x[""]<!> = nullableInt
+    x[""] = 1
+
+    val b1: MutableMap<String?, Int?> = <!TYPE_MISMATCH!>x<!>
+    val b2: MutableMap<String?, Int> = x
+    val b3: Map<String?, Int> = x
+    val b4: Map<String?, Int?> = x
+    val b5: Map<String, Int?> = <!TYPE_MISMATCH!>x<!>
+
+    val b6: Int = <!TYPE_MISMATCH!>x[""]<!>
+    val b7: Int = <!TYPE_MISMATCH!>x.get("")<!>
+
+    val b8: Int? = x.get("")
+}
diff --git a/compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/mapsWithNullableKey.txt b/compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/mapsWithNullableKey.txt
new file mode 100644
index 00000000000..51b387b7d42
--- /dev/null
+++ b/compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/mapsWithNullableKey.txt
@@ -0,0 +1,6 @@
+package
+
+internal val nullableInt: kotlin.Int? = null
+internal fun bar(): kotlin.String?
+internal fun hashMapTest(): kotlin.Unit
+internal fun treeMapTest(): kotlin.Unit
diff --git a/compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/mapsWithNullableValues.kt b/compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/mapsWithNullableValues.kt
new file mode 100644
index 00000000000..2727dcaee70
--- /dev/null
+++ b/compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/mapsWithNullableValues.kt
@@ -0,0 +1,53 @@
+// !DIAGNOSTICS: -UNUSED_VARIABLE
+import java.util.*
+
+fun bar(): String? = null
+val nullableInt: Int? = null
+
+fun hashMapTest() {
+    var x: HashMap<String, Int?> = HashMap<String, Int?>()
+    x.put(<!NULL_FOR_NONNULL_TYPE!>null<!>, null)
+    x.put("", null)
+    x.put(<!TYPE_MISMATCH!>bar()<!>, 1)
+    x.put("", 1)
+
+    <!TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS!>x[null]<!> = 1
+    <!TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS!>x[bar()]<!> = 1
+    x[""] = nullableInt
+    x[""] = 1
+
+    val b1: MutableMap<String, Int> = <!TYPE_MISMATCH!>x<!>
+    val b2: MutableMap<String, Int?> = x
+    val b3: Map<String, Int> = <!TYPE_MISMATCH!>x<!>
+    val b4: Map<String, Int?> = x
+    val b5: Map<String?, Int?> = <!TYPE_MISMATCH!>x<!>
+
+    val b6: Int = <!TYPE_MISMATCH!>x[""]<!>
+    val b7: Int = <!TYPE_MISMATCH!>x.get("")<!>
+
+    val b8: Int? = x.get("")
+}
+
+fun treeMapTest() {
+    var x: TreeMap<String, Int?> = TreeMap<String, Int?>()
+    x.put(<!NULL_FOR_NONNULL_TYPE!>null<!>, null)
+    x.put("", null)
+    x.put(<!TYPE_MISMATCH!>bar()<!>, 1)
+    x.put("", 1)
+
+    <!TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS!>x[null]<!> = 1
+    <!TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS!>x[bar()]<!> = 1
+    x[""] = nullableInt
+    x[""] = 1
+
+    val b1: MutableMap<String, Int> = <!TYPE_MISMATCH!>x<!>
+    val b2: MutableMap<String, Int?> = x
+    val b3: Map<String, Int> = <!TYPE_MISMATCH!>x<!>
+    val b4: Map<String, Int?> = x
+    val b5: Map<String?, Int?> = <!TYPE_MISMATCH!>x<!>
+
+    val b6: Int = <!TYPE_MISMATCH!>x[""]<!>
+    val b7: Int = <!TYPE_MISMATCH!>x.get("")<!>
+
+    val b8: Int? = x.get("")
+}
diff --git a/compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/mapsWithNullableValues.txt b/compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/mapsWithNullableValues.txt
new file mode 100644
index 00000000000..51b387b7d42
--- /dev/null
+++ b/compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/mapsWithNullableValues.txt
@@ -0,0 +1,6 @@
+package
+
+internal val nullableInt: kotlin.Int? = null
+internal fun bar(): kotlin.String?
+internal fun hashMapTest(): kotlin.Unit
+internal fun treeMapTest(): kotlin.Unit
diff --git a/compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/sets.kt b/compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/sets.kt
new file mode 100644
index 00000000000..7e37f0d0b55
--- /dev/null
+++ b/compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/sets.kt
@@ -0,0 +1,46 @@
+// !DIAGNOSTICS: -UNUSED_VARIABLE
+import java.util.*
+
+fun bar(): String? = null
+
+fun fooHashSet() {
+    var x = HashSet<String>()
+    x.add(<!NULL_FOR_NONNULL_TYPE!>null<!>)
+    x.add(<!TYPE_MISMATCH!>bar()<!>)
+    x.add("")
+
+    val b1: MutableSet<String?> = <!TYPE_MISMATCH!>x<!>
+    val b2: MutableSet<String> = x
+    val b3: Set<String?> = x
+
+    val b4: Collection<String?> = x
+    val b6: MutableCollection<String?> = <!TYPE_MISMATCH!>x<!>
+}
+
+fun fooTreeSet() {
+    var x = TreeSet<String>()
+    x.add(<!NULL_FOR_NONNULL_TYPE!>null<!>)
+    x.add(<!TYPE_MISMATCH!>bar()<!>)
+    x.add("")
+
+    val b1: MutableSet<String?> = <!TYPE_MISMATCH!>x<!>
+    val b2: MutableSet<String> = x
+    val b3: Set<String?> = x
+
+    val b4: Collection<String?> = x
+    val b6: MutableCollection<String?> = <!TYPE_MISMATCH!>x<!>
+}
+
+fun fooLinkedHashSet() {
+    var x = LinkedHashSet<String>()
+    x.add(<!NULL_FOR_NONNULL_TYPE!>null<!>)
+    x.add(<!TYPE_MISMATCH!>bar()<!>)
+    x.add("")
+
+    val b1: MutableSet<String?> = <!TYPE_MISMATCH!>x<!>
+    val b2: MutableSet<String> = x
+    val b3: Set<String?> = x
+
+    val b4: Collection<String?> = x
+    val b6: MutableCollection<String?> = <!TYPE_MISMATCH!>x<!>
+}
diff --git a/compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/sets.txt b/compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/sets.txt
new file mode 100644
index 00000000000..60371b78964
--- /dev/null
+++ b/compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/sets.txt
@@ -0,0 +1,6 @@
+package
+
+internal fun bar(): kotlin.String?
+internal fun fooHashSet(): kotlin.Unit
+internal fun fooLinkedHashSet(): kotlin.Unit
+internal fun fooTreeSet(): kotlin.Unit
diff --git a/compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/wrongTypeParametersCount.kt b/compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/wrongTypeParametersCount.kt
new file mode 100644
index 00000000000..63d95658bdb
--- /dev/null
+++ b/compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/wrongTypeParametersCount.kt
@@ -0,0 +1,39 @@
+// !DIAGNOSTICS: -UNUSED_VARIABLE
+
+import java.util.*
+
+// FILE: A.java
+@kotlin.jvm.PurelyImplements("kotlin.MutableList")
+class A<T, V> extends AbstractList<T> {
+    @Override
+    public T get(int index) {
+        return null;
+    }
+
+    @Override
+    public int size() {
+        return 0;
+    }
+}
+
+// FILE: b.kt
+
+fun bar(): String? = null
+
+fun foo() {
+    var x = A<String, String>()
+    x.add(null)
+    x.add(bar())
+    x.add("")
+
+    x[0] = null
+    x[0] = bar()
+    x[0] = ""
+
+    val b1: MutableList<String?> = x
+    val b2: MutableList<String> = x
+    val b3: List<String?> = x
+
+    val b4: Collection<String?> = x
+    val b6: MutableCollection<String?> = x
+}
diff --git a/compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/wrongTypeParametersCount.txt b/compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/wrongTypeParametersCount.txt
new file mode 100644
index 00000000000..436b84b19f5
--- /dev/null
+++ b/compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/wrongTypeParametersCount.txt
@@ -0,0 +1,38 @@
+package
+
+internal fun bar(): kotlin.String?
+internal fun foo(): kotlin.Unit
+
+kotlin.jvm.PurelyImplements(value = "kotlin.MutableList") public/*package*/ open class A</*0*/ T, /*1*/ V> : java.util.AbstractList<T!> {
+    public/*package*/ constructor A</*0*/ T, /*1*/ V>()
+    protected/*protected and package*/ final override /*1*/ /*fake_override*/ var modCount: kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun add(/*0*/ e: T!): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun add(/*0*/ index: kotlin.Int, /*1*/ element: T!): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun addAll(/*0*/ c: kotlin.Collection<T!>): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun addAll(/*0*/ index: kotlin.Int, /*1*/ c: kotlin.Collection<T!>): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun clear(): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun contains(/*0*/ o: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun containsAll(/*0*/ c: kotlin.Collection<kotlin.Any?>): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    java.lang.Override() public open override /*1*/ fun get(/*0*/ index: kotlin.Int): T!
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun indexOf(/*0*/ o: kotlin.Any?): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun isEmpty(): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun iterator(): kotlin.MutableIterator<T!>
+    public open override /*1*/ /*fake_override*/ fun lastIndexOf(/*0*/ o: kotlin.Any?): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun listIterator(): kotlin.MutableListIterator<T!>
+    public open override /*1*/ /*fake_override*/ fun listIterator(/*0*/ index: kotlin.Int): kotlin.MutableListIterator<T!>
+    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): T!
+    public open override /*1*/ /*fake_override*/ fun removeAll(/*0*/ c: kotlin.Collection<kotlin.Any?>): kotlin.Boolean
+    protected/*protected and package*/ open override /*1*/ /*fake_override*/ fun removeRange(/*0*/ p0: kotlin.Int, /*1*/ p1: kotlin.Int): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun retainAll(/*0*/ c: kotlin.Collection<kotlin.Any?>): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun set(/*0*/ index: kotlin.Int, /*1*/ element: T!): T!
+    java.lang.Override() public open override /*1*/ fun size(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun subList(/*0*/ fromIndex: kotlin.Int, /*1*/ toIndex: kotlin.Int): kotlin.MutableList<T!>
+    public open override /*1*/ /*fake_override*/ fun toArray(): kotlin.Array<(out) kotlin.Any!>!
+    public open override /*1*/ /*fake_override*/ fun </*0*/ T> toArray(/*0*/ p0: kotlin.Array<(out) T!>!): kotlin.Array<(out) T!>!
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
diff --git a/compiler/testData/diagnostics/testsWithStdLib/resolve/kt4711.kt b/compiler/testData/diagnostics/testsWithStdLib/resolve/kt4711.kt
index 0a14b59baa4..1d783be79c8 100644
--- a/compiler/testData/diagnostics/testsWithStdLib/resolve/kt4711.kt
+++ b/compiler/testData/diagnostics/testsWithStdLib/resolve/kt4711.kt
@@ -6,10 +6,10 @@ fun main(args:Array<String>) {
     val startTimeNanos = System.nanoTime()
 
     // the problem sits on the next line:
-    val pi = 4.0.toDouble() * delta <!OVERLOAD_RESOLUTION_AMBIGUITY!>*<!> (1..n).reduce(
+    val pi = 4.0.toDouble() * delta <!OVERLOAD_RESOLUTION_AMBIGUITY!>*<!> (1..n).<!TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS!>reduce<!>(
             {t, i ->
                 val x = (i - 0.5) * delta
-                <!TYPE_MISMATCH!>t + 1.0 / (1.0 + x * x)<!>
+                t + 1.0 / (1.0 + x * x)
 
             })
     // !!! pi has error type here
diff --git a/compiler/testData/evaluate/usesVariableAsConstant/OtherTypes.kt b/compiler/testData/evaluate/usesVariableAsConstant/OtherTypes.kt
index eed8758f371..a4e735bf812 100644
--- a/compiler/testData/evaluate/usesVariableAsConstant/OtherTypes.kt
+++ b/compiler/testData/evaluate/usesVariableAsConstant/OtherTypes.kt
@@ -6,11 +6,17 @@ fun foo(): Boolean = true
 
 val x = 1
 
-// val prop1: null
+// val prop1: false
 val prop1 = MyEnum.A
 
 // val prop2: null
 val prop2 = foo()
 
 // val prop3: true
-val prop3 = "$x"
\ No newline at end of file
+val prop3 = "$x"
+
+// val prop4: false
+val prop4 = intArrayOf(1, 2, 3)
+
+// val prop5: true
+val prop5 = intArrayOf(1, 2, x, x)
\ No newline at end of file
diff --git a/compiler/testData/loadJava/compiledJava/ClassDoesNotOverrideMethod.txt b/compiler/testData/loadJava/compiledJava/ClassDoesNotOverrideMethod.txt
index 25e55faf381..f9c862da9fa 100644
--- a/compiler/testData/loadJava/compiledJava/ClassDoesNotOverrideMethod.txt
+++ b/compiler/testData/loadJava/compiledJava/ClassDoesNotOverrideMethod.txt
@@ -6,7 +6,7 @@ public abstract class ClassDoesNotOverrideMethod : java.util.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 clone(): kotlin.Any!
+    public open override /*1*/ /*fake_override*/ fun clone(): kotlin.Any
     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") public open override /*1*/ /*fake_override*/ fun getDate(): kotlin.Int
diff --git a/compiler/testData/loadJava/compiledJava/annotations/AnnotatedAnnotation.txt b/compiler/testData/loadJava/compiledJava/annotations/AnnotatedAnnotation.txt
index f96ba4792ab..493171abcab 100644
--- a/compiler/testData/loadJava/compiledJava/annotations/AnnotatedAnnotation.txt
+++ b/compiler/testData/loadJava/compiledJava/annotations/AnnotatedAnnotation.txt
@@ -1,5 +1,5 @@
 package test
 
-test.AnnotatedAnnotation() public final annotation class AnnotatedAnnotation : kotlin.Annotation {
+test.AnnotatedAnnotation() public final class AnnotatedAnnotation : kotlin.Annotation {
     public constructor AnnotatedAnnotation()
 }
diff --git a/compiler/testData/loadJava/compiledJava/annotations/AnnotatedConstructor.txt b/compiler/testData/loadJava/compiledJava/annotations/AnnotatedConstructor.txt
index 95dca11e461..09d42cde161 100644
--- a/compiler/testData/loadJava/compiledJava/annotations/AnnotatedConstructor.txt
+++ b/compiler/testData/loadJava/compiledJava/annotations/AnnotatedConstructor.txt
@@ -3,7 +3,7 @@ package test
 public open class AnnotatedConstructor {
     test.AnnotatedConstructor.Anno(value = "constructor") public constructor AnnotatedConstructor()
 
-    public final annotation class Anno : kotlin.Annotation {
+    public final class Anno : kotlin.Annotation {
         public constructor Anno(/*0*/ value: kotlin.String)
         public final val value: kotlin.String
         public abstract fun value(): kotlin.String
diff --git a/compiler/testData/loadJava/compiledJava/annotations/AnnotatedField.txt b/compiler/testData/loadJava/compiledJava/annotations/AnnotatedField.txt
index 10e51ea5c51..701973217fb 100644
--- a/compiler/testData/loadJava/compiledJava/annotations/AnnotatedField.txt
+++ b/compiler/testData/loadJava/compiledJava/annotations/AnnotatedField.txt
@@ -4,7 +4,7 @@ public open class AnnotatedField {
     public constructor AnnotatedField()
     test.AnnotatedField.Anno(value = "member") public final val y: kotlin.Int = 0
 
-    public final annotation class Anno : kotlin.Annotation {
+    public final class Anno : kotlin.Annotation {
         public constructor Anno(/*0*/ value: kotlin.String)
         public final val value: kotlin.String
         public abstract fun value(): kotlin.String
diff --git a/compiler/testData/loadJava/compiledJava/annotations/AnnotatedMethod.txt b/compiler/testData/loadJava/compiledJava/annotations/AnnotatedMethod.txt
index 3289d27d40d..468eab0dfb9 100644
--- a/compiler/testData/loadJava/compiledJava/annotations/AnnotatedMethod.txt
+++ b/compiler/testData/loadJava/compiledJava/annotations/AnnotatedMethod.txt
@@ -4,7 +4,7 @@ public open class AnnotatedMethod {
     public constructor AnnotatedMethod()
     test.AnnotatedMethod.Anno(value = 42) public open fun f(): kotlin.Unit
 
-    public final annotation class Anno : kotlin.Annotation {
+    public final class Anno : kotlin.Annotation {
         public constructor Anno(/*0*/ value: kotlin.Int)
         public final val value: kotlin.Int
         public abstract fun value(): kotlin.Int
diff --git a/compiler/testData/loadJava/compiledJava/annotations/AnnotatedValueParameter.txt b/compiler/testData/loadJava/compiledJava/annotations/AnnotatedValueParameter.txt
index 16ceafcc8b5..f8253f22a54 100644
--- a/compiler/testData/loadJava/compiledJava/annotations/AnnotatedValueParameter.txt
+++ b/compiler/testData/loadJava/compiledJava/annotations/AnnotatedValueParameter.txt
@@ -4,7 +4,7 @@ public open class AnnotatedValueParameter {
     public constructor AnnotatedValueParameter()
     public open fun f(/*0*/ test.AnnotatedValueParameter.Anno(value = "non-empty") p0: kotlin.(Mutable)List<kotlin.String!>!): kotlin.Unit
 
-    public final annotation class Anno : kotlin.Annotation {
+    public final class Anno : kotlin.Annotation {
         public constructor Anno(/*0*/ value: kotlin.String)
         public final val value: kotlin.String
         public abstract fun value(): kotlin.String
diff --git a/compiler/testData/loadJava/compiledJava/annotations/AnnotationInParam.txt b/compiler/testData/loadJava/compiledJava/annotations/AnnotationInParam.txt
index 6a571b0e9d0..04376a23376 100644
--- a/compiler/testData/loadJava/compiledJava/annotations/AnnotationInParam.txt
+++ b/compiler/testData/loadJava/compiledJava/annotations/AnnotationInParam.txt
@@ -14,19 +14,19 @@ public interface AnnotationInParam {
         public constructor C()
     }
 
-    public final annotation class MyAnnotation : kotlin.Annotation {
+    public final class MyAnnotation : kotlin.Annotation {
         public constructor MyAnnotation(/*0*/ value: kotlin.String)
         public final val value: kotlin.String
         public abstract fun value(): kotlin.String
     }
 
-    public final annotation class MyAnnotation2 : kotlin.Annotation {
+    public final class MyAnnotation2 : kotlin.Annotation {
         public constructor MyAnnotation2(/*0*/ vararg value: kotlin.String /*kotlin.Array<out kotlin.String>*/)
         public final val value: kotlin.Array<kotlin.String>
         public abstract fun value(): kotlin.Array<kotlin.String>
     }
 
-    public final annotation class MyAnnotation3 : kotlin.Annotation {
+    public final class MyAnnotation3 : kotlin.Annotation {
         public constructor MyAnnotation3(/*0*/ first: kotlin.String, /*1*/ second: kotlin.String)
         public final val first: kotlin.String
         public final val second: kotlin.String
@@ -34,19 +34,19 @@ public interface AnnotationInParam {
         public abstract fun second(): kotlin.String
     }
 
-    public final annotation class MyAnnotationWithParam : kotlin.Annotation {
+    public final class MyAnnotationWithParam : kotlin.Annotation {
         public constructor MyAnnotationWithParam(/*0*/ value: test.AnnotationInParam.MyAnnotation)
         public final val value: test.AnnotationInParam.MyAnnotation
         public abstract fun value(): test.AnnotationInParam.MyAnnotation
     }
 
-    public final annotation class MyAnnotationWithParam2 : kotlin.Annotation {
+    public final class MyAnnotationWithParam2 : kotlin.Annotation {
         public constructor MyAnnotationWithParam2(/*0*/ value: test.AnnotationInParam.MyAnnotation2)
         public final val value: test.AnnotationInParam.MyAnnotation2
         public abstract fun value(): test.AnnotationInParam.MyAnnotation2
     }
 
-    public final annotation class MyAnnotationWithParam3 : kotlin.Annotation {
+    public final class MyAnnotationWithParam3 : kotlin.Annotation {
         public constructor MyAnnotationWithParam3(/*0*/ value: test.AnnotationInParam.MyAnnotation3)
         public final val value: test.AnnotationInParam.MyAnnotation3
         public abstract fun value(): test.AnnotationInParam.MyAnnotation3
diff --git a/compiler/testData/loadJava/compiledJava/annotations/ArithmeticExpressionInParam.txt b/compiler/testData/loadJava/compiledJava/annotations/ArithmeticExpressionInParam.txt
index 2018810e8e4..70f2c1f562a 100644
--- a/compiler/testData/loadJava/compiledJava/annotations/ArithmeticExpressionInParam.txt
+++ b/compiler/testData/loadJava/compiledJava/annotations/ArithmeticExpressionInParam.txt
@@ -3,7 +3,7 @@ package test
 public open class ArithmeticExpressionInParam {
     public constructor ArithmeticExpressionInParam()
 
-    public final annotation class Anno : kotlin.Annotation {
+    public final class Anno : kotlin.Annotation {
         public constructor Anno(/*0*/ value: kotlin.Int)
         public final val value: kotlin.Int
         public abstract fun value(): kotlin.Int
diff --git a/compiler/testData/loadJava/compiledJava/annotations/ArrayOfEnumInParam.txt b/compiler/testData/loadJava/compiledJava/annotations/ArrayOfEnumInParam.txt
index e8f1e248e0a..08cd4f72ffe 100644
--- a/compiler/testData/loadJava/compiledJava/annotations/ArrayOfEnumInParam.txt
+++ b/compiler/testData/loadJava/compiledJava/annotations/ArrayOfEnumInParam.txt
@@ -2,7 +2,7 @@ package test
 
 public interface ArrayOfEnumInParam {
 
-    java.lang.annotation.Target(value = {ElementType.FIELD, ElementType.CONSTRUCTOR}) public final annotation class targetAnnotation : kotlin.Annotation {
+    public final class targetAnnotation : kotlin.Annotation {
         public constructor targetAnnotation(/*0*/ value: kotlin.String)
         public final val value: kotlin.String
         public abstract fun value(): kotlin.String
diff --git a/compiler/testData/loadJava/compiledJava/annotations/ArrayOfStringInParam.txt b/compiler/testData/loadJava/compiledJava/annotations/ArrayOfStringInParam.txt
index 6ea8dbd0b25..dc32eb3b47b 100644
--- a/compiler/testData/loadJava/compiledJava/annotations/ArrayOfStringInParam.txt
+++ b/compiler/testData/loadJava/compiledJava/annotations/ArrayOfStringInParam.txt
@@ -6,7 +6,7 @@ public interface ArrayOfStringInParam {
         public constructor A()
     }
 
-    public final annotation class MyAnnotation : kotlin.Annotation {
+    public final class MyAnnotation : kotlin.Annotation {
         public constructor MyAnnotation(/*0*/ vararg value: kotlin.String /*kotlin.Array<out kotlin.String>*/)
         public final val value: kotlin.Array<kotlin.String>
         public abstract fun value(): kotlin.Array<kotlin.String>
diff --git a/compiler/testData/loadJava/compiledJava/annotations/ClassObjectArrayInParam.txt b/compiler/testData/loadJava/compiledJava/annotations/ClassObjectArrayInParam.txt
index 9ab3346d4b5..2f37306b809 100644
--- a/compiler/testData/loadJava/compiledJava/annotations/ClassObjectArrayInParam.txt
+++ b/compiler/testData/loadJava/compiledJava/annotations/ClassObjectArrayInParam.txt
@@ -3,7 +3,7 @@ package test
 public open class ClassObjectArrayInParam {
     public constructor ClassObjectArrayInParam()
 
-    public final annotation class Anno : kotlin.Annotation {
+    public final class Anno : kotlin.Annotation {
         public constructor Anno(/*0*/ vararg value: kotlin.reflect.KClass<*> /*kotlin.Array<out kotlin.reflect.KClass<*>>*/)
         public final val value: kotlin.Array<kotlin.reflect.KClass<*>>
         public abstract fun value(): kotlin.Array<kotlin.reflect.KClass<*>>
diff --git a/compiler/testData/loadJava/compiledJava/annotations/ClassObjectInParam.txt b/compiler/testData/loadJava/compiledJava/annotations/ClassObjectInParam.txt
index 30b7148f686..c27804ebb3c 100644
--- a/compiler/testData/loadJava/compiledJava/annotations/ClassObjectInParam.txt
+++ b/compiler/testData/loadJava/compiledJava/annotations/ClassObjectInParam.txt
@@ -3,7 +3,7 @@ package test
 public open class ClassObjectInParam {
     public constructor ClassObjectInParam()
 
-    public final annotation class Anno : kotlin.Annotation {
+    public final class Anno : kotlin.Annotation {
         public constructor Anno(/*0*/ value: kotlin.reflect.KClass<*>)
         public final val value: kotlin.reflect.KClass<*>
         public abstract fun value(): kotlin.reflect.KClass<*>
diff --git a/compiler/testData/loadJava/compiledJava/annotations/ClassObjectInParamRaw.txt b/compiler/testData/loadJava/compiledJava/annotations/ClassObjectInParamRaw.txt
index 884d7d88a9e..52ef7432620 100644
--- a/compiler/testData/loadJava/compiledJava/annotations/ClassObjectInParamRaw.txt
+++ b/compiler/testData/loadJava/compiledJava/annotations/ClassObjectInParamRaw.txt
@@ -3,7 +3,7 @@ package test
 public open class ClassObjectInParamRaw {
     public constructor ClassObjectInParamRaw()
 
-    public final annotation class Anno : kotlin.Annotation {
+    public final class Anno : kotlin.Annotation {
         public constructor Anno(/*0*/ value: kotlin.reflect.KClass<*>, /*1*/ arg: kotlin.Array<kotlin.reflect.KClass<*>>)
         public final val arg: kotlin.Array<kotlin.reflect.KClass<*>>
         public final val value: kotlin.reflect.KClass<*>
diff --git a/compiler/testData/loadJava/compiledJava/annotations/ClassObjectInParamVariance.txt b/compiler/testData/loadJava/compiledJava/annotations/ClassObjectInParamVariance.txt
index da7962c1fcc..0c8555932d6 100644
--- a/compiler/testData/loadJava/compiledJava/annotations/ClassObjectInParamVariance.txt
+++ b/compiler/testData/loadJava/compiledJava/annotations/ClassObjectInParamVariance.txt
@@ -3,7 +3,7 @@ package test
 public open class ClassObjectInParamVariance {
     public constructor ClassObjectInParamVariance()
 
-    public final annotation class Anno : kotlin.Annotation {
+    public final class Anno : kotlin.Annotation {
         public constructor Anno(/*0*/ arg1: kotlin.reflect.KClass<out kotlin.Int!>, /*1*/ arg2: kotlin.reflect.KClass<in kotlin.Int!>, /*2*/ arg3: kotlin.Array<kotlin.reflect.KClass<out kotlin.Int!>>, /*3*/ arg4: kotlin.Array<kotlin.reflect.KClass<in kotlin.Int!>>, /*4*/ arg5: kotlin.Array<kotlin.reflect.KClass<out java.lang.Class<*>!>>, /*5*/ arg6: kotlin.Array<kotlin.reflect.KClass<in java.lang.Class<*>!>>, /*6*/ arg7: kotlin.Array<kotlin.reflect.KClass<out java.lang.Class<kotlin.Int!>!>>, /*7*/ arg8: kotlin.Array<kotlin.reflect.KClass<in java.lang.Class<kotlin.Int!>!>>)
         public final val arg1: kotlin.reflect.KClass<out kotlin.Int!>
         public final val arg2: kotlin.reflect.KClass<in kotlin.Int!>
diff --git a/compiler/testData/loadJava/compiledJava/annotations/CustomAnnotation.txt b/compiler/testData/loadJava/compiledJava/annotations/CustomAnnotation.txt
index ad2240254a2..3c4e239984b 100644
--- a/compiler/testData/loadJava/compiledJava/annotations/CustomAnnotation.txt
+++ b/compiler/testData/loadJava/compiledJava/annotations/CustomAnnotation.txt
@@ -2,7 +2,7 @@ package test
 
 public interface CustomAnnotation {
 
-    public final annotation class MyAnnotation : kotlin.Annotation {
+    public final class MyAnnotation : kotlin.Annotation {
         public constructor MyAnnotation(/*0*/ value: test.CustomAnnotation.MyEnum)
         public final val value: test.CustomAnnotation.MyEnum
         public abstract fun value(): test.CustomAnnotation.MyEnum
diff --git a/compiler/testData/loadJava/compiledJava/annotations/CustomAnnotationWithDefaultParameter.txt b/compiler/testData/loadJava/compiledJava/annotations/CustomAnnotationWithDefaultParameter.txt
index 0aeb32d87e9..c1868ddb32e 100644
--- a/compiler/testData/loadJava/compiledJava/annotations/CustomAnnotationWithDefaultParameter.txt
+++ b/compiler/testData/loadJava/compiledJava/annotations/CustomAnnotationWithDefaultParameter.txt
@@ -2,7 +2,7 @@ package test
 
 public interface CustomAnnotationWithDefaultParameter {
 
-    public final annotation class MyAnnotation : kotlin.Annotation {
+    public final class MyAnnotation : kotlin.Annotation {
         public constructor MyAnnotation(/*0*/ first: kotlin.String, /*1*/ second: kotlin.String = ...)
         public final val first: kotlin.String
         public final val second: kotlin.String
diff --git a/compiler/testData/loadJava/compiledJava/annotations/EmptyArrayInParam.txt b/compiler/testData/loadJava/compiledJava/annotations/EmptyArrayInParam.txt
index 67585145f3f..9b035d95478 100644
--- a/compiler/testData/loadJava/compiledJava/annotations/EmptyArrayInParam.txt
+++ b/compiler/testData/loadJava/compiledJava/annotations/EmptyArrayInParam.txt
@@ -6,7 +6,7 @@ public interface EmptyArrayInParam {
         public constructor A()
     }
 
-    public final annotation class MyAnnotation : kotlin.Annotation {
+    public final class MyAnnotation : kotlin.Annotation {
         public constructor MyAnnotation(/*0*/ vararg value: kotlin.String /*kotlin.Array<out kotlin.String>*/)
         public final val value: kotlin.Array<kotlin.String>
         public abstract fun value(): kotlin.Array<kotlin.String>
diff --git a/compiler/testData/loadJava/compiledJava/annotations/EnumArgumentWithCustomToString.txt b/compiler/testData/loadJava/compiledJava/annotations/EnumArgumentWithCustomToString.txt
index dc660338c96..c9aa39761ce 100644
--- a/compiler/testData/loadJava/compiledJava/annotations/EnumArgumentWithCustomToString.txt
+++ b/compiler/testData/loadJava/compiledJava/annotations/EnumArgumentWithCustomToString.txt
@@ -22,13 +22,13 @@ public open class EnumArgumentWithCustomToString {
         public final /*synthesized*/ fun values(): kotlin.Array<test.EnumArgumentWithCustomToString.E>
     }
 
-    public final annotation class EnumAnno : kotlin.Annotation {
+    public final class EnumAnno : kotlin.Annotation {
         public constructor EnumAnno(/*0*/ value: test.EnumArgumentWithCustomToString.E)
         public final val value: test.EnumArgumentWithCustomToString.E
         public abstract fun value(): test.EnumArgumentWithCustomToString.E
     }
 
-    public final annotation class EnumArrayAnno : kotlin.Annotation {
+    public final class EnumArrayAnno : kotlin.Annotation {
         public constructor EnumArrayAnno(/*0*/ vararg value: test.EnumArgumentWithCustomToString.E /*kotlin.Array<out test.EnumArgumentWithCustomToString.E>*/)
         public final val value: kotlin.Array<test.EnumArgumentWithCustomToString.E>
         public abstract fun value(): kotlin.Array<test.EnumArgumentWithCustomToString.E>
diff --git a/compiler/testData/loadJava/compiledJava/annotations/EnumConstructorParameter.txt b/compiler/testData/loadJava/compiledJava/annotations/EnumConstructorParameter.txt
index aa5d3e430a5..f7431df93f5 100644
--- a/compiler/testData/loadJava/compiledJava/annotations/EnumConstructorParameter.txt
+++ b/compiler/testData/loadJava/compiledJava/annotations/EnumConstructorParameter.txt
@@ -14,7 +14,7 @@ public final enum class EnumConstructorParameter : kotlin.Enum<test.EnumConstruc
     public final override /*1*/ /*fake_override*/ fun name(): kotlin.String
     public final override /*1*/ /*fake_override*/ fun ordinal(): kotlin.Int
 
-    public final annotation class Anno : kotlin.Annotation {
+    public final class Anno : kotlin.Annotation {
         public constructor Anno(/*0*/ value: kotlin.String)
         public final val value: kotlin.String
         public abstract fun value(): kotlin.String
diff --git a/compiler/testData/loadJava/compiledJava/annotations/EnumInParam.txt b/compiler/testData/loadJava/compiledJava/annotations/EnumInParam.txt
index f96852c9f45..bb7fca9463c 100644
--- a/compiler/testData/loadJava/compiledJava/annotations/EnumInParam.txt
+++ b/compiler/testData/loadJava/compiledJava/annotations/EnumInParam.txt
@@ -2,13 +2,13 @@ package test
 
 public interface EnumInParam {
 
-    public final annotation class MyRetention : kotlin.Annotation {
+    public final class MyRetention : kotlin.Annotation {
         public constructor MyRetention(/*0*/ value: java.lang.annotation.RetentionPolicy)
         public final val value: java.lang.annotation.RetentionPolicy
         public abstract fun value(): java.lang.annotation.RetentionPolicy
     }
 
-    test.EnumInParam.MyRetention(value = RetentionPolicy.RUNTIME) public final annotation class RetentionAnnotation : kotlin.Annotation {
+    test.EnumInParam.MyRetention(value = RetentionPolicy.RUNTIME) public final class RetentionAnnotation : kotlin.Annotation {
         public constructor RetentionAnnotation(/*0*/ value: kotlin.String)
         public final val value: kotlin.String
         public abstract fun value(): kotlin.String
diff --git a/compiler/testData/loadJava/compiledJava/annotations/NestedEnumArgument.txt b/compiler/testData/loadJava/compiledJava/annotations/NestedEnumArgument.txt
index 49e3048693f..d4436bb8921 100644
--- a/compiler/testData/loadJava/compiledJava/annotations/NestedEnumArgument.txt
+++ b/compiler/testData/loadJava/compiledJava/annotations/NestedEnumArgument.txt
@@ -4,7 +4,7 @@ public open class NestedEnumArgument {
     public constructor NestedEnumArgument()
     test.NestedEnumArgument.Anno(value = E.FIRST) public/*package*/ open fun foo(): kotlin.Unit
 
-    public final annotation class Anno : kotlin.Annotation {
+    public final class Anno : kotlin.Annotation {
         public constructor Anno(/*0*/ value: test.NestedEnumArgument.E)
         public final val value: test.NestedEnumArgument.E
         public abstract fun value(): test.NestedEnumArgument.E
diff --git a/compiler/testData/loadJava/compiledJava/annotations/PrimitiveValueInParam.txt b/compiler/testData/loadJava/compiledJava/annotations/PrimitiveValueInParam.txt
index bad55772615..8d79b9f39c4 100644
--- a/compiler/testData/loadJava/compiledJava/annotations/PrimitiveValueInParam.txt
+++ b/compiler/testData/loadJava/compiledJava/annotations/PrimitiveValueInParam.txt
@@ -6,7 +6,7 @@ public interface PrimitiveValueInParam {
         public constructor A()
     }
 
-    public final annotation class Ann : kotlin.Annotation {
+    public final class Ann : kotlin.Annotation {
         public constructor Ann(/*0*/ i: kotlin.Int, /*1*/ l: kotlin.Long, /*2*/ d: kotlin.Double, /*3*/ f: kotlin.Float, /*4*/ bool: kotlin.Boolean, /*5*/ str: kotlin.String)
         public final val bool: kotlin.Boolean
         public final val d: kotlin.Double
diff --git a/compiler/testData/loadJava/compiledJava/annotations/RecursiveAnnotation.txt b/compiler/testData/loadJava/compiledJava/annotations/RecursiveAnnotation.txt
index 11ef47aaa6d..512ad82a346 100644
--- a/compiler/testData/loadJava/compiledJava/annotations/RecursiveAnnotation.txt
+++ b/compiler/testData/loadJava/compiledJava/annotations/RecursiveAnnotation.txt
@@ -2,13 +2,13 @@ package test
 
 public interface RecursiveAnnotation {
 
-    test.RecursiveAnnotation.B(value = test.RecursiveAnnotation.A(value = "test")) public final annotation class A : kotlin.Annotation {
+    test.RecursiveAnnotation.B(value = test.RecursiveAnnotation.A(value = "test")) public final class A : kotlin.Annotation {
         public constructor A(/*0*/ value: kotlin.String)
         public final val value: kotlin.String
         public abstract fun value(): kotlin.String
     }
 
-    test.RecursiveAnnotation.B(value = test.RecursiveAnnotation.A(value = "test")) public final annotation class B : kotlin.Annotation {
+    test.RecursiveAnnotation.B(value = test.RecursiveAnnotation.A(value = "test")) public final class B : kotlin.Annotation {
         public constructor B(/*0*/ value: test.RecursiveAnnotation.A)
         public final val value: test.RecursiveAnnotation.A
         public abstract fun value(): test.RecursiveAnnotation.A
diff --git a/compiler/testData/loadJava/compiledJava/annotations/RecursiveAnnotation2.txt b/compiler/testData/loadJava/compiledJava/annotations/RecursiveAnnotation2.txt
index c42658f26f9..047351bad50 100644
--- a/compiler/testData/loadJava/compiledJava/annotations/RecursiveAnnotation2.txt
+++ b/compiler/testData/loadJava/compiledJava/annotations/RecursiveAnnotation2.txt
@@ -2,13 +2,13 @@ package test
 
 public interface RecursiveAnnotation2 {
 
-    public final annotation class A : kotlin.Annotation {
+    public final class A : kotlin.Annotation {
         public constructor A(/*0*/ value: test.RecursiveAnnotation2.B)
         public final val value: test.RecursiveAnnotation2.B
         public abstract fun value(): test.RecursiveAnnotation2.B
     }
 
-    test.RecursiveAnnotation2.A(value = test.RecursiveAnnotation2.B(value = "test")) public final annotation class B : kotlin.Annotation {
+    test.RecursiveAnnotation2.A(value = test.RecursiveAnnotation2.B(value = "test")) public final class B : kotlin.Annotation {
         public constructor B(/*0*/ value: kotlin.String)
         public final val value: kotlin.String
         public abstract fun value(): kotlin.String
diff --git a/compiler/testData/loadJava/compiledJava/annotations/SimpleAnnotation.txt b/compiler/testData/loadJava/compiledJava/annotations/SimpleAnnotation.txt
index b53630f497e..2c44061e9d4 100644
--- a/compiler/testData/loadJava/compiledJava/annotations/SimpleAnnotation.txt
+++ b/compiler/testData/loadJava/compiledJava/annotations/SimpleAnnotation.txt
@@ -1,5 +1,5 @@
 package test
 
-public final annotation class SimpleAnnotation : kotlin.Annotation {
+public final class SimpleAnnotation : kotlin.Annotation {
     public constructor SimpleAnnotation()
 }
diff --git a/compiler/testData/loadJava/compiledJava/annotations/StringConcatenationInParam.txt b/compiler/testData/loadJava/compiledJava/annotations/StringConcatenationInParam.txt
index 91cb46c6318..88c59dd750f 100644
--- a/compiler/testData/loadJava/compiledJava/annotations/StringConcatenationInParam.txt
+++ b/compiler/testData/loadJava/compiledJava/annotations/StringConcatenationInParam.txt
@@ -2,7 +2,7 @@ package test
 
 public interface StringConcatenationInParam {
 
-    public final annotation class Anno : kotlin.Annotation {
+    public final class Anno : kotlin.Annotation {
         public constructor Anno(/*0*/ value: kotlin.String)
         public final val value: kotlin.String
         public abstract fun value(): kotlin.String
diff --git a/compiler/testData/loadJava/compiledJava/annotations/StringConstantInParam.txt b/compiler/testData/loadJava/compiledJava/annotations/StringConstantInParam.txt
index 66c54ad876d..e10cf3c559f 100644
--- a/compiler/testData/loadJava/compiledJava/annotations/StringConstantInParam.txt
+++ b/compiler/testData/loadJava/compiledJava/annotations/StringConstantInParam.txt
@@ -2,7 +2,7 @@ package test
 
 public interface StringConstantInParam {
 
-    public final annotation class Anno : kotlin.Annotation {
+    public final class Anno : kotlin.Annotation {
         public constructor Anno(/*0*/ value: kotlin.String)
         public final val value: kotlin.String
         public abstract fun value(): kotlin.String
diff --git a/compiler/testData/loadJava/compiledJava/annotations/StringInParam.txt b/compiler/testData/loadJava/compiledJava/annotations/StringInParam.txt
index 05152b47227..819282cceb1 100644
--- a/compiler/testData/loadJava/compiledJava/annotations/StringInParam.txt
+++ b/compiler/testData/loadJava/compiledJava/annotations/StringInParam.txt
@@ -2,7 +2,7 @@ package test
 
 public interface StringInParam {
 
-    public final annotation class Anno : kotlin.Annotation {
+    public final class Anno : kotlin.Annotation {
         public constructor Anno(/*0*/ value: kotlin.String)
         public final val value: kotlin.String
         public abstract fun value(): kotlin.String
diff --git a/compiler/testData/loadJava/compiledJava/kotlinSignature/MethodWithMappedClasses.txt b/compiler/testData/loadJava/compiledJava/kotlinSignature/MethodWithMappedClasses.txt
index af3fde71cba..ff5ea05cdd9 100644
--- a/compiler/testData/loadJava/compiledJava/kotlinSignature/MethodWithMappedClasses.txt
+++ b/compiler/testData/loadJava/compiledJava/kotlinSignature/MethodWithMappedClasses.txt
@@ -2,5 +2,5 @@ package test
 
 public open class MethodWithMappedClasses {
     public constructor MethodWithMappedClasses()
-    public open fun </*0*/ T> copy(/*0*/ dest: kotlin.(Mutable)List<in T!>!, /*1*/ src: kotlin.(Mutable)List<T!>!): kotlin.Unit
+    public open fun </*0*/ T> copy(/*0*/ dest: (kotlin.MutableList<in T!>..kotlin.List<*>?), /*1*/ src: kotlin.(Mutable)List<T!>!): kotlin.Unit
 }
diff --git a/compiler/testData/loadJava/compiledJava/kotlinSignature/MethodWithTypeParameters.txt b/compiler/testData/loadJava/compiledJava/kotlinSignature/MethodWithTypeParameters.txt
index 8a999647cfc..8c2a3a0006c 100644
--- a/compiler/testData/loadJava/compiledJava/kotlinSignature/MethodWithTypeParameters.txt
+++ b/compiler/testData/loadJava/compiledJava/kotlinSignature/MethodWithTypeParameters.txt
@@ -2,5 +2,5 @@ package test
 
 public open class MethodWithTypeParameters {
     public constructor MethodWithTypeParameters()
-    public open fun </*0*/ A, /*1*/ B : java.lang.Runnable!> foo(/*0*/ a: A!, /*1*/ b: (kotlin.MutableList<out B!>..kotlin.List<B!>?), /*2*/ c: kotlin.(Mutable)List<in kotlin.String!>!): kotlin.Unit where B : kotlin.(Mutable)List<kotlin.Cloneable!>!
+    public open fun </*0*/ A, /*1*/ B : java.lang.Runnable!> foo(/*0*/ a: A!, /*1*/ b: (kotlin.MutableList<out B!>..kotlin.List<B!>?), /*2*/ c: (kotlin.MutableList<in kotlin.String!>..kotlin.List<*>?)): kotlin.Unit where B : kotlin.(Mutable)List<kotlin.Cloneable!>!
 }
diff --git a/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/InheritNotVararg.txt b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/InheritNotVararg.txt
index d5c09e06b57..2e95f51a5ee 100644
--- a/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/InheritNotVararg.txt
+++ b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/InheritNotVararg.txt
@@ -4,7 +4,7 @@ public interface InheritNotVararg {
 
     public interface Sub : test.InheritNotVararg.Super {
         public abstract override /*1*/ /*fake_override*/ fun dummy(): kotlin.Unit
-        public abstract override /*1*/ fun foo(/*0*/ p0: (kotlin.Array<kotlin.String!>?..kotlin.Array<out kotlin.String!>?)): kotlin.Unit
+        public abstract override /*1*/ fun foo(/*0*/ p0: kotlin.Array<(out) kotlin.String!>?): kotlin.Unit
     }
 
     public interface Super {
diff --git a/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/InheritNotVarargInteger.txt b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/InheritNotVarargInteger.txt
index dc659f6a6ad..a8db63ba808 100644
--- a/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/InheritNotVarargInteger.txt
+++ b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/InheritNotVarargInteger.txt
@@ -4,7 +4,7 @@ public interface InheritNotVarargInteger {
 
     public interface Sub : test.InheritNotVarargInteger.Super {
         public abstract override /*1*/ /*fake_override*/ fun dummy(): kotlin.Unit
-        public abstract override /*1*/ fun foo(/*0*/ p0: (kotlin.Array<kotlin.Int!>?..kotlin.Array<out kotlin.Int!>?)): kotlin.Unit
+        public abstract override /*1*/ fun foo(/*0*/ p0: kotlin.Array<(out) kotlin.Int!>?): kotlin.Unit
     }
 
     public interface Super {
diff --git a/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/InheritNotVarargNotNull.txt b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/InheritNotVarargNotNull.txt
index fc338970c32..aafe1541a83 100644
--- a/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/InheritNotVarargNotNull.txt
+++ b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/InheritNotVarargNotNull.txt
@@ -4,7 +4,7 @@ public interface InheritNotVarargNotNull {
 
     public interface Sub : test.InheritNotVarargNotNull.Super {
         public abstract override /*1*/ /*fake_override*/ fun dummy(): kotlin.Unit
-        public abstract override /*1*/ fun foo(/*0*/ p: (kotlin.Array<kotlin.String!>?..kotlin.Array<out kotlin.String!>?)): kotlin.Unit
+        public abstract override /*1*/ fun foo(/*0*/ p: kotlin.Array<(out) kotlin.String!>?): kotlin.Unit
     }
 
     public interface Super {
diff --git a/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/InheritNullability.txt b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/InheritNullability.txt
index e1fd0fc86de..4acef4ae49c 100644
--- a/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/InheritNullability.txt
+++ b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/InheritNullability.txt
@@ -4,11 +4,11 @@ public interface InheritNullability {
 
     public interface Sub : test.InheritNullability.Super {
         public abstract override /*1*/ /*fake_override*/ fun dummy(): kotlin.Unit
-        public abstract override /*1*/ fun foo(/*0*/ p0: kotlin.String!): kotlin.Unit
+        public abstract override /*1*/ fun foo(/*0*/ p0: kotlin.String): kotlin.Unit
     }
 
     public interface Super {
         public abstract fun dummy(): kotlin.Unit
-        public abstract fun foo(/*0*/ org.jetbrains.annotations.NotNull() p0: kotlin.String!): kotlin.Unit
+        public abstract fun foo(/*0*/ org.jetbrains.annotations.NotNull() p0: kotlin.String): kotlin.Unit
     }
 }
diff --git a/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/InheritVararg.txt b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/InheritVararg.txt
index c020a7d2089..6939cfb447f 100644
--- a/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/InheritVararg.txt
+++ b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/InheritVararg.txt
@@ -4,7 +4,7 @@ public interface InheritVararg {
 
     public interface Sub : test.InheritVararg.Super {
         public abstract override /*1*/ /*fake_override*/ fun dummy(): kotlin.Unit
-        public abstract override /*1*/ fun foo(/*0*/ vararg p0: kotlin.String! /*kotlin.Array<(out) kotlin.String!>!*/): kotlin.Unit
+        public abstract override /*1*/ fun foo(/*0*/ vararg p0: kotlin.String! /*kotlin.Array<(out) kotlin.String!>*/): kotlin.Unit
     }
 
     public interface Super {
diff --git a/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/InheritVarargInteger.txt b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/InheritVarargInteger.txt
index 85b925cd3ad..1751f272446 100644
--- a/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/InheritVarargInteger.txt
+++ b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/InheritVarargInteger.txt
@@ -4,7 +4,7 @@ public interface InheritVarargInteger {
 
     public interface Sub : test.InheritVarargInteger.Super {
         public abstract override /*1*/ /*fake_override*/ fun dummy(): kotlin.Unit
-        public abstract override /*1*/ fun foo(/*0*/ vararg p0: kotlin.Int! /*kotlin.Array<(out) kotlin.Int!>!*/): kotlin.Unit
+        public abstract override /*1*/ fun foo(/*0*/ vararg p0: kotlin.Int! /*kotlin.Array<(out) kotlin.Int!>*/): kotlin.Unit
     }
 
     public interface Super {
diff --git a/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/InheritVarargNotNull.txt b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/InheritVarargNotNull.txt
index ec47d07815c..ed8a0965ecb 100644
--- a/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/InheritVarargNotNull.txt
+++ b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/InheritVarargNotNull.txt
@@ -4,7 +4,7 @@ public interface InheritVarargNotNull {
 
     public interface Sub : test.InheritVarargNotNull.Super {
         public abstract override /*1*/ /*fake_override*/ fun dummy(): kotlin.Unit
-        public abstract override /*1*/ fun foo(/*0*/ vararg p: kotlin.String! /*kotlin.Array<(out) kotlin.String!>!*/): kotlin.Unit
+        public abstract override /*1*/ fun foo(/*0*/ vararg p: kotlin.String! /*kotlin.Array<(out) kotlin.String!>*/): kotlin.Unit
     }
 
     public interface Super {
diff --git a/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/Kt3302.txt b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/Kt3302.txt
index ff7c0e33b6c..c8baccc2a06 100644
--- a/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/Kt3302.txt
+++ b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/Kt3302.txt
@@ -4,12 +4,12 @@ public interface Kt3302 {
 
     public interface BSONObject {
         public abstract fun dummy(): kotlin.Unit
-        public abstract fun put(/*0*/ org.jetbrains.annotations.NotNull() p0: kotlin.String!, /*1*/ org.jetbrains.annotations.NotNull() p1: kotlin.Any!): kotlin.Any!
+        public abstract fun put(/*0*/ org.jetbrains.annotations.NotNull() p0: kotlin.String, /*1*/ org.jetbrains.annotations.NotNull() p1: kotlin.Any): kotlin.Any!
     }
 
     public interface BasicBSONObject : test.Kt3302.LinkedHashMap<kotlin.String!, kotlin.Any!>, test.Kt3302.BSONObject {
         public abstract override /*2*/ /*fake_override*/ fun dummy(): kotlin.Unit
-        public abstract override /*2*/ fun put(/*0*/ key: kotlin.String!, /*1*/ value: kotlin.Any!): kotlin.Any!
+        public abstract override /*2*/ fun put(/*0*/ key: kotlin.String, /*1*/ value: kotlin.Any): kotlin.Any!
     }
 
     public interface LinkedHashMap</*0*/ K, /*1*/ V> {
diff --git a/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/NotNullToNullable.txt b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/NotNullToNullable.txt
index ea246554807..725c802b7ff 100644
--- a/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/NotNullToNullable.txt
+++ b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/NotNullToNullable.txt
@@ -4,11 +4,11 @@ public interface NotNullToNullable {
 
     public interface Sub : test.NotNullToNullable.Super {
         public abstract override /*1*/ /*fake_override*/ fun dummy(): kotlin.Unit
-        public abstract override /*1*/ fun foo(/*0*/ p: kotlin.String!): kotlin.Unit
+        public abstract override /*1*/ fun foo(/*0*/ p: kotlin.String): kotlin.Unit
     }
 
     public interface Super {
         public abstract fun dummy(): kotlin.Unit
-        public abstract fun foo(/*0*/ org.jetbrains.annotations.NotNull() p0: kotlin.String!): kotlin.Unit
+        public abstract fun foo(/*0*/ org.jetbrains.annotations.NotNull() p0: kotlin.String): kotlin.Unit
     }
 }
diff --git a/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/NullableToNotNull.txt b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/NullableToNotNull.txt
index 99a6a6ef179..7b3bf60f07a 100644
--- a/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/NullableToNotNull.txt
+++ b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/NullableToNotNull.txt
@@ -4,7 +4,7 @@ public interface NullableToNotNull {
 
     public interface Sub : test.NullableToNotNull.Super {
         public abstract override /*1*/ /*fake_override*/ fun dummy(): kotlin.Unit
-        public abstract override /*1*/ fun foo(/*0*/ org.jetbrains.annotations.NotNull() p0: kotlin.String!): kotlin.Unit
+        public abstract override /*1*/ fun foo(/*0*/ org.jetbrains.annotations.NotNull() p0: kotlin.String): kotlin.Unit
     }
 
     public interface Super {
diff --git a/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/SubclassFromGenericAndNot.txt b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/SubclassFromGenericAndNot.txt
index e5a07aef461..ef69af33b02 100644
--- a/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/SubclassFromGenericAndNot.txt
+++ b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/SubclassFromGenericAndNot.txt
@@ -9,11 +9,11 @@ public interface SubclassFromGenericAndNot {
 
     public interface NonGeneric {
         public abstract fun dummy(): kotlin.Unit
-        public abstract fun foo(/*0*/ org.jetbrains.annotations.NotNull() p0: kotlin.String!): kotlin.Unit
+        public abstract fun foo(/*0*/ org.jetbrains.annotations.NotNull() p0: kotlin.String): kotlin.Unit
     }
 
     public interface Sub : test.SubclassFromGenericAndNot.NonGeneric, test.SubclassFromGenericAndNot.Generic<kotlin.String!> {
         public abstract override /*2*/ /*fake_override*/ fun dummy(): kotlin.Unit
-        public abstract override /*2*/ fun foo(/*0*/ key: kotlin.String!): kotlin.Unit
+        public abstract override /*2*/ fun foo(/*0*/ key: kotlin.String): kotlin.Unit
     }
 }
diff --git a/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/AddNotNullJavaSubtype.txt b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/AddNotNullJavaSubtype.txt
index b432f192568..6b95bff2fe8 100644
--- a/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/AddNotNullJavaSubtype.txt
+++ b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/AddNotNullJavaSubtype.txt
@@ -4,7 +4,7 @@ public interface AddNotNullJavaSubtype {
 
     public interface Sub : test.AddNotNullJavaSubtype.Super {
         public abstract override /*1*/ /*fake_override*/ fun dummy(): kotlin.Unit
-        org.jetbrains.annotations.NotNull() public abstract override /*1*/ fun foo(): kotlin.String!
+        org.jetbrains.annotations.NotNull() public abstract override /*1*/ fun foo(): kotlin.String
     }
 
     public interface Super {
diff --git a/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/AddNotNullSameJavaType.txt b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/AddNotNullSameJavaType.txt
index 16c66d601eb..9d15cc371b4 100644
--- a/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/AddNotNullSameJavaType.txt
+++ b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/AddNotNullSameJavaType.txt
@@ -4,7 +4,7 @@ public interface AddNotNullSameJavaType {
 
     public interface Sub : test.AddNotNullSameJavaType.Super {
         public abstract override /*1*/ /*fake_override*/ fun dummy(): kotlin.Unit
-        org.jetbrains.annotations.NotNull() public abstract override /*1*/ fun foo(): kotlin.CharSequence!
+        org.jetbrains.annotations.NotNull() public abstract override /*1*/ fun foo(): kotlin.CharSequence
     }
 
     public interface Super {
diff --git a/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/AddNullabilityJavaSubtype.txt b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/AddNullabilityJavaSubtype.txt
index 119585dda3e..7f6f5b9f32c 100644
--- a/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/AddNullabilityJavaSubtype.txt
+++ b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/AddNullabilityJavaSubtype.txt
@@ -4,11 +4,11 @@ public interface AddNullabilityJavaSubtype {
 
     public interface Sub : test.AddNullabilityJavaSubtype.Super {
         public abstract override /*1*/ /*fake_override*/ fun dummy(): kotlin.Unit
-        public abstract override /*1*/ fun foo(): kotlin.String!
+        public abstract override /*1*/ fun foo(): kotlin.String
     }
 
     public interface Super {
         public abstract fun dummy(): kotlin.Unit
-        org.jetbrains.annotations.NotNull() public abstract fun foo(): kotlin.CharSequence!
+        org.jetbrains.annotations.NotNull() public abstract fun foo(): kotlin.CharSequence
     }
 }
diff --git a/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/AddNullabilitySameJavaType.txt b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/AddNullabilitySameJavaType.txt
index e314b0c1afc..6dfd67de948 100644
--- a/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/AddNullabilitySameJavaType.txt
+++ b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/AddNullabilitySameJavaType.txt
@@ -4,11 +4,11 @@ public interface AddNullabilitySameJavaType {
 
     public interface Sub : test.AddNullabilitySameJavaType.Super {
         public abstract override /*1*/ /*fake_override*/ fun dummy(): kotlin.Unit
-        public abstract override /*1*/ fun foo(): kotlin.CharSequence!
+        public abstract override /*1*/ fun foo(): kotlin.CharSequence
     }
 
     public interface Super {
         public abstract fun dummy(): kotlin.Unit
-        org.jetbrains.annotations.NotNull() public abstract fun foo(): kotlin.CharSequence!
+        org.jetbrains.annotations.NotNull() public abstract fun foo(): kotlin.CharSequence
     }
 }
diff --git a/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/InheritNullabilityJavaSubtype.txt b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/InheritNullabilityJavaSubtype.txt
index 3f186405d99..0310ee65635 100644
--- a/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/InheritNullabilityJavaSubtype.txt
+++ b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/InheritNullabilityJavaSubtype.txt
@@ -4,11 +4,11 @@ public interface InheritNullabilityJavaSubtype {
 
     public interface Sub : test.InheritNullabilityJavaSubtype.Super {
         public abstract override /*1*/ /*fake_override*/ fun dummy(): kotlin.Unit
-        public abstract override /*1*/ fun foo(): kotlin.String!
+        public abstract override /*1*/ fun foo(): kotlin.String
     }
 
     public interface Super {
         public abstract fun dummy(): kotlin.Unit
-        org.jetbrains.annotations.NotNull() public abstract fun foo(): kotlin.CharSequence!
+        org.jetbrains.annotations.NotNull() public abstract fun foo(): kotlin.CharSequence
     }
 }
diff --git a/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/InheritNullabilitySameJavaType.txt b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/InheritNullabilitySameJavaType.txt
index e0c68dc5b42..06ea5118974 100644
--- a/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/InheritNullabilitySameJavaType.txt
+++ b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/InheritNullabilitySameJavaType.txt
@@ -4,11 +4,11 @@ public interface InheritNullabilitySameJavaType {
 
     public interface Sub : test.InheritNullabilitySameJavaType.Super {
         public abstract override /*1*/ /*fake_override*/ fun dummy(): kotlin.Unit
-        public abstract override /*1*/ fun foo(): kotlin.CharSequence!
+        public abstract override /*1*/ fun foo(): kotlin.CharSequence
     }
 
     public interface Super {
         public abstract fun dummy(): kotlin.Unit
-        org.jetbrains.annotations.NotNull() public abstract fun foo(): kotlin.CharSequence!
+        org.jetbrains.annotations.NotNull() public abstract fun foo(): kotlin.CharSequence
     }
 }
diff --git a/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/SubclassOfCollection.txt b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/SubclassOfCollection.txt
index 116c51fa854..4aaff4269d9 100644
--- a/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/SubclassOfCollection.txt
+++ b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/SubclassOfCollection.txt
@@ -7,7 +7,7 @@ public interface SubclassOfCollection</*0*/ E> : kotlin.MutableCollection<E!> {
     public abstract override /*1*/ /*fake_override*/ fun contains(/*0*/ o: kotlin.Any?): kotlin.Boolean
     public abstract override /*1*/ /*fake_override*/ fun containsAll(/*0*/ c: kotlin.Collection<kotlin.Any?>): kotlin.Boolean
     public abstract override /*1*/ /*fake_override*/ fun isEmpty(): kotlin.Boolean
-    public abstract override /*1*/ fun iterator(): kotlin.(Mutable)Iterator<E!>!
+    public abstract override /*1*/ fun iterator(): kotlin.MutableIterator<E!>
     public abstract override /*1*/ /*fake_override*/ fun remove(/*0*/ o: kotlin.Any?): kotlin.Boolean
     public abstract override /*1*/ /*fake_override*/ fun removeAll(/*0*/ c: kotlin.Collection<kotlin.Any?>): kotlin.Boolean
     public abstract override /*1*/ /*fake_override*/ fun retainAll(/*0*/ c: kotlin.Collection<kotlin.Any?>): kotlin.Boolean
diff --git a/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/TwoSuperclassesReturnJavaSubtype.txt b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/TwoSuperclassesReturnJavaSubtype.txt
index 23c06c4bd70..c306b3311f4 100644
--- a/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/TwoSuperclassesReturnJavaSubtype.txt
+++ b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/TwoSuperclassesReturnJavaSubtype.txt
@@ -4,7 +4,7 @@ public interface TwoSuperclassesReturnJavaSubtype {
 
     public interface Sub : test.TwoSuperclassesReturnJavaSubtype.Super1, test.TwoSuperclassesReturnJavaSubtype.Super2 {
         public abstract override /*2*/ /*fake_override*/ fun dummy(): kotlin.Unit
-        public abstract override /*2*/ fun foo(): kotlin.String!
+        public abstract override /*2*/ fun foo(): kotlin.String
     }
 
     public interface Super1 {
@@ -14,6 +14,6 @@ public interface TwoSuperclassesReturnJavaSubtype {
 
     public interface Super2 {
         public abstract fun dummy(): kotlin.Unit
-        org.jetbrains.annotations.NotNull() public abstract fun foo(): kotlin.CharSequence!
+        org.jetbrains.annotations.NotNull() public abstract fun foo(): kotlin.CharSequence
     }
 }
diff --git a/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/TwoSuperclassesReturnSameJavaType.txt b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/TwoSuperclassesReturnSameJavaType.txt
index 635d8a77bd9..792b870788a 100644
--- a/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/TwoSuperclassesReturnSameJavaType.txt
+++ b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/TwoSuperclassesReturnSameJavaType.txt
@@ -4,7 +4,7 @@ public interface TwoSuperclassesReturnSameJavaType {
 
     public interface Sub : test.TwoSuperclassesReturnSameJavaType.Super1, test.TwoSuperclassesReturnSameJavaType.Super2 {
         public abstract override /*2*/ /*fake_override*/ fun dummy(): kotlin.Unit
-        public abstract override /*2*/ fun foo(): kotlin.CharSequence!
+        public abstract override /*2*/ fun foo(): kotlin.CharSequence
     }
 
     public interface Super1 {
@@ -14,6 +14,6 @@ public interface TwoSuperclassesReturnSameJavaType {
 
     public interface Super2 {
         public abstract fun dummy(): kotlin.Unit
-        org.jetbrains.annotations.NotNull() public abstract fun foo(): kotlin.CharSequence!
+        org.jetbrains.annotations.NotNull() public abstract fun foo(): kotlin.CharSequence
     }
 }
diff --git a/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/TypeParamOfClass.txt b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/TypeParamOfClass.txt
index 192d611dfa4..73432c13ca7 100644
--- a/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/TypeParamOfClass.txt
+++ b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/TypeParamOfClass.txt
@@ -9,6 +9,6 @@ public interface TypeParamOfClass {
 
     public interface Super</*0*/ T> {
         public abstract fun dummy(): kotlin.Unit
-        org.jetbrains.annotations.NotNull() public abstract fun foo(): T!
+        org.jetbrains.annotations.NotNull() public abstract fun foo(): T
     }
 }
diff --git a/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/TypeParamOfClassSubstituted.txt b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/TypeParamOfClassSubstituted.txt
index 1c759f64976..2a7210129e7 100644
--- a/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/TypeParamOfClassSubstituted.txt
+++ b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/TypeParamOfClassSubstituted.txt
@@ -9,6 +9,6 @@ public interface TypeParamOfClassSubstituted {
 
     public interface Super</*0*/ T> {
         public abstract fun dummy(): kotlin.Unit
-        org.jetbrains.annotations.NotNull() public abstract fun foo(): T!
+        org.jetbrains.annotations.NotNull() public abstract fun foo(): T
     }
 }
diff --git a/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/TypeParamOfFun.txt b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/TypeParamOfFun.txt
index 283136f6ebb..cf25cb6eb92 100644
--- a/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/TypeParamOfFun.txt
+++ b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/TypeParamOfFun.txt
@@ -4,11 +4,11 @@ public interface TypeParamOfFun {
 
     public interface Sub : test.TypeParamOfFun.Super {
         public abstract override /*1*/ /*fake_override*/ fun dummy(): kotlin.Unit
-        public abstract override /*1*/ fun </*0*/ E> foo(): E!
+        public abstract override /*1*/ fun </*0*/ E> foo(): E
     }
 
     public interface Super {
         public abstract fun dummy(): kotlin.Unit
-        org.jetbrains.annotations.NotNull() public abstract fun </*0*/ T> foo(): T!
+        org.jetbrains.annotations.NotNull() public abstract fun </*0*/ T> foo(): T
     }
 }
diff --git a/compiler/testData/loadJava/compiledJava/modality/ModalityOfFakeOverrides.txt b/compiler/testData/loadJava/compiledJava/modality/ModalityOfFakeOverrides.txt
index 0252161588b..310024e6e0b 100644
--- a/compiler/testData/loadJava/compiledJava/modality/ModalityOfFakeOverrides.txt
+++ b/compiler/testData/loadJava/compiledJava/modality/ModalityOfFakeOverrides.txt
@@ -6,17 +6,17 @@ public open class ModalityOfFakeOverrides : java.util.AbstractList<kotlin.String
     public open override /*1*/ /*fake_override*/ fun add(/*0*/ index: kotlin.Int, /*1*/ element: kotlin.String!): kotlin.Unit
     public open override /*1*/ /*fake_override*/ fun add(/*0*/ e: kotlin.String!): kotlin.Boolean
     public open override /*1*/ /*fake_override*/ fun addAll(/*0*/ c: kotlin.Collection<kotlin.String!>): kotlin.Boolean
-    public open override /*1*/ /*fake_override*/ fun addAll(/*0*/ index: kotlin.Int, /*1*/ c: (kotlin.MutableCollection<out kotlin.String!>..kotlin.Collection<kotlin.String!>?)): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun addAll(/*0*/ index: kotlin.Int, /*1*/ c: kotlin.Collection<kotlin.String!>): kotlin.Boolean
     public open override /*1*/ /*fake_override*/ fun clear(): kotlin.Unit
     public open override /*1*/ /*fake_override*/ fun contains(/*0*/ o: kotlin.Any?): kotlin.Boolean
     public open override /*1*/ /*fake_override*/ fun containsAll(/*0*/ c: kotlin.Collection<kotlin.Any?>): kotlin.Boolean
-    org.jetbrains.annotations.NotNull() public open override /*1*/ fun get(/*0*/ index: kotlin.Int): kotlin.String!
-    public open override /*1*/ /*fake_override*/ fun indexOf(/*0*/ o: kotlin.Any!): kotlin.Int
+    org.jetbrains.annotations.NotNull() public open override /*1*/ fun get(/*0*/ index: kotlin.Int): kotlin.String
+    public open override /*1*/ /*fake_override*/ fun indexOf(/*0*/ o: kotlin.Any?): kotlin.Int
     public open override /*1*/ /*fake_override*/ fun isEmpty(): kotlin.Boolean
-    public open override /*1*/ /*fake_override*/ fun iterator(): kotlin.(Mutable)Iterator<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.(Mutable)ListIterator<kotlin.String!>!
-    public open override /*1*/ /*fake_override*/ fun listIterator(/*0*/ index: kotlin.Int): kotlin.(Mutable)ListIterator<kotlin.String!>!
+    public open override /*1*/ /*fake_override*/ fun iterator(): kotlin.MutableIterator<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
@@ -26,7 +26,7 @@ public open class ModalityOfFakeOverrides : java.util.AbstractList<kotlin.String
     public open override /*1*/ /*fake_override*/ fun retainAll(/*0*/ c: kotlin.Collection<kotlin.Any?>): kotlin.Boolean
     public open override /*1*/ /*fake_override*/ fun set(/*0*/ index: kotlin.Int, /*1*/ element: kotlin.String!): kotlin.String!
     public open override /*1*/ fun size(): kotlin.Int
-    public open override /*1*/ /*fake_override*/ fun subList(/*0*/ fromIndex: kotlin.Int, /*1*/ toIndex: kotlin.Int): kotlin.(Mutable)List<kotlin.String!>!
+    public open override /*1*/ /*fake_override*/ fun subList(/*0*/ fromIndex: kotlin.Int, /*1*/ toIndex: kotlin.Int): kotlin.MutableList<kotlin.String!>
     public open override /*1*/ /*fake_override*/ fun toArray(): kotlin.Array<(out) kotlin.Any!>!
     public open override /*1*/ /*fake_override*/ fun </*0*/ T> toArray(/*0*/ p0: kotlin.Array<(out) T!>!): kotlin.Array<(out) T!>!
 }
diff --git a/compiler/testData/loadJava/compiledJava/mutability/LoadIterable.txt b/compiler/testData/loadJava/compiledJava/mutability/LoadIterable.txt
index c380b33c65b..36940f5e657 100644
--- a/compiler/testData/loadJava/compiledJava/mutability/LoadIterable.txt
+++ b/compiler/testData/loadJava/compiledJava/mutability/LoadIterable.txt
@@ -1,8 +1,8 @@
 package test
 
 public interface LoadIterable</*0*/ T> {
-    org.jetbrains.annotations.Mutable() public abstract fun getIterable(): kotlin.(Mutable)Iterable<T!>!
-    org.jetbrains.annotations.ReadOnly() public abstract fun getReadOnlyIterable(): kotlin.(Mutable)Iterable<T!>!
-    public abstract fun setIterable(/*0*/ org.jetbrains.annotations.Mutable() p0: kotlin.(Mutable)Iterable<T!>!): kotlin.Unit
-    public abstract fun setReadOnlyIterable(/*0*/ org.jetbrains.annotations.ReadOnly() p0: kotlin.(Mutable)Iterable<T!>!): kotlin.Unit
+    org.jetbrains.annotations.Mutable() public abstract fun getIterable(): kotlin.MutableIterable<T!>!
+    org.jetbrains.annotations.ReadOnly() public abstract fun getReadOnlyIterable(): kotlin.Iterable<T!>!
+    public abstract fun setIterable(/*0*/ org.jetbrains.annotations.Mutable() p0: kotlin.MutableIterable<T!>!): kotlin.Unit
+    public abstract fun setReadOnlyIterable(/*0*/ org.jetbrains.annotations.ReadOnly() p0: kotlin.Iterable<T!>!): kotlin.Unit
 }
diff --git a/compiler/testData/loadJava/compiledJava/mutability/LoadIterableWithNullability.txt b/compiler/testData/loadJava/compiledJava/mutability/LoadIterableWithNullability.txt
index 486bea8b4fd..f100a0859c1 100644
--- a/compiler/testData/loadJava/compiledJava/mutability/LoadIterableWithNullability.txt
+++ b/compiler/testData/loadJava/compiledJava/mutability/LoadIterableWithNullability.txt
@@ -1,8 +1,8 @@
 package test
 
 public interface LoadIterableWithNullability</*0*/ T> {
-    org.jetbrains.annotations.NotNull() org.jetbrains.annotations.Mutable() public abstract fun getIterable(): kotlin.(Mutable)Iterable<T!>!
-    org.jetbrains.annotations.NotNull() org.jetbrains.annotations.ReadOnly() public abstract fun getReadOnlyIterable(): kotlin.(Mutable)Iterable<T!>!
-    public abstract fun setIterable(/*0*/ org.jetbrains.annotations.Mutable() org.jetbrains.annotations.NotNull() p0: kotlin.(Mutable)Iterable<T!>!): kotlin.Unit
-    public abstract fun setReadOnlyIterable(/*0*/ org.jetbrains.annotations.ReadOnly() org.jetbrains.annotations.NotNull() p0: kotlin.(Mutable)Iterable<T!>!): kotlin.Unit
+    org.jetbrains.annotations.NotNull() org.jetbrains.annotations.Mutable() public abstract fun getIterable(): kotlin.MutableIterable<T!>
+    org.jetbrains.annotations.NotNull() org.jetbrains.annotations.ReadOnly() public abstract fun getReadOnlyIterable(): kotlin.Iterable<T!>
+    public abstract fun setIterable(/*0*/ org.jetbrains.annotations.Mutable() org.jetbrains.annotations.NotNull() p0: kotlin.MutableIterable<T!>): kotlin.Unit
+    public abstract fun setReadOnlyIterable(/*0*/ org.jetbrains.annotations.ReadOnly() org.jetbrains.annotations.NotNull() p0: kotlin.Iterable<T!>): kotlin.Unit
 }
diff --git a/compiler/testData/loadJava/compiledJava/mutability/LoadIterableWithPropagation.txt b/compiler/testData/loadJava/compiledJava/mutability/LoadIterableWithPropagation.txt
index 3e9b39c46d8..b60f86b8058 100644
--- a/compiler/testData/loadJava/compiledJava/mutability/LoadIterableWithPropagation.txt
+++ b/compiler/testData/loadJava/compiledJava/mutability/LoadIterableWithPropagation.txt
@@ -3,17 +3,17 @@ package test
 public interface LoadIterableWithPropagation {
 
     public interface LoadIterable</*0*/ T> {
-        org.jetbrains.annotations.Mutable() public abstract fun getIterable(): kotlin.(Mutable)Iterable<T!>!
-        org.jetbrains.annotations.ReadOnly() public abstract fun getReadOnlyIterable(): kotlin.(Mutable)Iterable<T!>!
-        public abstract fun setIterable(/*0*/ org.jetbrains.annotations.Mutable() p0: kotlin.(Mutable)Iterable<T!>!): kotlin.Unit
-        public abstract fun setReadOnlyIterable(/*0*/ org.jetbrains.annotations.ReadOnly() p0: kotlin.(Mutable)Iterable<T!>!): kotlin.Unit
+        org.jetbrains.annotations.Mutable() public abstract fun getIterable(): kotlin.MutableIterable<T!>!
+        org.jetbrains.annotations.ReadOnly() public abstract fun getReadOnlyIterable(): kotlin.Iterable<T!>!
+        public abstract fun setIterable(/*0*/ org.jetbrains.annotations.Mutable() p0: kotlin.MutableIterable<T!>!): kotlin.Unit
+        public abstract fun setReadOnlyIterable(/*0*/ org.jetbrains.annotations.ReadOnly() p0: kotlin.Iterable<T!>!): kotlin.Unit
     }
 
     public open class LoadIterableImpl</*0*/ T> : test.LoadIterableWithPropagation.LoadIterable<T!> {
         public constructor LoadIterableImpl</*0*/ T>()
-        public open override /*1*/ fun getIterable(): kotlin.(Mutable)Iterable<T!>!
-        public open override /*1*/ fun getReadOnlyIterable(): kotlin.(Mutable)Iterable<T!>!
-        public open override /*1*/ fun setIterable(/*0*/ p0: kotlin.(Mutable)Iterable<T!>!): kotlin.Unit
-        public open override /*1*/ fun setReadOnlyIterable(/*0*/ p0: kotlin.(Mutable)Iterable<T!>!): kotlin.Unit
+        public open override /*1*/ fun getIterable(): kotlin.MutableIterable<T!>!
+        public open override /*1*/ fun getReadOnlyIterable(): kotlin.Iterable<T!>!
+        public open override /*1*/ fun setIterable(/*0*/ p0: kotlin.MutableIterable<T!>!): kotlin.Unit
+        public open override /*1*/ fun setReadOnlyIterable(/*0*/ p0: kotlin.Iterable<T!>!): kotlin.Unit
     }
 }
diff --git a/compiler/testData/loadJava/compiledJava/notNull/NotNullField.txt b/compiler/testData/loadJava/compiledJava/notNull/NotNullField.txt
index 18c748212c0..7c3c4d0f703 100644
--- a/compiler/testData/loadJava/compiledJava/notNull/NotNullField.txt
+++ b/compiler/testData/loadJava/compiledJava/notNull/NotNullField.txt
@@ -2,5 +2,5 @@ package test
 
 public open class NotNullField {
     public constructor NotNullField()
-    org.jetbrains.annotations.NotNull() public final var hi: kotlin.String!
+    org.jetbrains.annotations.NotNull() public final var hi: kotlin.String
 }
diff --git a/compiler/testData/loadJava/compiledJava/notNull/NotNullIntArray.txt b/compiler/testData/loadJava/compiledJava/notNull/NotNullIntArray.txt
index d755f202faa..c658fa481d0 100644
--- a/compiler/testData/loadJava/compiledJava/notNull/NotNullIntArray.txt
+++ b/compiler/testData/loadJava/compiledJava/notNull/NotNullIntArray.txt
@@ -2,5 +2,5 @@ package test
 
 public open class NotNullIntArray {
     public constructor NotNullIntArray()
-    org.jetbrains.annotations.NotNull() public open fun hi(): kotlin.IntArray!
+    org.jetbrains.annotations.NotNull() public open fun hi(): kotlin.IntArray
 }
diff --git a/compiler/testData/loadJava/compiledJava/notNull/NotNullMethod.txt b/compiler/testData/loadJava/compiledJava/notNull/NotNullMethod.txt
index 156a9fe5391..0c30b0c6f59 100644
--- a/compiler/testData/loadJava/compiledJava/notNull/NotNullMethod.txt
+++ b/compiler/testData/loadJava/compiledJava/notNull/NotNullMethod.txt
@@ -2,5 +2,5 @@ package test
 
 public open class NotNullMethod {
     public constructor NotNullMethod()
-    org.jetbrains.annotations.NotNull() public open fun hi(): kotlin.String!
+    org.jetbrains.annotations.NotNull() public open fun hi(): kotlin.String
 }
diff --git a/compiler/testData/loadJava/compiledJava/notNull/NotNullObjectArray.txt b/compiler/testData/loadJava/compiledJava/notNull/NotNullObjectArray.txt
index d96514dc9ec..01ce03723aa 100644
--- a/compiler/testData/loadJava/compiledJava/notNull/NotNullObjectArray.txt
+++ b/compiler/testData/loadJava/compiledJava/notNull/NotNullObjectArray.txt
@@ -2,5 +2,5 @@ package test
 
 public open class NotNullObjectArray {
     public constructor NotNullObjectArray()
-    org.jetbrains.annotations.NotNull() public open fun hi(): kotlin.Array<(out) kotlin.Any!>!
+    org.jetbrains.annotations.NotNull() public open fun hi(): kotlin.Array<(out) kotlin.Any!>
 }
diff --git a/compiler/testData/loadJava/compiledJava/notNull/NotNullParameter.txt b/compiler/testData/loadJava/compiledJava/notNull/NotNullParameter.txt
index 9cb03cf421f..06636c18c82 100644
--- a/compiler/testData/loadJava/compiledJava/notNull/NotNullParameter.txt
+++ b/compiler/testData/loadJava/compiledJava/notNull/NotNullParameter.txt
@@ -2,5 +2,5 @@ package test
 
 public open class NotNullParameter {
     public constructor NotNullParameter()
-    public open fun hi(/*0*/ org.jetbrains.annotations.NotNull() p0: kotlin.String!): kotlin.Unit
+    public open fun hi(/*0*/ org.jetbrains.annotations.NotNull() p0: kotlin.String): kotlin.Unit
 }
diff --git a/compiler/testData/loadJava/compiledJava/sam/adapters/ConstructorWithAnnotations.java b/compiler/testData/loadJava/compiledJava/sam/adapters/ConstructorWithAnnotations.java
new file mode 100644
index 00000000000..6c83ef8687b
--- /dev/null
+++ b/compiler/testData/loadJava/compiledJava/sam/adapters/ConstructorWithAnnotations.java
@@ -0,0 +1,10 @@
+package test;
+
+import org.jetbrains.annotations.NotNull;
+
+import java.lang.String;
+
+public class ConstructorWithAnnotations {
+    public ConstructorWithAnnotations(Runnable r, @NotNull String s) {
+    }
+}
diff --git a/compiler/testData/loadJava/compiledJava/sam/adapters/ConstructorWithAnnotations.txt b/compiler/testData/loadJava/compiledJava/sam/adapters/ConstructorWithAnnotations.txt
new file mode 100644
index 00000000000..913ac28d907
--- /dev/null
+++ b/compiler/testData/loadJava/compiledJava/sam/adapters/ConstructorWithAnnotations.txt
@@ -0,0 +1,6 @@
+package test
+
+public open class ConstructorWithAnnotations {
+    public /*synthesized*/ constructor ConstructorWithAnnotations(/*0*/ p0: (() -> kotlin.Unit)!, /*1*/ org.jetbrains.annotations.NotNull() p1: kotlin.String)
+    public constructor ConstructorWithAnnotations(/*0*/ p0: java.lang.Runnable!, /*1*/ org.jetbrains.annotations.NotNull() p1: kotlin.String)
+}
diff --git a/compiler/testData/loadJava/compiledJava/sam/adapters/NoSamForClassTypeParameter.java b/compiler/testData/loadJava/compiledJava/sam/adapters/NoSamForClassTypeParameter.java
new file mode 100644
index 00000000000..9ca4c1a9bfa
--- /dev/null
+++ b/compiler/testData/loadJava/compiledJava/sam/adapters/NoSamForClassTypeParameter.java
@@ -0,0 +1,24 @@
+package test;
+
+class NoSamForTypeParameter<K extends Runnable> {
+    void foo(K runnable1, Runnable runnable2) {}
+}
+
+class NoSamForTypeParameterDerived1 extends NoSamForTypeParameter<Runnable> {
+    @Override
+    void foo(Runnable runnable1, Runnable runnable2) {}
+}
+
+class NoSamForTypeParameterDerived2<E extends Runnable> extends NoSamForTypeParameter<E> {
+     void foo(E runnable1, Runnable runnable2) {}
+}
+
+class NoSamForTypeParameterDerived3 extends NoSamForTypeParameterDerived1 {
+    @Override
+    void foo(Runnable runnable1, Runnable runnable2) {}
+}
+
+class NoSamForTypeParameterDerived4 extends NoSamForTypeParameterDerived2<Runnable> {
+    @Override
+    void foo(Runnable runnable1, Runnable runnable2) {}
+}
diff --git a/compiler/testData/loadJava/compiledJava/sam/adapters/NoSamForClassTypeParameter.txt b/compiler/testData/loadJava/compiledJava/sam/adapters/NoSamForClassTypeParameter.txt
new file mode 100644
index 00000000000..41549d6757e
--- /dev/null
+++ b/compiler/testData/loadJava/compiledJava/sam/adapters/NoSamForClassTypeParameter.txt
@@ -0,0 +1,34 @@
+package test
+
+public/*package*/ open class NoSamForTypeParameter</*0*/ K : java.lang.Runnable!> {
+    public/*package*/ constructor NoSamForTypeParameter</*0*/ K : java.lang.Runnable!>()
+    public/*package*/ final /*synthesized*/ fun foo(/*0*/ p0: K!, /*1*/ p1: (() -> kotlin.Unit)!): kotlin.Unit
+    public/*package*/ open fun foo(/*0*/ p0: K!, /*1*/ p1: java.lang.Runnable!): kotlin.Unit
+}
+
+public/*package*/ open class NoSamForTypeParameterDerived1 : test.NoSamForTypeParameter<java.lang.Runnable!> {
+    public/*package*/ constructor NoSamForTypeParameterDerived1()
+    public/*package*/ final /*synthesized*/ fun foo(/*0*/ p0: (() -> kotlin.Unit)!, /*1*/ p1: (() -> kotlin.Unit)!): kotlin.Unit
+    public/*package*/ final override /*1*/ /*fake_override*/ fun foo(/*0*/ p0: java.lang.Runnable!, /*1*/ p1: (() -> kotlin.Unit)!): kotlin.Unit
+    public/*package*/ open override /*1*/ fun foo(/*0*/ p0: java.lang.Runnable!, /*1*/ p1: java.lang.Runnable!): kotlin.Unit
+}
+
+public/*package*/ open class NoSamForTypeParameterDerived2</*0*/ E : java.lang.Runnable!> : test.NoSamForTypeParameter<E!> {
+    public/*package*/ constructor NoSamForTypeParameterDerived2</*0*/ E : java.lang.Runnable!>()
+    public/*package*/ final override /*1*/ /*synthesized*/ fun foo(/*0*/ p0: E!, /*1*/ p1: (() -> kotlin.Unit)!): kotlin.Unit
+    public/*package*/ open override /*1*/ fun foo(/*0*/ p0: E!, /*1*/ p1: java.lang.Runnable!): kotlin.Unit
+}
+
+public/*package*/ open class NoSamForTypeParameterDerived3 : test.NoSamForTypeParameterDerived1 {
+    public/*package*/ constructor NoSamForTypeParameterDerived3()
+    public/*package*/ final override /*1*/ /*synthesized*/ fun foo(/*0*/ p0: (() -> kotlin.Unit)!, /*1*/ p1: (() -> kotlin.Unit)!): kotlin.Unit
+    public/*package*/ final override /*1*/ /*fake_override*/ fun foo(/*0*/ p0: java.lang.Runnable!, /*1*/ p1: (() -> kotlin.Unit)!): kotlin.Unit
+    public/*package*/ open override /*1*/ fun foo(/*0*/ p0: java.lang.Runnable!, /*1*/ p1: java.lang.Runnable!): kotlin.Unit
+}
+
+public/*package*/ open class NoSamForTypeParameterDerived4 : test.NoSamForTypeParameterDerived2<java.lang.Runnable!> {
+    public/*package*/ constructor NoSamForTypeParameterDerived4()
+    public/*package*/ final /*synthesized*/ fun foo(/*0*/ p0: (() -> kotlin.Unit)!, /*1*/ p1: (() -> kotlin.Unit)!): kotlin.Unit
+    public/*package*/ final override /*1*/ /*fake_override*/ fun foo(/*0*/ p0: java.lang.Runnable!, /*1*/ p1: (() -> kotlin.Unit)!): kotlin.Unit
+    public/*package*/ open override /*1*/ fun foo(/*0*/ p0: java.lang.Runnable!, /*1*/ p1: java.lang.Runnable!): kotlin.Unit
+}
diff --git a/compiler/testData/loadJava/compiledJava/sam/adapters/NoSamForMethodTypeParameter.java b/compiler/testData/loadJava/compiledJava/sam/adapters/NoSamForMethodTypeParameter.java
new file mode 100644
index 00000000000..0b938967e81
--- /dev/null
+++ b/compiler/testData/loadJava/compiledJava/sam/adapters/NoSamForMethodTypeParameter.java
@@ -0,0 +1,20 @@
+package test;
+
+class NoSamForTypeParameter {
+    <K extends Runnable> void foo(K runnable1, Runnable runnable2) {}
+}
+
+class NoSamForTypeParameterDerived1 extends NoSamForTypeParameter {
+    @Override
+    void foo(Runnable runnable1, Runnable runnable2) {}
+}
+
+class NoSamForTypeParameterDerived2 extends NoSamForTypeParameter {
+    @Override
+    <K extends Runnable> void foo(K runnable1, Runnable runnable2) {}
+}
+
+class NoSamForTypeParameterDerived3 extends NoSamForTypeParameterDerived1 {
+    @Override
+    void foo(Runnable runnable1, Runnable runnable2) {}
+}
diff --git a/compiler/testData/loadJava/compiledJava/sam/adapters/NoSamForMethodTypeParameter.txt b/compiler/testData/loadJava/compiledJava/sam/adapters/NoSamForMethodTypeParameter.txt
new file mode 100644
index 00000000000..502943c5a02
--- /dev/null
+++ b/compiler/testData/loadJava/compiledJava/sam/adapters/NoSamForMethodTypeParameter.txt
@@ -0,0 +1,27 @@
+package test
+
+public/*package*/ open class NoSamForTypeParameter {
+    public/*package*/ constructor NoSamForTypeParameter()
+    public/*package*/ final /*synthesized*/ fun </*0*/ K : java.lang.Runnable!> foo(/*0*/ p0: K!, /*1*/ p1: (() -> kotlin.Unit)!): kotlin.Unit
+    public/*package*/ open fun </*0*/ K : java.lang.Runnable!> foo(/*0*/ p0: K!, /*1*/ p1: java.lang.Runnable!): kotlin.Unit
+}
+
+public/*package*/ open class NoSamForTypeParameterDerived1 : test.NoSamForTypeParameter {
+    public/*package*/ constructor NoSamForTypeParameterDerived1()
+    public/*package*/ final /*synthesized*/ fun foo(/*0*/ p0: (() -> kotlin.Unit)!, /*1*/ p1: (() -> kotlin.Unit)!): kotlin.Unit
+    public/*package*/ final override /*1*/ /*fake_override*/ fun </*0*/ K : java.lang.Runnable!> foo(/*0*/ p0: K!, /*1*/ p1: (() -> kotlin.Unit)!): kotlin.Unit
+    public/*package*/ open fun foo(/*0*/ p0: java.lang.Runnable!, /*1*/ p1: java.lang.Runnable!): kotlin.Unit
+}
+
+public/*package*/ open class NoSamForTypeParameterDerived2 : test.NoSamForTypeParameter {
+    public/*package*/ constructor NoSamForTypeParameterDerived2()
+    public/*package*/ final override /*1*/ /*synthesized*/ fun </*0*/ K : java.lang.Runnable!> foo(/*0*/ p0: K!, /*1*/ p1: (() -> kotlin.Unit)!): kotlin.Unit
+    public/*package*/ open override /*1*/ fun </*0*/ K : java.lang.Runnable!> foo(/*0*/ p0: K!, /*1*/ p1: java.lang.Runnable!): kotlin.Unit
+}
+
+public/*package*/ open class NoSamForTypeParameterDerived3 : test.NoSamForTypeParameterDerived1 {
+    public/*package*/ constructor NoSamForTypeParameterDerived3()
+    public/*package*/ final override /*1*/ /*synthesized*/ fun foo(/*0*/ p0: (() -> kotlin.Unit)!, /*1*/ p1: (() -> kotlin.Unit)!): kotlin.Unit
+    public/*package*/ final override /*1*/ /*fake_override*/ fun </*0*/ K : java.lang.Runnable!> foo(/*0*/ p0: K!, /*1*/ p1: (() -> kotlin.Unit)!): kotlin.Unit
+    public/*package*/ open override /*1*/ fun foo(/*0*/ p0: java.lang.Runnable!, /*1*/ p1: java.lang.Runnable!): kotlin.Unit
+}
diff --git a/compiler/testData/loadJava/compiledJava/sam/adapters/inheritance/InheritedOverriddenAdapter.txt b/compiler/testData/loadJava/compiledJava/sam/adapters/inheritance/InheritedOverriddenAdapter.txt
index 12bc206e50e..802355c6bf4 100644
--- a/compiler/testData/loadJava/compiledJava/sam/adapters/inheritance/InheritedOverriddenAdapter.txt
+++ b/compiler/testData/loadJava/compiledJava/sam/adapters/inheritance/InheritedOverriddenAdapter.txt
@@ -4,7 +4,7 @@ public interface InheritedOverriddenAdapter {
 
     public open class Sub : test.InheritedOverriddenAdapter.Super {
         public constructor Sub()
-        public open override /*1*/ fun foo(/*0*/ p0: (() -> kotlin.Unit!)!): kotlin.Unit
+        public open override /*1*/ fun foo(/*0*/ p0: (() -> kotlin.Unit)!): kotlin.Unit
         public open override /*1*/ /*fake_override*/ fun foo(/*0*/ p0: java.lang.Runnable!): kotlin.Unit
     }
 
diff --git a/compiler/testData/loadJava/compiledJava/sam/adapters/inheritance/OverriddenAmbiguousAdapters.txt b/compiler/testData/loadJava/compiledJava/sam/adapters/inheritance/OverriddenAmbiguousAdapters.txt
index 3c14e209a7f..376b3ef7589 100644
--- a/compiler/testData/loadJava/compiledJava/sam/adapters/inheritance/OverriddenAmbiguousAdapters.txt
+++ b/compiler/testData/loadJava/compiledJava/sam/adapters/inheritance/OverriddenAmbiguousAdapters.txt
@@ -3,7 +3,7 @@ package test
 public interface OverriddenAmbiguousAdapters {
 
     public interface Sub : test.OverriddenAmbiguousAdapters.Super {
-        public abstract override /*2*/ fun foo(/*0*/ p0: (() -> kotlin.Unit!)!): kotlin.Unit
+        public abstract override /*2*/ fun foo(/*0*/ p0: (() -> kotlin.Unit)!): kotlin.Unit
         public abstract override /*1*/ /*fake_override*/ fun foo(/*0*/ p0: java.io.Closeable!): kotlin.Unit
         public abstract override /*1*/ /*fake_override*/ fun foo(/*0*/ p0: java.lang.Runnable!): kotlin.Unit
     }
diff --git a/compiler/testData/loadJava/compiledJava/signaturePropagation/RawSuperType.txt b/compiler/testData/loadJava/compiledJava/signaturePropagation/RawSuperType.txt
index d8aecadb676..302b5090c63 100644
--- a/compiler/testData/loadJava/compiledJava/signaturePropagation/RawSuperType.txt
+++ b/compiler/testData/loadJava/compiledJava/signaturePropagation/RawSuperType.txt
@@ -6,7 +6,7 @@ public open class RawSuperType {
     public open inner class Derived : test.RawSuperType.Super<kotlin.Any?> {
         public constructor Derived()
         public open override /*1*/ fun dummy(): kotlin.Unit
-        public open override /*1*/ fun foo(/*0*/ p0: kotlin.Any!): kotlin.Unit
+        public open override /*1*/ fun foo(/*0*/ p0: kotlin.Any?): kotlin.Unit
     }
 
     public interface Super</*0*/ T> {
diff --git a/compiler/testData/loadJava/compiledJava/signaturePropagation/RawSuperTypeWithRecursiveBoundMultipleParameters.txt b/compiler/testData/loadJava/compiledJava/signaturePropagation/RawSuperTypeWithRecursiveBoundMultipleParameters.txt
index f19f6f76e92..b6d22fba192 100644
--- a/compiler/testData/loadJava/compiledJava/signaturePropagation/RawSuperTypeWithRecursiveBoundMultipleParameters.txt
+++ b/compiler/testData/loadJava/compiledJava/signaturePropagation/RawSuperTypeWithRecursiveBoundMultipleParameters.txt
@@ -7,7 +7,7 @@ public open class RawSuperTypeWithRecursiveBoundMultipleParameters {
         public constructor Derived()
         public open override /*1*/ fun dummy(): kotlin.Unit
         public open fun foo(/*0*/ p0: kotlin.Any!, /*1*/ p1: kotlin.Any!): kotlin.Unit
-        public open override /*1*/ fun foo(/*0*/ p0: kotlin.Any!, /*1*/ p1: test.RawSuperTypeWithRecursiveBoundMultipleParameters.Super<*, *>!): kotlin.Unit
+        public open override /*1*/ fun foo(/*0*/ p0: kotlin.Any?, /*1*/ p1: test.RawSuperTypeWithRecursiveBoundMultipleParameters.Super<*, *>!): kotlin.Unit
     }
 
     public interface Super</*0*/ R, /*1*/ T : test.RawSuperTypeWithRecursiveBoundMultipleParameters.Super<R!, T!>!> {
diff --git a/compiler/testData/loadJava/compiledJavaIncludeObjectMethods/ClassWithObjectMethod.txt b/compiler/testData/loadJava/compiledJavaIncludeObjectMethods/ClassWithObjectMethod.txt
index 96ba443f37e..d83e51668c1 100644
--- a/compiler/testData/loadJava/compiledJavaIncludeObjectMethods/ClassWithObjectMethod.txt
+++ b/compiler/testData/loadJava/compiledJavaIncludeObjectMethods/ClassWithObjectMethod.txt
@@ -4,5 +4,5 @@ public final class ClassWithObjectMethod {
     public constructor ClassWithObjectMethod()
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
     public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
-    public open override /*1*/ fun toString(): kotlin.String!
+    public open override /*1*/ fun toString(): kotlin.String
 }
diff --git a/compiler/testData/loadJava/compiledKotlin/annotations/AnnotatedAnnotation.txt b/compiler/testData/loadJava/compiledKotlin/annotations/AnnotatedAnnotation.txt
index d1caf03972e..4942e256940 100644
--- a/compiler/testData/loadJava/compiledKotlin/annotations/AnnotatedAnnotation.txt
+++ b/compiler/testData/loadJava/compiledKotlin/annotations/AnnotatedAnnotation.txt
@@ -1,5 +1,5 @@
 package test
 
-test.AnnotatedAnnotation() public final annotation class AnnotatedAnnotation : kotlin.Annotation {
+test.AnnotatedAnnotation() kotlin.annotation.annotation() public final class AnnotatedAnnotation : kotlin.Annotation {
     /*primary*/ public constructor AnnotatedAnnotation()
 }
diff --git a/compiler/testData/loadJava/compiledKotlin/annotations/AnnotationInAnnotationArguments.txt b/compiler/testData/loadJava/compiledKotlin/annotations/AnnotationInAnnotationArguments.txt
index bf8bb667d3b..d7c67438af2 100644
--- a/compiler/testData/loadJava/compiledKotlin/annotations/AnnotationInAnnotationArguments.txt
+++ b/compiler/testData/loadJava/compiledKotlin/annotations/AnnotationInAnnotationArguments.txt
@@ -22,13 +22,13 @@ internal final enum class E : kotlin.Enum<test.E> {
     public final /*synthesized*/ fun values(): kotlin.Array<test.E>
 }
 
-internal final annotation class EnumOption : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class EnumOption : kotlin.Annotation {
     /*primary*/ public constructor EnumOption(/*0*/ option: test.E)
     internal final val option: test.E
         internal final fun <get-option>(): test.E
 }
 
-internal final annotation class OptionGroups : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class OptionGroups : kotlin.Annotation {
     /*primary*/ public constructor OptionGroups(/*0*/ o1: test.StringOptions, /*1*/ o2: test.EnumOption)
     internal final val o1: test.StringOptions
         internal final fun <get-o1>(): test.StringOptions
@@ -36,7 +36,7 @@ internal final annotation class OptionGroups : kotlin.Annotation {
         internal final fun <get-o2>(): test.EnumOption
 }
 
-internal final annotation class StringOptions : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class StringOptions : kotlin.Annotation {
     /*primary*/ public constructor StringOptions(/*0*/ vararg option: kotlin.String /*kotlin.Array<out kotlin.String>*/)
     internal final val option: kotlin.Array<out kotlin.String>
         internal final fun <get-option>(): kotlin.Array<out kotlin.String>
diff --git a/compiler/testData/loadJava/compiledKotlin/annotations/EnumArgumentWithCustomToString.txt b/compiler/testData/loadJava/compiledKotlin/annotations/EnumArgumentWithCustomToString.txt
index 74a4ece988e..9ecf3aaec69 100644
--- a/compiler/testData/loadJava/compiledKotlin/annotations/EnumArgumentWithCustomToString.txt
+++ b/compiler/testData/loadJava/compiledKotlin/annotations/EnumArgumentWithCustomToString.txt
@@ -18,7 +18,7 @@ internal final enum class E : kotlin.Enum<test.E> {
     public final /*synthesized*/ fun values(): kotlin.Array<test.E>
 }
 
-internal final annotation class EnumAnno : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class EnumAnno : kotlin.Annotation {
     /*primary*/ public constructor EnumAnno(/*0*/ value: test.E)
     internal final val value: test.E
         internal final fun <get-value>(): test.E
@@ -29,7 +29,7 @@ public final class EnumArgumentWithCustomToString {
     test.EnumAnno(value = E.CAKE) test.EnumArrayAnno(value = {E.CAKE, E.CAKE}) internal final fun annotated(): kotlin.Unit
 }
 
-internal final annotation class EnumArrayAnno : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class EnumArrayAnno : kotlin.Annotation {
     /*primary*/ public constructor EnumArrayAnno(/*0*/ vararg value: test.E /*kotlin.Array<out test.E>*/)
     internal final val value: kotlin.Array<out test.E>
         internal final fun <get-value>(): kotlin.Array<out test.E>
diff --git a/compiler/testData/loadJava/compiledKotlin/annotations/MultiDimensionalArrayMethod.txt b/compiler/testData/loadJava/compiledKotlin/annotations/MultiDimensionalArrayMethod.txt
index 457fe635eee..c961f664c64 100644
--- a/compiler/testData/loadJava/compiledKotlin/annotations/MultiDimensionalArrayMethod.txt
+++ b/compiler/testData/loadJava/compiledKotlin/annotations/MultiDimensionalArrayMethod.txt
@@ -1,6 +1,6 @@
 package test
 
-internal final annotation class Anno : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class Anno : kotlin.Annotation {
     /*primary*/ public constructor Anno(/*0*/ s: kotlin.String)
     internal final val s: kotlin.String
         internal final fun <get-s>(): kotlin.String
diff --git a/compiler/testData/loadJava/compiledKotlin/annotations/SimpleAnnotation.txt b/compiler/testData/loadJava/compiledKotlin/annotations/SimpleAnnotation.txt
index 99a705e74ff..1ebd05de6b8 100644
--- a/compiler/testData/loadJava/compiledKotlin/annotations/SimpleAnnotation.txt
+++ b/compiler/testData/loadJava/compiledKotlin/annotations/SimpleAnnotation.txt
@@ -1,5 +1,5 @@
 package test
 
-public final annotation class SimpleAnnotation : kotlin.Annotation {
+kotlin.annotation.annotation() public final class SimpleAnnotation : kotlin.Annotation {
     /*primary*/ public constructor SimpleAnnotation()
 }
diff --git a/compiler/testData/loadJava/compiledKotlin/annotations/TargetedAnnotation.kt b/compiler/testData/loadJava/compiledKotlin/annotations/TargetedAnnotation.kt
new file mode 100644
index 00000000000..5127231dbc9
--- /dev/null
+++ b/compiler/testData/loadJava/compiledKotlin/annotations/TargetedAnnotation.kt
@@ -0,0 +1,6 @@
+// ALLOW_AST_ACCESS
+
+package test
+
+target(AnnotationTarget.CLASSIFIER)
+public annotation class TargetedAnnotation
diff --git a/compiler/testData/loadJava/compiledKotlin/annotations/TargetedAnnotation.txt b/compiler/testData/loadJava/compiledKotlin/annotations/TargetedAnnotation.txt
new file mode 100644
index 00000000000..fab329677cf
--- /dev/null
+++ b/compiler/testData/loadJava/compiledKotlin/annotations/TargetedAnnotation.txt
@@ -0,0 +1,5 @@
+package test
+
+kotlin.annotation.target(allowedTargets = {AnnotationTarget.CLASSIFIER}) kotlin.annotation.annotation() public final class TargetedAnnotation : kotlin.Annotation {
+    /*primary*/ public constructor TargetedAnnotation()
+}
diff --git a/compiler/testData/loadJava/compiledKotlin/annotations/classMembers/ClassObjectPropertyField.txt b/compiler/testData/loadJava/compiledKotlin/annotations/classMembers/ClassObjectPropertyField.txt
index c253b8d5a4d..4ad780aedfb 100644
--- a/compiler/testData/loadJava/compiledKotlin/annotations/classMembers/ClassObjectPropertyField.txt
+++ b/compiler/testData/loadJava/compiledKotlin/annotations/classMembers/ClassObjectPropertyField.txt
@@ -1,6 +1,6 @@
 package test
 
-internal final annotation class Anno : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class Anno : kotlin.Annotation {
     /*primary*/ public constructor Anno()
 }
 
diff --git a/compiler/testData/loadJava/compiledKotlin/annotations/classMembers/Constructor.txt b/compiler/testData/loadJava/compiledKotlin/annotations/classMembers/Constructor.txt
index 7632f8e8dc0..32fa1fab70d 100644
--- a/compiler/testData/loadJava/compiledKotlin/annotations/classMembers/Constructor.txt
+++ b/compiler/testData/loadJava/compiledKotlin/annotations/classMembers/Constructor.txt
@@ -1,6 +1,6 @@
 package test
 
-internal final annotation class Anno : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class Anno : kotlin.Annotation {
     /*primary*/ public constructor Anno(/*0*/ value: kotlin.String)
     internal final val value: kotlin.String
         internal final fun <get-value>(): kotlin.String
diff --git a/compiler/testData/loadJava/compiledKotlin/annotations/classMembers/DelegatedProperty.txt b/compiler/testData/loadJava/compiledKotlin/annotations/classMembers/DelegatedProperty.txt
index d269b2347a0..c7e0e9473ed 100644
--- a/compiler/testData/loadJava/compiledKotlin/annotations/classMembers/DelegatedProperty.txt
+++ b/compiler/testData/loadJava/compiledKotlin/annotations/classMembers/DelegatedProperty.txt
@@ -1,6 +1,6 @@
 package test
 
-internal final annotation class Anno : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class Anno : kotlin.Annotation {
     /*primary*/ public constructor Anno()
 }
 
diff --git a/compiler/testData/loadJava/compiledKotlin/annotations/classMembers/EnumArgument.txt b/compiler/testData/loadJava/compiledKotlin/annotations/classMembers/EnumArgument.txt
index c8637c254e2..42e31ecfc79 100644
--- a/compiler/testData/loadJava/compiledKotlin/annotations/classMembers/EnumArgument.txt
+++ b/compiler/testData/loadJava/compiledKotlin/annotations/classMembers/EnumArgument.txt
@@ -1,6 +1,6 @@
 package test
 
-internal final annotation class Anno : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class Anno : kotlin.Annotation {
     /*primary*/ public constructor Anno(/*0*/ t: java.lang.annotation.ElementType)
     internal final val t: java.lang.annotation.ElementType
         internal final fun <get-t>(): java.lang.annotation.ElementType
diff --git a/compiler/testData/loadJava/compiledKotlin/annotations/classMembers/Function.txt b/compiler/testData/loadJava/compiledKotlin/annotations/classMembers/Function.txt
index 35b8b67f0ff..eabef133146 100644
--- a/compiler/testData/loadJava/compiledKotlin/annotations/classMembers/Function.txt
+++ b/compiler/testData/loadJava/compiledKotlin/annotations/classMembers/Function.txt
@@ -1,6 +1,6 @@
 package test
 
-internal final annotation class Anno : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class Anno : kotlin.Annotation {
     /*primary*/ public constructor Anno()
 }
 
diff --git a/compiler/testData/loadJava/compiledKotlin/annotations/classMembers/Getter.txt b/compiler/testData/loadJava/compiledKotlin/annotations/classMembers/Getter.txt
index 8dc529d4f7d..1e3f2918105 100644
--- a/compiler/testData/loadJava/compiledKotlin/annotations/classMembers/Getter.txt
+++ b/compiler/testData/loadJava/compiledKotlin/annotations/classMembers/Getter.txt
@@ -1,6 +1,6 @@
 package test
 
-internal final annotation class Anno : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class Anno : kotlin.Annotation {
     /*primary*/ public constructor Anno()
 }
 
diff --git a/compiler/testData/loadJava/compiledKotlin/annotations/classMembers/PropertyField.txt b/compiler/testData/loadJava/compiledKotlin/annotations/classMembers/PropertyField.txt
index 6f98192e1e6..44c27f1ce64 100644
--- a/compiler/testData/loadJava/compiledKotlin/annotations/classMembers/PropertyField.txt
+++ b/compiler/testData/loadJava/compiledKotlin/annotations/classMembers/PropertyField.txt
@@ -1,6 +1,6 @@
 package test
 
-internal final annotation class Anno : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class Anno : kotlin.Annotation {
     /*primary*/ public constructor Anno()
 }
 
diff --git a/compiler/testData/loadJava/compiledKotlin/annotations/classMembers/Setter.txt b/compiler/testData/loadJava/compiledKotlin/annotations/classMembers/Setter.txt
index c3ead292592..3d032c01d95 100644
--- a/compiler/testData/loadJava/compiledKotlin/annotations/classMembers/Setter.txt
+++ b/compiler/testData/loadJava/compiledKotlin/annotations/classMembers/Setter.txt
@@ -1,6 +1,6 @@
 package test
 
-internal final annotation class Anno : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class Anno : kotlin.Annotation {
     /*primary*/ public constructor Anno()
 }
 
diff --git a/compiler/testData/loadJava/compiledKotlin/annotations/classes/AnnotationInClassObject.txt b/compiler/testData/loadJava/compiledKotlin/annotations/classes/AnnotationInClassObject.txt
index 29a6baac275..91d3ed913c9 100644
--- a/compiler/testData/loadJava/compiledKotlin/annotations/classes/AnnotationInClassObject.txt
+++ b/compiler/testData/loadJava/compiledKotlin/annotations/classes/AnnotationInClassObject.txt
@@ -6,14 +6,14 @@ internal final class A {
     public companion object Companion {
         /*primary*/ private constructor Companion()
 
-        internal final annotation class Anno1 : kotlin.Annotation {
+        kotlin.annotation.annotation() internal final class Anno1 : kotlin.Annotation {
             /*primary*/ public constructor Anno1()
         }
 
         internal final class B {
             /*primary*/ public constructor B()
 
-            internal final annotation class Anno2 : kotlin.Annotation {
+            kotlin.annotation.annotation() internal final class Anno2 : kotlin.Annotation {
                 /*primary*/ public constructor Anno2()
             }
         }
diff --git a/compiler/testData/loadJava/compiledKotlin/annotations/classes/ClassInClassObject.txt b/compiler/testData/loadJava/compiledKotlin/annotations/classes/ClassInClassObject.txt
index ca4816dab10..96fb06f7282 100644
--- a/compiler/testData/loadJava/compiledKotlin/annotations/classes/ClassInClassObject.txt
+++ b/compiler/testData/loadJava/compiledKotlin/annotations/classes/ClassInClassObject.txt
@@ -1,6 +1,6 @@
 package test
 
-internal final annotation class Anno : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class Anno : kotlin.Annotation {
     /*primary*/ public constructor Anno()
 }
 
diff --git a/compiler/testData/loadJava/compiledKotlin/annotations/classes/ClassObject.txt b/compiler/testData/loadJava/compiledKotlin/annotations/classes/ClassObject.txt
index ea76204d029..2aa2a930bbe 100644
--- a/compiler/testData/loadJava/compiledKotlin/annotations/classes/ClassObject.txt
+++ b/compiler/testData/loadJava/compiledKotlin/annotations/classes/ClassObject.txt
@@ -1,6 +1,6 @@
 package test
 
-internal final annotation class Anno : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class Anno : kotlin.Annotation {
     /*primary*/ public constructor Anno()
 }
 
diff --git a/compiler/testData/loadJava/compiledKotlin/annotations/classes/DataClass.kt b/compiler/testData/loadJava/compiledKotlin/annotations/classes/DataClass.kt
new file mode 100644
index 00000000000..423299db385
--- /dev/null
+++ b/compiler/testData/loadJava/compiledKotlin/annotations/classes/DataClass.kt
@@ -0,0 +1,3 @@
+package test
+
+data class My(val x: Int)
diff --git a/compiler/testData/loadJava/compiledKotlin/annotations/classes/DataClass.txt b/compiler/testData/loadJava/compiledKotlin/annotations/classes/DataClass.txt
new file mode 100644
index 00000000000..89946f14107
--- /dev/null
+++ b/compiler/testData/loadJava/compiledKotlin/annotations/classes/DataClass.txt
@@ -0,0 +1,9 @@
+package test
+
+kotlin.data() internal final class My {
+    /*primary*/ public constructor My(/*0*/ x: kotlin.Int)
+    internal final val x: kotlin.Int
+        internal final fun <get-x>(): kotlin.Int
+    internal final /*synthesized*/ fun component1(): kotlin.Int
+    public final /*synthesized*/ fun copy(/*0*/ x: kotlin.Int = ...): test.My
+}
diff --git a/compiler/testData/loadJava/compiledKotlin/annotations/classes/DollarsInAnnotationName.txt b/compiler/testData/loadJava/compiledKotlin/annotations/classes/DollarsInAnnotationName.txt
index 92194a689e2..19eeea564aa 100644
--- a/compiler/testData/loadJava/compiledKotlin/annotations/classes/DollarsInAnnotationName.txt
+++ b/compiler/testData/loadJava/compiledKotlin/annotations/classes/DollarsInAnnotationName.txt
@@ -1,6 +1,6 @@
 package test
 
-internal final annotation class `$$$$$$` : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class `$$$$$$` : kotlin.Annotation {
     /*primary*/ public constructor `$$$$$$`()
 }
 
@@ -8,7 +8,7 @@ test.`$$$$$$`() internal final class A {
     /*primary*/ public constructor A()
 }
 
-internal final annotation class `Anno$tation` : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class `Anno$tation` : kotlin.Annotation {
     /*primary*/ public constructor `Anno$tation`()
 }
 
diff --git a/compiler/testData/loadJava/compiledKotlin/annotations/classes/EnumArgument.txt b/compiler/testData/loadJava/compiledKotlin/annotations/classes/EnumArgument.txt
index 3c830300993..10b33f0bdd9 100644
--- a/compiler/testData/loadJava/compiledKotlin/annotations/classes/EnumArgument.txt
+++ b/compiler/testData/loadJava/compiledKotlin/annotations/classes/EnumArgument.txt
@@ -1,6 +1,6 @@
 package test
 
-internal final annotation class Anno : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class Anno : kotlin.Annotation {
     /*primary*/ public constructor Anno(/*0*/ t: java.lang.annotation.ElementType)
     internal final val t: java.lang.annotation.ElementType
         internal final fun <get-t>(): java.lang.annotation.ElementType
diff --git a/compiler/testData/loadJava/compiledKotlin/annotations/classes/MultipleAnnotations.txt b/compiler/testData/loadJava/compiledKotlin/annotations/classes/MultipleAnnotations.txt
index 7fc605e1161..35b2e56e329 100644
--- a/compiler/testData/loadJava/compiledKotlin/annotations/classes/MultipleAnnotations.txt
+++ b/compiler/testData/loadJava/compiledKotlin/annotations/classes/MultipleAnnotations.txt
@@ -1,14 +1,14 @@
 package test
 
-internal final annotation class A1 : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class A1 : kotlin.Annotation {
     /*primary*/ public constructor A1()
 }
 
-internal final annotation class A2 : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class A2 : kotlin.Annotation {
     /*primary*/ public constructor A2()
 }
 
-internal final annotation class A3 : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class A3 : kotlin.Annotation {
     /*primary*/ public constructor A3()
 }
 
diff --git a/compiler/testData/loadJava/compiledKotlin/annotations/classes/NestedAnnotation.txt b/compiler/testData/loadJava/compiledKotlin/annotations/classes/NestedAnnotation.txt
index 45e5bdac392..f7a5a2a5a0b 100644
--- a/compiler/testData/loadJava/compiledKotlin/annotations/classes/NestedAnnotation.txt
+++ b/compiler/testData/loadJava/compiledKotlin/annotations/classes/NestedAnnotation.txt
@@ -3,7 +3,7 @@ package test
 internal final class A {
     /*primary*/ public constructor A()
 
-    internal final annotation class Anno : kotlin.Annotation {
+    kotlin.annotation.annotation() internal final class Anno : kotlin.Annotation {
         /*primary*/ public constructor Anno()
     }
 }
diff --git a/compiler/testData/loadJava/compiledKotlin/annotations/classes/NestedClass.txt b/compiler/testData/loadJava/compiledKotlin/annotations/classes/NestedClass.txt
index cf073499c7d..365077aef49 100644
--- a/compiler/testData/loadJava/compiledKotlin/annotations/classes/NestedClass.txt
+++ b/compiler/testData/loadJava/compiledKotlin/annotations/classes/NestedClass.txt
@@ -1,6 +1,6 @@
 package test
 
-internal final annotation class Anno : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class Anno : kotlin.Annotation {
     /*primary*/ public constructor Anno()
 }
 
diff --git a/compiler/testData/loadJava/compiledKotlin/annotations/classes/Retention.kt b/compiler/testData/loadJava/compiledKotlin/annotations/classes/Retention.kt
index 6f1ded2bbd0..bd9b66be01f 100644
--- a/compiler/testData/loadJava/compiledKotlin/annotations/classes/Retention.kt
+++ b/compiler/testData/loadJava/compiledKotlin/annotations/classes/Retention.kt
@@ -2,6 +2,4 @@
 //SKIP_IN_RUNTIME_TEST
 package test
 
-import java.lang.annotation.*
-
-Retention(RetentionPolicy.RUNTIME) annotation class Anno
+annotation(retention = AnnotationRetention.RUNTIME) class Anno
diff --git a/compiler/testData/loadJava/compiledKotlin/annotations/classes/Retention.txt b/compiler/testData/loadJava/compiledKotlin/annotations/classes/Retention.txt
index 6ff485396f2..8159335fcc1 100644
--- a/compiler/testData/loadJava/compiledKotlin/annotations/classes/Retention.txt
+++ b/compiler/testData/loadJava/compiledKotlin/annotations/classes/Retention.txt
@@ -1,5 +1,5 @@
 package test
 
-java.lang.annotation.Retention(value = RetentionPolicy.RUNTIME) internal final annotation class Anno : kotlin.Annotation {
+kotlin.annotation.annotation(retention = AnnotationRetention.RUNTIME) internal final class Anno : kotlin.Annotation {
     /*primary*/ public constructor Anno()
 }
diff --git a/compiler/testData/loadJava/compiledKotlin/annotations/classes/Simple.txt b/compiler/testData/loadJava/compiledKotlin/annotations/classes/Simple.txt
index 5172f44f966..2c2ed8919e3 100644
--- a/compiler/testData/loadJava/compiledKotlin/annotations/classes/Simple.txt
+++ b/compiler/testData/loadJava/compiledKotlin/annotations/classes/Simple.txt
@@ -1,6 +1,6 @@
 package test
 
-internal final annotation class Anno : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class Anno : kotlin.Annotation {
     /*primary*/ public constructor Anno()
 }
 
diff --git a/compiler/testData/loadJava/compiledKotlin/annotations/classes/WithArgument.txt b/compiler/testData/loadJava/compiledKotlin/annotations/classes/WithArgument.txt
index c0287d9def2..b58cb2c56bc 100644
--- a/compiler/testData/loadJava/compiledKotlin/annotations/classes/WithArgument.txt
+++ b/compiler/testData/loadJava/compiledKotlin/annotations/classes/WithArgument.txt
@@ -1,18 +1,18 @@
 package test
 
-internal final annotation class BooleanAnno : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class BooleanAnno : kotlin.Annotation {
     /*primary*/ public constructor BooleanAnno(/*0*/ value: kotlin.Boolean)
     internal final val value: kotlin.Boolean
         internal final fun <get-value>(): kotlin.Boolean
 }
 
-internal final annotation class ByteAnno : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class ByteAnno : kotlin.Annotation {
     /*primary*/ public constructor ByteAnno(/*0*/ value: kotlin.Byte)
     internal final val value: kotlin.Byte
         internal final fun <get-value>(): kotlin.Byte
 }
 
-internal final annotation class CharAnno : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class CharAnno : kotlin.Annotation {
     /*primary*/ public constructor CharAnno(/*0*/ value: kotlin.Char)
     internal final val value: kotlin.Char
         internal final fun <get-value>(): kotlin.Char
@@ -22,31 +22,31 @@ test.IntAnno(value = 42) test.ShortAnno(value = 42.toShort()) test.ByteAnno(valu
     /*primary*/ public constructor Class()
 }
 
-internal final annotation class DoubleAnno : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class DoubleAnno : kotlin.Annotation {
     /*primary*/ public constructor DoubleAnno(/*0*/ value: kotlin.Double)
     internal final val value: kotlin.Double
         internal final fun <get-value>(): kotlin.Double
 }
 
-internal final annotation class FloatAnno : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class FloatAnno : kotlin.Annotation {
     /*primary*/ public constructor FloatAnno(/*0*/ value: kotlin.Float)
     internal final val value: kotlin.Float
         internal final fun <get-value>(): kotlin.Float
 }
 
-internal final annotation class IntAnno : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class IntAnno : kotlin.Annotation {
     /*primary*/ public constructor IntAnno(/*0*/ value: kotlin.Int)
     internal final val value: kotlin.Int
         internal final fun <get-value>(): kotlin.Int
 }
 
-internal final annotation class LongAnno : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class LongAnno : kotlin.Annotation {
     /*primary*/ public constructor LongAnno(/*0*/ value: kotlin.Long)
     internal final val value: kotlin.Long
         internal final fun <get-value>(): kotlin.Long
 }
 
-internal final annotation class ShortAnno : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class ShortAnno : kotlin.Annotation {
     /*primary*/ public constructor ShortAnno(/*0*/ value: kotlin.Short)
     internal final val value: kotlin.Short
         internal final fun <get-value>(): kotlin.Short
diff --git a/compiler/testData/loadJava/compiledKotlin/annotations/classes/WithMultipleArguments.txt b/compiler/testData/loadJava/compiledKotlin/annotations/classes/WithMultipleArguments.txt
index 8c56ddfb41d..c9810d4bc12 100644
--- a/compiler/testData/loadJava/compiledKotlin/annotations/classes/WithMultipleArguments.txt
+++ b/compiler/testData/loadJava/compiledKotlin/annotations/classes/WithMultipleArguments.txt
@@ -1,6 +1,6 @@
 package test
 
-internal final annotation class Anno : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class Anno : kotlin.Annotation {
     /*primary*/ public constructor Anno(/*0*/ int: kotlin.Int, /*1*/ string: kotlin.String, /*2*/ double: kotlin.Double)
     internal final val double: kotlin.Double
         internal final fun <get-double>(): kotlin.Double
diff --git a/compiler/testData/loadJava/compiledKotlin/annotations/packageMembers/DelegatedProperty.txt b/compiler/testData/loadJava/compiledKotlin/annotations/packageMembers/DelegatedProperty.txt
index 33cfe343b75..41fb1aa192b 100644
--- a/compiler/testData/loadJava/compiledKotlin/annotations/packageMembers/DelegatedProperty.txt
+++ b/compiler/testData/loadJava/compiledKotlin/annotations/packageMembers/DelegatedProperty.txt
@@ -3,6 +3,6 @@ package test
 test.Anno() internal val x: kotlin.Int
     internal fun <get-x>(): kotlin.Int
 
-internal final annotation class Anno : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class Anno : kotlin.Annotation {
     /*primary*/ public constructor Anno()
 }
diff --git a/compiler/testData/loadJava/compiledKotlin/annotations/packageMembers/EnumArgument.txt b/compiler/testData/loadJava/compiledKotlin/annotations/packageMembers/EnumArgument.txt
index 0aff1f871e6..9d851d40c4e 100644
--- a/compiler/testData/loadJava/compiledKotlin/annotations/packageMembers/EnumArgument.txt
+++ b/compiler/testData/loadJava/compiledKotlin/annotations/packageMembers/EnumArgument.txt
@@ -4,7 +4,7 @@ test.Anno(t = ElementType.FIELD) internal val bar: kotlin.Int = 42
     internal fun <get-bar>(): kotlin.Int
 test.Anno(t = ElementType.METHOD) internal fun foo(): kotlin.Unit
 
-internal final annotation class Anno : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class Anno : kotlin.Annotation {
     /*primary*/ public constructor Anno(/*0*/ t: java.lang.annotation.ElementType)
     internal final val t: java.lang.annotation.ElementType
         internal final fun <get-t>(): java.lang.annotation.ElementType
diff --git a/compiler/testData/loadJava/compiledKotlin/annotations/packageMembers/EnumArrayArgument.txt b/compiler/testData/loadJava/compiledKotlin/annotations/packageMembers/EnumArrayArgument.txt
index 9039fb35eda..a4eabd6ee5d 100644
--- a/compiler/testData/loadJava/compiledKotlin/annotations/packageMembers/EnumArrayArgument.txt
+++ b/compiler/testData/loadJava/compiledKotlin/annotations/packageMembers/EnumArrayArgument.txt
@@ -5,7 +5,7 @@ test.Anno(t = {ElementType.PACKAGE}) internal val bar: kotlin.Int = 42
 test.Anno(t = {}) internal fun baz(): kotlin.Unit
 test.Anno(t = {ElementType.METHOD, ElementType.FIELD}) internal fun foo(): kotlin.Unit
 
-internal final annotation class Anno : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class Anno : kotlin.Annotation {
     /*primary*/ public constructor Anno(/*0*/ vararg t: java.lang.annotation.ElementType /*kotlin.Array<out java.lang.annotation.ElementType>*/)
     internal final val t: kotlin.Array<out java.lang.annotation.ElementType>
         internal final fun <get-t>(): kotlin.Array<out java.lang.annotation.ElementType>
diff --git a/compiler/testData/loadJava/compiledKotlin/annotations/packageMembers/Function.txt b/compiler/testData/loadJava/compiledKotlin/annotations/packageMembers/Function.txt
index 4783daf41d6..5bb274c0472 100644
--- a/compiler/testData/loadJava/compiledKotlin/annotations/packageMembers/Function.txt
+++ b/compiler/testData/loadJava/compiledKotlin/annotations/packageMembers/Function.txt
@@ -2,6 +2,6 @@ package test
 
 test.Anno() internal fun function(): kotlin.Unit
 
-internal final annotation class Anno : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class Anno : kotlin.Annotation {
     /*primary*/ public constructor Anno()
 }
diff --git a/compiler/testData/loadJava/compiledKotlin/annotations/packageMembers/Getter.txt b/compiler/testData/loadJava/compiledKotlin/annotations/packageMembers/Getter.txt
index f39ae47fe92..b92b8539aac 100644
--- a/compiler/testData/loadJava/compiledKotlin/annotations/packageMembers/Getter.txt
+++ b/compiler/testData/loadJava/compiledKotlin/annotations/packageMembers/Getter.txt
@@ -3,6 +3,6 @@ package test
 internal val property: kotlin.Int
     test.Anno() internal fun <get-property>(): kotlin.Int
 
-internal final annotation class Anno : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class Anno : kotlin.Annotation {
     /*primary*/ public constructor Anno()
 }
diff --git a/compiler/testData/loadJava/compiledKotlin/annotations/packageMembers/PropertyField.txt b/compiler/testData/loadJava/compiledKotlin/annotations/packageMembers/PropertyField.txt
index 31c1b1fdf12..8f138279dfc 100644
--- a/compiler/testData/loadJava/compiledKotlin/annotations/packageMembers/PropertyField.txt
+++ b/compiler/testData/loadJava/compiledKotlin/annotations/packageMembers/PropertyField.txt
@@ -4,6 +4,6 @@ test.Anno() internal var property: kotlin.Int
     internal fun <get-property>(): kotlin.Int
     internal fun <set-property>(/*0*/ <set-?>: kotlin.Int): kotlin.Unit
 
-internal final annotation class Anno : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class Anno : kotlin.Annotation {
     /*primary*/ public constructor Anno()
 }
diff --git a/compiler/testData/loadJava/compiledKotlin/annotations/packageMembers/Setter.txt b/compiler/testData/loadJava/compiledKotlin/annotations/packageMembers/Setter.txt
index 22bb8faa2dd..84b2c392e1a 100644
--- a/compiler/testData/loadJava/compiledKotlin/annotations/packageMembers/Setter.txt
+++ b/compiler/testData/loadJava/compiledKotlin/annotations/packageMembers/Setter.txt
@@ -4,6 +4,6 @@ internal var property: kotlin.Int
     internal fun <get-property>(): kotlin.Int
     test.Anno() internal fun <set-property>(/*0*/ value: kotlin.Int): kotlin.Unit
 
-internal final annotation class Anno : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class Anno : kotlin.Annotation {
     /*primary*/ public constructor Anno()
 }
diff --git a/compiler/testData/loadJava/compiledKotlin/annotations/packageMembers/StringArrayArgument.txt b/compiler/testData/loadJava/compiledKotlin/annotations/packageMembers/StringArrayArgument.txt
index b0b4765b8bf..b5fd307a2f4 100644
--- a/compiler/testData/loadJava/compiledKotlin/annotations/packageMembers/StringArrayArgument.txt
+++ b/compiler/testData/loadJava/compiledKotlin/annotations/packageMembers/StringArrayArgument.txt
@@ -5,7 +5,7 @@ test.Anno(t = {"prosper"}) internal val bar: kotlin.Int = 42
 test.Anno(t = {}) internal fun baz(): kotlin.Unit
 test.Anno(t = {"live", "long"}) internal fun foo(): kotlin.Unit
 
-internal final annotation class Anno : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class Anno : kotlin.Annotation {
     /*primary*/ public constructor Anno(/*0*/ vararg t: kotlin.String /*kotlin.Array<out kotlin.String>*/)
     internal final val t: kotlin.Array<out kotlin.String>
         internal final fun <get-t>(): kotlin.Array<out kotlin.String>
diff --git a/compiler/testData/loadJava/compiledKotlin/annotations/parameters/Constructor.txt b/compiler/testData/loadJava/compiledKotlin/annotations/parameters/Constructor.txt
index be17a96e471..ab0e3a3c78c 100644
--- a/compiler/testData/loadJava/compiledKotlin/annotations/parameters/Constructor.txt
+++ b/compiler/testData/loadJava/compiledKotlin/annotations/parameters/Constructor.txt
@@ -1,10 +1,10 @@
 package test
 
-internal final annotation class A : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class A : kotlin.Annotation {
     /*primary*/ public constructor A()
 }
 
-internal final annotation class B : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class B : kotlin.Annotation {
     /*primary*/ public constructor B()
 }
 
diff --git a/compiler/testData/loadJava/compiledKotlin/annotations/parameters/EnumConstructor.txt b/compiler/testData/loadJava/compiledKotlin/annotations/parameters/EnumConstructor.txt
index 01a39ef6bb0..3f2bf6f2b1a 100644
--- a/compiler/testData/loadJava/compiledKotlin/annotations/parameters/EnumConstructor.txt
+++ b/compiler/testData/loadJava/compiledKotlin/annotations/parameters/EnumConstructor.txt
@@ -1,10 +1,10 @@
 package test
 
-internal final annotation class A : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class A : kotlin.Annotation {
     /*primary*/ public constructor A()
 }
 
-internal final annotation class B : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class B : kotlin.Annotation {
     /*primary*/ public constructor B()
 }
 
diff --git a/compiler/testData/loadJava/compiledKotlin/annotations/parameters/ExtensionFunction.txt b/compiler/testData/loadJava/compiledKotlin/annotations/parameters/ExtensionFunction.txt
index 7b1b075ce94..3e8eb8ed2d7 100644
--- a/compiler/testData/loadJava/compiledKotlin/annotations/parameters/ExtensionFunction.txt
+++ b/compiler/testData/loadJava/compiledKotlin/annotations/parameters/ExtensionFunction.txt
@@ -2,6 +2,6 @@ package test
 
 internal fun kotlin.Int.foo(/*0*/ test.A() x: kotlin.Int): kotlin.Unit
 
-internal final annotation class A : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class A : kotlin.Annotation {
     /*primary*/ public constructor A()
 }
diff --git a/compiler/testData/loadJava/compiledKotlin/annotations/parameters/ExtensionFunctionInClass.txt b/compiler/testData/loadJava/compiledKotlin/annotations/parameters/ExtensionFunctionInClass.txt
index 073b165297f..000278bdc48 100644
--- a/compiler/testData/loadJava/compiledKotlin/annotations/parameters/ExtensionFunctionInClass.txt
+++ b/compiler/testData/loadJava/compiledKotlin/annotations/parameters/ExtensionFunctionInClass.txt
@@ -1,6 +1,6 @@
 package test
 
-internal final annotation class Anno : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class Anno : kotlin.Annotation {
     /*primary*/ public constructor Anno()
 }
 
diff --git a/compiler/testData/loadJava/compiledKotlin/annotations/parameters/ExtensionPropertySetter.txt b/compiler/testData/loadJava/compiledKotlin/annotations/parameters/ExtensionPropertySetter.txt
index a071d5ecd84..b920161d443 100644
--- a/compiler/testData/loadJava/compiledKotlin/annotations/parameters/ExtensionPropertySetter.txt
+++ b/compiler/testData/loadJava/compiledKotlin/annotations/parameters/ExtensionPropertySetter.txt
@@ -1,6 +1,6 @@
 package test
 
-internal final annotation class A : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class A : kotlin.Annotation {
     /*primary*/ public constructor A()
 }
 
diff --git a/compiler/testData/loadJava/compiledKotlin/annotations/parameters/FunctionInClass.txt b/compiler/testData/loadJava/compiledKotlin/annotations/parameters/FunctionInClass.txt
index 6f983d509e5..6188cef5000 100644
--- a/compiler/testData/loadJava/compiledKotlin/annotations/parameters/FunctionInClass.txt
+++ b/compiler/testData/loadJava/compiledKotlin/annotations/parameters/FunctionInClass.txt
@@ -1,6 +1,6 @@
 package test
 
-internal final annotation class Anno : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class Anno : kotlin.Annotation {
     /*primary*/ public constructor Anno()
 }
 
diff --git a/compiler/testData/loadJava/compiledKotlin/annotations/parameters/FunctionInTrait.txt b/compiler/testData/loadJava/compiledKotlin/annotations/parameters/FunctionInTrait.txt
index 5c9f78e5745..35407d90748 100644
--- a/compiler/testData/loadJava/compiledKotlin/annotations/parameters/FunctionInTrait.txt
+++ b/compiler/testData/loadJava/compiledKotlin/annotations/parameters/FunctionInTrait.txt
@@ -1,6 +1,6 @@
 package test
 
-internal final annotation class Anno : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class Anno : kotlin.Annotation {
     /*primary*/ public constructor Anno()
 }
 
diff --git a/compiler/testData/loadJava/compiledKotlin/annotations/parameters/InnerClassConstructor.txt b/compiler/testData/loadJava/compiledKotlin/annotations/parameters/InnerClassConstructor.txt
index d1546823bc5..41fe04dd9dc 100644
--- a/compiler/testData/loadJava/compiledKotlin/annotations/parameters/InnerClassConstructor.txt
+++ b/compiler/testData/loadJava/compiledKotlin/annotations/parameters/InnerClassConstructor.txt
@@ -1,6 +1,6 @@
 package test
 
-internal final annotation class A : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class A : kotlin.Annotation {
     /*primary*/ public constructor A(/*0*/ s: kotlin.String)
     internal final val s: kotlin.String
         internal final fun <get-s>(): kotlin.String
diff --git a/compiler/testData/loadJava/compiledKotlin/annotations/parameters/ManyAnnotations.txt b/compiler/testData/loadJava/compiledKotlin/annotations/parameters/ManyAnnotations.txt
index fecebf555ba..abb4292a20c 100644
--- a/compiler/testData/loadJava/compiledKotlin/annotations/parameters/ManyAnnotations.txt
+++ b/compiler/testData/loadJava/compiledKotlin/annotations/parameters/ManyAnnotations.txt
@@ -3,18 +3,18 @@ package test
 internal fun bar(/*0*/ test.A() test.B() test.C() test.D() x: kotlin.Int): kotlin.Unit
 internal fun foo(/*0*/ test.A() test.B() x: kotlin.Int, /*1*/ test.A() test.C() y: kotlin.Double, /*2*/ test.B() test.C() test.D() z: kotlin.String): kotlin.Unit
 
-internal final annotation class A : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class A : kotlin.Annotation {
     /*primary*/ public constructor A()
 }
 
-internal final annotation class B : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class B : kotlin.Annotation {
     /*primary*/ public constructor B()
 }
 
-internal final annotation class C : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class C : kotlin.Annotation {
     /*primary*/ public constructor C()
 }
 
-internal final annotation class D : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class D : kotlin.Annotation {
     /*primary*/ public constructor D()
 }
diff --git a/compiler/testData/loadJava/compiledKotlin/annotations/parameters/PropertySetterInClass.txt b/compiler/testData/loadJava/compiledKotlin/annotations/parameters/PropertySetterInClass.txt
index 7cf6937db80..064d3f53fe4 100644
--- a/compiler/testData/loadJava/compiledKotlin/annotations/parameters/PropertySetterInClass.txt
+++ b/compiler/testData/loadJava/compiledKotlin/annotations/parameters/PropertySetterInClass.txt
@@ -1,6 +1,6 @@
 package test
 
-internal final annotation class A : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class A : kotlin.Annotation {
     /*primary*/ public constructor A()
 }
 
diff --git a/compiler/testData/loadJava/compiledKotlin/annotations/parameters/TopLevelFunction.txt b/compiler/testData/loadJava/compiledKotlin/annotations/parameters/TopLevelFunction.txt
index eda01e83b37..8bc9d7e5a07 100644
--- a/compiler/testData/loadJava/compiledKotlin/annotations/parameters/TopLevelFunction.txt
+++ b/compiler/testData/loadJava/compiledKotlin/annotations/parameters/TopLevelFunction.txt
@@ -2,6 +2,6 @@ package test
 
 internal fun foo(/*0*/ test.Anno() x: kotlin.Int): kotlin.Unit
 
-internal final annotation class Anno : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class Anno : kotlin.Annotation {
     /*primary*/ public constructor Anno()
 }
diff --git a/compiler/testData/loadJava/compiledKotlin/annotations/parameters/TopLevelPropertySetter.txt b/compiler/testData/loadJava/compiledKotlin/annotations/parameters/TopLevelPropertySetter.txt
index 0ec4bce6951..9bf02b3fb29 100644
--- a/compiler/testData/loadJava/compiledKotlin/annotations/parameters/TopLevelPropertySetter.txt
+++ b/compiler/testData/loadJava/compiledKotlin/annotations/parameters/TopLevelPropertySetter.txt
@@ -4,10 +4,10 @@ internal var foo: kotlin.Int
     internal fun <get-foo>(): kotlin.Int
     internal fun <set-foo>(/*0*/ test.A() test.B() value: kotlin.Int): kotlin.Unit
 
-internal final annotation class A : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class A : kotlin.Annotation {
     /*primary*/ public constructor A()
 }
 
-internal final annotation class B : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class B : kotlin.Annotation {
     /*primary*/ public constructor B()
 }
diff --git a/compiler/testData/loadJava/compiledKotlin/annotations/propertiesWithoutBackingFields/Class.txt b/compiler/testData/loadJava/compiledKotlin/annotations/propertiesWithoutBackingFields/Class.txt
index af76793d7b7..45cc5c02a33 100644
--- a/compiler/testData/loadJava/compiledKotlin/annotations/propertiesWithoutBackingFields/Class.txt
+++ b/compiler/testData/loadJava/compiledKotlin/annotations/propertiesWithoutBackingFields/Class.txt
@@ -1,6 +1,6 @@
 package test
 
-internal final annotation class Anno : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class Anno : kotlin.Annotation {
     /*primary*/ public constructor Anno()
 }
 
diff --git a/compiler/testData/loadJava/compiledKotlin/annotations/propertiesWithoutBackingFields/ClassObject.txt b/compiler/testData/loadJava/compiledKotlin/annotations/propertiesWithoutBackingFields/ClassObject.txt
index 5b093257651..7d80dc02fd7 100644
--- a/compiler/testData/loadJava/compiledKotlin/annotations/propertiesWithoutBackingFields/ClassObject.txt
+++ b/compiler/testData/loadJava/compiledKotlin/annotations/propertiesWithoutBackingFields/ClassObject.txt
@@ -1,6 +1,6 @@
 package test
 
-internal final annotation class Anno : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class Anno : kotlin.Annotation {
     /*primary*/ public constructor Anno()
 }
 
diff --git a/compiler/testData/loadJava/compiledKotlin/annotations/propertiesWithoutBackingFields/ExtensionsWithSameNameClass.txt b/compiler/testData/loadJava/compiledKotlin/annotations/propertiesWithoutBackingFields/ExtensionsWithSameNameClass.txt
index 198c49875e9..41b9bc19b9c 100644
--- a/compiler/testData/loadJava/compiledKotlin/annotations/propertiesWithoutBackingFields/ExtensionsWithSameNameClass.txt
+++ b/compiler/testData/loadJava/compiledKotlin/annotations/propertiesWithoutBackingFields/ExtensionsWithSameNameClass.txt
@@ -10,14 +10,14 @@ internal final class Class {
         internal final fun kotlin.String.<get-extension>(): kotlin.String
 }
 
-internal final annotation class DoubleAnno : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class DoubleAnno : kotlin.Annotation {
     /*primary*/ public constructor DoubleAnno()
 }
 
-internal final annotation class IntAnno : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class IntAnno : kotlin.Annotation {
     /*primary*/ public constructor IntAnno()
 }
 
-internal final annotation class StringAnno : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class StringAnno : kotlin.Annotation {
     /*primary*/ public constructor StringAnno()
 }
diff --git a/compiler/testData/loadJava/compiledKotlin/annotations/propertiesWithoutBackingFields/ExtensionsWithSameNamePackage.txt b/compiler/testData/loadJava/compiledKotlin/annotations/propertiesWithoutBackingFields/ExtensionsWithSameNamePackage.txt
index 1d022c66ed8..3f24c08d080 100644
--- a/compiler/testData/loadJava/compiledKotlin/annotations/propertiesWithoutBackingFields/ExtensionsWithSameNamePackage.txt
+++ b/compiler/testData/loadJava/compiledKotlin/annotations/propertiesWithoutBackingFields/ExtensionsWithSameNamePackage.txt
@@ -7,14 +7,14 @@ test.IntAnno() internal val kotlin.Int.extension: kotlin.Int
 test.StringAnno() internal val kotlin.String.extension: kotlin.String
     internal fun kotlin.String.<get-extension>(): kotlin.String
 
-internal final annotation class DoubleAnno : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class DoubleAnno : kotlin.Annotation {
     /*primary*/ public constructor DoubleAnno()
 }
 
-internal final annotation class IntAnno : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class IntAnno : kotlin.Annotation {
     /*primary*/ public constructor IntAnno()
 }
 
-internal final annotation class StringAnno : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class StringAnno : kotlin.Annotation {
     /*primary*/ public constructor StringAnno()
 }
diff --git a/compiler/testData/loadJava/compiledKotlin/annotations/propertiesWithoutBackingFields/NestedTrait.txt b/compiler/testData/loadJava/compiledKotlin/annotations/propertiesWithoutBackingFields/NestedTrait.txt
index c5983f0ac0f..370dcc1b041 100644
--- a/compiler/testData/loadJava/compiledKotlin/annotations/propertiesWithoutBackingFields/NestedTrait.txt
+++ b/compiler/testData/loadJava/compiledKotlin/annotations/propertiesWithoutBackingFields/NestedTrait.txt
@@ -1,6 +1,6 @@
 package test
 
-internal final annotation class Anno : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class Anno : kotlin.Annotation {
     /*primary*/ public constructor Anno()
 }
 
diff --git a/compiler/testData/loadJava/compiledKotlin/annotations/propertiesWithoutBackingFields/TopLevel.txt b/compiler/testData/loadJava/compiledKotlin/annotations/propertiesWithoutBackingFields/TopLevel.txt
index 0da708e5673..a1f6fc2342d 100644
--- a/compiler/testData/loadJava/compiledKotlin/annotations/propertiesWithoutBackingFields/TopLevel.txt
+++ b/compiler/testData/loadJava/compiledKotlin/annotations/propertiesWithoutBackingFields/TopLevel.txt
@@ -3,6 +3,6 @@ package test
 test.Anno() internal val property: kotlin.Int
     internal fun <get-property>(): kotlin.Int
 
-internal final annotation class Anno : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class Anno : kotlin.Annotation {
     /*primary*/ public constructor Anno()
 }
diff --git a/compiler/testData/loadJava/compiledKotlin/annotations/propertiesWithoutBackingFields/Trait.txt b/compiler/testData/loadJava/compiledKotlin/annotations/propertiesWithoutBackingFields/Trait.txt
index d4e5d39b108..197bcc1db98 100644
--- a/compiler/testData/loadJava/compiledKotlin/annotations/propertiesWithoutBackingFields/Trait.txt
+++ b/compiler/testData/loadJava/compiledKotlin/annotations/propertiesWithoutBackingFields/Trait.txt
@@ -1,6 +1,6 @@
 package test
 
-internal final annotation class Anno : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class Anno : kotlin.Annotation {
     /*primary*/ public constructor Anno()
 }
 
diff --git a/compiler/testData/loadJava/compiledKotlin/annotations/propertiesWithoutBackingFields/TraitClassObject.txt b/compiler/testData/loadJava/compiledKotlin/annotations/propertiesWithoutBackingFields/TraitClassObject.txt
index 02901516852..813266df8f0 100644
--- a/compiler/testData/loadJava/compiledKotlin/annotations/propertiesWithoutBackingFields/TraitClassObject.txt
+++ b/compiler/testData/loadJava/compiledKotlin/annotations/propertiesWithoutBackingFields/TraitClassObject.txt
@@ -1,6 +1,6 @@
 package test
 
-internal final annotation class Anno : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class Anno : kotlin.Annotation {
     /*primary*/ public constructor Anno()
 }
 
diff --git a/compiler/testData/loadJava/compiledKotlin/annotations/types/ReceiverParameter.txt b/compiler/testData/loadJava/compiledKotlin/annotations/types/ReceiverParameter.txt
index 821362e88fa..49b0ae3d3da 100644
--- a/compiler/testData/loadJava/compiledKotlin/annotations/types/ReceiverParameter.txt
+++ b/compiler/testData/loadJava/compiledKotlin/annotations/types/ReceiverParameter.txt
@@ -2,6 +2,6 @@ package test
 
 internal fun @[test.A()] kotlin.String.foo(): kotlin.Unit
 
-internal final annotation class A : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class A : kotlin.Annotation {
     /*primary*/ public constructor A()
 }
diff --git a/compiler/testData/loadJava/compiledKotlin/annotations/types/SimpleTypeAnnotation.kt b/compiler/testData/loadJava/compiledKotlin/annotations/types/SimpleTypeAnnotation.kt
index 81fe623b989..2e545ac8769 100644
--- a/compiler/testData/loadJava/compiledKotlin/annotations/types/SimpleTypeAnnotation.kt
+++ b/compiler/testData/loadJava/compiledKotlin/annotations/types/SimpleTypeAnnotation.kt
@@ -1,5 +1,8 @@
+// ALLOW_AST_ACCESS
+
 package test
 
+target(AnnotationTarget.TYPE)
 annotation class A
 
 class SimpleTypeAnnotation {
diff --git a/compiler/testData/loadJava/compiledKotlin/annotations/types/SimpleTypeAnnotation.txt b/compiler/testData/loadJava/compiledKotlin/annotations/types/SimpleTypeAnnotation.txt
index 2e19340c417..e28ef2829f2 100644
--- a/compiler/testData/loadJava/compiledKotlin/annotations/types/SimpleTypeAnnotation.txt
+++ b/compiler/testData/loadJava/compiledKotlin/annotations/types/SimpleTypeAnnotation.txt
@@ -1,6 +1,6 @@
 package test
 
-internal final annotation class A : kotlin.Annotation {
+kotlin.annotation.target(allowedTargets = {AnnotationTarget.TYPE}) kotlin.annotation.annotation() internal final class A : kotlin.Annotation {
     /*primary*/ public constructor A()
 }
 
diff --git a/compiler/testData/loadJava/compiledKotlin/annotations/types/SupertypesAndBounds.txt b/compiler/testData/loadJava/compiledKotlin/annotations/types/SupertypesAndBounds.txt
index c19b9bbc9fc..7650fdaabbe 100644
--- a/compiler/testData/loadJava/compiledKotlin/annotations/types/SupertypesAndBounds.txt
+++ b/compiler/testData/loadJava/compiledKotlin/annotations/types/SupertypesAndBounds.txt
@@ -1,6 +1,6 @@
 package test
 
-internal final annotation class A : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class A : kotlin.Annotation {
     /*primary*/ public constructor A()
 }
 
diff --git a/compiler/testData/loadJava/compiledKotlin/annotations/types/TypeAnnotationWithArguments.kt b/compiler/testData/loadJava/compiledKotlin/annotations/types/TypeAnnotationWithArguments.kt
index 9e09e32ac43..40278100b5a 100644
--- a/compiler/testData/loadJava/compiledKotlin/annotations/types/TypeAnnotationWithArguments.kt
+++ b/compiler/testData/loadJava/compiledKotlin/annotations/types/TypeAnnotationWithArguments.kt
@@ -2,6 +2,7 @@
 
 package test
 
+target(AnnotationTarget.TYPE)
 annotation class Ann(val x: String, val y: Double)
 
 class TypeAnnotationWithArguments {
diff --git a/compiler/testData/loadJava/compiledKotlin/annotations/types/TypeAnnotationWithArguments.txt b/compiler/testData/loadJava/compiledKotlin/annotations/types/TypeAnnotationWithArguments.txt
index 5e6e5a4658c..f7a5831e0ac 100644
--- a/compiler/testData/loadJava/compiledKotlin/annotations/types/TypeAnnotationWithArguments.txt
+++ b/compiler/testData/loadJava/compiledKotlin/annotations/types/TypeAnnotationWithArguments.txt
@@ -1,6 +1,6 @@
 package test
 
-internal final annotation class Ann : kotlin.Annotation {
+kotlin.annotation.target(allowedTargets = {AnnotationTarget.TYPE}) kotlin.annotation.annotation() internal final class Ann : kotlin.Annotation {
     /*primary*/ public constructor Ann(/*0*/ x: kotlin.String, /*1*/ y: kotlin.Double)
     internal final val x: kotlin.String
         internal final fun <get-x>(): kotlin.String
diff --git a/compiler/testData/loadJava/compiledKotlin/fromLoadJava/ClassDoesNotOverrideMethod.txt b/compiler/testData/loadJava/compiledKotlin/fromLoadJava/ClassDoesNotOverrideMethod.txt
index 436e31f8308..6def49899eb 100644
--- a/compiler/testData/loadJava/compiledKotlin/fromLoadJava/ClassDoesNotOverrideMethod.txt
+++ b/compiler/testData/loadJava/compiledKotlin/fromLoadJava/ClassDoesNotOverrideMethod.txt
@@ -6,7 +6,7 @@ public abstract class ClassDoesNotOverrideMethod : java.util.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 clone(): kotlin.Any!
+    public open override /*1*/ /*fake_override*/ fun clone(): kotlin.Any
     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") public open override /*1*/ /*fake_override*/ fun getDate(): kotlin.Int
diff --git a/compiler/testData/loadJava/compiledKotlin/fromLoadJava/classObjectAnnotation.txt b/compiler/testData/loadJava/compiledKotlin/fromLoadJava/classObjectAnnotation.txt
index a9f8f7f5278..27141a06545 100644
--- a/compiler/testData/loadJava/compiledKotlin/fromLoadJava/classObjectAnnotation.txt
+++ b/compiler/testData/loadJava/compiledKotlin/fromLoadJava/classObjectAnnotation.txt
@@ -6,7 +6,7 @@ internal final class Some {
     test.Some.Companion.TestAnnotation() public companion object Companion {
         /*primary*/ private constructor Companion()
 
-        internal final annotation class TestAnnotation : kotlin.Annotation {
+        kotlin.annotation.annotation() internal final class TestAnnotation : kotlin.Annotation {
             /*primary*/ public constructor TestAnnotation()
         }
     }
diff --git a/compiler/testData/loadJava/compiledKotlin/fromLoadJava/modality/ModalityOfFakeOverrides.txt b/compiler/testData/loadJava/compiledKotlin/fromLoadJava/modality/ModalityOfFakeOverrides.txt
index 909ff1c844a..18cd766a66d 100644
--- a/compiler/testData/loadJava/compiledKotlin/fromLoadJava/modality/ModalityOfFakeOverrides.txt
+++ b/compiler/testData/loadJava/compiledKotlin/fromLoadJava/modality/ModalityOfFakeOverrides.txt
@@ -6,17 +6,17 @@ public open class ModalityOfFakeOverrides : java.util.AbstractList<kotlin.String
     public open override /*1*/ /*fake_override*/ fun add(/*0*/ index: kotlin.Int, /*1*/ element: kotlin.String!): kotlin.Unit
     public open override /*1*/ /*fake_override*/ fun add(/*0*/ e: kotlin.String!): kotlin.Boolean
     public open override /*1*/ /*fake_override*/ fun addAll(/*0*/ c: kotlin.Collection<kotlin.String!>): kotlin.Boolean
-    public open override /*1*/ /*fake_override*/ fun addAll(/*0*/ index: kotlin.Int, /*1*/ c: (kotlin.MutableCollection<out kotlin.String!>..kotlin.Collection<kotlin.String!>?)): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun addAll(/*0*/ index: kotlin.Int, /*1*/ c: kotlin.Collection<kotlin.String!>): kotlin.Boolean
     public open override /*1*/ /*fake_override*/ fun clear(): kotlin.Unit
     public open override /*1*/ /*fake_override*/ fun contains(/*0*/ o: kotlin.Any?): kotlin.Boolean
     public open override /*1*/ /*fake_override*/ fun containsAll(/*0*/ c: kotlin.Collection<kotlin.Any?>): kotlin.Boolean
     public open override /*1*/ fun get(/*0*/ index: kotlin.Int): kotlin.String
-    public open override /*1*/ /*fake_override*/ fun indexOf(/*0*/ o: kotlin.Any!): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun indexOf(/*0*/ o: kotlin.Any?): kotlin.Int
     public open override /*1*/ /*fake_override*/ fun isEmpty(): kotlin.Boolean
-    public open override /*1*/ /*fake_override*/ fun iterator(): kotlin.(Mutable)Iterator<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.(Mutable)ListIterator<kotlin.String!>!
-    public open override /*1*/ /*fake_override*/ fun listIterator(/*0*/ index: kotlin.Int): kotlin.(Mutable)ListIterator<kotlin.String!>!
+    public open override /*1*/ /*fake_override*/ fun iterator(): kotlin.MutableIterator<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
@@ -26,7 +26,7 @@ public open class ModalityOfFakeOverrides : java.util.AbstractList<kotlin.String
     public open override /*1*/ /*fake_override*/ fun retainAll(/*0*/ c: kotlin.Collection<kotlin.Any?>): kotlin.Boolean
     public open override /*1*/ /*fake_override*/ fun set(/*0*/ index: kotlin.Int, /*1*/ element: kotlin.String!): kotlin.String!
     public open override /*1*/ fun size(): kotlin.Int
-    public open override /*1*/ /*fake_override*/ fun subList(/*0*/ fromIndex: kotlin.Int, /*1*/ toIndex: kotlin.Int): kotlin.(Mutable)List<kotlin.String!>!
+    public open override /*1*/ /*fake_override*/ fun subList(/*0*/ fromIndex: kotlin.Int, /*1*/ toIndex: kotlin.Int): kotlin.MutableList<kotlin.String!>
     public open override /*1*/ /*fake_override*/ fun toArray(): kotlin.Array<(out) kotlin.Any!>!
     public open override /*1*/ /*fake_override*/ fun </*0*/ T> toArray(/*0*/ p0: kotlin.Array<(out) T!>!): kotlin.Array<(out) T!>!
 }
diff --git a/compiler/testData/loadJava/compiledKotlin/platformTypes/notnullTypeArgument.txt b/compiler/testData/loadJava/compiledKotlin/platformTypes/notnullTypeArgument.txt
index f141b72352f..7b862069cee 100644
--- a/compiler/testData/loadJava/compiledKotlin/platformTypes/notnullTypeArgument.txt
+++ b/compiler/testData/loadJava/compiledKotlin/platformTypes/notnullTypeArgument.txt
@@ -5,39 +5,39 @@ internal final class C : java.util.ArrayList<kotlin.String> {
     invisible_fake final override /*1*/ /*fake_override*/ var elementData: kotlin.Array<(out) kotlin.Any!>!
     protected/*protected and package*/ final override /*1*/ /*fake_override*/ var modCount: kotlin.Int
     invisible_fake final override /*1*/ /*fake_override*/ var size: kotlin.Int
-    public open override /*1*/ /*fake_override*/ fun add(/*0*/ index: kotlin.Int, /*1*/ element: kotlin.String!): kotlin.Unit
-    public open override /*1*/ /*fake_override*/ fun add(/*0*/ e: kotlin.String!): kotlin.Boolean
-    public open override /*1*/ /*fake_override*/ fun addAll(/*0*/ c: (kotlin.MutableCollection<out kotlin.String!>..kotlin.Collection<kotlin.String!>?)): kotlin.Boolean
-    public open override /*1*/ /*fake_override*/ fun addAll(/*0*/ index: kotlin.Int, /*1*/ c: (kotlin.MutableCollection<out kotlin.String!>..kotlin.Collection<kotlin.String!>?)): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun add(/*0*/ index: kotlin.Int, /*1*/ element: kotlin.String): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun add(/*0*/ e: kotlin.String): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun addAll(/*0*/ c: kotlin.Collection<kotlin.String>): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun addAll(/*0*/ index: kotlin.Int, /*1*/ c: kotlin.Collection<kotlin.String>): kotlin.Boolean
     invisible_fake open override /*1*/ /*fake_override*/ fun batchRemove(/*0*/ p0: kotlin.(Mutable)Collection<*>!, /*1*/ p1: kotlin.Boolean): kotlin.Boolean
     public open override /*1*/ /*fake_override*/ fun clear(): kotlin.Unit
-    public open override /*1*/ /*fake_override*/ fun clone(): kotlin.Any!
-    public open override /*1*/ /*fake_override*/ fun contains(/*0*/ o: kotlin.Any!): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun clone(): kotlin.Any
+    public open override /*1*/ /*fake_override*/ fun contains(/*0*/ o: kotlin.Any?): kotlin.Boolean
     public open override /*1*/ /*fake_override*/ fun containsAll(/*0*/ c: kotlin.Collection<kotlin.Any?>): kotlin.Boolean
     invisible_fake open override /*1*/ /*fake_override*/ fun elementData(/*0*/ p0: kotlin.Int): kotlin.String!
     public open override /*1*/ /*fake_override*/ fun ensureCapacity(/*0*/ p0: kotlin.Int): kotlin.Unit
     invisible_fake open override /*1*/ /*fake_override*/ fun ensureCapacityInternal(/*0*/ p0: kotlin.Int): kotlin.Unit
     invisible_fake open override /*1*/ /*fake_override*/ fun fastRemove(/*0*/ p0: kotlin.Int): kotlin.Unit
-    public open override /*1*/ /*fake_override*/ fun get(/*0*/ index: kotlin.Int): kotlin.String!
+    public open override /*1*/ /*fake_override*/ fun get(/*0*/ index: kotlin.Int): kotlin.String
     invisible_fake open override /*1*/ /*fake_override*/ fun grow(/*0*/ p0: kotlin.Int): kotlin.Unit
-    public open override /*1*/ /*fake_override*/ fun indexOf(/*0*/ o: kotlin.Any!): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun indexOf(/*0*/ o: kotlin.Any?): kotlin.Int
     public open override /*1*/ /*fake_override*/ fun isEmpty(): kotlin.Boolean
-    public open override /*1*/ /*fake_override*/ fun iterator(): kotlin.(Mutable)Iterator<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.(Mutable)ListIterator<kotlin.String!>!
-    public open override /*1*/ /*fake_override*/ fun listIterator(/*0*/ index: kotlin.Int): kotlin.(Mutable)ListIterator<kotlin.String!>!
+    public open override /*1*/ /*fake_override*/ fun iterator(): kotlin.MutableIterator<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 rangeCheck(/*0*/ p0: kotlin.Int): kotlin.Unit
     invisible_fake open override /*1*/ /*fake_override*/ fun rangeCheckForAdd(/*0*/ p0: kotlin.Int): kotlin.Unit
     invisible_fake open override /*1*/ /*fake_override*/ fun readObject(/*0*/ p0: java.io.ObjectInputStream!): 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.(Mutable)Collection<*>!): kotlin.Boolean
+    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.Boolean
     protected/*protected and package*/ open override /*1*/ /*fake_override*/ fun removeRange(/*0*/ p0: kotlin.Int, /*1*/ p1: kotlin.Int): kotlin.Unit
-    public open override /*1*/ /*fake_override*/ fun retainAll(/*0*/ c: kotlin.(Mutable)Collection<*>!): kotlin.Boolean
-    public open override /*1*/ /*fake_override*/ fun set(/*0*/ index: kotlin.Int, /*1*/ element: kotlin.String!): kotlin.String!
+    public open override /*1*/ /*fake_override*/ fun retainAll(/*0*/ c: kotlin.Collection<*>): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun set(/*0*/ index: kotlin.Int, /*1*/ element: kotlin.String): kotlin.String
     public open override /*1*/ /*fake_override*/ fun size(): kotlin.Int
-    public open override /*1*/ /*fake_override*/ fun subList(/*0*/ fromIndex: kotlin.Int, /*1*/ toIndex: kotlin.Int): kotlin.(Mutable)List<kotlin.String!>!
+    public open override /*1*/ /*fake_override*/ fun subList(/*0*/ fromIndex: kotlin.Int, /*1*/ toIndex: kotlin.Int): kotlin.MutableList<kotlin.String>
     public open override /*1*/ /*fake_override*/ fun toArray(): kotlin.Array<(out) kotlin.Any!>!
     public open override /*1*/ /*fake_override*/ fun </*0*/ T> toArray(/*0*/ p0: kotlin.Array<(out) T!>!): kotlin.Array<(out) T!>!
     public open override /*1*/ /*fake_override*/ fun trimToSize(): kotlin.Unit
diff --git a/compiler/testData/loadJava/compiledKotlin/platformTypes/nullableTypeArgument.txt b/compiler/testData/loadJava/compiledKotlin/platformTypes/nullableTypeArgument.txt
index 74a2a4542fa..d2b6a1ba643 100644
--- a/compiler/testData/loadJava/compiledKotlin/platformTypes/nullableTypeArgument.txt
+++ b/compiler/testData/loadJava/compiledKotlin/platformTypes/nullableTypeArgument.txt
@@ -7,12 +7,12 @@ internal final class C : java.util.ArrayList<kotlin.String?> {
     invisible_fake final override /*1*/ /*fake_override*/ var size: kotlin.Int
     public open override /*1*/ /*fake_override*/ fun add(/*0*/ index: kotlin.Int, /*1*/ element: kotlin.String?): kotlin.Unit
     public open override /*1*/ /*fake_override*/ fun add(/*0*/ e: kotlin.String?): kotlin.Boolean
-    public open override /*1*/ /*fake_override*/ fun addAll(/*0*/ c: (kotlin.MutableCollection<out kotlin.String?>..kotlin.Collection<kotlin.String?>?)): kotlin.Boolean
-    public open override /*1*/ /*fake_override*/ fun addAll(/*0*/ index: kotlin.Int, /*1*/ c: (kotlin.MutableCollection<out kotlin.String?>..kotlin.Collection<kotlin.String?>?)): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun addAll(/*0*/ c: kotlin.Collection<kotlin.String?>): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun addAll(/*0*/ index: kotlin.Int, /*1*/ c: kotlin.Collection<kotlin.String?>): kotlin.Boolean
     invisible_fake open override /*1*/ /*fake_override*/ fun batchRemove(/*0*/ p0: kotlin.(Mutable)Collection<*>!, /*1*/ p1: kotlin.Boolean): kotlin.Boolean
     public open override /*1*/ /*fake_override*/ fun clear(): kotlin.Unit
-    public open override /*1*/ /*fake_override*/ fun clone(): kotlin.Any!
-    public open override /*1*/ /*fake_override*/ fun contains(/*0*/ o: kotlin.Any!): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun clone(): kotlin.Any
+    public open override /*1*/ /*fake_override*/ fun contains(/*0*/ o: kotlin.Any?): kotlin.Boolean
     public open override /*1*/ /*fake_override*/ fun containsAll(/*0*/ c: kotlin.Collection<kotlin.Any?>): kotlin.Boolean
     invisible_fake open override /*1*/ /*fake_override*/ fun elementData(/*0*/ p0: kotlin.Int): kotlin.String?
     public open override /*1*/ /*fake_override*/ fun ensureCapacity(/*0*/ p0: kotlin.Int): kotlin.Unit
@@ -20,24 +20,24 @@ internal final class C : java.util.ArrayList<kotlin.String?> {
     invisible_fake open override /*1*/ /*fake_override*/ fun fastRemove(/*0*/ p0: kotlin.Int): kotlin.Unit
     public open override /*1*/ /*fake_override*/ fun get(/*0*/ index: kotlin.Int): kotlin.String?
     invisible_fake open override /*1*/ /*fake_override*/ fun grow(/*0*/ p0: kotlin.Int): kotlin.Unit
-    public open override /*1*/ /*fake_override*/ fun indexOf(/*0*/ o: kotlin.Any!): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun indexOf(/*0*/ o: kotlin.Any?): kotlin.Int
     public open override /*1*/ /*fake_override*/ fun isEmpty(): kotlin.Boolean
-    public open override /*1*/ /*fake_override*/ fun iterator(): kotlin.(Mutable)Iterator<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.(Mutable)ListIterator<kotlin.String?>!
-    public open override /*1*/ /*fake_override*/ fun listIterator(/*0*/ index: kotlin.Int): kotlin.(Mutable)ListIterator<kotlin.String?>!
+    public open override /*1*/ /*fake_override*/ fun iterator(): kotlin.MutableIterator<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 rangeCheck(/*0*/ p0: kotlin.Int): kotlin.Unit
     invisible_fake open override /*1*/ /*fake_override*/ fun rangeCheckForAdd(/*0*/ p0: kotlin.Int): kotlin.Unit
     invisible_fake open override /*1*/ /*fake_override*/ fun readObject(/*0*/ p0: java.io.ObjectInputStream!): 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*/ 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.(Mutable)Collection<*>!): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun removeAll(/*0*/ c: kotlin.Collection<*>): kotlin.Boolean
     protected/*protected and package*/ open override /*1*/ /*fake_override*/ fun removeRange(/*0*/ p0: kotlin.Int, /*1*/ p1: kotlin.Int): kotlin.Unit
-    public open override /*1*/ /*fake_override*/ fun retainAll(/*0*/ c: kotlin.(Mutable)Collection<*>!): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun retainAll(/*0*/ c: kotlin.Collection<*>): kotlin.Boolean
     public open override /*1*/ /*fake_override*/ fun set(/*0*/ index: kotlin.Int, /*1*/ element: kotlin.String?): kotlin.String?
     public open override /*1*/ /*fake_override*/ fun size(): kotlin.Int
-    public open override /*1*/ /*fake_override*/ fun subList(/*0*/ fromIndex: kotlin.Int, /*1*/ toIndex: kotlin.Int): kotlin.(Mutable)List<kotlin.String?>!
+    public open override /*1*/ /*fake_override*/ fun subList(/*0*/ fromIndex: kotlin.Int, /*1*/ toIndex: kotlin.Int): kotlin.MutableList<kotlin.String?>
     public open override /*1*/ /*fake_override*/ fun toArray(): kotlin.Array<(out) kotlin.Any!>!
     public open override /*1*/ /*fake_override*/ fun </*0*/ T> toArray(/*0*/ p0: kotlin.Array<(out) T!>!): kotlin.Array<(out) T!>!
     public open override /*1*/ /*fake_override*/ fun trimToSize(): kotlin.Unit
diff --git a/compiler/testData/loadJava/compiledKotlinWithStdlib/platformNames/functionName.txt b/compiler/testData/loadJava/compiledKotlinWithStdlib/platformNames/functionName.txt
index c35cd5a3556..3eb82760baf 100644
--- a/compiler/testData/loadJava/compiledKotlinWithStdlib/platformNames/functionName.txt
+++ b/compiler/testData/loadJava/compiledKotlinWithStdlib/platformNames/functionName.txt
@@ -5,7 +5,7 @@ test.A(s = "2") internal var v: kotlin.Int
     kotlin.platform.platformName(name = "vset") test.A(s = "4") internal fun <set-v>(/*0*/ <set-?>: kotlin.Int): kotlin.Unit
 kotlin.platform.platformName(name = "bar") test.A(s = "1") internal fun foo(): kotlin.String
 
-internal final annotation class A : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class A : kotlin.Annotation {
     /*primary*/ public constructor A(/*0*/ s: kotlin.String)
     internal final val s: kotlin.String
         internal final fun <get-s>(): kotlin.String
diff --git a/compiler/testData/loadJava/javaAgainstKotlin/samAdapters/SamAdapterForOverriddenFromKotlin.txt b/compiler/testData/loadJava/javaAgainstKotlin/samAdapters/SamAdapterForOverriddenFromKotlin.txt
index 8d5333eac12..bd1deb09d8e 100644
--- a/compiler/testData/loadJava/javaAgainstKotlin/samAdapters/SamAdapterForOverriddenFromKotlin.txt
+++ b/compiler/testData/loadJava/javaAgainstKotlin/samAdapters/SamAdapterForOverriddenFromKotlin.txt
@@ -3,7 +3,7 @@ package test
 public open class Sub : test.Super {
     public constructor Sub()
     public final /*synthesized*/ fun foo(/*0*/ r: (() -> kotlin.Unit)!): kotlin.Unit
-    public open override /*1*/ fun foo(/*0*/ r: java.lang.Runnable!): kotlin.Unit
+    public open override /*1*/ fun foo(/*0*/ r: java.lang.Runnable): kotlin.Unit
 }
 
 public final class Super {
diff --git a/compiler/testData/loadJava/javaAgainstKotlin/signaturePropagation/DeepSubclassingKotlinInJava.txt b/compiler/testData/loadJava/javaAgainstKotlin/signaturePropagation/DeepSubclassingKotlinInJava.txt
index 223dfd90158..8f00c29fcc6 100644
--- a/compiler/testData/loadJava/javaAgainstKotlin/signaturePropagation/DeepSubclassingKotlinInJava.txt
+++ b/compiler/testData/loadJava/javaAgainstKotlin/signaturePropagation/DeepSubclassingKotlinInJava.txt
@@ -7,7 +7,7 @@ public open class A {
 
 public open class B : test.A {
     public constructor B()
-    public open override /*1*/ fun foo(): kotlin.String!
+    public open override /*1*/ fun foo(): kotlin.String
 }
 
 public open class C : test.B {
@@ -17,7 +17,7 @@ public open class C : test.B {
 
 public open class D : test.C {
     public constructor D()
-    public open override /*1*/ fun foo(): kotlin.String!
+    public open override /*1*/ fun foo(): kotlin.String
 }
 
 public open class E : test.D {
@@ -27,5 +27,5 @@ public open class E : test.D {
 
 public open class F : test.E {
     public constructor F()
-    public open override /*1*/ fun foo(): kotlin.String!
+    public open override /*1*/ fun foo(): kotlin.String
 }
diff --git a/compiler/testData/loadJava/javaAgainstKotlin/signaturePropagation/InheritExtensionAndNot.txt b/compiler/testData/loadJava/javaAgainstKotlin/signaturePropagation/InheritExtensionAndNot.txt
index 517383458fb..b4f71eac63a 100644
--- a/compiler/testData/loadJava/javaAgainstKotlin/signaturePropagation/InheritExtensionAndNot.txt
+++ b/compiler/testData/loadJava/javaAgainstKotlin/signaturePropagation/InheritExtensionAndNot.txt
@@ -1,8 +1,8 @@
 package test
 
 public interface Sub : test.Super1, test.Super2 {
-    public abstract override /*1*/ fun bar(/*0*/ vararg p: kotlin.String! /*kotlin.Array<(out) kotlin.String!>!*/): kotlin.Unit
-    public abstract override /*1*/ fun foo(/*0*/ p: kotlin.String!): kotlin.Unit
+    public abstract override /*1*/ fun bar(/*0*/ vararg p: kotlin.String /*kotlin.Array<(out) kotlin.String>*/): kotlin.Unit
+    public abstract override /*1*/ fun foo(/*0*/ p: kotlin.String): kotlin.Unit
     public abstract override /*1*/ /*fake_override*/ fun kotlin.Array<kotlin.String>.bar(): kotlin.Unit
     public abstract override /*1*/ /*fake_override*/ fun kotlin.String.foo(): kotlin.Unit
 }
diff --git a/compiler/testData/loadJava/javaAgainstKotlin/signaturePropagation/InheritExtensionFunction.txt b/compiler/testData/loadJava/javaAgainstKotlin/signaturePropagation/InheritExtensionFunction.txt
index b15451c9d0f..aca2de9c103 100644
--- a/compiler/testData/loadJava/javaAgainstKotlin/signaturePropagation/InheritExtensionFunction.txt
+++ b/compiler/testData/loadJava/javaAgainstKotlin/signaturePropagation/InheritExtensionFunction.txt
@@ -2,7 +2,7 @@ package test
 
 public open class Sub : test.Super {
     public constructor Sub()
-    public open override /*1*/ fun kotlin.String!.bar(/*0*/ p: kotlin.String!): kotlin.String!
+    public open override /*1*/ fun kotlin.String.bar(/*0*/ p: kotlin.String): kotlin.String
     public final override /*1*/ /*fake_override*/ fun kotlin.String.foo(): kotlin.Unit
 }
 
diff --git a/compiler/testData/loadJava/javaAgainstKotlin/signaturePropagation/SubclassFromTraitImplementation.txt b/compiler/testData/loadJava/javaAgainstKotlin/signaturePropagation/SubclassFromTraitImplementation.txt
index b3ea369efd1..af61cb0a0f2 100644
--- a/compiler/testData/loadJava/javaAgainstKotlin/signaturePropagation/SubclassFromTraitImplementation.txt
+++ b/compiler/testData/loadJava/javaAgainstKotlin/signaturePropagation/SubclassFromTraitImplementation.txt
@@ -8,7 +8,7 @@ internal open class Impl : test.Trait {
 
 public open class Subclass : test.Impl {
     public constructor Subclass()
-    java.lang.Override() public open override /*1*/ fun bar(): kotlin.String!
+    java.lang.Override() public open override /*1*/ fun bar(): kotlin.String
     internal open override /*1*/ /*fake_override*/ fun foo(): kotlin.String
 }
 
diff --git a/compiler/testData/loadJava/javaAgainstKotlin/signaturePropagation/SubclassingKotlinInJava.txt b/compiler/testData/loadJava/javaAgainstKotlin/signaturePropagation/SubclassingKotlinInJava.txt
index d9c07762f24..cd5842fdebe 100644
--- a/compiler/testData/loadJava/javaAgainstKotlin/signaturePropagation/SubclassingKotlinInJava.txt
+++ b/compiler/testData/loadJava/javaAgainstKotlin/signaturePropagation/SubclassingKotlinInJava.txt
@@ -2,7 +2,7 @@ package test
 
 public open class JavaSubclass : test.KotlinClass {
     public constructor JavaSubclass()
-    public open override /*1*/ fun foo(): kotlin.String!
+    public open override /*1*/ fun foo(): kotlin.String
 }
 
 public open class KotlinClass {
diff --git a/compiler/testData/loadJava/kotlinAgainstCompiledJavaWithKotlin/propagationAgainstDeserializedSuperclass.txt b/compiler/testData/loadJava/kotlinAgainstCompiledJavaWithKotlin/propagationAgainstDeserializedSuperclass.txt
index 980f9346556..8c3668c4786 100644
--- a/compiler/testData/loadJava/kotlinAgainstCompiledJavaWithKotlin/propagationAgainstDeserializedSuperclass.txt
+++ b/compiler/testData/loadJava/kotlinAgainstCompiledJavaWithKotlin/propagationAgainstDeserializedSuperclass.txt
@@ -2,7 +2,7 @@ package test
 
 public open class J : test.K {
     public constructor J()
-    public open override /*1*/ fun foo(/*0*/ l: kotlin.(Mutable)List<kotlin.String!>!): kotlin.String!
+    public open override /*1*/ fun foo(/*0*/ l: kotlin.MutableList<kotlin.String>): kotlin.String
 }
 
 internal interface K {
diff --git a/compiler/testData/loadJava/sourceJava/NullInAnnotation.txt b/compiler/testData/loadJava/sourceJava/NullInAnnotation.txt
index 6faf51d956c..4724d7b698c 100644
--- a/compiler/testData/loadJava/sourceJava/NullInAnnotation.txt
+++ b/compiler/testData/loadJava/sourceJava/NullInAnnotation.txt
@@ -5,7 +5,7 @@ public /*synthesized*/ fun NullInAnnotation(/*0*/ function: () -> kotlin.Unit):
 public interface NullInAnnotation {
     test.NullInAnnotation.Ann(a = null, b = {null}) public abstract fun foo(): kotlin.Unit
 
-    public final annotation class Ann : kotlin.Annotation {
+    public final class Ann : kotlin.Annotation {
         public constructor Ann(/*0*/ a: kotlin.String, /*1*/ b: kotlin.Array<kotlin.String>)
         public final val a: kotlin.String
         public final val b: kotlin.Array<kotlin.String>
diff --git a/compiler/testData/loadJava/sourceJava/TypeAnnotations.java b/compiler/testData/loadJava/sourceJava/TypeAnnotations.java
new file mode 100644
index 00000000000..30516b4fbb9
--- /dev/null
+++ b/compiler/testData/loadJava/sourceJava/TypeAnnotations.java
@@ -0,0 +1,16 @@
+package test;
+
+import java.lang.annotation.*;
+
+@Target(ElementType.TYPE_USE)
+@interface A {
+    String value() default "";
+}
+
+interface G<T> {}
+interface G2<A, B> {}
+
+public interface TypeAnnotations<TT> {
+    void f(G<@A String> p);
+    void f(G2<@A String, @A Integer> p);
+}
\ No newline at end of file
diff --git a/compiler/testData/loadJava/sourceJava/TypeAnnotations.txt b/compiler/testData/loadJava/sourceJava/TypeAnnotations.txt
new file mode 100644
index 00000000000..8021ab11fcc
--- /dev/null
+++ b/compiler/testData/loadJava/sourceJava/TypeAnnotations.txt
@@ -0,0 +1,6 @@
+package test
+
+public interface TypeAnnotations</*0*/ TT> {
+    public abstract fun f(/*0*/ p: test.G2<@[test.A()] kotlin.String!, @[test.A()] kotlin.Int!>!): kotlin.Unit
+    public abstract fun f(/*0*/ p: test.G<@[test.A()] kotlin.String!>!): kotlin.Unit
+}
diff --git a/compiler/testData/mockJDK/jre/lib/rt.jar b/compiler/testData/mockJDK/jre/lib/rt.jar
index a97cdd5ff3d..0077dce4512 100644
Binary files a/compiler/testData/mockJDK/jre/lib/rt.jar and b/compiler/testData/mockJDK/jre/lib/rt.jar differ
diff --git a/compiler/testData/mockJDK/src.zip b/compiler/testData/mockJDK/src.zip
index f5c454a3a6b..4ccea0710d6 100644
Binary files a/compiler/testData/mockJDK/src.zip and b/compiler/testData/mockJDK/src.zip differ
diff --git a/compiler/testData/psi/EnumWithAnnotationKeyword.kt b/compiler/testData/psi/EnumWithAnnotationKeyword.kt
new file mode 100644
index 00000000000..009686dd353
--- /dev/null
+++ b/compiler/testData/psi/EnumWithAnnotationKeyword.kt
@@ -0,0 +1,7 @@
+data annotation enum class E {
+    D
+}
+
+enum annotation E1 {
+    D
+}
\ No newline at end of file
diff --git a/compiler/testData/psi/EnumWithAnnotationKeyword.txt b/compiler/testData/psi/EnumWithAnnotationKeyword.txt
new file mode 100644
index 00000000000..7a124338c7f
--- /dev/null
+++ b/compiler/testData/psi/EnumWithAnnotationKeyword.txt
@@ -0,0 +1,63 @@
+JetFile: EnumWithAnnotationKeyword.kt
+  PACKAGE_DIRECTIVE
+    <empty list>
+  IMPORT_LIST
+    <empty list>
+  CLASS
+    MODIFIER_LIST
+      ANNOTATION_ENTRY
+        CONSTRUCTOR_CALLEE
+          TYPE_REFERENCE
+            USER_TYPE
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('data')
+      PsiWhiteSpace(' ')
+      ANNOTATION_ENTRY
+        CONSTRUCTOR_CALLEE
+          TYPE_REFERENCE
+            USER_TYPE
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('annotation')
+      PsiWhiteSpace(' ')
+      PsiElement(enum)('enum')
+    PsiWhiteSpace(' ')
+    PsiElement(class)('class')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('E')
+    PsiWhiteSpace(' ')
+    CLASS_BODY
+      PsiElement(LBRACE)('{')
+      PsiWhiteSpace('\n    ')
+      ENUM_ENTRY
+        OBJECT_DECLARATION_NAME
+          PsiElement(IDENTIFIER)('D')
+      PsiWhiteSpace('\n')
+      PsiElement(RBRACE)('}')
+  PsiWhiteSpace('\n\n')
+  FUN
+    MODIFIER_LIST
+      PsiElement(enum)('enum')
+      PsiWhiteSpace(' ')
+      ANNOTATION_ENTRY
+        CONSTRUCTOR_CALLEE
+          TYPE_REFERENCE
+            USER_TYPE
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('annotation')
+      PsiWhiteSpace(' ')
+      ANNOTATION_ENTRY
+        CONSTRUCTOR_CALLEE
+          TYPE_REFERENCE
+            USER_TYPE
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('E1')
+    PsiErrorElement:Expecting a top level declaration
+      <empty list>
+    PsiWhiteSpace(' ')
+    BLOCK
+      PsiElement(LBRACE)('{')
+      PsiWhiteSpace('\n    ')
+      REFERENCE_EXPRESSION
+        PsiElement(IDENTIFIER)('D')
+      PsiWhiteSpace('\n')
+      PsiElement(RBRACE)('}')
\ No newline at end of file
diff --git a/compiler/testData/psi/InterfaceWithEnumKeyword.kt b/compiler/testData/psi/InterfaceWithEnumKeyword.kt
new file mode 100644
index 00000000000..31ee2f6e2bc
--- /dev/null
+++ b/compiler/testData/psi/InterfaceWithEnumKeyword.kt
@@ -0,0 +1,11 @@
+enum interface class E1 {
+    D
+}
+
+interface enum class E2 {
+    D
+}
+
+enum interface E3 {
+    D
+}
\ No newline at end of file
diff --git a/compiler/testData/psi/InterfaceWithEnumKeyword.txt b/compiler/testData/psi/InterfaceWithEnumKeyword.txt
new file mode 100644
index 00000000000..a7700037e02
--- /dev/null
+++ b/compiler/testData/psi/InterfaceWithEnumKeyword.txt
@@ -0,0 +1,74 @@
+JetFile: InterfaceWithEnumKeyword.kt
+  PACKAGE_DIRECTIVE
+    <empty list>
+  IMPORT_LIST
+    <empty list>
+  CLASS
+    MODIFIER_LIST
+      PsiElement(enum)('enum')
+    PsiWhiteSpace(' ')
+    PsiElement(interface)('interface')
+    PsiErrorElement:Name expected
+      <empty list>
+  PsiWhiteSpace(' ')
+  CLASS
+    PsiElement(class)('class')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('E1')
+    PsiWhiteSpace(' ')
+    CLASS_BODY
+      PsiElement(LBRACE)('{')
+      PsiWhiteSpace('\n    ')
+      MODIFIER_LIST
+        ANNOTATION_ENTRY
+          CONSTRUCTOR_CALLEE
+            TYPE_REFERENCE
+              USER_TYPE
+                REFERENCE_EXPRESSION
+                  PsiElement(IDENTIFIER)('D')
+      PsiErrorElement:Expecting member declaration
+        <empty list>
+      PsiWhiteSpace('\n')
+      PsiElement(RBRACE)('}')
+  PsiWhiteSpace('\n\n')
+  CLASS
+    PsiElement(interface)('interface')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('enum')
+  PsiWhiteSpace(' ')
+  CLASS
+    PsiElement(class)('class')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('E2')
+    PsiWhiteSpace(' ')
+    CLASS_BODY
+      PsiElement(LBRACE)('{')
+      PsiWhiteSpace('\n    ')
+      MODIFIER_LIST
+        ANNOTATION_ENTRY
+          CONSTRUCTOR_CALLEE
+            TYPE_REFERENCE
+              USER_TYPE
+                REFERENCE_EXPRESSION
+                  PsiElement(IDENTIFIER)('D')
+      PsiErrorElement:Expecting member declaration
+        <empty list>
+      PsiWhiteSpace('\n')
+      PsiElement(RBRACE)('}')
+  PsiWhiteSpace('\n\n')
+  CLASS
+    MODIFIER_LIST
+      PsiElement(enum)('enum')
+    PsiWhiteSpace(' ')
+    PsiElement(interface)('interface')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('E3')
+    PsiWhiteSpace(' ')
+    CLASS_BODY
+      PsiElement(LBRACE)('{')
+      PsiWhiteSpace('\n    ')
+      ENUM_ENTRY
+        OBJECT_DECLARATION_NAME
+          PsiElement(IDENTIFIER)('D')
+      PsiWhiteSpace('\n')
+      PsiElement(RBRACE)('}')
\ No newline at end of file
diff --git a/compiler/testData/psi/SimpleModifiers.txt b/compiler/testData/psi/SimpleModifiers.txt
index 24d0a897668..4f12a5390f4 100644
--- a/compiler/testData/psi/SimpleModifiers.txt
+++ b/compiler/testData/psi/SimpleModifiers.txt
@@ -25,7 +25,12 @@ JetFile: SimpleModifiers.kt
       PsiWhiteSpace('\n')
       PsiElement(open)('open')
       PsiWhiteSpace('\n')
-      PsiElement(annotation)('annotation')
+      ANNOTATION_ENTRY
+        CONSTRUCTOR_CALLEE
+          TYPE_REFERENCE
+            USER_TYPE
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('annotation')
       PsiWhiteSpace('\n')
       PsiElement(override)('override')
       PsiWhiteSpace('\n')
@@ -67,7 +72,12 @@ JetFile: SimpleModifiers.kt
           PsiWhiteSpace('\n        ')
           PsiElement(open)('open')
           PsiWhiteSpace('\n        ')
-          PsiElement(annotation)('annotation')
+          ANNOTATION_ENTRY
+            CONSTRUCTOR_CALLEE
+              TYPE_REFERENCE
+                USER_TYPE
+                  REFERENCE_EXPRESSION
+                    PsiElement(IDENTIFIER)('annotation')
           PsiWhiteSpace('\n        ')
           PsiElement(override)('override')
           PsiWhiteSpace('\n        ')
diff --git a/compiler/testData/psi/SoftKeywords.txt b/compiler/testData/psi/SoftKeywords.txt
index 9a8f32e1a1e..b99c8b8983e 100644
--- a/compiler/testData/psi/SoftKeywords.txt
+++ b/compiler/testData/psi/SoftKeywords.txt
@@ -38,7 +38,12 @@ JetFile: SoftKeywords.kt
       PsiWhiteSpace('\n')
       PsiElement(open)('open')
       PsiWhiteSpace('\n')
-      PsiElement(annotation)('annotation')
+      ANNOTATION_ENTRY
+        CONSTRUCTOR_CALLEE
+          TYPE_REFERENCE
+            USER_TYPE
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('annotation')
       PsiWhiteSpace('\n')
       PsiElement(override)('override')
       PsiWhiteSpace('\n')
@@ -113,7 +118,12 @@ JetFile: SoftKeywords.kt
           PsiWhiteSpace('\n    ')
           PsiElement(open)('open')
           PsiWhiteSpace('\n    ')
-          PsiElement(annotation)('annotation')
+          ANNOTATION_ENTRY
+            CONSTRUCTOR_CALLEE
+              TYPE_REFERENCE
+                USER_TYPE
+                  REFERENCE_EXPRESSION
+                    PsiElement(IDENTIFIER)('annotation')
           PsiWhiteSpace('\n    ')
           PsiElement(override)('override')
           PsiWhiteSpace('\n    ')
@@ -972,7 +982,12 @@ JetFile: SoftKeywords.kt
               PsiWhiteSpace('\n    ')
               PsiElement(open)('open')
               PsiWhiteSpace('\n    ')
-              PsiElement(annotation)('annotation')
+              ANNOTATION_ENTRY
+                CONSTRUCTOR_CALLEE
+                  TYPE_REFERENCE
+                    USER_TYPE
+                      REFERENCE_EXPRESSION
+                        PsiElement(IDENTIFIER)('annotation')
               PsiWhiteSpace('\n    ')
               PsiElement(override)('override')
               PsiWhiteSpace('\n    ')
@@ -1292,7 +1307,12 @@ JetFile: SoftKeywords.kt
             PsiWhiteSpace('\n    ')
             PsiElement(open)('open')
             PsiWhiteSpace('\n    ')
-            PsiElement(annotation)('annotation')
+            ANNOTATION_ENTRY
+              CONSTRUCTOR_CALLEE
+                TYPE_REFERENCE
+                  USER_TYPE
+                    REFERENCE_EXPRESSION
+                      PsiElement(IDENTIFIER)('annotation')
             PsiWhiteSpace('\n    ')
             PsiElement(override)('override')
             PsiWhiteSpace('\n    ')
diff --git a/compiler/testData/psi/annotation/Annotations.txt b/compiler/testData/psi/annotation/Annotations.txt
index 4113551639f..863e9201d08 100644
--- a/compiler/testData/psi/annotation/Annotations.txt
+++ b/compiler/testData/psi/annotation/Annotations.txt
@@ -25,7 +25,12 @@ JetFile: Annotations.kt
       PsiWhiteSpace('\n')
       PsiElement(open)('open')
       PsiWhiteSpace('\n')
-      PsiElement(annotation)('annotation')
+      ANNOTATION_ENTRY
+        CONSTRUCTOR_CALLEE
+          TYPE_REFERENCE
+            USER_TYPE
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('annotation')
       PsiWhiteSpace('\n')
       PsiElement(override)('override')
       PsiWhiteSpace('\n')
@@ -266,7 +271,12 @@ JetFile: Annotations.kt
           PsiWhiteSpace('\n')
           PsiElement(open)('open')
           PsiWhiteSpace('\n')
-          PsiElement(annotation)('annotation')
+          ANNOTATION_ENTRY
+            CONSTRUCTOR_CALLEE
+              TYPE_REFERENCE
+                USER_TYPE
+                  REFERENCE_EXPRESSION
+                    PsiElement(IDENTIFIER)('annotation')
           PsiWhiteSpace('\n')
           PsiElement(override)('override')
           PsiWhiteSpace('\n')
diff --git a/compiler/testData/psi/annotation/Annotations_ERR.txt b/compiler/testData/psi/annotation/Annotations_ERR.txt
index 80389fcc24d..48b229fc3e5 100644
--- a/compiler/testData/psi/annotation/Annotations_ERR.txt
+++ b/compiler/testData/psi/annotation/Annotations_ERR.txt
@@ -25,7 +25,12 @@ JetFile: Annotations_ERR.kt
       PsiWhiteSpace('\n')
       PsiElement(open)('open')
       PsiWhiteSpace('\n')
-      PsiElement(annotation)('annotation')
+      ANNOTATION_ENTRY
+        CONSTRUCTOR_CALLEE
+          TYPE_REFERENCE
+            USER_TYPE
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('annotation')
       PsiWhiteSpace('\n')
       PsiElement(override)('override')
       PsiWhiteSpace('\n')
@@ -221,7 +226,12 @@ JetFile: Annotations_ERR.kt
           PsiWhiteSpace('\n')
           PsiElement(open)('open')
           PsiWhiteSpace('\n')
-          PsiElement(annotation)('annotation')
+          ANNOTATION_ENTRY
+            CONSTRUCTOR_CALLEE
+              TYPE_REFERENCE
+                USER_TYPE
+                  REFERENCE_EXPRESSION
+                    PsiElement(IDENTIFIER)('annotation')
           PsiWhiteSpace('\n')
           PsiElement(override)('override')
           PsiWhiteSpace('\n')
diff --git a/compiler/testData/psi/annotation/onFile/withoutFileAnnotationAndPackageDeclaration.txt b/compiler/testData/psi/annotation/onFile/withoutFileAnnotationAndPackageDeclaration.txt
index 6f56c7d133a..5ff571a1866 100644
--- a/compiler/testData/psi/annotation/onFile/withoutFileAnnotationAndPackageDeclaration.txt
+++ b/compiler/testData/psi/annotation/onFile/withoutFileAnnotationAndPackageDeclaration.txt
@@ -35,7 +35,12 @@ JetFile: withoutFileAnnotationAndPackageDeclaration.kt
   PsiWhiteSpace('\n\n')
   CLASS
     MODIFIER_LIST
-      PsiElement(annotation)('annotation')
+      ANNOTATION_ENTRY
+        CONSTRUCTOR_CALLEE
+          TYPE_REFERENCE
+            USER_TYPE
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('annotation')
     PsiWhiteSpace(' ')
     PsiElement(class)('class')
     PsiWhiteSpace(' ')
diff --git a/compiler/testData/psi/annotation/options/annotAsArgComplex.kt b/compiler/testData/psi/annotation/options/annotAsArgComplex.kt
new file mode 100644
index 00000000000..87da177827e
--- /dev/null
+++ b/compiler/testData/psi/annotation/options/annotAsArgComplex.kt
@@ -0,0 +1,9 @@
+class Annotation {
+    fun setProblemGroup() {}
+    fun getQuickFixes() = 0
+}
+
+fun registerQuickFix(annot: Annotation) {
+    annot.setProblemGroup()
+    val fixes = annot.getQuickFixes()
+}
diff --git a/compiler/testData/psi/annotation/options/annotAsArgComplex.txt b/compiler/testData/psi/annotation/options/annotAsArgComplex.txt
new file mode 100644
index 00000000000..ac790f3733a
--- /dev/null
+++ b/compiler/testData/psi/annotation/options/annotAsArgComplex.txt
@@ -0,0 +1,89 @@
+JetFile: annotAsArgComplex.kt
+  PACKAGE_DIRECTIVE
+    <empty list>
+  IMPORT_LIST
+    <empty list>
+  CLASS
+    PsiElement(class)('class')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('Annotation')
+    PsiWhiteSpace(' ')
+    CLASS_BODY
+      PsiElement(LBRACE)('{')
+      PsiWhiteSpace('\n    ')
+      FUN
+        PsiElement(fun)('fun')
+        PsiWhiteSpace(' ')
+        PsiElement(IDENTIFIER)('setProblemGroup')
+        VALUE_PARAMETER_LIST
+          PsiElement(LPAR)('(')
+          PsiElement(RPAR)(')')
+        PsiWhiteSpace(' ')
+        BLOCK
+          PsiElement(LBRACE)('{')
+          PsiElement(RBRACE)('}')
+      PsiWhiteSpace('\n    ')
+      FUN
+        PsiElement(fun)('fun')
+        PsiWhiteSpace(' ')
+        PsiElement(IDENTIFIER)('getQuickFixes')
+        VALUE_PARAMETER_LIST
+          PsiElement(LPAR)('(')
+          PsiElement(RPAR)(')')
+        PsiWhiteSpace(' ')
+        PsiElement(EQ)('=')
+        PsiWhiteSpace(' ')
+        INTEGER_CONSTANT
+          PsiElement(INTEGER_LITERAL)('0')
+      PsiWhiteSpace('\n')
+      PsiElement(RBRACE)('}')
+  PsiWhiteSpace('\n\n')
+  FUN
+    PsiElement(fun)('fun')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('registerQuickFix')
+    VALUE_PARAMETER_LIST
+      PsiElement(LPAR)('(')
+      VALUE_PARAMETER
+        PsiElement(IDENTIFIER)('annot')
+        PsiElement(COLON)(':')
+        PsiWhiteSpace(' ')
+        TYPE_REFERENCE
+          USER_TYPE
+            REFERENCE_EXPRESSION
+              PsiElement(IDENTIFIER)('Annotation')
+      PsiElement(RPAR)(')')
+    PsiWhiteSpace(' ')
+    BLOCK
+      PsiElement(LBRACE)('{')
+      PsiWhiteSpace('\n    ')
+      DOT_QUALIFIED_EXPRESSION
+        REFERENCE_EXPRESSION
+          PsiElement(IDENTIFIER)('annot')
+        PsiElement(DOT)('.')
+        CALL_EXPRESSION
+          REFERENCE_EXPRESSION
+            PsiElement(IDENTIFIER)('setProblemGroup')
+          VALUE_ARGUMENT_LIST
+            PsiElement(LPAR)('(')
+            PsiElement(RPAR)(')')
+      PsiWhiteSpace('\n    ')
+      PROPERTY
+        PsiElement(val)('val')
+        PsiWhiteSpace(' ')
+        PsiElement(IDENTIFIER)('fixes')
+        PsiWhiteSpace(' ')
+        PsiElement(EQ)('=')
+        PsiWhiteSpace(' ')
+        DOT_QUALIFIED_EXPRESSION
+          REFERENCE_EXPRESSION
+            PsiElement(IDENTIFIER)('annot')
+          PsiElement(DOT)('.')
+          CALL_EXPRESSION
+            REFERENCE_EXPRESSION
+              PsiElement(IDENTIFIER)('getQuickFixes')
+            VALUE_ARGUMENT_LIST
+              PsiElement(LPAR)('(')
+              PsiElement(RPAR)(')')
+      PsiWhiteSpace('\n')
+      PsiElement(RBRACE)('}')
\ No newline at end of file
diff --git a/compiler/testData/psi/annotation/options/annotation.kt b/compiler/testData/psi/annotation/options/annotation.kt
new file mode 100644
index 00000000000..05e089a8935
--- /dev/null
+++ b/compiler/testData/psi/annotation/options/annotation.kt
@@ -0,0 +1,20 @@
+// Annotations used for annotations :)
+enum class Target {
+    CLASSIFIER,
+    FUNCTION
+}
+
+enum class Retention {
+    SOURCE,
+    BINARY,
+    RUNTIME
+}
+
+target(Target.CLASSIFIER) 
+public annotation class target(vararg val allowedTargets: Target)
+
+target(Target.CLASSIFIER)
+public annotation(Retention.SOURCE) class annotation(
+    val retention: Retention = Retention.RUNTIME,
+    val repeatable: Boolean = false
+)
diff --git a/compiler/testData/psi/annotation/options/annotation.txt b/compiler/testData/psi/annotation/options/annotation.txt
new file mode 100644
index 00000000000..f1df48cc47f
--- /dev/null
+++ b/compiler/testData/psi/annotation/options/annotation.txt
@@ -0,0 +1,188 @@
+JetFile: annotation.kt
+  PACKAGE_DIRECTIVE
+    <empty list>
+  IMPORT_LIST
+    <empty list>
+  CLASS
+    PsiComment(EOL_COMMENT)('// Annotations used for annotations :)')
+    PsiWhiteSpace('\n')
+    MODIFIER_LIST
+      PsiElement(enum)('enum')
+    PsiWhiteSpace(' ')
+    PsiElement(class)('class')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('Target')
+    PsiWhiteSpace(' ')
+    CLASS_BODY
+      PsiElement(LBRACE)('{')
+      PsiWhiteSpace('\n    ')
+      ENUM_ENTRY
+        OBJECT_DECLARATION_NAME
+          PsiElement(IDENTIFIER)('CLASSIFIER')
+      PsiElement(COMMA)(',')
+      PsiWhiteSpace('\n    ')
+      ENUM_ENTRY
+        OBJECT_DECLARATION_NAME
+          PsiElement(IDENTIFIER)('FUNCTION')
+      PsiWhiteSpace('\n')
+      PsiElement(RBRACE)('}')
+  PsiWhiteSpace('\n\n')
+  CLASS
+    MODIFIER_LIST
+      PsiElement(enum)('enum')
+    PsiWhiteSpace(' ')
+    PsiElement(class)('class')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('Retention')
+    PsiWhiteSpace(' ')
+    CLASS_BODY
+      PsiElement(LBRACE)('{')
+      PsiWhiteSpace('\n    ')
+      ENUM_ENTRY
+        OBJECT_DECLARATION_NAME
+          PsiElement(IDENTIFIER)('SOURCE')
+      PsiElement(COMMA)(',')
+      PsiWhiteSpace('\n    ')
+      ENUM_ENTRY
+        OBJECT_DECLARATION_NAME
+          PsiElement(IDENTIFIER)('BINARY')
+      PsiElement(COMMA)(',')
+      PsiWhiteSpace('\n    ')
+      ENUM_ENTRY
+        OBJECT_DECLARATION_NAME
+          PsiElement(IDENTIFIER)('RUNTIME')
+      PsiWhiteSpace('\n')
+      PsiElement(RBRACE)('}')
+  PsiWhiteSpace('\n\n')
+  CLASS
+    MODIFIER_LIST
+      ANNOTATION_ENTRY
+        CONSTRUCTOR_CALLEE
+          TYPE_REFERENCE
+            USER_TYPE
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('target')
+        VALUE_ARGUMENT_LIST
+          PsiElement(LPAR)('(')
+          VALUE_ARGUMENT
+            DOT_QUALIFIED_EXPRESSION
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('Target')
+              PsiElement(DOT)('.')
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('CLASSIFIER')
+          PsiElement(RPAR)(')')
+      PsiWhiteSpace(' \n')
+      PsiElement(public)('public')
+      PsiWhiteSpace(' ')
+      ANNOTATION_ENTRY
+        CONSTRUCTOR_CALLEE
+          TYPE_REFERENCE
+            USER_TYPE
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('annotation')
+    PsiWhiteSpace(' ')
+    PsiElement(class)('class')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('target')
+    PRIMARY_CONSTRUCTOR
+      VALUE_PARAMETER_LIST
+        PsiElement(LPAR)('(')
+        VALUE_PARAMETER
+          MODIFIER_LIST
+            PsiElement(vararg)('vararg')
+          PsiWhiteSpace(' ')
+          PsiElement(val)('val')
+          PsiWhiteSpace(' ')
+          PsiElement(IDENTIFIER)('allowedTargets')
+          PsiElement(COLON)(':')
+          PsiWhiteSpace(' ')
+          TYPE_REFERENCE
+            USER_TYPE
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('Target')
+        PsiElement(RPAR)(')')
+  PsiWhiteSpace('\n\n')
+  CLASS
+    MODIFIER_LIST
+      ANNOTATION_ENTRY
+        CONSTRUCTOR_CALLEE
+          TYPE_REFERENCE
+            USER_TYPE
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('target')
+        VALUE_ARGUMENT_LIST
+          PsiElement(LPAR)('(')
+          VALUE_ARGUMENT
+            DOT_QUALIFIED_EXPRESSION
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('Target')
+              PsiElement(DOT)('.')
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('CLASSIFIER')
+          PsiElement(RPAR)(')')
+      PsiWhiteSpace('\n')
+      PsiElement(public)('public')
+      PsiWhiteSpace(' ')
+      ANNOTATION_ENTRY
+        CONSTRUCTOR_CALLEE
+          TYPE_REFERENCE
+            USER_TYPE
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('annotation')
+        VALUE_ARGUMENT_LIST
+          PsiElement(LPAR)('(')
+          VALUE_ARGUMENT
+            DOT_QUALIFIED_EXPRESSION
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('Retention')
+              PsiElement(DOT)('.')
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('SOURCE')
+          PsiElement(RPAR)(')')
+    PsiWhiteSpace(' ')
+    PsiElement(class)('class')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('annotation')
+    PRIMARY_CONSTRUCTOR
+      VALUE_PARAMETER_LIST
+        PsiElement(LPAR)('(')
+        PsiWhiteSpace('\n    ')
+        VALUE_PARAMETER
+          PsiElement(val)('val')
+          PsiWhiteSpace(' ')
+          PsiElement(IDENTIFIER)('retention')
+          PsiElement(COLON)(':')
+          PsiWhiteSpace(' ')
+          TYPE_REFERENCE
+            USER_TYPE
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('Retention')
+          PsiWhiteSpace(' ')
+          PsiElement(EQ)('=')
+          PsiWhiteSpace(' ')
+          DOT_QUALIFIED_EXPRESSION
+            REFERENCE_EXPRESSION
+              PsiElement(IDENTIFIER)('Retention')
+            PsiElement(DOT)('.')
+            REFERENCE_EXPRESSION
+              PsiElement(IDENTIFIER)('RUNTIME')
+        PsiElement(COMMA)(',')
+        PsiWhiteSpace('\n    ')
+        VALUE_PARAMETER
+          PsiElement(val)('val')
+          PsiWhiteSpace(' ')
+          PsiElement(IDENTIFIER)('repeatable')
+          PsiElement(COLON)(':')
+          PsiWhiteSpace(' ')
+          TYPE_REFERENCE
+            USER_TYPE
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('Boolean')
+          PsiWhiteSpace(' ')
+          PsiElement(EQ)('=')
+          PsiWhiteSpace(' ')
+          BOOLEAN_CONSTANT
+            PsiElement(false)('false')
+        PsiWhiteSpace('\n')
+        PsiElement(RPAR)(')')
\ No newline at end of file
diff --git a/compiler/testData/psi/annotation/options/annotationAsArg.kt b/compiler/testData/psi/annotation/options/annotationAsArg.kt
new file mode 100644
index 00000000000..5484366eef0
--- /dev/null
+++ b/compiler/testData/psi/annotation/options/annotationAsArg.kt
@@ -0,0 +1,14 @@
+class Annotation(val x: Int) {
+    fun baz() {}
+    fun bar() = x
+}
+
+fun foo(annotation: Annotation): Int {
+    if (annotation.bar() == 0) {
+        annotation.baz()
+        return 0
+    }
+    else {
+        return -1
+    }
+}
diff --git a/compiler/testData/psi/annotation/options/annotationAsArg.txt b/compiler/testData/psi/annotation/options/annotationAsArg.txt
new file mode 100644
index 00000000000..4a9e7c9ab32
--- /dev/null
+++ b/compiler/testData/psi/annotation/options/annotationAsArg.txt
@@ -0,0 +1,144 @@
+JetFile: annotationAsArg.kt
+  PACKAGE_DIRECTIVE
+    <empty list>
+  IMPORT_LIST
+    <empty list>
+  CLASS
+    PsiElement(class)('class')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('Annotation')
+    PRIMARY_CONSTRUCTOR
+      VALUE_PARAMETER_LIST
+        PsiElement(LPAR)('(')
+        VALUE_PARAMETER
+          PsiElement(val)('val')
+          PsiWhiteSpace(' ')
+          PsiElement(IDENTIFIER)('x')
+          PsiElement(COLON)(':')
+          PsiWhiteSpace(' ')
+          TYPE_REFERENCE
+            USER_TYPE
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('Int')
+        PsiElement(RPAR)(')')
+    PsiWhiteSpace(' ')
+    CLASS_BODY
+      PsiElement(LBRACE)('{')
+      PsiWhiteSpace('\n    ')
+      FUN
+        PsiElement(fun)('fun')
+        PsiWhiteSpace(' ')
+        PsiElement(IDENTIFIER)('baz')
+        VALUE_PARAMETER_LIST
+          PsiElement(LPAR)('(')
+          PsiElement(RPAR)(')')
+        PsiWhiteSpace(' ')
+        BLOCK
+          PsiElement(LBRACE)('{')
+          PsiElement(RBRACE)('}')
+      PsiWhiteSpace('\n    ')
+      FUN
+        PsiElement(fun)('fun')
+        PsiWhiteSpace(' ')
+        PsiElement(IDENTIFIER)('bar')
+        VALUE_PARAMETER_LIST
+          PsiElement(LPAR)('(')
+          PsiElement(RPAR)(')')
+        PsiWhiteSpace(' ')
+        PsiElement(EQ)('=')
+        PsiWhiteSpace(' ')
+        REFERENCE_EXPRESSION
+          PsiElement(IDENTIFIER)('x')
+      PsiWhiteSpace('\n')
+      PsiElement(RBRACE)('}')
+  PsiWhiteSpace('\n\n')
+  FUN
+    PsiElement(fun)('fun')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('foo')
+    VALUE_PARAMETER_LIST
+      PsiElement(LPAR)('(')
+      VALUE_PARAMETER
+        PsiElement(IDENTIFIER)('annotation')
+        PsiElement(COLON)(':')
+        PsiWhiteSpace(' ')
+        TYPE_REFERENCE
+          USER_TYPE
+            REFERENCE_EXPRESSION
+              PsiElement(IDENTIFIER)('Annotation')
+      PsiElement(RPAR)(')')
+    PsiElement(COLON)(':')
+    PsiWhiteSpace(' ')
+    TYPE_REFERENCE
+      USER_TYPE
+        REFERENCE_EXPRESSION
+          PsiElement(IDENTIFIER)('Int')
+    PsiWhiteSpace(' ')
+    BLOCK
+      PsiElement(LBRACE)('{')
+      PsiWhiteSpace('\n    ')
+      IF
+        PsiElement(if)('if')
+        PsiWhiteSpace(' ')
+        PsiElement(LPAR)('(')
+        CONDITION
+          BINARY_EXPRESSION
+            DOT_QUALIFIED_EXPRESSION
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('annotation')
+              PsiElement(DOT)('.')
+              CALL_EXPRESSION
+                REFERENCE_EXPRESSION
+                  PsiElement(IDENTIFIER)('bar')
+                VALUE_ARGUMENT_LIST
+                  PsiElement(LPAR)('(')
+                  PsiElement(RPAR)(')')
+            PsiWhiteSpace(' ')
+            OPERATION_REFERENCE
+              PsiElement(EQEQ)('==')
+            PsiWhiteSpace(' ')
+            INTEGER_CONSTANT
+              PsiElement(INTEGER_LITERAL)('0')
+        PsiElement(RPAR)(')')
+        PsiWhiteSpace(' ')
+        THEN
+          BLOCK
+            PsiElement(LBRACE)('{')
+            PsiWhiteSpace('\n        ')
+            DOT_QUALIFIED_EXPRESSION
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('annotation')
+              PsiElement(DOT)('.')
+              CALL_EXPRESSION
+                REFERENCE_EXPRESSION
+                  PsiElement(IDENTIFIER)('baz')
+                VALUE_ARGUMENT_LIST
+                  PsiElement(LPAR)('(')
+                  PsiElement(RPAR)(')')
+            PsiWhiteSpace('\n        ')
+            RETURN
+              PsiElement(return)('return')
+              PsiWhiteSpace(' ')
+              INTEGER_CONSTANT
+                PsiElement(INTEGER_LITERAL)('0')
+            PsiWhiteSpace('\n    ')
+            PsiElement(RBRACE)('}')
+        PsiWhiteSpace('\n    ')
+        PsiElement(else)('else')
+        PsiWhiteSpace(' ')
+        ELSE
+          BLOCK
+            PsiElement(LBRACE)('{')
+            PsiWhiteSpace('\n        ')
+            RETURN
+              PsiElement(return)('return')
+              PsiWhiteSpace(' ')
+              PREFIX_EXPRESSION
+                OPERATION_REFERENCE
+                  PsiElement(MINUS)('-')
+                INTEGER_CONSTANT
+                  PsiElement(INTEGER_LITERAL)('1')
+            PsiWhiteSpace('\n    ')
+            PsiElement(RBRACE)('}')
+      PsiWhiteSpace('\n')
+      PsiElement(RBRACE)('}')
\ No newline at end of file
diff --git a/compiler/testData/psi/annotation/options/annotationAsArgComplex.kt b/compiler/testData/psi/annotation/options/annotationAsArgComplex.kt
new file mode 100644
index 00000000000..2f8aa3161d0
--- /dev/null
+++ b/compiler/testData/psi/annotation/options/annotationAsArgComplex.kt
@@ -0,0 +1,9 @@
+class Annotation {
+    fun setProblemGroup() {}
+    fun getQuickFixes() = 0
+}
+
+fun registerQuickFix(annotation: Annotation) {
+    annotation.setProblemGroup()
+    val fixes = annotation.getQuickFixes()
+}
diff --git a/compiler/testData/psi/annotation/options/annotationAsArgComplex.txt b/compiler/testData/psi/annotation/options/annotationAsArgComplex.txt
new file mode 100644
index 00000000000..6000806b13d
--- /dev/null
+++ b/compiler/testData/psi/annotation/options/annotationAsArgComplex.txt
@@ -0,0 +1,89 @@
+JetFile: annotationAsArgComplex.kt
+  PACKAGE_DIRECTIVE
+    <empty list>
+  IMPORT_LIST
+    <empty list>
+  CLASS
+    PsiElement(class)('class')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('Annotation')
+    PsiWhiteSpace(' ')
+    CLASS_BODY
+      PsiElement(LBRACE)('{')
+      PsiWhiteSpace('\n    ')
+      FUN
+        PsiElement(fun)('fun')
+        PsiWhiteSpace(' ')
+        PsiElement(IDENTIFIER)('setProblemGroup')
+        VALUE_PARAMETER_LIST
+          PsiElement(LPAR)('(')
+          PsiElement(RPAR)(')')
+        PsiWhiteSpace(' ')
+        BLOCK
+          PsiElement(LBRACE)('{')
+          PsiElement(RBRACE)('}')
+      PsiWhiteSpace('\n    ')
+      FUN
+        PsiElement(fun)('fun')
+        PsiWhiteSpace(' ')
+        PsiElement(IDENTIFIER)('getQuickFixes')
+        VALUE_PARAMETER_LIST
+          PsiElement(LPAR)('(')
+          PsiElement(RPAR)(')')
+        PsiWhiteSpace(' ')
+        PsiElement(EQ)('=')
+        PsiWhiteSpace(' ')
+        INTEGER_CONSTANT
+          PsiElement(INTEGER_LITERAL)('0')
+      PsiWhiteSpace('\n')
+      PsiElement(RBRACE)('}')
+  PsiWhiteSpace('\n\n')
+  FUN
+    PsiElement(fun)('fun')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('registerQuickFix')
+    VALUE_PARAMETER_LIST
+      PsiElement(LPAR)('(')
+      VALUE_PARAMETER
+        PsiElement(IDENTIFIER)('annotation')
+        PsiElement(COLON)(':')
+        PsiWhiteSpace(' ')
+        TYPE_REFERENCE
+          USER_TYPE
+            REFERENCE_EXPRESSION
+              PsiElement(IDENTIFIER)('Annotation')
+      PsiElement(RPAR)(')')
+    PsiWhiteSpace(' ')
+    BLOCK
+      PsiElement(LBRACE)('{')
+      PsiWhiteSpace('\n    ')
+      DOT_QUALIFIED_EXPRESSION
+        REFERENCE_EXPRESSION
+          PsiElement(IDENTIFIER)('annotation')
+        PsiElement(DOT)('.')
+        CALL_EXPRESSION
+          REFERENCE_EXPRESSION
+            PsiElement(IDENTIFIER)('setProblemGroup')
+          VALUE_ARGUMENT_LIST
+            PsiElement(LPAR)('(')
+            PsiElement(RPAR)(')')
+      PsiWhiteSpace('\n    ')
+      PROPERTY
+        PsiElement(val)('val')
+        PsiWhiteSpace(' ')
+        PsiElement(IDENTIFIER)('fixes')
+        PsiWhiteSpace(' ')
+        PsiElement(EQ)('=')
+        PsiWhiteSpace(' ')
+        DOT_QUALIFIED_EXPRESSION
+          REFERENCE_EXPRESSION
+            PsiElement(IDENTIFIER)('annotation')
+          PsiElement(DOT)('.')
+          CALL_EXPRESSION
+            REFERENCE_EXPRESSION
+              PsiElement(IDENTIFIER)('getQuickFixes')
+            VALUE_ARGUMENT_LIST
+              PsiElement(LPAR)('(')
+              PsiElement(RPAR)(')')
+      PsiWhiteSpace('\n')
+      PsiElement(RBRACE)('}')
\ No newline at end of file
diff --git a/compiler/testData/psi/annotation/options/java.kt b/compiler/testData/psi/annotation/options/java.kt
new file mode 100644
index 00000000000..64d86b337ca
--- /dev/null
+++ b/compiler/testData/psi/annotation/options/java.kt
@@ -0,0 +1,10 @@
+import java.lang.annotation.*
+
+annotation 
+@java.lang.annotation.Retention(RetentionPolicy.CLASS) 
+class my
+
+annotation 
+Retention(RetentionPolicy.RUNTIME) 
+Target(ElementType.ANNOTATION_TYPE, ElementType.CONSTRUCTOR) 
+class my1
diff --git a/compiler/testData/psi/annotation/options/java.txt b/compiler/testData/psi/annotation/options/java.txt
new file mode 100644
index 00000000000..7609d622a01
--- /dev/null
+++ b/compiler/testData/psi/annotation/options/java.txt
@@ -0,0 +1,118 @@
+JetFile: java.kt
+  PACKAGE_DIRECTIVE
+    <empty list>
+  IMPORT_LIST
+    IMPORT_DIRECTIVE
+      PsiElement(import)('import')
+      PsiWhiteSpace(' ')
+      DOT_QUALIFIED_EXPRESSION
+        DOT_QUALIFIED_EXPRESSION
+          REFERENCE_EXPRESSION
+            PsiElement(IDENTIFIER)('java')
+          PsiElement(DOT)('.')
+          REFERENCE_EXPRESSION
+            PsiElement(IDENTIFIER)('lang')
+        PsiElement(DOT)('.')
+        REFERENCE_EXPRESSION
+          PsiElement(IDENTIFIER)('annotation')
+      PsiElement(DOT)('.')
+      PsiElement(MUL)('*')
+  PsiWhiteSpace('\n\n')
+  CLASS
+    MODIFIER_LIST
+      ANNOTATION_ENTRY
+        CONSTRUCTOR_CALLEE
+          TYPE_REFERENCE
+            USER_TYPE
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('annotation')
+      PsiWhiteSpace(' \n')
+      ANNOTATION_ENTRY
+        PsiElement(AT)('@')
+        CONSTRUCTOR_CALLEE
+          TYPE_REFERENCE
+            USER_TYPE
+              USER_TYPE
+                USER_TYPE
+                  USER_TYPE
+                    REFERENCE_EXPRESSION
+                      PsiElement(IDENTIFIER)('java')
+                  PsiElement(DOT)('.')
+                  REFERENCE_EXPRESSION
+                    PsiElement(IDENTIFIER)('lang')
+                PsiElement(DOT)('.')
+                REFERENCE_EXPRESSION
+                  PsiElement(IDENTIFIER)('annotation')
+              PsiElement(DOT)('.')
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('Retention')
+        VALUE_ARGUMENT_LIST
+          PsiElement(LPAR)('(')
+          VALUE_ARGUMENT
+            DOT_QUALIFIED_EXPRESSION
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('RetentionPolicy')
+              PsiElement(DOT)('.')
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('CLASS')
+          PsiElement(RPAR)(')')
+    PsiWhiteSpace(' \n')
+    PsiElement(class)('class')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('my')
+  PsiWhiteSpace('\n\n')
+  CLASS
+    MODIFIER_LIST
+      ANNOTATION_ENTRY
+        CONSTRUCTOR_CALLEE
+          TYPE_REFERENCE
+            USER_TYPE
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('annotation')
+      PsiWhiteSpace(' \n')
+      ANNOTATION_ENTRY
+        CONSTRUCTOR_CALLEE
+          TYPE_REFERENCE
+            USER_TYPE
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('Retention')
+        VALUE_ARGUMENT_LIST
+          PsiElement(LPAR)('(')
+          VALUE_ARGUMENT
+            DOT_QUALIFIED_EXPRESSION
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('RetentionPolicy')
+              PsiElement(DOT)('.')
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('RUNTIME')
+          PsiElement(RPAR)(')')
+      PsiWhiteSpace(' \n')
+      ANNOTATION_ENTRY
+        CONSTRUCTOR_CALLEE
+          TYPE_REFERENCE
+            USER_TYPE
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('Target')
+        VALUE_ARGUMENT_LIST
+          PsiElement(LPAR)('(')
+          VALUE_ARGUMENT
+            DOT_QUALIFIED_EXPRESSION
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('ElementType')
+              PsiElement(DOT)('.')
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('ANNOTATION_TYPE')
+          PsiElement(COMMA)(',')
+          PsiWhiteSpace(' ')
+          VALUE_ARGUMENT
+            DOT_QUALIFIED_EXPRESSION
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('ElementType')
+              PsiElement(DOT)('.')
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('CONSTRUCTOR')
+          PsiElement(RPAR)(')')
+    PsiWhiteSpace(' \n')
+    PsiElement(class)('class')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('my1')
\ No newline at end of file
diff --git a/compiler/testData/psi/annotation/options/local.kt b/compiler/testData/psi/annotation/options/local.kt
new file mode 100644
index 00000000000..21c6e0b4629
--- /dev/null
+++ b/compiler/testData/psi/annotation/options/local.kt
@@ -0,0 +1,5 @@
+fun foo(): Int {
+    @annotation class Ann
+    @Ann val x = 1
+    return x
+}
\ No newline at end of file
diff --git a/compiler/testData/psi/annotation/options/local.txt b/compiler/testData/psi/annotation/options/local.txt
new file mode 100644
index 00000000000..9a25e12b7be
--- /dev/null
+++ b/compiler/testData/psi/annotation/options/local.txt
@@ -0,0 +1,62 @@
+JetFile: local.kt
+  PACKAGE_DIRECTIVE
+    <empty list>
+  IMPORT_LIST
+    <empty list>
+  FUN
+    PsiElement(fun)('fun')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('foo')
+    VALUE_PARAMETER_LIST
+      PsiElement(LPAR)('(')
+      PsiElement(RPAR)(')')
+    PsiElement(COLON)(':')
+    PsiWhiteSpace(' ')
+    TYPE_REFERENCE
+      USER_TYPE
+        REFERENCE_EXPRESSION
+          PsiElement(IDENTIFIER)('Int')
+    PsiWhiteSpace(' ')
+    BLOCK
+      PsiElement(LBRACE)('{')
+      PsiWhiteSpace('\n    ')
+      CLASS
+        MODIFIER_LIST
+          ANNOTATION_ENTRY
+            PsiElement(AT)('@')
+            CONSTRUCTOR_CALLEE
+              TYPE_REFERENCE
+                USER_TYPE
+                  REFERENCE_EXPRESSION
+                    PsiElement(IDENTIFIER)('annotation')
+        PsiWhiteSpace(' ')
+        PsiElement(class)('class')
+        PsiWhiteSpace(' ')
+        PsiElement(IDENTIFIER)('Ann')
+      PsiWhiteSpace('\n    ')
+      PROPERTY
+        MODIFIER_LIST
+          ANNOTATION_ENTRY
+            PsiElement(AT)('@')
+            CONSTRUCTOR_CALLEE
+              TYPE_REFERENCE
+                USER_TYPE
+                  REFERENCE_EXPRESSION
+                    PsiElement(IDENTIFIER)('Ann')
+        PsiWhiteSpace(' ')
+        PsiElement(val)('val')
+        PsiWhiteSpace(' ')
+        PsiElement(IDENTIFIER)('x')
+        PsiWhiteSpace(' ')
+        PsiElement(EQ)('=')
+        PsiWhiteSpace(' ')
+        INTEGER_CONSTANT
+          PsiElement(INTEGER_LITERAL)('1')
+      PsiWhiteSpace('\n    ')
+      RETURN
+        PsiElement(return)('return')
+        PsiWhiteSpace(' ')
+        REFERENCE_EXPRESSION
+          PsiElement(IDENTIFIER)('x')
+      PsiWhiteSpace('\n')
+      PsiElement(RBRACE)('}')
\ No newline at end of file
diff --git a/compiler/testData/psi/annotation/options/options.kt b/compiler/testData/psi/annotation/options/options.kt
new file mode 100644
index 00000000000..f51b6127ec7
--- /dev/null
+++ b/compiler/testData/psi/annotation/options/options.kt
@@ -0,0 +1,12 @@
+annotation class base
+
+annotation() class empty
+
+annotation(repeatable = true) class ann
+
+annotation(Retention.BINARY, false) class ann2
+
+annotation(retention = Retention.RUNTIME) class ann3
+
+target(Target.FUNCTION, Target.CLASSIFIER, Target.EXPRESSION)
+annotation(Retention.SOURCE) class ann4
\ No newline at end of file
diff --git a/compiler/testData/psi/annotation/options/options.txt b/compiler/testData/psi/annotation/options/options.txt
new file mode 100644
index 00000000000..0352a3b4644
--- /dev/null
+++ b/compiler/testData/psi/annotation/options/options.txt
@@ -0,0 +1,173 @@
+JetFile: options.kt
+  PACKAGE_DIRECTIVE
+    <empty list>
+  IMPORT_LIST
+    <empty list>
+  CLASS
+    MODIFIER_LIST
+      ANNOTATION_ENTRY
+        CONSTRUCTOR_CALLEE
+          TYPE_REFERENCE
+            USER_TYPE
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('annotation')
+    PsiWhiteSpace(' ')
+    PsiElement(class)('class')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('base')
+  PsiWhiteSpace('\n\n')
+  CLASS
+    MODIFIER_LIST
+      ANNOTATION_ENTRY
+        CONSTRUCTOR_CALLEE
+          TYPE_REFERENCE
+            USER_TYPE
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('annotation')
+        VALUE_ARGUMENT_LIST
+          PsiElement(LPAR)('(')
+          PsiElement(RPAR)(')')
+    PsiWhiteSpace(' ')
+    PsiElement(class)('class')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('empty')
+  PsiWhiteSpace('\n\n')
+  CLASS
+    MODIFIER_LIST
+      ANNOTATION_ENTRY
+        CONSTRUCTOR_CALLEE
+          TYPE_REFERENCE
+            USER_TYPE
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('annotation')
+        VALUE_ARGUMENT_LIST
+          PsiElement(LPAR)('(')
+          VALUE_ARGUMENT
+            VALUE_ARGUMENT_NAME
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('repeatable')
+            PsiWhiteSpace(' ')
+            PsiElement(EQ)('=')
+            PsiWhiteSpace(' ')
+            BOOLEAN_CONSTANT
+              PsiElement(true)('true')
+          PsiElement(RPAR)(')')
+    PsiWhiteSpace(' ')
+    PsiElement(class)('class')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('ann')
+  PsiWhiteSpace('\n\n')
+  CLASS
+    MODIFIER_LIST
+      ANNOTATION_ENTRY
+        CONSTRUCTOR_CALLEE
+          TYPE_REFERENCE
+            USER_TYPE
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('annotation')
+        VALUE_ARGUMENT_LIST
+          PsiElement(LPAR)('(')
+          VALUE_ARGUMENT
+            DOT_QUALIFIED_EXPRESSION
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('Retention')
+              PsiElement(DOT)('.')
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('BINARY')
+          PsiElement(COMMA)(',')
+          PsiWhiteSpace(' ')
+          VALUE_ARGUMENT
+            BOOLEAN_CONSTANT
+              PsiElement(false)('false')
+          PsiElement(RPAR)(')')
+    PsiWhiteSpace(' ')
+    PsiElement(class)('class')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('ann2')
+  PsiWhiteSpace('\n\n')
+  CLASS
+    MODIFIER_LIST
+      ANNOTATION_ENTRY
+        CONSTRUCTOR_CALLEE
+          TYPE_REFERENCE
+            USER_TYPE
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('annotation')
+        VALUE_ARGUMENT_LIST
+          PsiElement(LPAR)('(')
+          VALUE_ARGUMENT
+            VALUE_ARGUMENT_NAME
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('retention')
+            PsiWhiteSpace(' ')
+            PsiElement(EQ)('=')
+            PsiWhiteSpace(' ')
+            DOT_QUALIFIED_EXPRESSION
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('Retention')
+              PsiElement(DOT)('.')
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('RUNTIME')
+          PsiElement(RPAR)(')')
+    PsiWhiteSpace(' ')
+    PsiElement(class)('class')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('ann3')
+  PsiWhiteSpace('\n\n')
+  CLASS
+    MODIFIER_LIST
+      ANNOTATION_ENTRY
+        CONSTRUCTOR_CALLEE
+          TYPE_REFERENCE
+            USER_TYPE
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('target')
+        VALUE_ARGUMENT_LIST
+          PsiElement(LPAR)('(')
+          VALUE_ARGUMENT
+            DOT_QUALIFIED_EXPRESSION
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('Target')
+              PsiElement(DOT)('.')
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('FUNCTION')
+          PsiElement(COMMA)(',')
+          PsiWhiteSpace(' ')
+          VALUE_ARGUMENT
+            DOT_QUALIFIED_EXPRESSION
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('Target')
+              PsiElement(DOT)('.')
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('CLASSIFIER')
+          PsiElement(COMMA)(',')
+          PsiWhiteSpace(' ')
+          VALUE_ARGUMENT
+            DOT_QUALIFIED_EXPRESSION
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('Target')
+              PsiElement(DOT)('.')
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('EXPRESSION')
+          PsiElement(RPAR)(')')
+      PsiWhiteSpace('\n')
+      ANNOTATION_ENTRY
+        CONSTRUCTOR_CALLEE
+          TYPE_REFERENCE
+            USER_TYPE
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('annotation')
+        VALUE_ARGUMENT_LIST
+          PsiElement(LPAR)('(')
+          VALUE_ARGUMENT
+            DOT_QUALIFIED_EXPRESSION
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('Retention')
+              PsiElement(DOT)('.')
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('SOURCE')
+          PsiElement(RPAR)(')')
+    PsiWhiteSpace(' ')
+    PsiElement(class)('class')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('ann4')
\ No newline at end of file
diff --git a/compiler/testData/psi/script/ShebangIncorrect.txt b/compiler/testData/psi/script/ShebangIncorrect.txt
index b7abfe89664..2a6d234577d 100644
--- a/compiler/testData/psi/script/ShebangIncorrect.txt
+++ b/compiler/testData/psi/script/ShebangIncorrect.txt
@@ -16,24 +16,20 @@ JetFile: ShebangIncorrect.kts
           PsiElement(RPAR)(')')
       PsiElement(SEMICOLON)(';')
       PsiWhiteSpace(' ')
+      PsiErrorElement:Expecting an element
+        PsiElement(HASH)('#')
       BINARY_EXPRESSION
-        PsiErrorElement:Tuples are not supported. Use data classes instead.
-          PsiElement(HASH)('#')
-          PsiElement(EXCL)('!')
-          PsiErrorElement:Expecting an expression
-            <empty list>
+        PREFIX_EXPRESSION
+          OPERATION_REFERENCE
+            PsiElement(EXCL)('!')
+          PsiErrorElement:Expecting an element
+            PsiElement(DIV)('/')
         OPERATION_REFERENCE
-          PsiElement(DIV)('/')
-        REFERENCE_EXPRESSION
           PsiElement(IDENTIFIER)('usr')
-      PsiWhiteSpace('\n\n')
-      BINARY_EXPRESSION
-        PsiErrorElement:Tuples are not supported. Use data classes instead.
+        PsiWhiteSpace('\n\n')
+        PsiErrorElement:Expecting an element
           PsiElement(HASH)('#')
-          PsiElement(EXCL)('!')
-          PsiErrorElement:Expecting an expression
-            <empty list>
-        OPERATION_REFERENCE
-          PsiElement(DIV)('/')
-        REFERENCE_EXPRESSION
-          PsiElement(IDENTIFIER)('hi')
+      PsiErrorElement:Unexpected tokens (use ';' to separate expressions on the same line)
+        PsiElement(EXCL)('!')
+        PsiElement(DIV)('/')
+        PsiElement(IDENTIFIER)('hi')
\ No newline at end of file
diff --git a/compiler/testData/renderer/Classes.kt b/compiler/testData/renderer/Classes.kt
index 31df8ff1a43..722173536e6 100644
--- a/compiler/testData/renderer/Classes.kt
+++ b/compiler/testData/renderer/Classes.kt
@@ -35,9 +35,9 @@ public class WithReified<reified A, reified out B>
 public interface TwoUpperBounds<T> where T : Number, T : Any
 
 //package rendererTest
-//internal final annotation class TheAnnotation : kotlin.Annotation defined in rendererTest
+//kotlin.annotation.annotation internal final class TheAnnotation : kotlin.Annotation defined in rendererTest
 //public constructor TheAnnotation() defined in rendererTest.TheAnnotation
-//internal final annotation class AnotherAnnotation : kotlin.Annotation defined in rendererTest
+//kotlin.annotation.annotation internal final class AnotherAnnotation : kotlin.Annotation defined in rendererTest
 //public constructor AnotherAnnotation() defined in rendererTest.AnotherAnnotation
 //rendererTest.TheAnnotation public open class TheClass<out T : kotlin.Int, X> defined in rendererTest
 //<out T : kotlin.Int> defined in rendererTest.TheClass
diff --git a/compiler/testData/renderer/KeywordsInNames.kt b/compiler/testData/renderer/KeywordsInNames.kt
index 1c92b06d8f7..b76e7c22f7c 100644
--- a/compiler/testData/renderer/KeywordsInNames.kt
+++ b/compiler/testData/renderer/KeywordsInNames.kt
@@ -17,7 +17,7 @@ val AS_SAFE = 1
 val NOT_IN = 2
 val NOT_IS = 3
 
-//internal final annotation class `true` : kotlin.Annotation defined in root package
+//kotlin.annotation.annotation internal final class `true` : kotlin.Annotation defined in root package
 //public constructor `true`() defined in `true`
 //internal val `val`: kotlin.Int defined in root package
 //`true` internal interface `interface` defined in root package
diff --git a/compiler/testData/repl/useJava/syntheticProperty.repl b/compiler/testData/repl/useJava/syntheticProperty.repl
new file mode 100644
index 00000000000..a43a5f40c56
--- /dev/null
+++ b/compiler/testData/repl/useJava/syntheticProperty.repl
@@ -0,0 +1,2 @@
+>>> java.util.Date(0).time
+0
diff --git a/compiler/testData/resolveAnnotations/parameters/byte.kt b/compiler/testData/resolveAnnotations/parameters/byte.kt
index 975bd272817..b953532f881 100644
--- a/compiler/testData/resolveAnnotations/parameters/byte.kt
+++ b/compiler/testData/resolveAnnotations/parameters/byte.kt
@@ -9,4 +9,4 @@ annotation class Ann(
 
 Ann(1, 1.toByte(), 128.toByte(), 128) class MyClass
 
-// EXPECTED: Ann(b1 = IntegerValueType(1), b2 = 1.toByte(), b3 = -128.toByte(), b4 = IntegerValueType(128))
\ No newline at end of file
+// EXPECTED: Ann(b1 = 1.toByte(), b2 = 1.toByte(), b3 = -128.toByte(), b4 = 128)
\ No newline at end of file
diff --git a/compiler/testData/resolveAnnotations/parameters/expressions/char.kt b/compiler/testData/resolveAnnotations/parameters/expressions/char.kt
index 2be63e20012..004b0288ea9 100644
--- a/compiler/testData/resolveAnnotations/parameters/expressions/char.kt
+++ b/compiler/testData/resolveAnnotations/parameters/expressions/char.kt
@@ -4,4 +4,4 @@ annotation class Ann(val c1: Char)
 
 Ann('a' - 'a') class MyClass
 
-// EXPECTED: Ann(c1 = IntegerValueType(0))
+// EXPECTED: Ann(c1 = 0)
diff --git a/compiler/testData/resolveAnnotations/parameters/expressions/divide.kt b/compiler/testData/resolveAnnotations/parameters/expressions/divide.kt
index 5a146c2e77f..f5e60dd97e1 100644
--- a/compiler/testData/resolveAnnotations/parameters/expressions/divide.kt
+++ b/compiler/testData/resolveAnnotations/parameters/expressions/divide.kt
@@ -9,4 +9,4 @@ annotation class Ann(
 
 Ann(1 / 1, 1 / 1, 1 / 1, 1 / 1) class MyClass
 
-// EXPECTED: Ann(b = IntegerValueType(1), i = IntegerValueType(1), l = IntegerValueType(1), s = IntegerValueType(1))
+// EXPECTED: Ann(b = 1.toByte(), i = 1, l = 1.toLong(), s = 1.toShort())
diff --git a/compiler/testData/resolveAnnotations/parameters/expressions/infixCallBinary.kt b/compiler/testData/resolveAnnotations/parameters/expressions/infixCallBinary.kt
index 6d36415f438..0d67ae790da 100644
--- a/compiler/testData/resolveAnnotations/parameters/expressions/infixCallBinary.kt
+++ b/compiler/testData/resolveAnnotations/parameters/expressions/infixCallBinary.kt
@@ -10,4 +10,4 @@ annotation class Ann(
 
 Ann(1 plus 1, 1 minus 1, 1 times 1, 1 div 1, 1 mod 1) class MyClass
 
-// EXPECTED: Ann(p1 = IntegerValueType(2), p2 = IntegerValueType(0), p3 = IntegerValueType(1), p4 = IntegerValueType(1), p5 = IntegerValueType(0))
+// EXPECTED: Ann(p1 = 2, p2 = 0, p3 = 1, p4 = 1, p5 = 0)
diff --git a/compiler/testData/resolveAnnotations/parameters/expressions/intrincics.kt b/compiler/testData/resolveAnnotations/parameters/expressions/intrincics.kt
index 57df6738438..eac70c9d80f 100644
--- a/compiler/testData/resolveAnnotations/parameters/expressions/intrincics.kt
+++ b/compiler/testData/resolveAnnotations/parameters/expressions/intrincics.kt
@@ -10,4 +10,4 @@ annotation class Ann(p1: Int,
 
 Ann(1 or 1, 1 and 1, 1 xor 1, 1 shl 1, 1 shr 1, 1 ushr 1) class MyClass
 
-// EXPECTED: Ann(p1 = IntegerValueType(1), p2 = IntegerValueType(1), p3 = IntegerValueType(0), p4 = IntegerValueType(2), p5 = IntegerValueType(0), p6 = IntegerValueType(0))
+// EXPECTED: Ann(p1 = 1, p2 = 1.toShort(), p3 = 0.toByte(), p4 = 2, p5 = 0, p6 = 0)
diff --git a/compiler/testData/resolveAnnotations/parameters/expressions/long.kt b/compiler/testData/resolveAnnotations/parameters/expressions/long.kt
index fd46cfc7617..1363d922c3a 100644
--- a/compiler/testData/resolveAnnotations/parameters/expressions/long.kt
+++ b/compiler/testData/resolveAnnotations/parameters/expressions/long.kt
@@ -8,4 +8,4 @@ annotation class Ann(
 
 Ann(1 + 1, java.lang.Long.MAX_VALUE + 1 - 1, java.lang.Long.MAX_VALUE - 1) class MyClass
 
-// EXPECTED: Ann(l1 = IntegerValueType(2), l2 = 9223372036854775807.toLong(), l3 = 9223372036854775806.toLong())
+// EXPECTED: Ann(l1 = 2.toLong(), l2 = 9223372036854775807.toLong(), l3 = 9223372036854775806.toLong())
diff --git a/compiler/testData/resolveAnnotations/parameters/expressions/maxValueByte.kt b/compiler/testData/resolveAnnotations/parameters/expressions/maxValueByte.kt
index 699ed948087..9127af4c873 100644
--- a/compiler/testData/resolveAnnotations/parameters/expressions/maxValueByte.kt
+++ b/compiler/testData/resolveAnnotations/parameters/expressions/maxValueByte.kt
@@ -16,4 +16,4 @@ Ann(
     p5 = 1.toByte() + 1.toByte()
 ) class MyClass
 
-// EXPECTED: Ann(p1 = 128, p2 = IntegerValueType(2), p3 = 128, p4 = 2, p5 = 2)
+// EXPECTED: Ann(p1 = 128, p2 = 2.toByte(), p3 = 128, p4 = 2, p5 = 2)
diff --git a/compiler/testData/resolveAnnotations/parameters/expressions/maxValueInt.kt b/compiler/testData/resolveAnnotations/parameters/expressions/maxValueInt.kt
index 9d558c9aef3..ad28cc95479 100644
--- a/compiler/testData/resolveAnnotations/parameters/expressions/maxValueInt.kt
+++ b/compiler/testData/resolveAnnotations/parameters/expressions/maxValueInt.kt
@@ -16,4 +16,4 @@ Ann(
     p5 = 1.toInt() + 1.toInt()
 ) class MyClass
 
-// EXPECTED: Ann(p1 = -2147483648, p2 = IntegerValueType(2), p3 = -2147483648, p4 = 2, p5 = 2)
+// EXPECTED: Ann(p1 = -2147483648, p2 = 2, p3 = -2147483648, p4 = 2, p5 = 2)
diff --git a/compiler/testData/resolveAnnotations/parameters/expressions/miltiply.kt b/compiler/testData/resolveAnnotations/parameters/expressions/miltiply.kt
index 18e45eb61ff..6974a5e5986 100644
--- a/compiler/testData/resolveAnnotations/parameters/expressions/miltiply.kt
+++ b/compiler/testData/resolveAnnotations/parameters/expressions/miltiply.kt
@@ -9,4 +9,4 @@ annotation class Ann(
 
 Ann(1 * 1, 1 * 1, 1 * 1, 1 * 1) class MyClass
 
-// EXPECTED: Ann(b = IntegerValueType(1), i = IntegerValueType(1), l = IntegerValueType(1), s = IntegerValueType(1))
+// EXPECTED: Ann(b = 1.toByte(), i = 1, l = 1.toLong(), s = 1.toShort())
diff --git a/compiler/testData/resolveAnnotations/parameters/expressions/minus.kt b/compiler/testData/resolveAnnotations/parameters/expressions/minus.kt
index 71fd2ae8bc3..f3e7cb53f57 100644
--- a/compiler/testData/resolveAnnotations/parameters/expressions/minus.kt
+++ b/compiler/testData/resolveAnnotations/parameters/expressions/minus.kt
@@ -9,4 +9,4 @@ annotation class Ann(
 
 Ann(1 - 1, 1 - 1, 1 - 1, 1 - 1) class MyClass
 
-// EXPECTED: Ann(b = IntegerValueType(0), i = IntegerValueType(0), l = IntegerValueType(0), s = IntegerValueType(0))
+// EXPECTED: Ann(b = 0.toByte(), i = 0, l = 0.toLong(), s = 0.toShort())
diff --git a/compiler/testData/resolveAnnotations/parameters/expressions/mod.kt b/compiler/testData/resolveAnnotations/parameters/expressions/mod.kt
index 1df17b2e9f1..0754ffe3dc1 100644
--- a/compiler/testData/resolveAnnotations/parameters/expressions/mod.kt
+++ b/compiler/testData/resolveAnnotations/parameters/expressions/mod.kt
@@ -9,4 +9,4 @@ annotation class Ann(
 
 Ann(1 % 1, 1 % 1, 1 % 1, 1 % 1) class MyClass
 
-// EXPECTED: Ann(b = IntegerValueType(0), i = IntegerValueType(0), l = IntegerValueType(0), s = IntegerValueType(0))
+// EXPECTED: Ann(b = 0.toByte(), i = 0, l = 0.toLong(), s = 0.toShort())
diff --git a/compiler/testData/resolveAnnotations/parameters/expressions/paranthesized.kt b/compiler/testData/resolveAnnotations/parameters/expressions/paranthesized.kt
index bc997c607cb..42bd629f2db 100644
--- a/compiler/testData/resolveAnnotations/parameters/expressions/paranthesized.kt
+++ b/compiler/testData/resolveAnnotations/parameters/expressions/paranthesized.kt
@@ -4,4 +4,4 @@ annotation class Ann(i: Int)
 
 Ann((1 + 2) * 2) class MyClass
 
-// EXPECTED: Ann(i = IntegerValueType(6))
+// EXPECTED: Ann(i = 6)
diff --git a/compiler/testData/resolveAnnotations/parameters/expressions/plus.kt b/compiler/testData/resolveAnnotations/parameters/expressions/plus.kt
index 9c8042b543a..36d84f9b39d 100644
--- a/compiler/testData/resolveAnnotations/parameters/expressions/plus.kt
+++ b/compiler/testData/resolveAnnotations/parameters/expressions/plus.kt
@@ -9,4 +9,4 @@ annotation class Ann(
 
 Ann(1 + 1, 1 + 1, 1 + 1, 1 + 1) class MyClass
 
-// EXPECTED: Ann(b = IntegerValueType(2), i = IntegerValueType(2), l = IntegerValueType(2), s = IntegerValueType(2))
+// EXPECTED: Ann(b = 2.toByte(), i = 2, l = 2.toLong(), s = 2.toShort())
diff --git a/compiler/testData/resolveAnnotations/parameters/expressions/simpleCallBinary.kt b/compiler/testData/resolveAnnotations/parameters/expressions/simpleCallBinary.kt
index ccd45c47ed1..5e474748142 100644
--- a/compiler/testData/resolveAnnotations/parameters/expressions/simpleCallBinary.kt
+++ b/compiler/testData/resolveAnnotations/parameters/expressions/simpleCallBinary.kt
@@ -10,4 +10,4 @@ annotation class Ann(
 
 Ann(1.plus(1), 1.minus(1), 1.times(1), 1.div(1), 1.mod(1)) class MyClass
 
-// EXPECTED: Ann(p1 = IntegerValueType(2), p2 = IntegerValueType(0), p3 = IntegerValueType(1), p4 = IntegerValueType(1), p5 = IntegerValueType(0))
+// EXPECTED: Ann(p1 = 2, p2 = 0, p3 = 1, p4 = 1, p5 = 0)
diff --git a/compiler/testData/resolveAnnotations/parameters/expressions/unaryMinus.kt b/compiler/testData/resolveAnnotations/parameters/expressions/unaryMinus.kt
index b318960bcb6..f7f7c911aac 100644
--- a/compiler/testData/resolveAnnotations/parameters/expressions/unaryMinus.kt
+++ b/compiler/testData/resolveAnnotations/parameters/expressions/unaryMinus.kt
@@ -6,10 +6,9 @@ annotation class Ann(
         val b3: Int,
         val b4: Long,
         val b5: Double,
-        val b6: Float,
-        val b7: Char
+        val b6: Float
 )
 
-Ann(-1, -1, -1, -1, -1.0, -1.0.toFloat(), -'c') class MyClass
+Ann(-1, -1, -1, -1, -1.0, -1.0.toFloat()) class MyClass
 
-// EXPECTED: Ann(b1 = IntegerValueType(-1), b2 = IntegerValueType(-1), b3 = IntegerValueType(-1), b4 = IntegerValueType(-1), b5 = -1.0.toDouble(), b6 = -1.0.toFloat(), b7 = IntegerValueType(-99))
+// EXPECTED: Ann(b1 = -1.toByte(), b2 = -1.toShort(), b3 = -1, b4 = -1.toLong(), b5 = -1.0.toDouble(), b6 = -1.0.toFloat())
diff --git a/compiler/testData/resolveAnnotations/parameters/expressions/unaryPlus.kt b/compiler/testData/resolveAnnotations/parameters/expressions/unaryPlus.kt
index c0751b02203..8d9a91b50af 100644
--- a/compiler/testData/resolveAnnotations/parameters/expressions/unaryPlus.kt
+++ b/compiler/testData/resolveAnnotations/parameters/expressions/unaryPlus.kt
@@ -6,10 +6,9 @@ annotation class Ann(
         val b3: Int,
         val b4: Long,
         val b5: Double,
-        val b6: Float,
-        val b7: Char
+        val b6: Float
 )
 
-Ann(+1, +1, +1, +1, +1.0, +1.0.toFloat(), +'c') class MyClass
+Ann(+1, +1, +1, +1, +1.0, +1.0.toFloat()) class MyClass
 
-// EXPECTED: Ann(b1 = IntegerValueType(1), b2 = IntegerValueType(1), b3 = IntegerValueType(1), b4 = IntegerValueType(1), b5 = 1.0.toDouble(), b6 = 1.0.toFloat(), b7 = IntegerValueType(99))
+// EXPECTED: Ann(b1 = 1.toByte(), b2 = 1.toShort(), b3 = 1, b4 = 1.toLong(), b5 = 1.0.toDouble(), b6 = 1.0.toFloat())
diff --git a/compiler/testData/resolveAnnotations/parameters/int.kt b/compiler/testData/resolveAnnotations/parameters/int.kt
index f66cf48ab35..f02f77b3c02 100644
--- a/compiler/testData/resolveAnnotations/parameters/int.kt
+++ b/compiler/testData/resolveAnnotations/parameters/int.kt
@@ -9,4 +9,4 @@ annotation class Ann(
 
 Ann(1, 1.toInt(), 2147483648.toInt(), 2147483648) class MyClass
 
-// EXPECTED: Ann(b1 = IntegerValueType(1), b2 = 1, b3 = -2147483648, b4 = IntegerValueType(2147483648))
\ No newline at end of file
+// EXPECTED: Ann(b1 = 1, b2 = 1, b3 = -2147483648, b4 = 2147483648.toLong())
\ No newline at end of file
diff --git a/compiler/testData/resolveAnnotations/parameters/long.kt b/compiler/testData/resolveAnnotations/parameters/long.kt
index a5e737289e6..06c689d50ef 100644
--- a/compiler/testData/resolveAnnotations/parameters/long.kt
+++ b/compiler/testData/resolveAnnotations/parameters/long.kt
@@ -7,4 +7,4 @@ annotation class Ann(
 
 Ann(1, 1.toLong()) class MyClass
 
-// EXPECTED: Ann(b1 = IntegerValueType(1), b2 = 1.toLong())
\ No newline at end of file
+// EXPECTED: Ann(b1 = 1.toLong(), b2 = 1.toLong())
\ No newline at end of file
diff --git a/compiler/testData/resolveAnnotations/parameters/short.kt b/compiler/testData/resolveAnnotations/parameters/short.kt
index bdd892a457a..9192a5bbcb2 100644
--- a/compiler/testData/resolveAnnotations/parameters/short.kt
+++ b/compiler/testData/resolveAnnotations/parameters/short.kt
@@ -9,4 +9,4 @@ annotation class Ann(
 
 Ann(1, 1.toShort(), 32768.toShort(), 32768) class MyClass
 
-// EXPECTED: Ann(b1 = IntegerValueType(1), b2 = 1.toShort(), b3 = -32768.toShort(), b4 = IntegerValueType(32768))
\ No newline at end of file
+// EXPECTED: Ann(b1 = 1.toShort(), b2 = 1.toShort(), b3 = -32768.toShort(), b4 = 32768)
\ No newline at end of file
diff --git a/compiler/testData/resolvedCalls/arguments/realExamples/emptyList.txt b/compiler/testData/resolvedCalls/arguments/realExamples/emptyList.txt
index 24203fd1e26..2ae11394112 100644
--- a/compiler/testData/resolvedCalls/arguments/realExamples/emptyList.txt
+++ b/compiler/testData/resolvedCalls/arguments/realExamples/emptyList.txt
@@ -12,7 +12,7 @@ fun bar() {
 Resolved call:
 
 Candidate descriptor: fun <T> foo(t: T): Unit defined in root package
-Resulting descriptor: fun <T> foo(t: List<???>): Unit defined in root package
+Resulting descriptor: fun <T> foo(t: ???): Unit defined in root package
 
 Explicit receiver kind = NO_EXPLICIT_RECEIVER
 Dispatch receiver = NO_RECEIVER
@@ -20,4 +20,4 @@ Extension receiver = NO_RECEIVER
 
 Value arguments mapping:
 
-MATCH_MODULO_UNINFERRED_TYPES  t : List<???> = someList()
+MATCH_MODULO_UNINFERRED_TYPES  t : ??? = someList()
diff --git a/compiler/testData/resolvedCalls/arguments/realExamples/emptyMutableList.txt b/compiler/testData/resolvedCalls/arguments/realExamples/emptyMutableList.txt
index 6537d71ccba..55ee516d0d4 100644
--- a/compiler/testData/resolvedCalls/arguments/realExamples/emptyMutableList.txt
+++ b/compiler/testData/resolvedCalls/arguments/realExamples/emptyMutableList.txt
@@ -12,7 +12,7 @@ fun bar() {
 Resolved call:
 
 Candidate descriptor: fun <T> foo(t: T): Unit defined in root package
-Resulting descriptor: fun <T> foo(t: MutableList<???>): Unit defined in root package
+Resulting descriptor: fun <T> foo(t: ???): Unit defined in root package
 
 Explicit receiver kind = NO_EXPLICIT_RECEIVER
 Dispatch receiver = NO_RECEIVER
@@ -20,4 +20,4 @@ Extension receiver = NO_RECEIVER
 
 Value arguments mapping:
 
-MATCH_MODULO_UNINFERRED_TYPES  t : MutableList<???> = someList()
+MATCH_MODULO_UNINFERRED_TYPES  t : ??? = someList()
diff --git a/compiler/testData/serialization/builtinsSerializer/annotationArguments/annotation.txt b/compiler/testData/serialization/builtinsSerializer/annotationArguments/annotation.txt
index 406e0750e80..09c493ea2a4 100644
--- a/compiler/testData/serialization/builtinsSerializer/annotationArguments/annotation.txt
+++ b/compiler/testData/serialization/builtinsSerializer/annotationArguments/annotation.txt
@@ -1,6 +1,6 @@
 package test
 
-internal final annotation class AnnotationArray : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class AnnotationArray : kotlin.Annotation {
     public constructor AnnotationArray(/*0*/ annotationArray: kotlin.Array<test.JustAnnotation>)
     internal final val annotationArray: kotlin.Array<test.JustAnnotation>
 }
@@ -13,11 +13,11 @@ test.AnnotationArray(annotationArray = {test.JustAnnotation(annotation = test.Em
     public constructor C2()
 }
 
-internal final annotation class Empty : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class Empty : kotlin.Annotation {
     public constructor Empty()
 }
 
-internal final annotation class JustAnnotation : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class JustAnnotation : kotlin.Annotation {
     public constructor JustAnnotation(/*0*/ annotation: test.Empty)
     internal final val annotation: test.Empty
 }
diff --git a/compiler/testData/serialization/builtinsSerializer/annotationArguments/enum.txt b/compiler/testData/serialization/builtinsSerializer/annotationArguments/enum.txt
index 11a76ebc119..d37e6bbe6e8 100644
--- a/compiler/testData/serialization/builtinsSerializer/annotationArguments/enum.txt
+++ b/compiler/testData/serialization/builtinsSerializer/annotationArguments/enum.txt
@@ -8,12 +8,12 @@ test.EnumArray(enumArray = {Weapon.PAPER, Weapon.ROCK}) internal final class C2
     public constructor C2()
 }
 
-internal final annotation class EnumArray : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class EnumArray : kotlin.Annotation {
     public constructor EnumArray(/*0*/ enumArray: kotlin.Array<test.Weapon>)
     internal final val enumArray: kotlin.Array<test.Weapon>
 }
 
-internal final annotation class JustEnum : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class JustEnum : kotlin.Annotation {
     public constructor JustEnum(/*0*/ weapon: test.Weapon)
     internal final val weapon: test.Weapon
 }
diff --git a/compiler/testData/serialization/builtinsSerializer/annotationArguments/primitiveArrays.txt b/compiler/testData/serialization/builtinsSerializer/annotationArguments/primitiveArrays.txt
index d21aca61ed4..ba43984c650 100644
--- a/compiler/testData/serialization/builtinsSerializer/annotationArguments/primitiveArrays.txt
+++ b/compiler/testData/serialization/builtinsSerializer/annotationArguments/primitiveArrays.txt
@@ -8,7 +8,7 @@ test.PrimitiveArrays(booleanArray = {}, byteArray = {}, charArray = {}, doubleAr
     public constructor C2()
 }
 
-internal final annotation class PrimitiveArrays : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class PrimitiveArrays : kotlin.Annotation {
     public constructor PrimitiveArrays(/*0*/ byteArray: kotlin.ByteArray, /*1*/ charArray: kotlin.CharArray, /*2*/ shortArray: kotlin.ShortArray, /*3*/ intArray: kotlin.IntArray, /*4*/ longArray: kotlin.LongArray, /*5*/ floatArray: kotlin.FloatArray, /*6*/ doubleArray: kotlin.DoubleArray, /*7*/ booleanArray: kotlin.BooleanArray)
     internal final val booleanArray: kotlin.BooleanArray
     internal final val byteArray: kotlin.ByteArray
diff --git a/compiler/testData/serialization/builtinsSerializer/annotationArguments/primitives.txt b/compiler/testData/serialization/builtinsSerializer/annotationArguments/primitives.txt
index 9607ed110cf..36f1e4f7b0a 100644
--- a/compiler/testData/serialization/builtinsSerializer/annotationArguments/primitives.txt
+++ b/compiler/testData/serialization/builtinsSerializer/annotationArguments/primitives.txt
@@ -8,7 +8,7 @@ test.Primitives(boolean = true, byte = 7.toByte(), char = \u0025 ('%'), double =
     public constructor D()
 }
 
-internal final annotation class Primitives : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class Primitives : kotlin.Annotation {
     public constructor Primitives(/*0*/ byte: kotlin.Byte, /*1*/ char: kotlin.Char, /*2*/ short: kotlin.Short, /*3*/ int: kotlin.Int, /*4*/ long: kotlin.Long, /*5*/ float: kotlin.Float, /*6*/ double: kotlin.Double, /*7*/ boolean: kotlin.Boolean)
     internal final val boolean: kotlin.Boolean
     internal final val byte: kotlin.Byte
diff --git a/compiler/testData/serialization/builtinsSerializer/annotationArguments/string.txt b/compiler/testData/serialization/builtinsSerializer/annotationArguments/string.txt
index 27a8890911b..4c074ac6138 100644
--- a/compiler/testData/serialization/builtinsSerializer/annotationArguments/string.txt
+++ b/compiler/testData/serialization/builtinsSerializer/annotationArguments/string.txt
@@ -8,12 +8,12 @@ test.StringArray(stringArray = {"java", ""}) internal final class C2 {
     public constructor C2()
 }
 
-internal final annotation class JustString : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class JustString : kotlin.Annotation {
     public constructor JustString(/*0*/ string: kotlin.String)
     internal final val string: kotlin.String
 }
 
-internal final annotation class StringArray : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class StringArray : kotlin.Annotation {
     public constructor StringArray(/*0*/ stringArray: kotlin.Array<kotlin.String>)
     internal final val stringArray: kotlin.Array<kotlin.String>
 }
diff --git a/compiler/testData/serialization/builtinsSerializer/annotationArguments/varargs.txt b/compiler/testData/serialization/builtinsSerializer/annotationArguments/varargs.txt
index a65fdc5c1b1..af5bb7fcbb9 100644
--- a/compiler/testData/serialization/builtinsSerializer/annotationArguments/varargs.txt
+++ b/compiler/testData/serialization/builtinsSerializer/annotationArguments/varargs.txt
@@ -32,11 +32,11 @@ internal final enum class My : kotlin.Enum<test.My> {
     public final /*synthesized*/ fun values(): kotlin.Array<test.My>
 }
 
-internal final annotation class ann : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class ann : kotlin.Annotation {
     public constructor ann(/*0*/ vararg m: test.My /*kotlin.Array<out test.My>*/)
     internal final val m: kotlin.Array<out test.My>
 }
 
-test.ann(m = {My.ALPHA, My.BETA}) internal final annotation class annotated : kotlin.Annotation {
+test.ann(m = {My.ALPHA, My.BETA}) kotlin.annotation.annotation() internal final class annotated : kotlin.Annotation {
     public constructor annotated()
 }
diff --git a/compiler/testData/serialization/builtinsSerializer/annotationTargets.txt b/compiler/testData/serialization/builtinsSerializer/annotationTargets.txt
index 0ab4c38a7b1..6389756693d 100644
--- a/compiler/testData/serialization/builtinsSerializer/annotationTargets.txt
+++ b/compiler/testData/serialization/builtinsSerializer/annotationTargets.txt
@@ -21,7 +21,7 @@ test.anno(x = "top level class") internal final class C1 {
     }
 }
 
-internal final annotation class anno : kotlin.Annotation {
+kotlin.annotation.annotation() internal final class anno : kotlin.Annotation {
     public constructor anno(/*0*/ x: kotlin.String)
     internal final val x: kotlin.String
 }
diff --git a/compiler/testData/writeFlags/callableReference/visibility/functionReference.kt b/compiler/testData/writeFlags/callableReference/visibility/functionReference.kt
new file mode 100644
index 00000000000..6ff451d264e
--- /dev/null
+++ b/compiler/testData/writeFlags/callableReference/visibility/functionReference.kt
@@ -0,0 +1,9 @@
+class A {
+    fun foo() {}
+
+    val bar = A::foo
+}
+
+// TESTED_OBJECT_KIND: class
+// TESTED_OBJECTS: A$bar$1
+// FLAGS: ACC_FINAL, ACC_SUPER
diff --git a/compiler/testData/writeFlags/callableReference/visibility/functionReferenceInInlineFunction.kt b/compiler/testData/writeFlags/callableReference/visibility/functionReferenceInInlineFunction.kt
new file mode 100644
index 00000000000..ac3186c0552
--- /dev/null
+++ b/compiler/testData/writeFlags/callableReference/visibility/functionReferenceInInlineFunction.kt
@@ -0,0 +1,9 @@
+class A {
+    fun foo() {}
+
+    inline fun bar() = A::foo
+}
+
+// TESTED_OBJECT_KIND: class
+// TESTED_OBJECTS: A$bar$1
+// FLAGS: ACC_FINAL, ACC_PUBLIC, ACC_SUPER
diff --git a/compiler/testData/writeFlags/callableReference/visibility/propertyReference.kt b/compiler/testData/writeFlags/callableReference/visibility/propertyReference.kt
new file mode 100644
index 00000000000..8f737e2a173
--- /dev/null
+++ b/compiler/testData/writeFlags/callableReference/visibility/propertyReference.kt
@@ -0,0 +1,9 @@
+class A {
+    val foo = ""
+
+    val bar = A::foo
+}
+
+// TESTED_OBJECT_KIND: class
+// TESTED_OBJECTS: A$bar$1
+// FLAGS: ACC_FINAL, ACC_SUPER
diff --git a/compiler/testData/writeFlags/callableReference/visibility/propertyReferenceInInlineFunction.kt b/compiler/testData/writeFlags/callableReference/visibility/propertyReferenceInInlineFunction.kt
new file mode 100644
index 00000000000..261fa973e3e
--- /dev/null
+++ b/compiler/testData/writeFlags/callableReference/visibility/propertyReferenceInInlineFunction.kt
@@ -0,0 +1,9 @@
+class A {
+    val foo = ""
+
+    inline fun bar() = A::foo
+}
+
+// TESTED_OBJECT_KIND: class
+// TESTED_OBJECTS: A$bar$1
+// FLAGS: ACC_FINAL, ACC_PUBLIC, ACC_SUPER
diff --git a/compiler/tests/org/jetbrains/kotlin/asJava/KotlinLightClassTestGenerated.java b/compiler/tests/org/jetbrains/kotlin/asJava/KotlinLightClassTestGenerated.java
index 15bd3924d0a..01d5419a21c 100644
--- a/compiler/tests/org/jetbrains/kotlin/asJava/KotlinLightClassTestGenerated.java
+++ b/compiler/tests/org/jetbrains/kotlin/asJava/KotlinLightClassTestGenerated.java
@@ -190,4 +190,25 @@ public class KotlinLightClassTestGenerated extends AbstractKotlinLightClassTest
             doTest(fileName);
         }
     }
+
+    @TestMetadata("compiler/testData/asJava/lightClasses/publicField")
+    @TestDataPath("$PROJECT_ROOT")
+    @RunWith(JUnit3RunnerWithInners.class)
+    public static class PublicField extends AbstractKotlinLightClassTest {
+        public void testAllFilesPresentInPublicField() throws Exception {
+            JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/asJava/lightClasses/publicField"), Pattern.compile("^(.+)\\.kt$"), true);
+        }
+
+        @TestMetadata("CompanionObject.kt")
+        public void testCompanionObject() throws Exception {
+            String fileName = JetTestUtils.navigationMetadata("compiler/testData/asJava/lightClasses/publicField/CompanionObject.kt");
+            doTest(fileName);
+        }
+
+        @TestMetadata("Simple.kt")
+        public void testSimple() throws Exception {
+            String fileName = JetTestUtils.navigationMetadata("compiler/testData/asJava/lightClasses/publicField/Simple.kt");
+            doTest(fileName);
+        }
+    }
 }
diff --git a/compiler/tests/org/jetbrains/kotlin/checkers/JetDiagnosticsTestGenerated.java b/compiler/tests/org/jetbrains/kotlin/checkers/JetDiagnosticsTestGenerated.java
index ff2bcebd025..649dfdeb967 100644
--- a/compiler/tests/org/jetbrains/kotlin/checkers/JetDiagnosticsTestGenerated.java
+++ b/compiler/tests/org/jetbrains/kotlin/checkers/JetDiagnosticsTestGenerated.java
@@ -645,6 +645,12 @@ public class JetDiagnosticsTestGenerated extends AbstractJetDiagnosticsTest {
                 doTest(fileName);
             }
 
+            @TestMetadata("AnnotationAsDefaultParameter.kt")
+            public void testAnnotationAsDefaultParameter() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/AnnotationAsDefaultParameter.kt");
+                doTest(fileName);
+            }
+
             @TestMetadata("AnnotationForClassTypeParameter.kt")
             public void testAnnotationForClassTypeParameter() throws Exception {
                 String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/AnnotationForClassTypeParameter.kt");
@@ -977,6 +983,180 @@ public class JetDiagnosticsTestGenerated extends AbstractJetDiagnosticsTest {
                     doTest(fileName);
                 }
             }
+
+            @TestMetadata("compiler/testData/diagnostics/tests/annotations/options")
+            @TestDataPath("$PROJECT_ROOT")
+            @RunWith(JUnit3RunnerWithInners.class)
+            public static class Options extends AbstractJetDiagnosticsTest {
+                public void testAllFilesPresentInOptions() throws Exception {
+                    JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/annotations/options"), Pattern.compile("^(.+)\\.kt$"), true);
+                }
+
+                @TestMetadata("annotation.kt")
+                public void testAnnotation() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/options/annotation.kt");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("annotationAsArg.kt")
+                public void testAnnotationAsArg() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/options/annotationAsArg.kt");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("annotationAsArgComplex.kt")
+                public void testAnnotationAsArgComplex() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/options/annotationAsArgComplex.kt");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("brackets.kt")
+                public void testBrackets() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/options/brackets.kt");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("repeatable.kt")
+                public void testRepeatable() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/options/repeatable.kt");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("retention.kt")
+                public void testRetention() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/options/retention.kt");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("target.kt")
+                public void testTarget() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/options/target.kt");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("compiler/testData/diagnostics/tests/annotations/options/targets")
+                @TestDataPath("$PROJECT_ROOT")
+                @RunWith(JUnit3RunnerWithInners.class)
+                public static class Targets extends AbstractJetDiagnosticsTest {
+                    @TestMetadata("accessors.kt")
+                    public void testAccessors() throws Exception {
+                        String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/options/targets/accessors.kt");
+                        doTest(fileName);
+                    }
+
+                    public void testAllFilesPresentInTargets() throws Exception {
+                        JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/annotations/options/targets"), Pattern.compile("^(.+)\\.kt$"), true);
+                    }
+
+                    @TestMetadata("annotation.kt")
+                    public void testAnnotation() throws Exception {
+                        String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/options/targets/annotation.kt");
+                        doTest(fileName);
+                    }
+
+                    @TestMetadata("classifier.kt")
+                    public void testClassifier() throws Exception {
+                        String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/options/targets/classifier.kt");
+                        doTest(fileName);
+                    }
+
+                    @TestMetadata("constructor.kt")
+                    public void testConstructor() throws Exception {
+                        String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/options/targets/constructor.kt");
+                        doTest(fileName);
+                    }
+
+                    @TestMetadata("empty.kt")
+                    public void testEmpty() throws Exception {
+                        String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/options/targets/empty.kt");
+                        doTest(fileName);
+                    }
+
+                    @TestMetadata("expr.kt")
+                    public void testExpr() throws Exception {
+                        String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/options/targets/expr.kt");
+                        doTest(fileName);
+                    }
+
+                    @TestMetadata("file.kt")
+                    public void testFile() throws Exception {
+                        String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/options/targets/file.kt");
+                        doTest(fileName);
+                    }
+
+                    @TestMetadata("function.kt")
+                    public void testFunction() throws Exception {
+                        String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/options/targets/function.kt");
+                        doTest(fileName);
+                    }
+
+                    @TestMetadata("funtypeargs.kt")
+                    public void testFuntypeargs() throws Exception {
+                        String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/options/targets/funtypeargs.kt");
+                        doTest(fileName);
+                    }
+
+                    @TestMetadata("incorrect.kt")
+                    public void testIncorrect() throws Exception {
+                        String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/options/targets/incorrect.kt");
+                        doTest(fileName);
+                    }
+
+                    @TestMetadata("init.kt")
+                    public void testInit() throws Exception {
+                        String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/options/targets/init.kt");
+                        doTest(fileName);
+                    }
+
+                    @TestMetadata("local.kt")
+                    public void testLocal() throws Exception {
+                        String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/options/targets/local.kt");
+                        doTest(fileName);
+                    }
+
+                    @TestMetadata("nested.kt")
+                    public void testNested() throws Exception {
+                        String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/options/targets/nested.kt");
+                        doTest(fileName);
+                    }
+
+                    @TestMetadata("property.kt")
+                    public void testProperty() throws Exception {
+                        String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/options/targets/property.kt");
+                        doTest(fileName);
+                    }
+
+                    @TestMetadata("returntype.kt")
+                    public void testReturntype() throws Exception {
+                        String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/options/targets/returntype.kt");
+                        doTest(fileName);
+                    }
+
+                    @TestMetadata("suppress.kt")
+                    public void testSuppress() throws Exception {
+                        String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/options/targets/suppress.kt");
+                        doTest(fileName);
+                    }
+
+                    @TestMetadata("type.kt")
+                    public void testType() throws Exception {
+                        String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/options/targets/type.kt");
+                        doTest(fileName);
+                    }
+
+                    @TestMetadata("typeargs.kt")
+                    public void testTypeargs() throws Exception {
+                        String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/options/targets/typeargs.kt");
+                        doTest(fileName);
+                    }
+
+                    @TestMetadata("valueparam.kt")
+                    public void testValueparam() throws Exception {
+                        String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/options/targets/valueparam.kt");
+                        doTest(fileName);
+                    }
+                }
+            }
         }
 
         @TestMetadata("compiler/testData/diagnostics/tests/backingField")
@@ -2031,6 +2211,12 @@ public class JetDiagnosticsTestGenerated extends AbstractJetDiagnosticsTest {
                 doTest(fileName);
             }
 
+            @TestMetadata("classLiteralType.kt")
+            public void testClassLiteralType() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/classLiteral/classLiteralType.kt");
+                doTest(fileName);
+            }
+
             @TestMetadata("genericClasses.kt")
             public void testGenericClasses() throws Exception {
                 String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/classLiteral/genericClasses.kt");
@@ -4947,6 +5133,12 @@ public class JetDiagnosticsTestGenerated extends AbstractJetDiagnosticsTest {
                 doTest(fileName);
             }
 
+            @TestMetadata("enumWithAnnotationKeyword.kt")
+            public void testEnumWithAnnotationKeyword() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/enum/enumWithAnnotationKeyword.kt");
+                doTest(fileName);
+            }
+
             @TestMetadata("enumWithEmptyName.kt")
             public void testEnumWithEmptyName() throws Exception {
                 String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/enum/enumWithEmptyName.kt");
@@ -5001,6 +5193,12 @@ public class JetDiagnosticsTestGenerated extends AbstractJetDiagnosticsTest {
                 doTest(fileName);
             }
 
+            @TestMetadata("interfaceWithEnumKeyword.kt")
+            public void testInterfaceWithEnumKeyword() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/enum/interfaceWithEnumKeyword.kt");
+                doTest(fileName);
+            }
+
             @TestMetadata("isEnumEntry.kt")
             public void testIsEnumEntry() throws Exception {
                 String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/enum/isEnumEntry.kt");
@@ -6696,6 +6894,63 @@ public class JetDiagnosticsTestGenerated extends AbstractJetDiagnosticsTest {
                 }
             }
 
+            @TestMetadata("compiler/testData/diagnostics/tests/inference/commonSystem")
+            @TestDataPath("$PROJECT_ROOT")
+            @RunWith(JUnit3RunnerWithInners.class)
+            public static class CommonSystem extends AbstractJetDiagnosticsTest {
+                public void testAllFilesPresentInCommonSystem() throws Exception {
+                    JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/inference/commonSystem"), Pattern.compile("^(.+)\\.kt$"), true);
+                }
+
+                @TestMetadata("boundOnNullableVariable.kt")
+                public void testBoundOnNullableVariable() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/commonSystem/boundOnNullableVariable.kt");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("dontCaptureTypeVariable.kt")
+                public void testDontCaptureTypeVariable() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/commonSystem/dontCaptureTypeVariable.kt");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("fixVariablesInRightOrder.kt")
+                public void testFixVariablesInRightOrder() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/commonSystem/fixVariablesInRightOrder.kt");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("genericCandidateInGenericClass.kt")
+                public void testGenericCandidateInGenericClass() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/commonSystem/genericCandidateInGenericClass.kt");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("inferenceWithUpperBoundsInLambda.kt")
+                public void testInferenceWithUpperBoundsInLambda() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/commonSystem/inferenceWithUpperBoundsInLambda.kt");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("kt3372toCollection.kt")
+                public void testKt3372toCollection() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/commonSystem/kt3372toCollection.kt");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("nestedLambdas.kt")
+                public void testNestedLambdas() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/commonSystem/nestedLambdas.kt");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("theSameFunctionInArgs.kt")
+                public void testTheSameFunctionInArgs() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/commonSystem/theSameFunctionInArgs.kt");
+                    doTest(fileName);
+                }
+            }
+
             @TestMetadata("compiler/testData/diagnostics/tests/inference/constraints")
             @TestDataPath("$PROJECT_ROOT")
             @RunWith(JUnit3RunnerWithInners.class)
@@ -6896,6 +7151,12 @@ public class JetDiagnosticsTestGenerated extends AbstractJetDiagnosticsTest {
                     doTest(fileName);
                 }
 
+                @TestMetadata("kt2057.kt")
+                public void testKt2057() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/regressions/kt2057.kt");
+                    doTest(fileName);
+                }
+
                 @TestMetadata("kt2179.kt")
                 public void testKt2179() throws Exception {
                     String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/regressions/kt2179.kt");
@@ -6974,12 +7235,24 @@ public class JetDiagnosticsTestGenerated extends AbstractJetDiagnosticsTest {
                     doTest(fileName);
                 }
 
+                @TestMetadata("kt2588.kt")
+                public void testKt2588() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/regressions/kt2588.kt");
+                    doTest(fileName);
+                }
+
                 @TestMetadata("kt2741.kt")
                 public void testKt2741() throws Exception {
                     String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/regressions/kt2741.kt");
                     doTest(fileName);
                 }
 
+                @TestMetadata("kt2754.kt")
+                public void testKt2754() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/regressions/kt2754.kt");
+                    doTest(fileName);
+                }
+
                 @TestMetadata("kt2838.kt")
                 public void testKt2838() throws Exception {
                     String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/regressions/kt2838.kt");
@@ -7058,6 +7331,30 @@ public class JetDiagnosticsTestGenerated extends AbstractJetDiagnosticsTest {
                     doTest(fileName);
                 }
 
+                @TestMetadata("kt3496.kt")
+                public void testKt3496() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/regressions/kt3496.kt");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("kt3496_2.kt")
+                public void testKt3496_2() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/regressions/kt3496_2.kt");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("kt3559.kt")
+                public void testKt3559() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/regressions/kt3559.kt");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("kt4420.kt")
+                public void testKt4420() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/regressions/kt4420.kt");
+                    doTest(fileName);
+                }
+
                 @TestMetadata("kt702.kt")
                 public void testKt702() throws Exception {
                     String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/regressions/kt702.kt");
@@ -7076,6 +7373,12 @@ public class JetDiagnosticsTestGenerated extends AbstractJetDiagnosticsTest {
                     doTest(fileName);
                 }
 
+                @TestMetadata("kt8132.kt")
+                public void testKt8132() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/regressions/kt8132.kt");
+                    doTest(fileName);
+                }
+
                 @TestMetadata("kt832.kt")
                 public void testKt832() throws Exception {
                     String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/regressions/kt832.kt");
@@ -7142,6 +7445,12 @@ public class JetDiagnosticsTestGenerated extends AbstractJetDiagnosticsTest {
                     JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/inference/substitutions"), Pattern.compile("^(.+)\\.kt$"), true);
                 }
 
+                @TestMetadata("delegationAndInference.kt")
+                public void testDelegationAndInference() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/substitutions/delegationAndInference.kt");
+                    doTest(fileName);
+                }
+
                 @TestMetadata("kt6081SubstituteIntoClassCorrectly.kt")
                 public void testKt6081SubstituteIntoClassCorrectly() throws Exception {
                     String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/substitutions/kt6081SubstituteIntoClassCorrectly.kt");
@@ -7956,6 +8265,12 @@ public class JetDiagnosticsTestGenerated extends AbstractJetDiagnosticsTest {
                 doTest(fileName);
             }
 
+            @TestMetadata("computeIfAbsentConcurrent.kt")
+            public void testComputeIfAbsentConcurrent() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/computeIfAbsentConcurrent.kt");
+                doTest(fileName);
+            }
+
             @TestMetadata("GenericsInSupertypes.kt")
             public void testGenericsInSupertypes() throws Exception {
                 String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/GenericsInSupertypes.kt");
@@ -8100,6 +8415,12 @@ public class JetDiagnosticsTestGenerated extends AbstractJetDiagnosticsTest {
                 doTest(fileName);
             }
 
+            @TestMetadata("overrideWithSamAndTypeParameter.kt")
+            public void testOverrideWithSamAndTypeParameter() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/overrideWithSamAndTypeParameter.kt");
+                doTest(fileName);
+            }
+
             @TestMetadata("packagePrivateClassStaticMember.kt")
             public void testPackagePrivateClassStaticMember() throws Exception {
                 String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/packagePrivateClassStaticMember.kt");
@@ -8183,6 +8504,45 @@ public class JetDiagnosticsTestGenerated extends AbstractJetDiagnosticsTest {
                 String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/UnboxingNulls.kt");
                 doTest(fileName);
             }
+
+            @TestMetadata("compiler/testData/diagnostics/tests/j+k/types")
+            @TestDataPath("$PROJECT_ROOT")
+            @RunWith(JUnit3RunnerWithInners.class)
+            public static class Types extends AbstractJetDiagnosticsTest {
+                public void testAllFilesPresentInTypes() throws Exception {
+                    JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/j+k/types"), Pattern.compile("^(.+)\\.kt$"), true);
+                }
+
+                @TestMetadata("arrayList.kt")
+                public void testArrayList() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/types/arrayList.kt");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("returnCollection.kt")
+                public void testReturnCollection() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/types/returnCollection.kt");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("shapeMismatchInCovariantPosition.kt")
+                public void testShapeMismatchInCovariantPosition() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/types/shapeMismatchInCovariantPosition.kt");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("shapeMismatchInCovariantPositionGeneric.kt")
+                public void testShapeMismatchInCovariantPositionGeneric() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/types/shapeMismatchInCovariantPositionGeneric.kt");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("typeParameter.kt")
+                public void testTypeParameter() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/types/typeParameter.kt");
+                    doTest(fileName);
+                }
+            }
         }
 
         @TestMetadata("compiler/testData/diagnostics/tests/jdk-annotations")
@@ -8388,6 +8748,12 @@ public class JetDiagnosticsTestGenerated extends AbstractJetDiagnosticsTest {
                 doTest(fileName);
             }
 
+            @TestMetadata("varargConflict.kt")
+            public void testVarargConflict() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/multimodule/varargConflict.kt");
+                doTest(fileName);
+            }
+
             @TestMetadata("compiler/testData/diagnostics/tests/multimodule/duplicateClass")
             @TestDataPath("$PROJECT_ROOT")
             @RunWith(JUnit3RunnerWithInners.class)
@@ -10070,6 +10436,63 @@ public class JetDiagnosticsTestGenerated extends AbstractJetDiagnosticsTest {
                     doTest(fileName);
                 }
             }
+
+            @TestMetadata("compiler/testData/diagnostics/tests/platformTypes/typeEnhancement")
+            @TestDataPath("$PROJECT_ROOT")
+            @RunWith(JUnit3RunnerWithInners.class)
+            public static class TypeEnhancement extends AbstractJetDiagnosticsTest {
+                public void testAllFilesPresentInTypeEnhancement() throws Exception {
+                    JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/platformTypes/typeEnhancement"), Pattern.compile("^(.+)\\.kt$"), true);
+                }
+
+                @TestMetadata("annotatedTypeArguments.kt")
+                public void testAnnotatedTypeArguments() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/platformTypes/typeEnhancement/annotatedTypeArguments.kt");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("methodWithTypeParameter.kt")
+                public void testMethodWithTypeParameter() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/platformTypes/typeEnhancement/methodWithTypeParameter.kt");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("overriddenExtensions.kt")
+                public void testOverriddenExtensions() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/platformTypes/typeEnhancement/overriddenExtensions.kt");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("returnTypeDifferentConstructor.kt")
+                public void testReturnTypeDifferentConstructor() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/platformTypes/typeEnhancement/returnTypeDifferentConstructor.kt");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("returnTypeOverrideInKotlin.kt")
+                public void testReturnTypeOverrideInKotlin() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/platformTypes/typeEnhancement/returnTypeOverrideInKotlin.kt");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("saveAnnotationAfterSubstitution.kt")
+                public void testSaveAnnotationAfterSubstitution() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/platformTypes/typeEnhancement/saveAnnotationAfterSubstitution.kt");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("supertypeDifferentParameterNullability.kt")
+                public void testSupertypeDifferentParameterNullability() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/platformTypes/typeEnhancement/supertypeDifferentParameterNullability.kt");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("supertypeDifferentReturnNullability.kt")
+                public void testSupertypeDifferentReturnNullability() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/platformTypes/typeEnhancement/supertypeDifferentReturnNullability.kt");
+                    doTest(fileName);
+                }
+            }
         }
 
         @TestMetadata("compiler/testData/diagnostics/tests/recovery")
@@ -10216,6 +10639,21 @@ public class JetDiagnosticsTestGenerated extends AbstractJetDiagnosticsTest {
             }
         }
 
+        @TestMetadata("compiler/testData/diagnostics/tests/reflection")
+        @TestDataPath("$PROJECT_ROOT")
+        @RunWith(JUnit3RunnerWithInners.class)
+        public static class Reflection extends AbstractJetDiagnosticsTest {
+            public void testAllFilesPresentInReflection() throws Exception {
+                JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/reflection"), Pattern.compile("^(.+)\\.kt$"), true);
+            }
+
+            @TestMetadata("noReflectionInClassPath.kt")
+            public void testNoReflectionInClassPath() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/reflection/noReflectionInClassPath.kt");
+                doTest(fileName);
+            }
+        }
+
         @TestMetadata("compiler/testData/diagnostics/tests/regressions")
         @TestDataPath("$PROJECT_ROOT")
         @RunWith(JUnit3RunnerWithInners.class)
@@ -10290,6 +10728,12 @@ public class JetDiagnosticsTestGenerated extends AbstractJetDiagnosticsTest {
                 doTest(fileName);
             }
 
+            @TestMetadata("intchar.kt")
+            public void testIntchar() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/intchar.kt");
+                doTest(fileName);
+            }
+
             @TestMetadata("itselfAsUpperBound.kt")
             public void testItselfAsUpperBound() throws Exception {
                 String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/itselfAsUpperBound.kt");
@@ -10929,12 +11373,30 @@ public class JetDiagnosticsTestGenerated extends AbstractJetDiagnosticsTest {
                 doTest(fileName);
             }
 
+            @TestMetadata("ambiguityWithTwoCorrespondingFunctionTypes.kt")
+            public void testAmbiguityWithTwoCorrespondingFunctionTypes() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/resolve/ambiguityWithTwoCorrespondingFunctionTypes.kt");
+                doTest(fileName);
+            }
+
             @TestMetadata("incompleteConstructorInvocation.kt")
             public void testIncompleteConstructorInvocation() throws Exception {
                 String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/resolve/incompleteConstructorInvocation.kt");
                 doTest(fileName);
             }
 
+            @TestMetadata("inferenceInLinkedLambdas.kt")
+            public void testInferenceInLinkedLambdas() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/resolve/inferenceInLinkedLambdas.kt");
+                doTest(fileName);
+            }
+
+            @TestMetadata("inferenceInLinkedLambdasDependentOnExpectedType.kt")
+            public void testInferenceInLinkedLambdasDependentOnExpectedType() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/resolve/inferenceInLinkedLambdasDependentOnExpectedType.kt");
+                doTest(fileName);
+            }
+
             @TestMetadata("objectLiteralAsArgument.kt")
             public void testObjectLiteralAsArgument() throws Exception {
                 String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/resolve/objectLiteralAsArgument.kt");
@@ -12230,6 +12692,12 @@ public class JetDiagnosticsTestGenerated extends AbstractJetDiagnosticsTest {
                     doTest(fileName);
                 }
 
+                @TestMetadata("kt1275.kt")
+                public void testKt1275() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/inference/kt1275.kt");
+                    doTest(fileName);
+                }
+
                 @TestMetadata("kt1355.kt")
                 public void testKt1355() throws Exception {
                     String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/inference/kt1355.kt");
@@ -13275,6 +13743,12 @@ public class JetDiagnosticsTestGenerated extends AbstractJetDiagnosticsTest {
                 JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/subtyping"), Pattern.compile("^(.+)\\.kt$"), true);
             }
 
+            @TestMetadata("findClosestCorrespondingSupertype.kt")
+            public void testFindClosestCorrespondingSupertype() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/subtyping/findClosestCorrespondingSupertype.kt");
+                doTest(fileName);
+            }
+
             @TestMetadata("kt2069.kt")
             public void testKt2069() throws Exception {
                 String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/subtyping/kt2069.kt");
@@ -13540,6 +14014,153 @@ public class JetDiagnosticsTestGenerated extends AbstractJetDiagnosticsTest {
             }
         }
 
+        @TestMetadata("compiler/testData/diagnostics/tests/syntheticExtensions")
+        @TestDataPath("$PROJECT_ROOT")
+        @RunWith(JUnit3RunnerWithInners.class)
+        public static class SyntheticExtensions extends AbstractJetDiagnosticsTest {
+            @TestMetadata("AbbreviationName.kt")
+            public void testAbbreviationName() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/syntheticExtensions/AbbreviationName.kt");
+                doTest(fileName);
+            }
+
+            public void testAllFilesPresentInSyntheticExtensions() throws Exception {
+                JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/syntheticExtensions"), Pattern.compile("^(.+)\\.kt$"), true);
+            }
+
+            @TestMetadata("Bases.kt")
+            public void testBases() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/syntheticExtensions/Bases.kt");
+                doTest(fileName);
+            }
+
+            @TestMetadata("CompiledClass.kt")
+            public void testCompiledClass() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/syntheticExtensions/CompiledClass.kt");
+                doTest(fileName);
+            }
+
+            @TestMetadata("FalseGetters.kt")
+            public void testFalseGetters() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/syntheticExtensions/FalseGetters.kt");
+                doTest(fileName);
+            }
+
+            @TestMetadata("FalseSetters.kt")
+            public void testFalseSetters() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/syntheticExtensions/FalseSetters.kt");
+                doTest(fileName);
+            }
+
+            @TestMetadata("FromTwoBases.kt")
+            public void testFromTwoBases() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/syntheticExtensions/FromTwoBases.kt");
+                doTest(fileName);
+            }
+
+            @TestMetadata("GenericClass.kt")
+            public void testGenericClass() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/syntheticExtensions/GenericClass.kt");
+                doTest(fileName);
+            }
+
+            @TestMetadata("Getter.kt")
+            public void testGetter() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/syntheticExtensions/Getter.kt");
+                doTest(fileName);
+            }
+
+            @TestMetadata("GetterAndSetter.kt")
+            public void testGetterAndSetter() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/syntheticExtensions/GetterAndSetter.kt");
+                doTest(fileName);
+            }
+
+            @TestMetadata("ImplicitReceiver.kt")
+            public void testImplicitReceiver() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/syntheticExtensions/ImplicitReceiver.kt");
+                doTest(fileName);
+            }
+
+            @TestMetadata("IsNaming.kt")
+            public void testIsNaming() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/syntheticExtensions/IsNaming.kt");
+                doTest(fileName);
+            }
+
+            @TestMetadata("JavaOverridesKotlin.kt")
+            public void testJavaOverridesKotlin() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/syntheticExtensions/JavaOverridesKotlin.kt");
+                doTest(fileName);
+            }
+
+            @TestMetadata("KotlinOverridesJava.kt")
+            public void testKotlinOverridesJava() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/syntheticExtensions/KotlinOverridesJava.kt");
+                doTest(fileName);
+            }
+
+            @TestMetadata("KotlinOverridesJava2.kt")
+            public void testKotlinOverridesJava2() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/syntheticExtensions/KotlinOverridesJava2.kt");
+                doTest(fileName);
+            }
+
+            @TestMetadata("KotlinOverridesJava3.kt")
+            public void testKotlinOverridesJava3() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/syntheticExtensions/KotlinOverridesJava3.kt");
+                doTest(fileName);
+            }
+
+            @TestMetadata("KotlinOverridesJava4.kt")
+            public void testKotlinOverridesJava4() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/syntheticExtensions/KotlinOverridesJava4.kt");
+                doTest(fileName);
+            }
+
+            @TestMetadata("KotlinOverridesJava5.kt")
+            public void testKotlinOverridesJava5() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/syntheticExtensions/KotlinOverridesJava5.kt");
+                doTest(fileName);
+            }
+
+            @TestMetadata("OnlyPublic.kt")
+            public void testOnlyPublic() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/syntheticExtensions/OnlyPublic.kt");
+                doTest(fileName);
+            }
+
+            @TestMetadata("OverrideGetterOnly.kt")
+            public void testOverrideGetterOnly() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/syntheticExtensions/OverrideGetterOnly.kt");
+                doTest(fileName);
+            }
+
+            @TestMetadata("SetterOnly.kt")
+            public void testSetterOnly() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/syntheticExtensions/SetterOnly.kt");
+                doTest(fileName);
+            }
+
+            @TestMetadata("SmartCast.kt")
+            public void testSmartCast() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/syntheticExtensions/SmartCast.kt");
+                doTest(fileName);
+            }
+
+            @TestMetadata("SmartCastImplicitReceiver.kt")
+            public void testSmartCastImplicitReceiver() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/syntheticExtensions/SmartCastImplicitReceiver.kt");
+                doTest(fileName);
+            }
+
+            @TestMetadata("TypeParameterReceiver.kt")
+            public void testTypeParameterReceiver() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/syntheticExtensions/TypeParameterReceiver.kt");
+                doTest(fileName);
+            }
+        }
+
         @TestMetadata("compiler/testData/diagnostics/tests/thisAndSuper")
         @TestDataPath("$PROJECT_ROOT")
         @RunWith(JUnit3RunnerWithInners.class)
diff --git a/compiler/tests/org/jetbrains/kotlin/checkers/JetDiagnosticsTestWithStdLibGenerated.java b/compiler/tests/org/jetbrains/kotlin/checkers/JetDiagnosticsTestWithStdLibGenerated.java
index d42fea42f26..15df05dcafd 100644
--- a/compiler/tests/org/jetbrains/kotlin/checkers/JetDiagnosticsTestWithStdLibGenerated.java
+++ b/compiler/tests/org/jetbrains/kotlin/checkers/JetDiagnosticsTestWithStdLibGenerated.java
@@ -429,6 +429,27 @@ public class JetDiagnosticsTestWithStdLibGenerated extends AbstractJetDiagnostic
                 doTest(fileName);
             }
         }
+
+        @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/annotations/publicField")
+        @TestDataPath("$PROJECT_ROOT")
+        @RunWith(JUnit3RunnerWithInners.class)
+        public static class PublicField extends AbstractJetDiagnosticsTestWithStdLib {
+            public void testAllFilesPresentInPublicField() throws Exception {
+                JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/annotations/publicField"), Pattern.compile("^(.+)\\.kt$"), true);
+            }
+
+            @TestMetadata("publicFieldNotOnProperty.kt")
+            public void testPublicFieldNotOnProperty() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/annotations/publicField/publicFieldNotOnProperty.kt");
+                doTest(fileName);
+            }
+
+            @TestMetadata("publicFieldOnDelegatedProperty.kt")
+            public void testPublicFieldOnDelegatedProperty() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/annotations/publicField/publicFieldOnDelegatedProperty.kt");
+                doTest(fileName);
+            }
+        }
     }
 
     @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/duplicateJvmSignature")
@@ -510,6 +531,18 @@ public class JetDiagnosticsTestWithStdLibGenerated extends AbstractJetDiagnostic
             String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/inference/kt1558.kt");
             doTest(fileName);
         }
+
+        @TestMetadata("kt3458.kt")
+        public void testKt3458() throws Exception {
+            String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/inference/kt3458.kt");
+            doTest(fileName);
+        }
+
+        @TestMetadata("kt4975.kt")
+        public void testKt4975() throws Exception {
+            String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/inference/kt4975.kt");
+            doTest(fileName);
+        }
     }
 
     @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/kotlinSignature")
@@ -590,6 +623,69 @@ public class JetDiagnosticsTestWithStdLibGenerated extends AbstractJetDiagnostic
         }
     }
 
+    @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection")
+    @TestDataPath("$PROJECT_ROOT")
+    @RunWith(JUnit3RunnerWithInners.class)
+    public static class PurelyImplementedCollection extends AbstractJetDiagnosticsTestWithStdLib {
+        public void testAllFilesPresentInPurelyImplementedCollection() throws Exception {
+            JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection"), Pattern.compile("^(.+)\\.kt$"), true);
+        }
+
+        @TestMetadata("arrayList.kt")
+        public void testArrayList() throws Exception {
+            String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/arrayList.kt");
+            doTest(fileName);
+        }
+
+        @TestMetadata("arrayListNullable.kt")
+        public void testArrayListNullable() throws Exception {
+            String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/arrayListNullable.kt");
+            doTest(fileName);
+        }
+
+        @TestMetadata("customClassMutableCollection.kt")
+        public void testCustomClassMutableCollection() throws Exception {
+            String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/customClassMutableCollection.kt");
+            doTest(fileName);
+        }
+
+        @TestMetadata("customClassMutableList.kt")
+        public void testCustomClassMutableList() throws Exception {
+            String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/customClassMutableList.kt");
+            doTest(fileName);
+        }
+
+        @TestMetadata("maps.kt")
+        public void testMaps() throws Exception {
+            String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/maps.kt");
+            doTest(fileName);
+        }
+
+        @TestMetadata("mapsWithNullableKey.kt")
+        public void testMapsWithNullableKey() throws Exception {
+            String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/mapsWithNullableKey.kt");
+            doTest(fileName);
+        }
+
+        @TestMetadata("mapsWithNullableValues.kt")
+        public void testMapsWithNullableValues() throws Exception {
+            String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/mapsWithNullableValues.kt");
+            doTest(fileName);
+        }
+
+        @TestMetadata("sets.kt")
+        public void testSets() throws Exception {
+            String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/sets.kt");
+            doTest(fileName);
+        }
+
+        @TestMetadata("wrongTypeParametersCount.kt")
+        public void testWrongTypeParametersCount() throws Exception {
+            String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/wrongTypeParametersCount.kt");
+            doTest(fileName);
+        }
+    }
+
     @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/regression")
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
diff --git a/compiler/tests/org/jetbrains/kotlin/checkers/LazyOperationsLog.kt b/compiler/tests/org/jetbrains/kotlin/checkers/LazyOperationsLog.kt
index 015af25125c..15a5706bb2b 100644
--- a/compiler/tests/org/jetbrains/kotlin/checkers/LazyOperationsLog.kt
+++ b/compiler/tests/org/jetbrains/kotlin/checkers/LazyOperationsLog.kt
@@ -152,7 +152,7 @@ class LazyOperationsLog(
             }
             o.javaClass.getSimpleName() == "LazyJavaClassTypeConstructor" -> {
                 val javaClass = o.field<Any>("this\$0").field<JavaClassImpl>("jClass")
-                javaClass.getPsi().getName().appendQuoted()
+                javaClass.getPsi().getName()!!.appendQuoted()
             }
             o.javaClass.getSimpleName() == "DeserializedType" -> {
                 val typeDeserializer = o.field<TypeDeserializer>("typeDeserializer")
@@ -161,7 +161,7 @@ class LazyOperationsLog(
                 val text = when (typeProto.getConstructor().getKind()) {
                     ProtoBuf.Type.Constructor.Kind.CLASS -> context.nameResolver.getFqName(typeProto.getConstructor().getId()).asString()
                     ProtoBuf.Type.Constructor.Kind.TYPE_PARAMETER -> {
-                        val classifier = (o as JetType).getConstructor().getDeclarationDescriptor()
+                        val classifier = (o as JetType).getConstructor().getDeclarationDescriptor()!!
                         "" + classifier.getName() + " in " + DescriptorUtils.getFqName(classifier.getContainingDeclaration())
                     }
                     else -> "???"
diff --git a/compiler/tests/org/jetbrains/kotlin/cli/KotlincExecutableTestGenerated.java b/compiler/tests/org/jetbrains/kotlin/cli/KotlincExecutableTestGenerated.java
index 23ad7e546e4..0495cffe9fa 100644
--- a/compiler/tests/org/jetbrains/kotlin/cli/KotlincExecutableTestGenerated.java
+++ b/compiler/tests/org/jetbrains/kotlin/cli/KotlincExecutableTestGenerated.java
@@ -97,12 +97,6 @@ public class KotlincExecutableTestGenerated extends AbstractKotlincExecutableTes
             doJvmTest(fileName);
         }
 
-        @TestMetadata("noReflectionInClasspath.args")
-        public void testNoReflectionInClasspath() throws Exception {
-            String fileName = JetTestUtils.navigationMetadata("compiler/testData/cli/jvm/noReflectionInClasspath.args");
-            doJvmTest(fileName);
-        }
-
         @TestMetadata("nonExistingClassPathAndAnnotationsPath.args")
         public void testNonExistingClassPathAndAnnotationsPath() throws Exception {
             String fileName = JetTestUtils.navigationMetadata("compiler/testData/cli/jvm/nonExistingClassPathAndAnnotationsPath.args");
diff --git a/compiler/tests/org/jetbrains/kotlin/cli/jvm/KotlinCliJavaFileManagerTest.kt b/compiler/tests/org/jetbrains/kotlin/cli/jvm/KotlinCliJavaFileManagerTest.kt
index d7ccb8cc45a..32e7e827ba3 100644
--- a/compiler/tests/org/jetbrains/kotlin/cli/jvm/KotlinCliJavaFileManagerTest.kt
+++ b/compiler/tests/org/jetbrains/kotlin/cli/jvm/KotlinCliJavaFileManagerTest.kt
@@ -143,6 +143,7 @@ public class KotlinCliJavaFileManagerTest : PsiTestCase() {
         val pkg = root.createChildDirectory(this, "foo")
         val dir = myPsiManager.findDirectory(pkg)
         TestCase.assertNotNull(dir)
+        dir!!
         dir.add(PsiFileFactory.getInstance(getProject()).createFileFromText(className + ".java", JavaFileType.INSTANCE, text))
         val coreJavaFileManagerExt = KotlinCliJavaFileManagerImpl(myPsiManager)
         coreJavaFileManagerExt.initIndex(JvmDependenciesIndex(listOf(JavaRoot(root, JavaRoot.RootType.SOURCE))))
diff --git a/compiler/tests/org/jetbrains/kotlin/codegen/AbstractBytecodeTextTest.java b/compiler/tests/org/jetbrains/kotlin/codegen/AbstractBytecodeTextTest.java
index 42a6b8713fe..389b1c2b915 100644
--- a/compiler/tests/org/jetbrains/kotlin/codegen/AbstractBytecodeTextTest.java
+++ b/compiler/tests/org/jetbrains/kotlin/codegen/AbstractBytecodeTextTest.java
@@ -50,7 +50,7 @@ public abstract class AbstractBytecodeTextTest extends CodegenTestCase {
         }
 
         try {
-            assertEquals(expected.toString(), actual.toString());
+            assertEquals(text, expected.toString(), actual.toString());
         }
         catch (Throwable e) {
             System.out.println(text);
diff --git a/compiler/tests/org/jetbrains/kotlin/codegen/BytecodeTextTestGenerated.java b/compiler/tests/org/jetbrains/kotlin/codegen/BytecodeTextTestGenerated.java
index ac3f1ea6b05..d7b551fb128 100644
--- a/compiler/tests/org/jetbrains/kotlin/codegen/BytecodeTextTestGenerated.java
+++ b/compiler/tests/org/jetbrains/kotlin/codegen/BytecodeTextTestGenerated.java
@@ -47,6 +47,12 @@ public class BytecodeTextTestGenerated extends AbstractBytecodeTextTest {
         doTest(fileName);
     }
 
+    @TestMetadata("annotationJavaRetentionPolicyRuntime.kt")
+    public void testAnnotationJavaRetentionPolicyRuntime() throws Exception {
+        String fileName = JetTestUtils.navigationMetadata("compiler/testData/codegen/bytecodeText/annotationJavaRetentionPolicyRuntime.kt");
+        doTest(fileName);
+    }
+
     @TestMetadata("annotationRetentionPolicyClass.kt")
     public void testAnnotationRetentionPolicyClass() throws Exception {
         String fileName = JetTestUtils.navigationMetadata("compiler/testData/codegen/bytecodeText/annotationRetentionPolicyClass.kt");
diff --git a/compiler/tests/org/jetbrains/kotlin/codegen/CodegenTestCase.java b/compiler/tests/org/jetbrains/kotlin/codegen/CodegenTestCase.java
index f3eca85f790..de6bfde4436 100644
--- a/compiler/tests/org/jetbrains/kotlin/codegen/CodegenTestCase.java
+++ b/compiler/tests/org/jetbrains/kotlin/codegen/CodegenTestCase.java
@@ -246,7 +246,7 @@ public abstract class CodegenTestCase extends UsefulTestCase {
                 analyzer.analyze(classNode.name, method);
             }
             catch (Throwable e) {
-                System.out.println(file.asText());
+                System.err.println(file.asText());
                 System.err.println(classNode.name + "::" + method.name + method.desc);
 
                 //noinspection InstanceofCatchParameter
diff --git a/compiler/tests/org/jetbrains/kotlin/codegen/InlineTestUtil.kt b/compiler/tests/org/jetbrains/kotlin/codegen/InlineTestUtil.kt
index a23c9e83f8d..7935d59e598 100644
--- a/compiler/tests/org/jetbrains/kotlin/codegen/InlineTestUtil.kt
+++ b/compiler/tests/org/jetbrains/kotlin/codegen/InlineTestUtil.kt
@@ -194,9 +194,9 @@ public object InlineTestUtil {
                 override fun getFileContents(): ByteArray = throw UnsupportedOperationException()
                 override fun hashCode(): Int = throw UnsupportedOperationException()
                 override fun equals(other: Any?): Boolean = throw UnsupportedOperationException()
-                override fun toString(): String? = throw UnsupportedOperationException()
+                override fun toString(): String = throw UnsupportedOperationException()
             }
-        }.getClassHeader()
+        }!!.getClassHeader()
     }
 
     private class InlineInfo(val inlineMethods: Set<MethodInfo>, val classHeaders: Map<String, KotlinClassHeader>)
diff --git a/compiler/tests/org/jetbrains/kotlin/codegen/flags/WriteFlagsTestGenerated.java b/compiler/tests/org/jetbrains/kotlin/codegen/flags/WriteFlagsTestGenerated.java
index e94cfa19831..41638666d1d 100644
--- a/compiler/tests/org/jetbrains/kotlin/codegen/flags/WriteFlagsTestGenerated.java
+++ b/compiler/tests/org/jetbrains/kotlin/codegen/flags/WriteFlagsTestGenerated.java
@@ -35,6 +35,48 @@ public class WriteFlagsTestGenerated extends AbstractWriteFlagsTest {
         JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags"), Pattern.compile("^(.+)\\.kt$"), true);
     }
 
+    @TestMetadata("compiler/testData/writeFlags/callableReference")
+    @TestDataPath("$PROJECT_ROOT")
+    @RunWith(JUnit3RunnerWithInners.class)
+    public static class CallableReference extends AbstractWriteFlagsTest {
+        public void testAllFilesPresentInCallableReference() throws Exception {
+            JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/callableReference"), Pattern.compile("^(.+)\\.kt$"), true);
+        }
+
+        @TestMetadata("compiler/testData/writeFlags/callableReference/visibility")
+        @TestDataPath("$PROJECT_ROOT")
+        @RunWith(JUnit3RunnerWithInners.class)
+        public static class Visibility extends AbstractWriteFlagsTest {
+            public void testAllFilesPresentInVisibility() throws Exception {
+                JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/callableReference/visibility"), Pattern.compile("^(.+)\\.kt$"), true);
+            }
+
+            @TestMetadata("functionReference.kt")
+            public void testFunctionReference() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("compiler/testData/writeFlags/callableReference/visibility/functionReference.kt");
+                doTest(fileName);
+            }
+
+            @TestMetadata("functionReferenceInInlineFunction.kt")
+            public void testFunctionReferenceInInlineFunction() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("compiler/testData/writeFlags/callableReference/visibility/functionReferenceInInlineFunction.kt");
+                doTest(fileName);
+            }
+
+            @TestMetadata("propertyReference.kt")
+            public void testPropertyReference() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("compiler/testData/writeFlags/callableReference/visibility/propertyReference.kt");
+                doTest(fileName);
+            }
+
+            @TestMetadata("propertyReferenceInInlineFunction.kt")
+            public void testPropertyReferenceInInlineFunction() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("compiler/testData/writeFlags/callableReference/visibility/propertyReferenceInInlineFunction.kt");
+                doTest(fileName);
+            }
+        }
+    }
+
     @TestMetadata("compiler/testData/writeFlags/class")
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
diff --git a/compiler/tests/org/jetbrains/kotlin/codegen/generated/BlackBoxAgainstJavaCodegenTestGenerated.java b/compiler/tests/org/jetbrains/kotlin/codegen/generated/BlackBoxAgainstJavaCodegenTestGenerated.java
index e1eb33ee306..b623aa01867 100644
--- a/compiler/tests/org/jetbrains/kotlin/codegen/generated/BlackBoxAgainstJavaCodegenTestGenerated.java
+++ b/compiler/tests/org/jetbrains/kotlin/codegen/generated/BlackBoxAgainstJavaCodegenTestGenerated.java
@@ -597,6 +597,12 @@ public class BlackBoxAgainstJavaCodegenTestGenerated extends AbstractBlackBoxCod
                 doTestAgainstJava(fileName);
             }
 
+            @TestMetadata("doubleLongParameters.kt")
+            public void testDoubleLongParameters() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("compiler/testData/codegen/boxAgainstJava/sam/adapters/doubleLongParameters.kt");
+                doTestAgainstJava(fileName);
+            }
+
             @TestMetadata("fileFilter.kt")
             public void testFileFilter() throws Exception {
                 String fileName = JetTestUtils.navigationMetadata("compiler/testData/codegen/boxAgainstJava/sam/adapters/fileFilter.kt");
@@ -821,6 +827,51 @@ public class BlackBoxAgainstJavaCodegenTestGenerated extends AbstractBlackBoxCod
         }
     }
 
+    @TestMetadata("compiler/testData/codegen/boxAgainstJava/syntheticExtensions")
+    @TestDataPath("$PROJECT_ROOT")
+    @RunWith(JUnit3RunnerWithInners.class)
+    public static class SyntheticExtensions extends AbstractBlackBoxCodegenTest {
+        public void testAllFilesPresentInSyntheticExtensions() throws Exception {
+            JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/syntheticExtensions"), Pattern.compile("^(.+)\\.kt$"), true);
+        }
+
+        @TestMetadata("fromTwoBases.kt")
+        public void testFromTwoBases() throws Exception {
+            String fileName = JetTestUtils.navigationMetadata("compiler/testData/codegen/boxAgainstJava/syntheticExtensions/fromTwoBases.kt");
+            doTestAgainstJava(fileName);
+        }
+
+        @TestMetadata("getter.kt")
+        public void testGetter() throws Exception {
+            String fileName = JetTestUtils.navigationMetadata("compiler/testData/codegen/boxAgainstJava/syntheticExtensions/getter.kt");
+            doTestAgainstJava(fileName);
+        }
+
+        @TestMetadata("implicitReceiver.kt")
+        public void testImplicitReceiver() throws Exception {
+            String fileName = JetTestUtils.navigationMetadata("compiler/testData/codegen/boxAgainstJava/syntheticExtensions/implicitReceiver.kt");
+            doTestAgainstJava(fileName);
+        }
+
+        @TestMetadata("overrideOnlyGetter.kt")
+        public void testOverrideOnlyGetter() throws Exception {
+            String fileName = JetTestUtils.navigationMetadata("compiler/testData/codegen/boxAgainstJava/syntheticExtensions/overrideOnlyGetter.kt");
+            doTestAgainstJava(fileName);
+        }
+
+        @TestMetadata("plusPlus.kt")
+        public void testPlusPlus() throws Exception {
+            String fileName = JetTestUtils.navigationMetadata("compiler/testData/codegen/boxAgainstJava/syntheticExtensions/plusPlus.kt");
+            doTestAgainstJava(fileName);
+        }
+
+        @TestMetadata("setter.kt")
+        public void testSetter() throws Exception {
+            String fileName = JetTestUtils.navigationMetadata("compiler/testData/codegen/boxAgainstJava/syntheticExtensions/setter.kt");
+            doTestAgainstJava(fileName);
+        }
+    }
+
     @TestMetadata("compiler/testData/codegen/boxAgainstJava/visibility")
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
diff --git a/compiler/tests/org/jetbrains/kotlin/codegen/generated/BlackBoxCodegenTestGenerated.java b/compiler/tests/org/jetbrains/kotlin/codegen/generated/BlackBoxCodegenTestGenerated.java
index 908f62af7a2..e3921f3bf3f 100644
--- a/compiler/tests/org/jetbrains/kotlin/codegen/generated/BlackBoxCodegenTestGenerated.java
+++ b/compiler/tests/org/jetbrains/kotlin/codegen/generated/BlackBoxCodegenTestGenerated.java
@@ -262,6 +262,12 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest {
             doTest(fileName);
         }
 
+        @TestMetadata("callAny.kt")
+        public void testCallAny() throws Exception {
+            String fileName = JetTestUtils.navigationMetadata("compiler/testData/codegen/box/binaryOp/callAny.kt");
+            doTest(fileName);
+        }
+
         @TestMetadata("callNullable.kt")
         public void testCallNullable() throws Exception {
             String fileName = JetTestUtils.navigationMetadata("compiler/testData/codegen/box/binaryOp/callNullable.kt");
@@ -280,6 +286,12 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest {
             doTest(fileName);
         }
 
+        @TestMetadata("infixCallAny.kt")
+        public void testInfixCallAny() throws Exception {
+            String fileName = JetTestUtils.navigationMetadata("compiler/testData/codegen/box/binaryOp/infixCallAny.kt");
+            doTest(fileName);
+        }
+
         @TestMetadata("infixCallNullable.kt")
         public void testInfixCallNullable() throws Exception {
             String fileName = JetTestUtils.navigationMetadata("compiler/testData/codegen/box/binaryOp/infixCallNullable.kt");
@@ -292,6 +304,12 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest {
             doTest(fileName);
         }
 
+        @TestMetadata("intrinsicAny.kt")
+        public void testIntrinsicAny() throws Exception {
+            String fileName = JetTestUtils.navigationMetadata("compiler/testData/codegen/box/binaryOp/intrinsicAny.kt");
+            doTest(fileName);
+        }
+
         @TestMetadata("intrinsicNullable.kt")
         public void testIntrinsicNullable() throws Exception {
             String fileName = JetTestUtils.navigationMetadata("compiler/testData/codegen/box/binaryOp/intrinsicNullable.kt");
@@ -304,9 +322,21 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest {
             doTest(fileName);
         }
 
-        @TestMetadata("longOverflow.kt")
-        public void testLongOverflow() throws Exception {
-            String fileName = JetTestUtils.navigationMetadata("compiler/testData/codegen/box/binaryOp/longOverflow.kt");
+        @TestMetadata("overflowChar.kt")
+        public void testOverflowChar() throws Exception {
+            String fileName = JetTestUtils.navigationMetadata("compiler/testData/codegen/box/binaryOp/overflowChar.kt");
+            doTest(fileName);
+        }
+
+        @TestMetadata("overflowInt.kt")
+        public void testOverflowInt() throws Exception {
+            String fileName = JetTestUtils.navigationMetadata("compiler/testData/codegen/box/binaryOp/overflowInt.kt");
+            doTest(fileName);
+        }
+
+        @TestMetadata("overflowLong.kt")
+        public void testOverflowLong() throws Exception {
+            String fileName = JetTestUtils.navigationMetadata("compiler/testData/codegen/box/binaryOp/overflowLong.kt");
             doTest(fileName);
         }
     }
@@ -829,12 +859,6 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest {
             doTest(fileName);
         }
 
-        @TestMetadata("asAny.kt")
-        public void testAsAny() throws Exception {
-            String fileName = JetTestUtils.navigationMetadata("compiler/testData/codegen/box/casts/asAny.kt");
-            doTest(fileName);
-        }
-
         @TestMetadata("asForConstants.kt")
         public void testAsForConstants() throws Exception {
             String fileName = JetTestUtils.navigationMetadata("compiler/testData/codegen/box/casts/asForConstants.kt");
@@ -889,6 +913,18 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest {
             doTest(fileName);
         }
 
+        @TestMetadata("unitAsAny.kt")
+        public void testUnitAsAny() throws Exception {
+            String fileName = JetTestUtils.navigationMetadata("compiler/testData/codegen/box/casts/unitAsAny.kt");
+            doTest(fileName);
+        }
+
+        @TestMetadata("unitAsSafeAny.kt")
+        public void testUnitAsSafeAny() throws Exception {
+            String fileName = JetTestUtils.navigationMetadata("compiler/testData/codegen/box/casts/unitAsSafeAny.kt");
+            doTest(fileName);
+        }
+
         @TestMetadata("unitNullableCast.kt")
         public void testUnitNullableCast() throws Exception {
             String fileName = JetTestUtils.navigationMetadata("compiler/testData/codegen/box/casts/unitNullableCast.kt");
@@ -2265,6 +2301,129 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest {
                 doTest(fileName);
             }
         }
+
+        @TestMetadata("compiler/testData/codegen/box/controlStructures/tryCatchInExpressions")
+        @TestDataPath("$PROJECT_ROOT")
+        @RunWith(JUnit3RunnerWithInners.class)
+        public static class TryCatchInExpressions extends AbstractBlackBoxCodegenTest {
+            public void testAllFilesPresentInTryCatchInExpressions() throws Exception {
+                JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/tryCatchInExpressions"), Pattern.compile("^(.+)\\.kt$"), true);
+            }
+
+            @TestMetadata("catch.kt")
+            public void testCatch() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("compiler/testData/codegen/box/controlStructures/tryCatchInExpressions/catch.kt");
+                doTest(fileName);
+            }
+
+            @TestMetadata("complexChain.kt")
+            public void testComplexChain() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("compiler/testData/codegen/box/controlStructures/tryCatchInExpressions/complexChain.kt");
+                doTest(fileName);
+            }
+
+            @TestMetadata("differentTypes.kt")
+            public void testDifferentTypes() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("compiler/testData/codegen/box/controlStructures/tryCatchInExpressions/differentTypes.kt");
+                doTest(fileName);
+            }
+
+            @TestMetadata("expectException.kt")
+            public void testExpectException() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("compiler/testData/codegen/box/controlStructures/tryCatchInExpressions/expectException.kt");
+                doTest(fileName);
+            }
+
+            @TestMetadata("finally.kt")
+            public void testFinally() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("compiler/testData/codegen/box/controlStructures/tryCatchInExpressions/finally.kt");
+                doTest(fileName);
+            }
+
+            @TestMetadata("inlineTryCatch.kt")
+            public void testInlineTryCatch() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("compiler/testData/codegen/box/controlStructures/tryCatchInExpressions/inlineTryCatch.kt");
+                doTest(fileName);
+            }
+
+            @TestMetadata("inlineTryExpr.kt")
+            public void testInlineTryExpr() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("compiler/testData/codegen/box/controlStructures/tryCatchInExpressions/inlineTryExpr.kt");
+                doTest(fileName);
+            }
+
+            @TestMetadata("inlineTryFinally.kt")
+            public void testInlineTryFinally() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("compiler/testData/codegen/box/controlStructures/tryCatchInExpressions/inlineTryFinally.kt");
+                doTest(fileName);
+            }
+
+            @TestMetadata("multipleCatchBlocks.kt")
+            public void testMultipleCatchBlocks() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("compiler/testData/codegen/box/controlStructures/tryCatchInExpressions/multipleCatchBlocks.kt");
+                doTest(fileName);
+            }
+
+            @TestMetadata("splitTry.kt")
+            public void testSplitTry() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("compiler/testData/codegen/box/controlStructures/tryCatchInExpressions/splitTry.kt");
+                doTest(fileName);
+            }
+
+            @TestMetadata("splitTryCorner1.kt")
+            public void testSplitTryCorner1() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("compiler/testData/codegen/box/controlStructures/tryCatchInExpressions/splitTryCorner1.kt");
+                doTest(fileName);
+            }
+
+            @TestMetadata("splitTryCorner2.kt")
+            public void testSplitTryCorner2() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("compiler/testData/codegen/box/controlStructures/tryCatchInExpressions/splitTryCorner2.kt");
+                doTest(fileName);
+            }
+
+            @TestMetadata("try.kt")
+            public void testTry() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("compiler/testData/codegen/box/controlStructures/tryCatchInExpressions/try.kt");
+                doTest(fileName);
+            }
+
+            @TestMetadata("tryAfterTry.kt")
+            public void testTryAfterTry() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("compiler/testData/codegen/box/controlStructures/tryCatchInExpressions/tryAfterTry.kt");
+                doTest(fileName);
+            }
+
+            @TestMetadata("tryAndBreak.kt")
+            public void testTryAndBreak() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("compiler/testData/codegen/box/controlStructures/tryCatchInExpressions/tryAndBreak.kt");
+                doTest(fileName);
+            }
+
+            @TestMetadata("tryAndContinue.kt")
+            public void testTryAndContinue() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("compiler/testData/codegen/box/controlStructures/tryCatchInExpressions/tryAndContinue.kt");
+                doTest(fileName);
+            }
+
+            @TestMetadata("tryInsideCatch.kt")
+            public void testTryInsideCatch() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("compiler/testData/codegen/box/controlStructures/tryCatchInExpressions/tryInsideCatch.kt");
+                doTest(fileName);
+            }
+
+            @TestMetadata("tryInsideTry.kt")
+            public void testTryInsideTry() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("compiler/testData/codegen/box/controlStructures/tryCatchInExpressions/tryInsideTry.kt");
+                doTest(fileName);
+            }
+
+            @TestMetadata("unmatchedInlineMarkers.kt")
+            public void testUnmatchedInlineMarkers() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("compiler/testData/codegen/box/controlStructures/tryCatchInExpressions/unmatchedInlineMarkers.kt");
+                doTest(fileName);
+            }
+        }
     }
 
     @TestMetadata("compiler/testData/codegen/box/deadCodeElimination")
@@ -3328,6 +3487,12 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest {
             doTest(fileName);
         }
 
+        @TestMetadata("publicConstructorWithDefault.kt")
+        public void testPublicConstructorWithDefault() throws Exception {
+            String fileName = JetTestUtils.navigationMetadata("compiler/testData/codegen/box/enum/publicConstructorWithDefault.kt");
+            doTest(fileName);
+        }
+
         @TestMetadata("simple.kt")
         public void testSimple() throws Exception {
             String fileName = JetTestUtils.navigationMetadata("compiler/testData/codegen/box/enum/simple.kt");
diff --git a/compiler/tests/org/jetbrains/kotlin/codegen/generated/BlackBoxWithJavaCodegenTestGenerated.java b/compiler/tests/org/jetbrains/kotlin/codegen/generated/BlackBoxWithJavaCodegenTestGenerated.java
index 1b873ebae00..d3e078cf43e 100644
--- a/compiler/tests/org/jetbrains/kotlin/codegen/generated/BlackBoxWithJavaCodegenTestGenerated.java
+++ b/compiler/tests/org/jetbrains/kotlin/codegen/generated/BlackBoxWithJavaCodegenTestGenerated.java
@@ -249,6 +249,22 @@ public class BlackBoxWithJavaCodegenTestGenerated extends AbstractBlackBoxCodege
 
     }
 
+    @TestMetadata("compiler/testData/codegen/boxWithJava/publicField")
+    @TestDataPath("$PROJECT_ROOT")
+    @RunWith(JUnit3RunnerWithInners.class)
+    public static class PublicField extends AbstractBlackBoxCodegenTest {
+        public void testAllFilesPresentInPublicField() throws Exception {
+            JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/codegen/boxWithJava/publicField"), Pattern.compile("^([^\\.]+)$"), true);
+        }
+
+        @TestMetadata("simple")
+        public void testSimple() throws Exception {
+            String fileName = JetTestUtils.navigationMetadata("compiler/testData/codegen/boxWithJava/publicField/simple/");
+            doTestWithJava(fileName);
+        }
+
+    }
+
     @TestMetadata("compiler/testData/codegen/boxWithJava/reflection")
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
@@ -269,12 +285,24 @@ public class BlackBoxWithJavaCodegenTestGenerated extends AbstractBlackBoxCodege
             doTestWithJava(fileName);
         }
 
+        @TestMetadata("javaStaticField")
+        public void testJavaStaticField() throws Exception {
+            String fileName = JetTestUtils.navigationMetadata("compiler/testData/codegen/boxWithJava/reflection/javaStaticField/");
+            doTestWithJava(fileName);
+        }
+
         @TestMetadata("kotlinPropertyInheritedInJava")
         public void testKotlinPropertyInheritedInJava() throws Exception {
             String fileName = JetTestUtils.navigationMetadata("compiler/testData/codegen/boxWithJava/reflection/kotlinPropertyInheritedInJava/");
             doTestWithJava(fileName);
         }
 
+        @TestMetadata("noConflictOnKotlinGetterAndJavaField")
+        public void testNoConflictOnKotlinGetterAndJavaField() throws Exception {
+            String fileName = JetTestUtils.navigationMetadata("compiler/testData/codegen/boxWithJava/reflection/noConflictOnKotlinGetterAndJavaField/");
+            doTestWithJava(fileName);
+        }
+
     }
 
     @TestMetadata("compiler/testData/codegen/boxWithJava/secondaryConstructors")
diff --git a/compiler/tests/org/jetbrains/kotlin/codegen/generated/BlackBoxWithStdlibCodegenTestGenerated.java b/compiler/tests/org/jetbrains/kotlin/codegen/generated/BlackBoxWithStdlibCodegenTestGenerated.java
index 675239c3466..2407669c3b4 100644
--- a/compiler/tests/org/jetbrains/kotlin/codegen/generated/BlackBoxWithStdlibCodegenTestGenerated.java
+++ b/compiler/tests/org/jetbrains/kotlin/codegen/generated/BlackBoxWithStdlibCodegenTestGenerated.java
@@ -795,6 +795,12 @@ public class BlackBoxWithStdlibCodegenTestGenerated extends AbstractBlackBoxCode
                 doTestWithStdlib(fileName);
             }
 
+            @TestMetadata("kt6870_privatePropertyReference.kt")
+            public void testKt6870_privatePropertyReference() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("compiler/testData/codegen/boxWithStdlib/callableReference/property/kt6870_privatePropertyReference.kt");
+                doTestWithStdlib(fileName);
+            }
+
             @TestMetadata("localClassVar.kt")
             public void testLocalClassVar() throws Exception {
                 String fileName = JetTestUtils.navigationMetadata("compiler/testData/codegen/boxWithStdlib/callableReference/property/localClassVar.kt");
@@ -813,24 +819,6 @@ public class BlackBoxWithStdlibCodegenTestGenerated extends AbstractBlackBoxCode
                 doTestWithStdlib(fileName);
             }
 
-            @TestMetadata("privateClassVal.kt")
-            public void testPrivateClassVal() throws Exception {
-                String fileName = JetTestUtils.navigationMetadata("compiler/testData/codegen/boxWithStdlib/callableReference/property/privateClassVal.kt");
-                doTestWithStdlib(fileName);
-            }
-
-            @TestMetadata("privateClassVar.kt")
-            public void testPrivateClassVar() throws Exception {
-                String fileName = JetTestUtils.navigationMetadata("compiler/testData/codegen/boxWithStdlib/callableReference/property/privateClassVar.kt");
-                doTestWithStdlib(fileName);
-            }
-
-            @TestMetadata("protectedClassVar.kt")
-            public void testProtectedClassVar() throws Exception {
-                String fileName = JetTestUtils.navigationMetadata("compiler/testData/codegen/boxWithStdlib/callableReference/property/protectedClassVar.kt");
-                doTestWithStdlib(fileName);
-            }
-
             @TestMetadata("publicClassValAccessible.kt")
             public void testPublicClassValAccessible() throws Exception {
                 String fileName = JetTestUtils.navigationMetadata("compiler/testData/codegen/boxWithStdlib/callableReference/property/publicClassValAccessible.kt");
@@ -888,6 +876,12 @@ public class BlackBoxWithStdlibCodegenTestGenerated extends AbstractBlackBoxCode
             String fileName = JetTestUtils.navigationMetadata("compiler/testData/codegen/boxWithStdlib/casts/asWithGeneric.kt");
             doTestWithStdlib(fileName);
         }
+
+        @TestMetadata("unitAsInt.kt")
+        public void testUnitAsInt() throws Exception {
+            String fileName = JetTestUtils.navigationMetadata("compiler/testData/codegen/boxWithStdlib/casts/unitAsInt.kt");
+            doTestWithStdlib(fileName);
+        }
     }
 
     @TestMetadata("compiler/testData/codegen/boxWithStdlib/classes")
@@ -2757,6 +2751,12 @@ public class BlackBoxWithStdlibCodegenTestGenerated extends AbstractBlackBoxCode
                 JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/codegen/boxWithStdlib/reflection/classLiterals"), Pattern.compile("^(.+)\\.kt$"), true);
             }
 
+            @TestMetadata("annotationClassLiteral.kt")
+            public void testAnnotationClassLiteral() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("compiler/testData/codegen/boxWithStdlib/reflection/classLiterals/annotationClassLiteral.kt");
+                doTestWithStdlib(fileName);
+            }
+
             @TestMetadata("arrays.kt")
             public void testArrays() throws Exception {
                 String fileName = JetTestUtils.navigationMetadata("compiler/testData/codegen/boxWithStdlib/reflection/classLiterals/arrays.kt");
@@ -2769,24 +2769,12 @@ public class BlackBoxWithStdlibCodegenTestGenerated extends AbstractBlackBoxCode
                 doTestWithStdlib(fileName);
             }
 
-            @TestMetadata("classSimpleName.kt")
-            public void testClassSimpleName() throws Exception {
-                String fileName = JetTestUtils.navigationMetadata("compiler/testData/codegen/boxWithStdlib/reflection/classLiterals/classSimpleName.kt");
-                doTestWithStdlib(fileName);
-            }
-
             @TestMetadata("genericClass.kt")
             public void testGenericClass() throws Exception {
                 String fileName = JetTestUtils.navigationMetadata("compiler/testData/codegen/boxWithStdlib/reflection/classLiterals/genericClass.kt");
                 doTestWithStdlib(fileName);
             }
 
-            @TestMetadata("localClassSimpleName.kt")
-            public void testLocalClassSimpleName() throws Exception {
-                String fileName = JetTestUtils.navigationMetadata("compiler/testData/codegen/boxWithStdlib/reflection/classLiterals/localClassSimpleName.kt");
-                doTestWithStdlib(fileName);
-            }
-
             @TestMetadata("simpleClassLiteral.kt")
             public void testSimpleClassLiteral() throws Exception {
                 String fileName = JetTestUtils.navigationMetadata("compiler/testData/codegen/boxWithStdlib/reflection/classLiterals/simpleClassLiteral.kt");
@@ -2794,6 +2782,54 @@ public class BlackBoxWithStdlibCodegenTestGenerated extends AbstractBlackBoxCode
             }
         }
 
+        @TestMetadata("compiler/testData/codegen/boxWithStdlib/reflection/classes")
+        @TestDataPath("$PROJECT_ROOT")
+        @RunWith(JUnit3RunnerWithInners.class)
+        public static class Classes extends AbstractBlackBoxCodegenTest {
+            public void testAllFilesPresentInClasses() throws Exception {
+                JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/codegen/boxWithStdlib/reflection/classes"), Pattern.compile("^(.+)\\.kt$"), true);
+            }
+
+            @TestMetadata("classSimpleName.kt")
+            public void testClassSimpleName() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("compiler/testData/codegen/boxWithStdlib/reflection/classes/classSimpleName.kt");
+                doTestWithStdlib(fileName);
+            }
+
+            @TestMetadata("jvmName.kt")
+            public void testJvmName() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("compiler/testData/codegen/boxWithStdlib/reflection/classes/jvmName.kt");
+                doTestWithStdlib(fileName);
+            }
+
+            @TestMetadata("localClassSimpleName.kt")
+            public void testLocalClassSimpleName() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("compiler/testData/codegen/boxWithStdlib/reflection/classes/localClassSimpleName.kt");
+                doTestWithStdlib(fileName);
+            }
+
+            @TestMetadata("qualifiedName.kt")
+            public void testQualifiedName() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("compiler/testData/codegen/boxWithStdlib/reflection/classes/qualifiedName.kt");
+                doTestWithStdlib(fileName);
+            }
+        }
+
+        @TestMetadata("compiler/testData/codegen/boxWithStdlib/reflection/constructors")
+        @TestDataPath("$PROJECT_ROOT")
+        @RunWith(JUnit3RunnerWithInners.class)
+        public static class Constructors extends AbstractBlackBoxCodegenTest {
+            public void testAllFilesPresentInConstructors() throws Exception {
+                JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/codegen/boxWithStdlib/reflection/constructors"), Pattern.compile("^(.+)\\.kt$"), true);
+            }
+
+            @TestMetadata("constructorName.kt")
+            public void testConstructorName() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("compiler/testData/codegen/boxWithStdlib/reflection/constructors/constructorName.kt");
+                doTestWithStdlib(fileName);
+            }
+        }
+
         @TestMetadata("compiler/testData/codegen/boxWithStdlib/reflection/enclosing")
         @TestDataPath("$PROJECT_ROOT")
         @RunWith(JUnit3RunnerWithInners.class)
@@ -2947,6 +2983,33 @@ public class BlackBoxWithStdlibCodegenTestGenerated extends AbstractBlackBoxCode
             }
         }
 
+        @TestMetadata("compiler/testData/codegen/boxWithStdlib/reflection/functions")
+        @TestDataPath("$PROJECT_ROOT")
+        @RunWith(JUnit3RunnerWithInners.class)
+        public static class Functions extends AbstractBlackBoxCodegenTest {
+            public void testAllFilesPresentInFunctions() throws Exception {
+                JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/codegen/boxWithStdlib/reflection/functions"), Pattern.compile("^(.+)\\.kt$"), true);
+            }
+
+            @TestMetadata("localFunctionName.kt")
+            public void testLocalFunctionName() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("compiler/testData/codegen/boxWithStdlib/reflection/functions/localFunctionName.kt");
+                doTestWithStdlib(fileName);
+            }
+
+            @TestMetadata("platformName.kt")
+            public void testPlatformName() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("compiler/testData/codegen/boxWithStdlib/reflection/functions/platformName.kt");
+                doTestWithStdlib(fileName);
+            }
+
+            @TestMetadata("simpleNames.kt")
+            public void testSimpleNames() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("compiler/testData/codegen/boxWithStdlib/reflection/functions/simpleNames.kt");
+                doTestWithStdlib(fileName);
+            }
+        }
+
         @TestMetadata("compiler/testData/codegen/boxWithStdlib/reflection/genericSignature")
         @TestDataPath("$PROJECT_ROOT")
         @RunWith(JUnit3RunnerWithInners.class)
@@ -3066,18 +3129,24 @@ public class BlackBoxWithStdlibCodegenTestGenerated extends AbstractBlackBoxCode
                 doTestWithStdlib(fileName);
             }
 
-            @TestMetadata("equalsHashCode.kt")
-            public void testEqualsHashCode() throws Exception {
-                String fileName = JetTestUtils.navigationMetadata("compiler/testData/codegen/boxWithStdlib/reflection/methodsFromAny/equalsHashCode.kt");
-                doTestWithStdlib(fileName);
-            }
-
             @TestMetadata("extensionPropertyReceiverToString.kt")
             public void testExtensionPropertyReceiverToString() throws Exception {
                 String fileName = JetTestUtils.navigationMetadata("compiler/testData/codegen/boxWithStdlib/reflection/methodsFromAny/extensionPropertyReceiverToString.kt");
                 doTestWithStdlib(fileName);
             }
 
+            @TestMetadata("functionEqualsHashCode.kt")
+            public void testFunctionEqualsHashCode() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("compiler/testData/codegen/boxWithStdlib/reflection/methodsFromAny/functionEqualsHashCode.kt");
+                doTestWithStdlib(fileName);
+            }
+
+            @TestMetadata("functionToString.kt")
+            public void testFunctionToString() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("compiler/testData/codegen/boxWithStdlib/reflection/methodsFromAny/functionToString.kt");
+                doTestWithStdlib(fileName);
+            }
+
             @TestMetadata("memberExtensionToString.kt")
             public void testMemberExtensionToString() throws Exception {
                 String fileName = JetTestUtils.navigationMetadata("compiler/testData/codegen/boxWithStdlib/reflection/methodsFromAny/memberExtensionToString.kt");
@@ -3096,6 +3165,12 @@ public class BlackBoxWithStdlibCodegenTestGenerated extends AbstractBlackBoxCode
                 doTestWithStdlib(fileName);
             }
 
+            @TestMetadata("propertyEqualsHashCode.kt")
+            public void testPropertyEqualsHashCode() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("compiler/testData/codegen/boxWithStdlib/reflection/methodsFromAny/propertyEqualsHashCode.kt");
+                doTestWithStdlib(fileName);
+            }
+
             @TestMetadata("propertyToString.kt")
             public void testPropertyToString() throws Exception {
                 String fileName = JetTestUtils.navigationMetadata("compiler/testData/codegen/boxWithStdlib/reflection/methodsFromAny/propertyToString.kt");
@@ -3153,6 +3228,18 @@ public class BlackBoxWithStdlibCodegenTestGenerated extends AbstractBlackBoxCode
                 doTestWithStdlib(fileName);
             }
 
+            @TestMetadata("privateClassVal.kt")
+            public void testPrivateClassVal() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("compiler/testData/codegen/boxWithStdlib/reflection/properties/privateClassVal.kt");
+                doTestWithStdlib(fileName);
+            }
+
+            @TestMetadata("privateClassVar.kt")
+            public void testPrivateClassVar() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("compiler/testData/codegen/boxWithStdlib/reflection/properties/privateClassVar.kt");
+                doTestWithStdlib(fileName);
+            }
+
             @TestMetadata("privateFakeOverrideFromSuperclass.kt")
             public void testPrivateFakeOverrideFromSuperclass() throws Exception {
                 String fileName = JetTestUtils.navigationMetadata("compiler/testData/codegen/boxWithStdlib/reflection/properties/privateFakeOverrideFromSuperclass.kt");
@@ -3171,11 +3258,56 @@ public class BlackBoxWithStdlibCodegenTestGenerated extends AbstractBlackBoxCode
                 doTestWithStdlib(fileName);
             }
 
+            @TestMetadata("protectedClassVar.kt")
+            public void testProtectedClassVar() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("compiler/testData/codegen/boxWithStdlib/reflection/properties/protectedClassVar.kt");
+                doTestWithStdlib(fileName);
+            }
+
             @TestMetadata("simpleGetProperties.kt")
             public void testSimpleGetProperties() throws Exception {
                 String fileName = JetTestUtils.navigationMetadata("compiler/testData/codegen/boxWithStdlib/reflection/properties/simpleGetProperties.kt");
                 doTestWithStdlib(fileName);
             }
+
+            @TestMetadata("compiler/testData/codegen/boxWithStdlib/reflection/properties/accessors")
+            @TestDataPath("$PROJECT_ROOT")
+            @RunWith(JUnit3RunnerWithInners.class)
+            public static class Accessors extends AbstractBlackBoxCodegenTest {
+                @TestMetadata("accessorNames.kt")
+                public void testAccessorNames() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("compiler/testData/codegen/boxWithStdlib/reflection/properties/accessors/accessorNames.kt");
+                    doTestWithStdlib(fileName);
+                }
+
+                public void testAllFilesPresentInAccessors() throws Exception {
+                    JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/codegen/boxWithStdlib/reflection/properties/accessors"), Pattern.compile("^(.+)\\.kt$"), true);
+                }
+
+                @TestMetadata("extensionPropertyAccessors.kt")
+                public void testExtensionPropertyAccessors() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("compiler/testData/codegen/boxWithStdlib/reflection/properties/accessors/extensionPropertyAccessors.kt");
+                    doTestWithStdlib(fileName);
+                }
+
+                @TestMetadata("memberExtensions.kt")
+                public void testMemberExtensions() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("compiler/testData/codegen/boxWithStdlib/reflection/properties/accessors/memberExtensions.kt");
+                    doTestWithStdlib(fileName);
+                }
+
+                @TestMetadata("memberPropertyAccessors.kt")
+                public void testMemberPropertyAccessors() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("compiler/testData/codegen/boxWithStdlib/reflection/properties/accessors/memberPropertyAccessors.kt");
+                    doTestWithStdlib(fileName);
+                }
+
+                @TestMetadata("topLevelPropertyAccessors.kt")
+                public void testTopLevelPropertyAccessors() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("compiler/testData/codegen/boxWithStdlib/reflection/properties/accessors/topLevelPropertyAccessors.kt");
+                    doTestWithStdlib(fileName);
+                }
+            }
         }
     }
 
@@ -3295,6 +3427,12 @@ public class BlackBoxWithStdlibCodegenTestGenerated extends AbstractBlackBoxCode
             doTestWithStdlib(fileName);
         }
 
+        @TestMetadata("kt3850.kt")
+        public void testKt3850() throws Exception {
+            String fileName = JetTestUtils.navigationMetadata("compiler/testData/codegen/boxWithStdlib/regressions/kt3850.kt");
+            doTestWithStdlib(fileName);
+        }
+
         @TestMetadata("kt4142.kt")
         public void testKt4142() throws Exception {
             String fileName = JetTestUtils.navigationMetadata("compiler/testData/codegen/boxWithStdlib/regressions/kt4142.kt");
diff --git a/compiler/tests/org/jetbrains/kotlin/jvm/compiler/AbstractCompileJavaAgainstKotlinTest.java b/compiler/tests/org/jetbrains/kotlin/jvm/compiler/AbstractCompileJavaAgainstKotlinTest.java
index eccfaa7ed35..cd23c5db5e7 100644
--- a/compiler/tests/org/jetbrains/kotlin/jvm/compiler/AbstractCompileJavaAgainstKotlinTest.java
+++ b/compiler/tests/org/jetbrains/kotlin/jvm/compiler/AbstractCompileJavaAgainstKotlinTest.java
@@ -22,6 +22,7 @@ import org.jetbrains.kotlin.analyzer.AnalysisResult;
 import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles;
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment;
 import org.jetbrains.kotlin.descriptors.PackageViewDescriptor;
+import org.jetbrains.kotlin.name.FqName;
 import org.jetbrains.kotlin.psi.JetFile;
 import org.jetbrains.kotlin.renderer.DescriptorRenderer;
 import org.jetbrains.kotlin.renderer.DescriptorRendererOptions;
@@ -35,6 +36,7 @@ import org.junit.Assert;
 
 import java.io.File;
 import java.io.IOException;
+import java.lang.annotation.Retention;
 import java.util.Collections;
 
 import static org.jetbrains.kotlin.test.JetTestUtils.*;
@@ -53,6 +55,7 @@ public abstract class AbstractCompileJavaAgainstKotlinTest extends TestCaseWithT
                             options.setWithDefinedIn(false);
                             options.setParameterNameRenderingPolicy(ParameterNameRenderingPolicy.NONE);
                             options.setVerbose(true);
+                            options.setExcludedAnnotationClasses(Collections.singleton(new FqName(Retention.class.getName())));
                             return Unit.INSTANCE$;
                         }
                     }
diff --git a/compiler/tests/org/jetbrains/kotlin/jvm/compiler/CompileJavaAgainstKotlinTestGenerated.java b/compiler/tests/org/jetbrains/kotlin/jvm/compiler/CompileJavaAgainstKotlinTestGenerated.java
index 3498cf44ba1..c460efef005 100644
--- a/compiler/tests/org/jetbrains/kotlin/jvm/compiler/CompileJavaAgainstKotlinTestGenerated.java
+++ b/compiler/tests/org/jetbrains/kotlin/jvm/compiler/CompileJavaAgainstKotlinTestGenerated.java
@@ -553,4 +553,97 @@ public class CompileJavaAgainstKotlinTestGenerated extends AbstractCompileJavaAg
             doTest(fileName);
         }
     }
+
+    @TestMetadata("compiler/testData/compileJavaAgainstKotlin/targets")
+    @TestDataPath("$PROJECT_ROOT")
+    @RunWith(JUnit3RunnerWithInners.class)
+    public static class Targets extends AbstractCompileJavaAgainstKotlinTest {
+        public void testAllFilesPresentInTargets() throws Exception {
+            JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/targets"), Pattern.compile("^(.+)\\.kt$"), true);
+        }
+
+        @TestMetadata("annotation.kt")
+        public void testAnnotation() throws Exception {
+            String fileName = JetTestUtils.navigationMetadata("compiler/testData/compileJavaAgainstKotlin/targets/annotation.kt");
+            doTest(fileName);
+        }
+
+        @TestMetadata("base.kt")
+        public void testBase() throws Exception {
+            String fileName = JetTestUtils.navigationMetadata("compiler/testData/compileJavaAgainstKotlin/targets/base.kt");
+            doTest(fileName);
+        }
+
+        @TestMetadata("classifier.kt")
+        public void testClassifier() throws Exception {
+            String fileName = JetTestUtils.navigationMetadata("compiler/testData/compileJavaAgainstKotlin/targets/classifier.kt");
+            doTest(fileName);
+        }
+
+        @TestMetadata("constructor.kt")
+        public void testConstructor() throws Exception {
+            String fileName = JetTestUtils.navigationMetadata("compiler/testData/compileJavaAgainstKotlin/targets/constructor.kt");
+            doTest(fileName);
+        }
+
+        @TestMetadata("empty.kt")
+        public void testEmpty() throws Exception {
+            String fileName = JetTestUtils.navigationMetadata("compiler/testData/compileJavaAgainstKotlin/targets/empty.kt");
+            doTest(fileName);
+        }
+
+        @TestMetadata("field.kt")
+        public void testField() throws Exception {
+            String fileName = JetTestUtils.navigationMetadata("compiler/testData/compileJavaAgainstKotlin/targets/field.kt");
+            doTest(fileName);
+        }
+
+        @TestMetadata("function.kt")
+        public void testFunction() throws Exception {
+            String fileName = JetTestUtils.navigationMetadata("compiler/testData/compileJavaAgainstKotlin/targets/function.kt");
+            doTest(fileName);
+        }
+
+        @TestMetadata("getter.kt")
+        public void testGetter() throws Exception {
+            String fileName = JetTestUtils.navigationMetadata("compiler/testData/compileJavaAgainstKotlin/targets/getter.kt");
+            doTest(fileName);
+        }
+
+        @TestMetadata("local.kt")
+        public void testLocal() throws Exception {
+            String fileName = JetTestUtils.navigationMetadata("compiler/testData/compileJavaAgainstKotlin/targets/local.kt");
+            doTest(fileName);
+        }
+
+        @TestMetadata("multiple.kt")
+        public void testMultiple() throws Exception {
+            String fileName = JetTestUtils.navigationMetadata("compiler/testData/compileJavaAgainstKotlin/targets/multiple.kt");
+            doTest(fileName);
+        }
+
+        @TestMetadata("package-info.kt")
+        public void testPackage_info() throws Exception {
+            String fileName = JetTestUtils.navigationMetadata("compiler/testData/compileJavaAgainstKotlin/targets/package-info.kt");
+            doTest(fileName);
+        }
+
+        @TestMetadata("parameter.kt")
+        public void testParameter() throws Exception {
+            String fileName = JetTestUtils.navigationMetadata("compiler/testData/compileJavaAgainstKotlin/targets/parameter.kt");
+            doTest(fileName);
+        }
+
+        @TestMetadata("property.kt")
+        public void testProperty() throws Exception {
+            String fileName = JetTestUtils.navigationMetadata("compiler/testData/compileJavaAgainstKotlin/targets/property.kt");
+            doTest(fileName);
+        }
+
+        @TestMetadata("setter.kt")
+        public void testSetter() throws Exception {
+            String fileName = JetTestUtils.navigationMetadata("compiler/testData/compileJavaAgainstKotlin/targets/setter.kt");
+            doTest(fileName);
+        }
+    }
 }
diff --git a/compiler/tests/org/jetbrains/kotlin/jvm/compiler/ExpectedLoadErrorsUtil.java b/compiler/tests/org/jetbrains/kotlin/jvm/compiler/ExpectedLoadErrorsUtil.java
index cdf983a252a..77b4dc3a3f9 100644
--- a/compiler/tests/org/jetbrains/kotlin/jvm/compiler/ExpectedLoadErrorsUtil.java
+++ b/compiler/tests/org/jetbrains/kotlin/jvm/compiler/ExpectedLoadErrorsUtil.java
@@ -25,7 +25,7 @@ import org.jetbrains.kotlin.load.java.JavaBindingContext;
 import org.jetbrains.kotlin.name.FqName;
 import org.jetbrains.kotlin.renderer.DescriptorRenderer;
 import org.jetbrains.kotlin.resolve.BindingContext;
-import org.jetbrains.kotlin.resolve.constants.CompileTimeConstant;
+import org.jetbrains.kotlin.resolve.constants.ConstantValue;
 import org.jetbrains.kotlin.resolve.scopes.JetScope;
 
 import java.util.*;
@@ -84,13 +84,13 @@ public class ExpectedLoadErrorsUtil {
                 if (annotation == null) return null;
 
                 // we expect exactly one annotation argument
-                CompileTimeConstant<?> argument = annotation.getAllValueArguments().values().iterator().next();
+                ConstantValue<?> argument = annotation.getAllValueArguments().values().iterator().next();
 
                 String error = (String) argument.getValue();
                 //noinspection ConstantConditions
                 List<String> errors = Arrays.asList(error.split("\\|"));
 
-                map.put(descriptor, errors);
+                map.put(descriptor.getOriginal(), errors);
 
                 return null;
             }
@@ -113,7 +113,7 @@ public class ExpectedLoadErrorsUtil {
         Collection<DeclarationDescriptor> descriptors = bindingContext.getKeys(JavaBindingContext.LOAD_FROM_JAVA_SIGNATURE_ERRORS);
         for (DeclarationDescriptor descriptor : descriptors) {
             List<String> errors = bindingContext.get(JavaBindingContext.LOAD_FROM_JAVA_SIGNATURE_ERRORS, descriptor);
-            result.put(descriptor, errors);
+            result.put(descriptor.getOriginal(), errors);
         }
 
         return result;
diff --git a/compiler/tests/org/jetbrains/kotlin/jvm/compiler/LoadJavaTestGenerated.java b/compiler/tests/org/jetbrains/kotlin/jvm/compiler/LoadJavaTestGenerated.java
index 89d0b94765f..1e88eca050c 100644
--- a/compiler/tests/org/jetbrains/kotlin/jvm/compiler/LoadJavaTestGenerated.java
+++ b/compiler/tests/org/jetbrains/kotlin/jvm/compiler/LoadJavaTestGenerated.java
@@ -1568,12 +1568,30 @@ public class LoadJavaTestGenerated extends AbstractLoadJavaTest {
                     doTestCompiledJava(fileName);
                 }
 
+                @TestMetadata("ConstructorWithAnnotations.java")
+                public void testConstructorWithAnnotations() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/sam/adapters/ConstructorWithAnnotations.java");
+                    doTestCompiledJava(fileName);
+                }
+
                 @TestMetadata("DeepSamLoop.java")
                 public void testDeepSamLoop() throws Exception {
                     String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/sam/adapters/DeepSamLoop.java");
                     doTestCompiledJava(fileName);
                 }
 
+                @TestMetadata("NoSamForClassTypeParameter.java")
+                public void testNoSamForClassTypeParameter() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/sam/adapters/NoSamForClassTypeParameter.java");
+                    doTestCompiledJava(fileName);
+                }
+
+                @TestMetadata("NoSamForMethodTypeParameter.java")
+                public void testNoSamForMethodTypeParameter() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/sam/adapters/NoSamForMethodTypeParameter.java");
+                    doTestCompiledJava(fileName);
+                }
+
                 @TestMetadata("NonTrivialFunctionType.java")
                 public void testNonTrivialFunctionType() throws Exception {
                     String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/sam/adapters/NonTrivialFunctionType.java");
@@ -1924,6 +1942,12 @@ public class LoadJavaTestGenerated extends AbstractLoadJavaTest {
                 doTestCompiledKotlin(fileName);
             }
 
+            @TestMetadata("TargetedAnnotation.kt")
+            public void testTargetedAnnotation() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/annotations/TargetedAnnotation.kt");
+                doTestCompiledKotlin(fileName);
+            }
+
             @TestMetadata("compiler/testData/loadJava/compiledKotlin/annotations/classMembers")
             @TestDataPath("$PROJECT_ROOT")
             @RunWith(JUnit3RunnerWithInners.class)
@@ -2013,6 +2037,12 @@ public class LoadJavaTestGenerated extends AbstractLoadJavaTest {
                     doTestCompiledKotlin(fileName);
                 }
 
+                @TestMetadata("DataClass.kt")
+                public void testDataClass() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/annotations/classes/DataClass.kt");
+                    doTestCompiledKotlin(fileName);
+                }
+
                 @TestMetadata("Deprecated.kt")
                 public void testDeprecated() throws Exception {
                     String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/annotations/classes/Deprecated.kt");
@@ -5150,6 +5180,12 @@ public class LoadJavaTestGenerated extends AbstractLoadJavaTest {
             doTestSourceJava(fileName);
         }
 
+        @TestMetadata("TypeAnnotations.java")
+        public void testTypeAnnotations() throws Exception {
+            String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/sourceJava/TypeAnnotations.java");
+            doTestSourceJava(fileName);
+        }
+
         @TestMetadata("WrongNumberOfGenericParameters.java")
         public void testWrongNumberOfGenericParameters() throws Exception {
             String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/sourceJava/WrongNumberOfGenericParameters.java");
diff --git a/compiler/tests/org/jetbrains/kotlin/jvm/runtime/AbstractJvmRuntimeDescriptorLoaderTest.kt b/compiler/tests/org/jetbrains/kotlin/jvm/runtime/AbstractJvmRuntimeDescriptorLoaderTest.kt
index 77f2c3c8c95..9c7c0e8612d 100644
--- a/compiler/tests/org/jetbrains/kotlin/jvm/runtime/AbstractJvmRuntimeDescriptorLoaderTest.kt
+++ b/compiler/tests/org/jetbrains/kotlin/jvm/runtime/AbstractJvmRuntimeDescriptorLoaderTest.kt
@@ -44,6 +44,7 @@ import org.jetbrains.kotlin.test.util.RecursiveDescriptorComparator.Configuratio
 import org.jetbrains.kotlin.types.TypeSubstitutor
 import org.jetbrains.kotlin.utils.sure
 import java.io.File
+import java.lang.annotation.Retention
 import java.net.URLClassLoader
 import java.util.regex.Pattern
 
@@ -52,21 +53,19 @@ public abstract class AbstractJvmRuntimeDescriptorLoaderTest : TestCaseWithTmpdi
         private val renderer = DescriptorRenderer.withOptions {
             withDefinedIn = false
             excludedAnnotationClasses = (listOf(
-                    ExpectedLoadErrorsUtil.ANNOTATION_CLASS_NAME,
-                    // TODO: add these annotations when they are retained at runtime
-                    "kotlin.deprecated",
-                    "kotlin.data",
-                    "kotlin.inline"
-            ).map { FqName(it) } + JvmAnnotationNames.ANNOTATIONS_COPIED_TO_TYPES).toSet()
+                    FqName(ExpectedLoadErrorsUtil.ANNOTATION_CLASS_NAME)
+            ) + JvmAnnotationNames.ANNOTATIONS_COPIED_TO_TYPES).toSet()
             overrideRenderingPolicy = OverrideRenderingPolicy.RENDER_OPEN_OVERRIDE
             parameterNameRenderingPolicy = ParameterNameRenderingPolicy.NONE
             includePropertyConstant = false
             verbose = true
+            renderDefaultAnnotationArguments = true
         }
     }
 
     // NOTE: this test does a dirty hack of text substitution to make all annotations defined in source code retain at runtime.
-    // Specifically each "annotation class" in Kotlin sources is replaced by "Retention(RUNTIME) annotation class", and the same in Java
+    // Specifically each @interface in Java sources is extended by @java.lang.annotation.Retention(java.lang.annotation.RetentionPolicy.RUNTIME)
+    // Also type related annotations are removed from Java because they are invisible at runtime
     protected fun doTest(fileName: String) {
         val file = File(fileName)
         val text = FileUtil.loadFile(file, true)
@@ -112,7 +111,7 @@ public abstract class AbstractJvmRuntimeDescriptorLoaderTest : TestCaseWithTmpdi
                 val sources = JetTestUtils.createTestFiles(fileName, text, object : TestFileFactoryNoModules<File>() {
                     override fun create(fileName: String, text: String, directives: Map<String, String>): File {
                         val targetFile = File(tmpdir, fileName)
-                        targetFile.writeText(addRuntimeRetentionToJavaSource(text))
+                        targetFile.writeText(adaptJavaSource(text))
                         return targetFile
                     }
                 })
@@ -122,7 +121,7 @@ public abstract class AbstractJvmRuntimeDescriptorLoaderTest : TestCaseWithTmpdi
                 val environment = JetTestUtils.createEnvironmentWithJdkAndNullabilityAnnotationsFromIdea(
                         myTestRootDisposable, ConfigurationKind.ALL, jdkKind
                 )
-                val jetFile = JetTestUtils.createFile(file.getPath(), addRuntimeRetentionToKotlinSource(text), environment.project)
+                val jetFile = JetTestUtils.createFile(file.getPath(), text, environment.project)
                 GenerationUtils.compileFileGetClassFileFactoryForTest(jetFile).writeAllTo(tmpdir)
             }
         }
@@ -165,15 +164,9 @@ public abstract class AbstractJvmRuntimeDescriptorLoaderTest : TestCaseWithTmpdi
         return SyntheticPackageViewForTest(module, packageScopes, classes)
     }
 
-    private fun addRuntimeRetentionToKotlinSource(text: String): String {
-        return text.replace(
-                "annotation class",
-                "@[java.lang.annotation.Retention(java.lang.annotation.RetentionPolicy.RUNTIME)] annotation class"
-        )
-    }
-
-    private fun addRuntimeRetentionToJavaSource(text: String): String {
-        return text.replace(
+    private fun adaptJavaSource(text: String): String {
+        val typeAnnotations = arrayOf("NotNull", "Nullable", "ReadOnly", "Mutable")
+        return typeAnnotations.fold(text) { text, annotation -> text.replace("@$annotation", "") }.replace(
                 "@interface",
                 "@java.lang.annotation.Retention(java.lang.annotation.RetentionPolicy.RUNTIME) @interface"
         )
diff --git a/compiler/tests/org/jetbrains/kotlin/jvm/runtime/JvmRuntimeDescriptorLoaderTestGenerated.java b/compiler/tests/org/jetbrains/kotlin/jvm/runtime/JvmRuntimeDescriptorLoaderTestGenerated.java
index 9e1c62d4995..cf574eae3eb 100644
--- a/compiler/tests/org/jetbrains/kotlin/jvm/runtime/JvmRuntimeDescriptorLoaderTestGenerated.java
+++ b/compiler/tests/org/jetbrains/kotlin/jvm/runtime/JvmRuntimeDescriptorLoaderTestGenerated.java
@@ -81,6 +81,12 @@ public class JvmRuntimeDescriptorLoaderTestGenerated extends AbstractJvmRuntimeD
                 doTest(fileName);
             }
 
+            @TestMetadata("TargetedAnnotation.kt")
+            public void testTargetedAnnotation() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/annotations/TargetedAnnotation.kt");
+                doTest(fileName);
+            }
+
             @TestMetadata("compiler/testData/loadJava/compiledKotlin/annotations/classMembers")
             @TestDataPath("$PROJECT_ROOT")
             @RunWith(JUnit3RunnerWithInners.class)
@@ -170,6 +176,12 @@ public class JvmRuntimeDescriptorLoaderTestGenerated extends AbstractJvmRuntimeD
                     doTest(fileName);
                 }
 
+                @TestMetadata("DataClass.kt")
+                public void testDataClass() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/annotations/classes/DataClass.kt");
+                    doTest(fileName);
+                }
+
                 @TestMetadata("Deprecated.kt")
                 public void testDeprecated() throws Exception {
                     String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/annotations/classes/Deprecated.kt");
diff --git a/compiler/tests/org/jetbrains/kotlin/parsing/JetParsingTestGenerated.java b/compiler/tests/org/jetbrains/kotlin/parsing/JetParsingTestGenerated.java
index 0d212813153..defaa843337 100644
--- a/compiler/tests/org/jetbrains/kotlin/parsing/JetParsingTestGenerated.java
+++ b/compiler/tests/org/jetbrains/kotlin/parsing/JetParsingTestGenerated.java
@@ -259,6 +259,12 @@ public class JetParsingTestGenerated extends AbstractJetParsingTest {
             doParsingTest(fileName);
         }
 
+        @TestMetadata("EnumWithAnnotationKeyword.kt")
+        public void testEnumWithAnnotationKeyword() throws Exception {
+            String fileName = JetTestUtils.navigationMetadata("compiler/testData/psi/EnumWithAnnotationKeyword.kt");
+            doParsingTest(fileName);
+        }
+
         @TestMetadata("Enums.kt")
         public void testEnums() throws Exception {
             String fileName = JetTestUtils.navigationMetadata("compiler/testData/psi/Enums.kt");
@@ -415,6 +421,12 @@ public class JetParsingTestGenerated extends AbstractJetParsingTest {
             doParsingTest(fileName);
         }
 
+        @TestMetadata("InterfaceWithEnumKeyword.kt")
+        public void testInterfaceWithEnumKeyword() throws Exception {
+            String fileName = JetTestUtils.navigationMetadata("compiler/testData/psi/InterfaceWithEnumKeyword.kt");
+            doParsingTest(fileName);
+        }
+
         @TestMetadata("Labels.kt")
         public void testLabels() throws Exception {
             String fileName = JetTestUtils.navigationMetadata("compiler/testData/psi/Labels.kt");
@@ -899,6 +911,57 @@ public class JetParsingTestGenerated extends AbstractJetParsingTest {
                     doParsingTest(fileName);
                 }
             }
+
+            @TestMetadata("compiler/testData/psi/annotation/options")
+            @TestDataPath("$PROJECT_ROOT")
+            @RunWith(JUnit3RunnerWithInners.class)
+            public static class Options extends AbstractJetParsingTest {
+                public void testAllFilesPresentInOptions() throws Exception {
+                    JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/psi/annotation/options"), Pattern.compile("^(.*)\\.kts?$"), true);
+                }
+
+                @TestMetadata("annotAsArgComplex.kt")
+                public void testAnnotAsArgComplex() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("compiler/testData/psi/annotation/options/annotAsArgComplex.kt");
+                    doParsingTest(fileName);
+                }
+
+                @TestMetadata("annotation.kt")
+                public void testAnnotation() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("compiler/testData/psi/annotation/options/annotation.kt");
+                    doParsingTest(fileName);
+                }
+
+                @TestMetadata("annotationAsArg.kt")
+                public void testAnnotationAsArg() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("compiler/testData/psi/annotation/options/annotationAsArg.kt");
+                    doParsingTest(fileName);
+                }
+
+                @TestMetadata("annotationAsArgComplex.kt")
+                public void testAnnotationAsArgComplex() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("compiler/testData/psi/annotation/options/annotationAsArgComplex.kt");
+                    doParsingTest(fileName);
+                }
+
+                @TestMetadata("java.kt")
+                public void testJava() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("compiler/testData/psi/annotation/options/java.kt");
+                    doParsingTest(fileName);
+                }
+
+                @TestMetadata("local.kt")
+                public void testLocal() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("compiler/testData/psi/annotation/options/local.kt");
+                    doParsingTest(fileName);
+                }
+
+                @TestMetadata("options.kt")
+                public void testOptions() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("compiler/testData/psi/annotation/options/options.kt");
+                    doParsingTest(fileName);
+                }
+            }
         }
 
         @TestMetadata("compiler/testData/psi/examples")
diff --git a/compiler/tests/org/jetbrains/kotlin/renderer/AbstractDescriptorRendererTest.kt b/compiler/tests/org/jetbrains/kotlin/renderer/AbstractDescriptorRendererTest.kt
index 7ba11e2b160..3f2b65899bf 100644
--- a/compiler/tests/org/jetbrains/kotlin/renderer/AbstractDescriptorRendererTest.kt
+++ b/compiler/tests/org/jetbrains/kotlin/renderer/AbstractDescriptorRendererTest.kt
@@ -53,7 +53,8 @@ public abstract class AbstractDescriptorRendererTest : KotlinTestWithEnvironment
                 context,
                 FileBasedDeclarationProviderFactory(context.storageManager, listOf(psiFile)),
                 CliLightClassGenerationSupport.NoScopeRecordCliBindingTrace(),
-                KotlinJvmCheckerProvider, DynamicTypesSettings())
+                KotlinJvmCheckerProvider(context.module), DynamicTypesSettings()
+        )
 
         context.initializeModuleContents(resolveSession.getPackageFragmentProvider())
 
@@ -78,7 +79,7 @@ public abstract class AbstractDescriptorRendererTest : KotlinTestWithEnvironment
                     is JetPrimaryConstructor -> {
                         val jetClassOrObject: JetClassOrObject = declaringElement.getContainingClassOrObject()
                         val classDescriptor = getDescriptor(jetClassOrObject, resolveSession) as ClassDescriptor
-                        addCorrespondingParameterDescriptor(classDescriptor.getUnsubstitutedPrimaryConstructor(), parameter)
+                        addCorrespondingParameterDescriptor(classDescriptor.getUnsubstitutedPrimaryConstructor()!!, parameter)
                     }
                     else ->  super.visitParameter(parameter)
                 }
@@ -88,10 +89,10 @@ public abstract class AbstractDescriptorRendererTest : KotlinTestWithEnvironment
                 val parent = accessor.getParent() as JetProperty
                 val propertyDescriptor = getDescriptor(parent, resolveSession) as PropertyDescriptor
                 if (accessor.isGetter()) {
-                    descriptors.add(propertyDescriptor.getGetter())
+                    descriptors.add(propertyDescriptor.getGetter()!!)
                 }
                 else {
-                    descriptors.add(propertyDescriptor.getSetter())
+                    descriptors.add(propertyDescriptor.getSetter()!!)
                 }
                 accessor.acceptChildren(this)
             }
@@ -107,7 +108,7 @@ public abstract class AbstractDescriptorRendererTest : KotlinTestWithEnvironment
                     // if class has primary constructor then we visit it later, otherwise add it artificially
                     if (element !is JetClassOrObject || !element.hasExplicitPrimaryConstructor()) {
                         if (descriptor.getUnsubstitutedPrimaryConstructor() != null) {
-                            descriptors.add(descriptor.getUnsubstitutedPrimaryConstructor())
+                            descriptors.add(descriptor.getUnsubstitutedPrimaryConstructor()!!)
                         }
                     }
                 }
diff --git a/compiler/tests/org/jetbrains/kotlin/renderer/AbstractFunctionDescriptorInExpressionRendererTest.kt b/compiler/tests/org/jetbrains/kotlin/renderer/AbstractFunctionDescriptorInExpressionRendererTest.kt
index d8a4fd61974..fc971976b78 100644
--- a/compiler/tests/org/jetbrains/kotlin/renderer/AbstractFunctionDescriptorInExpressionRendererTest.kt
+++ b/compiler/tests/org/jetbrains/kotlin/renderer/AbstractFunctionDescriptorInExpressionRendererTest.kt
@@ -46,7 +46,7 @@ abstract public class AbstractFunctionDescriptorInExpressionRendererTest : Kotli
             }
             override fun visitFunctionLiteralExpression(expression: JetFunctionLiteralExpression) {
                 expression.acceptChildren(this)
-                descriptors.add(bindingContext.get(BindingContext.FUNCTION, expression.getFunctionLiteral()))
+                descriptors.add(bindingContext.get(BindingContext.FUNCTION, expression.getFunctionLiteral())!!)
             }
         })
 
diff --git a/compiler/tests/org/jetbrains/kotlin/repl/AbstractReplInterpreterTest.kt b/compiler/tests/org/jetbrains/kotlin/repl/AbstractReplInterpreterTest.kt
index 2dd04c7ad8e..35ac6d94312 100644
--- a/compiler/tests/org/jetbrains/kotlin/repl/AbstractReplInterpreterTest.kt
+++ b/compiler/tests/org/jetbrains/kotlin/repl/AbstractReplInterpreterTest.kt
@@ -24,11 +24,15 @@ import org.jetbrains.kotlin.test.JetTestUtils
 import org.jetbrains.kotlin.test.TestJdkKind
 import org.junit.Assert
 import java.io.File
+import java.io.PrintWriter
 import java.util.ArrayDeque
 import java.util.ArrayList
 import java.util.regex.Pattern
 import kotlin.text.Regex
 
+// Switch this flag to render bytecode after each line in the REPL test. Useful for debugging verify errors or other codegen problems
+private val DUMP_BYTECODE = false
+
 private val START_PATTERN = Pattern.compile(">>>( *)(.*)$")
 private val INCOMPLETE_PATTERN = Pattern.compile("\\.\\.\\.( *)(.*)$")
 private val TRAILING_NEWLINE_REGEX = Regex("\n$")
@@ -83,7 +87,12 @@ public abstract class AbstractReplInterpreterTest : UsefulTestCase() {
 
         for ((code, expected) in loadLines(File(path))) {
             val lineResult = repl.eval(code)
-            val actual = when (lineResult.getType()!!) {
+
+            if (DUMP_BYTECODE) {
+                repl.dumpClasses(PrintWriter(System.out))
+            }
+
+            val actual = when (lineResult.getType()) {
                 ReplInterpreter.LineResultType.SUCCESS -> lineResult.getValue()?.toString() ?: ""
                 ReplInterpreter.LineResultType.ERROR -> lineResult.getErrorText()
                 ReplInterpreter.LineResultType.INCOMPLETE -> INCOMPLETE_LINE_MESSAGE
diff --git a/compiler/tests/org/jetbrains/kotlin/repl/ReplInterpreterTestGenerated.java b/compiler/tests/org/jetbrains/kotlin/repl/ReplInterpreterTestGenerated.java
index 8bd0b971b61..88e6b383b61 100644
--- a/compiler/tests/org/jetbrains/kotlin/repl/ReplInterpreterTestGenerated.java
+++ b/compiler/tests/org/jetbrains/kotlin/repl/ReplInterpreterTestGenerated.java
@@ -286,4 +286,19 @@ public class ReplInterpreterTestGenerated extends AbstractReplInterpreterTest {
             doTest(fileName);
         }
     }
+
+    @TestMetadata("compiler/testData/repl/useJava")
+    @TestDataPath("$PROJECT_ROOT")
+    @RunWith(JUnit3RunnerWithInners.class)
+    public static class UseJava extends AbstractReplInterpreterTest {
+        public void testAllFilesPresentInUseJava() throws Exception {
+            JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/repl/useJava"), Pattern.compile("^(.+)\\.repl$"), true);
+        }
+
+        @TestMetadata("syntheticProperty.repl")
+        public void testSyntheticProperty() throws Exception {
+            String fileName = JetTestUtils.navigationMetadata("compiler/testData/repl/useJava/syntheticProperty.repl");
+            doTest(fileName);
+        }
+    }
 }
diff --git a/compiler/tests/org/jetbrains/kotlin/resolve/JetExpectedResolveDataUtil.java b/compiler/tests/org/jetbrains/kotlin/resolve/JetExpectedResolveDataUtil.java
index 9d5af24634e..179bcf2d4d1 100644
--- a/compiler/tests/org/jetbrains/kotlin/resolve/JetExpectedResolveDataUtil.java
+++ b/compiler/tests/org/jetbrains/kotlin/resolve/JetExpectedResolveDataUtil.java
@@ -21,6 +21,7 @@ import com.intellij.psi.*;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
 import org.jetbrains.kotlin.descriptors.*;
+import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl;
 import org.jetbrains.kotlin.name.FqName;
 import org.jetbrains.kotlin.name.Name;
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall;
@@ -126,8 +127,10 @@ public class JetExpectedResolveDataUtil {
             Project project,
             JetType... parameterTypes
     ) {
-        ModuleDescriptor emptyModule = JetTestUtils.createEmptyModule();
+        ModuleDescriptorImpl emptyModule = JetTestUtils.createEmptyModule();
         ContainerForTests container = DiPackage.createContainerForTests(project, emptyModule);
+        emptyModule.setDependencies(emptyModule);
+        emptyModule.initialize(PackageFragmentProvider.Empty.INSTANCE$);
 
         ExpressionTypingContext context = ExpressionTypingContext.newContext(
                 container.getAdditionalCheckerProvider(), new BindingTraceContext(), classDescriptor.getDefaultType().getMemberScope(),
diff --git a/compiler/tests/org/jetbrains/kotlin/resolve/annotation/AnnotationDescriptorResolveTest.java b/compiler/tests/org/jetbrains/kotlin/resolve/annotation/AnnotationDescriptorResolveTest.java
index 5cef40c425d..58202a730fe 100644
--- a/compiler/tests/org/jetbrains/kotlin/resolve/annotation/AnnotationDescriptorResolveTest.java
+++ b/compiler/tests/org/jetbrains/kotlin/resolve/annotation/AnnotationDescriptorResolveTest.java
@@ -21,7 +21,7 @@ import java.io.IOException;
 public class AnnotationDescriptorResolveTest extends AbstractAnnotationDescriptorResolveTest {
     public void testIntAnnotation() throws IOException {
         String content = getContent("AnnInt(1)");
-        String expectedAnnotation = "AnnInt(a = IntegerValueType(1))";
+        String expectedAnnotation = "AnnInt(a = 1)";
         doTest(content, expectedAnnotation);
     }
 
@@ -51,13 +51,13 @@ public class AnnotationDescriptorResolveTest extends AbstractAnnotationDescripto
 
     public void testIntArrayAnnotation() throws IOException {
         String content = getContent("AnnIntArray(intArray(1, 2))");
-        String expectedAnnotation = "AnnIntArray(a = {IntegerValueType(1), IntegerValueType(2)})";
+        String expectedAnnotation = "AnnIntArray(a = {1, 2})";
         doTest(content, expectedAnnotation);
     }
 
     public void testIntArrayVarargAnnotation() throws IOException {
         String content = getContent("AnnIntVararg(1, 2)");
-        String expectedAnnotation = "AnnIntVararg(a = {IntegerValueType(1), IntegerValueType(2)})";
+        String expectedAnnotation = "AnnIntVararg(a = {1, 2})";
         doTest(content, expectedAnnotation);
     }
 
@@ -81,7 +81,7 @@ public class AnnotationDescriptorResolveTest extends AbstractAnnotationDescripto
 
     public void testAnnotationAnnotation() throws Exception {
         String content = getContent("AnnAnn(AnnInt(1))");
-        String expectedAnnotation = "AnnAnn(a = AnnInt(a = IntegerValueType(1)))";
+        String expectedAnnotation = "AnnAnn(a = AnnInt(a = 1))";
         doTest(content, expectedAnnotation);
     }
 
diff --git a/compiler/tests/org/jetbrains/kotlin/resolve/calls/AbstractResolvedCallsTest.kt b/compiler/tests/org/jetbrains/kotlin/resolve/calls/AbstractResolvedCallsTest.kt
index 86ed538e515..81b739de555 100644
--- a/compiler/tests/org/jetbrains/kotlin/resolve/calls/AbstractResolvedCallsTest.kt
+++ b/compiler/tests/org/jetbrains/kotlin/resolve/calls/AbstractResolvedCallsTest.kt
@@ -66,7 +66,7 @@ public abstract class AbstractResolvedCallsTest : JetLiteFixture() {
     open protected fun buildCachedCall(
             bindingContext: BindingContext, jetFile: JetFile, text: String
     ): Pair<PsiElement?, ResolvedCall<out CallableDescriptor>?> {
-        val element = jetFile.findElementAt(text.indexOf("<caret>"))
+        val element = jetFile.findElementAt(text.indexOf("<caret>"))!!
         val expression = element.getStrictParentOfType<JetExpression>()
 
         val cachedCall = expression?.getParentResolvedCall(bindingContext, strict = false)
diff --git a/compiler/tests/org/jetbrains/kotlin/resolve/constants/evaluate/AbstractEvaluateExpressionTest.kt b/compiler/tests/org/jetbrains/kotlin/resolve/constants/evaluate/AbstractEvaluateExpressionTest.kt
index 36ff026c07e..7f53fbfad86 100644
--- a/compiler/tests/org/jetbrains/kotlin/resolve/constants/evaluate/AbstractEvaluateExpressionTest.kt
+++ b/compiler/tests/org/jetbrains/kotlin/resolve/constants/evaluate/AbstractEvaluateExpressionTest.kt
@@ -18,9 +18,12 @@ package org.jetbrains.kotlin.resolve.constants.evaluate
 
 import com.intellij.openapi.util.io.FileUtil
 import org.jetbrains.kotlin.descriptors.VariableDescriptor
+import org.jetbrains.kotlin.psi.JetProperty
 import org.jetbrains.kotlin.resolve.BindingContext
+import org.jetbrains.kotlin.resolve.DelegatingBindingTrace
+import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils
 import org.jetbrains.kotlin.resolve.annotation.AbstractAnnotationDescriptorResolveTest
-import org.jetbrains.kotlin.resolve.constants.IntegerValueConstant
+import org.jetbrains.kotlin.resolve.constants.CompileTimeConstant
 import org.jetbrains.kotlin.resolve.constants.StringValue
 import org.jetbrains.kotlin.test.InTextDirectivesUtils
 import org.jetbrains.kotlin.test.JetTestUtils
@@ -36,7 +39,7 @@ public abstract class AbstractEvaluateExpressionTest : AbstractAnnotationDescrip
             property, context ->
             val compileTimeConstant = property.getCompileTimeInitializer()
             if (compileTimeConstant is StringValue) {
-                "\\\"${compileTimeConstant.getValue()}\\\""
+                "\\\"${compileTimeConstant.value}\\\""
             } else {
                 "$compileTimeConstant"
             }
@@ -47,12 +50,7 @@ public abstract class AbstractEvaluateExpressionTest : AbstractAnnotationDescrip
     fun doIsPureTest(path: String) {
         doTest(path) {
             property, context ->
-            val compileTimeConstant = property.getCompileTimeInitializer()
-            if (compileTimeConstant is IntegerValueConstant) {
-                compileTimeConstant.isPure().toString()
-            } else {
-                "null"
-            }
+            evaluateInitializer(context, property)?.isPure.toString()
         }
     }
 
@@ -60,15 +58,20 @@ public abstract class AbstractEvaluateExpressionTest : AbstractAnnotationDescrip
     fun doUsesVariableAsConstantTest(path: String) {
         doTest(path) {
             property, context ->
-            val compileTimeConstant = property.getCompileTimeInitializer()
-            if (compileTimeConstant == null) {
-                "null"
-            } else {
-                compileTimeConstant.usesVariableAsConstant().toString()
-            }
+            evaluateInitializer(context, property)?.usesVariableAsConstant.toString()
         }
     }
 
+    private fun evaluateInitializer(context: BindingContext, property: VariableDescriptor): CompileTimeConstant<*>? {
+        val propertyDeclaration = DescriptorToSourceUtils.descriptorToDeclaration(property) as JetProperty
+        val compileTimeConstant = ConstantExpressionEvaluator.evaluate(
+                propertyDeclaration.getInitializer()!!,
+                DelegatingBindingTrace(context, "trace for evaluating compile time constant"),
+                property.getType()
+        )
+        return compileTimeConstant
+    }
+
     private fun doTest(path: String, getValueToTest: (VariableDescriptor, BindingContext) -> String) {
         val myFile = File(path)
         val fileText = FileUtil.loadFile(myFile, true)
diff --git a/compiler/tests/org/jetbrains/kotlin/resolve/constraintSystem/AbstractConstraintSystemTest.kt b/compiler/tests/org/jetbrains/kotlin/resolve/constraintSystem/AbstractConstraintSystemTest.kt
index 780dd7557e1..d1031c6d7fd 100644
--- a/compiler/tests/org/jetbrains/kotlin/resolve/constraintSystem/AbstractConstraintSystemTest.kt
+++ b/compiler/tests/org/jetbrains/kotlin/resolve/constraintSystem/AbstractConstraintSystemTest.kt
@@ -17,27 +17,24 @@
 package org.jetbrains.kotlin.resolve.constraintSystem
 
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
-import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor
 import org.jetbrains.kotlin.diagnostics.rendering.Renderers
+import org.jetbrains.kotlin.renderer.DescriptorRenderer
 import org.jetbrains.kotlin.resolve.TypeResolver
 import org.jetbrains.kotlin.resolve.calls.inference.ConstraintSystemImpl
 import org.jetbrains.kotlin.resolve.calls.inference.constraintPosition.ConstraintPositionKind.SPECIAL
-import org.jetbrains.kotlin.resolve.calls.inference.constraintPosition.ConstraintPositionKind.TYPE_BOUND_POSITION
+import org.jetbrains.kotlin.resolve.calls.inference.registerTypeVariables
 import org.jetbrains.kotlin.resolve.lazy.JvmResolveUtil
 import org.jetbrains.kotlin.test.ConfigurationKind
 import org.jetbrains.kotlin.test.JetLiteFixture
 import org.jetbrains.kotlin.test.JetTestUtils
 import org.jetbrains.kotlin.tests.di.createContainerForTests
+import org.jetbrains.kotlin.types.ErrorUtils
+import org.jetbrains.kotlin.types.JetType
 import org.jetbrains.kotlin.types.Variance
 import java.io.File
 import java.util.ArrayList
-import java.util.LinkedHashMap
-import java.util.regex.Pattern
 
 abstract public class AbstractConstraintSystemTest() : JetLiteFixture() {
-    private val typePattern = """([\w|<|>|\(|\)]+)"""
-    val constraintPattern = Pattern.compile("""(SUBTYPE|SUPERTYPE)\s+${typePattern}\s+${typePattern}\s+(weak)?""", Pattern.MULTILINE)
-    val variablesPattern = Pattern.compile("VARIABLES\\s+(.*)")
 
     private var _typeResolver: TypeResolver? = null
     private val typeResolver: TypeResolver
@@ -69,7 +66,7 @@ abstract public class AbstractConstraintSystemTest() : JetLiteFixture() {
     }
 
     private fun analyzeDeclarations(): ConstraintSystemTestData {
-        val fileName = "declarations/declarations.kt"
+        val fileName = "declarations.kt"
 
         val psiFile = createPsiFile(null, fileName, loadFile(fileName))!!
         val bindingContext = JvmResolveUtil.analyzeOneFileWithJavaIntegrationAndCheckForErrors(psiFile).bindingContext
@@ -77,70 +74,71 @@ abstract public class AbstractConstraintSystemTest() : JetLiteFixture() {
     }
 
     public fun doTest(filePath: String) {
-        val file = File(filePath)
-        val fileText = JetTestUtils.doLoadFile(file)!!
+        val constraintsFile = File(filePath)
+        val constraintsFileText = constraintsFile.readLines()
 
         val constraintSystem = ConstraintSystemImpl()
 
-        val typeParameterDescriptors = LinkedHashMap<TypeParameterDescriptor, Variance>()
-        val variables = parseVariables(fileText)
-        for (variable in variables) {
-            typeParameterDescriptors.put(testDeclarations.getParameterDescriptor(variable), Variance.INVARIANT)
-        }
-        constraintSystem.registerTypeVariables(typeParameterDescriptors)
+        val variables = parseVariables(constraintsFileText)
+        val fixVariables = constraintsFileText.contains("FIX_VARIABLES")
+        val typeParameterDescriptors = variables.map { testDeclarations.getParameterDescriptor(it) }
+        constraintSystem.registerTypeVariables(typeParameterDescriptors, { Variance.INVARIANT })
 
-        val constraints = parseConstraints(fileText)
+        val constraints = parseConstraints(constraintsFileText)
+        fun JetType.assertNotError(): JetType {
+            assert(!ErrorUtils.containsErrorType(this)) { "Type $this is resolved to or contains error type" }
+            return this
+        }
         for (constraint in constraints) {
-            val firstType = testDeclarations.getType(constraint.firstType)
-            val secondType = testDeclarations.getType(constraint.secondType)
-            val position = if (constraint.isWeak) TYPE_BOUND_POSITION.position(0) else SPECIAL.position()
+            val firstType = testDeclarations.getType(constraint.firstType).assertNotError()
+            val secondType = testDeclarations.getType(constraint.secondType).assertNotError()
+            val position = SPECIAL.position()
             when (constraint.kind) {
                 MyConstraintKind.SUBTYPE -> constraintSystem.addSubtypeConstraint(firstType, secondType, position)
                 MyConstraintKind.SUPERTYPE -> constraintSystem.addSupertypeConstraint(firstType, secondType, position)
+                MyConstraintKind.EQUAL -> constraintSystem.addConstraint(
+                        ConstraintSystemImpl.ConstraintKind.EQUAL, firstType, secondType, position, topLevel = true)
             }
         }
-        constraintSystem.processDeclaredBoundConstraints()
+        if (fixVariables) constraintSystem.fixVariables()
 
-        val resultingStatus = Renderers.RENDER_CONSTRAINT_SYSTEM.render(constraintSystem)
+        val resultingStatus = Renderers.RENDER_CONSTRAINT_SYSTEM_SHORT.render(constraintSystem)
 
         val resultingSubstitutor = constraintSystem.getResultingSubstitutor()
-        val result = StringBuilder() append "result:\n"
-        for ((typeParameter, variance) in typeParameterDescriptors) {
-            val parameterType = testDeclarations.getType(typeParameter.getName().asString())
-            val resultType = resultingSubstitutor.substitute(parameterType, variance)
-            result append "${typeParameter.getName()}=${resultType?.let{ Renderers.RENDER_TYPE.render(it) }}\n"
+        val result = typeParameterDescriptors.map {
+            val parameterType = testDeclarations.getType(it.getName().asString())
+            val resultType = resultingSubstitutor.substitute(parameterType, Variance.INVARIANT)
+            "${it.getName()}=${resultType?.let { DescriptorRenderer.SHORT_NAMES_IN_TYPES.renderType(it) }}"
+        }.join("\n", prefix = "result:\n")
+
+        val boundsFile = File(filePath.replace("constraints", "bounds"))
+        JetTestUtils.assertEqualsToFile(boundsFile, "${constraintsFileText.join("\n")}\n\n$resultingStatus\n\n$result")
+    }
+
+    class MyConstraint(val kind: MyConstraintKind, val firstType: String, val secondType: String)
+    enum class MyConstraintKind
+    private constructor(val token: String) {
+        SUBTYPE("<:"), SUPERTYPE(">:"), EQUAL(":=")
+    }
+
+    private fun parseVariables(lines: List<String>): List<String> {
+        val first = lines.first()
+        val variablesString = "VARIABLES "
+        assert (first.startsWith(variablesString)) { "The first line should contain variables: $first"}
+        val variables = first.substringAfter(variablesString).split(' ')
+        return variables.toList()
+    }
+
+    private fun parseConstraints(lines: List<String>): List<MyConstraint> {
+        val kindsMap = MyConstraintKind.values().map { it.token to it }.toMap()
+        val kinds = kindsMap.keySet()
+        val linesWithConstraints = lines.filter { line -> kinds.any { kind -> line.contains(kind) } }
+        return linesWithConstraints.map {
+            line ->
+            val kind = kinds.first { line.contains(it) }
+            val firstType = line.substringBefore(kind).trim()
+            val secondType = line.substringAfter(kind).trim()
+            MyConstraint(kindsMap[kind]!!, firstType, secondType)
         }
-
-        JetTestUtils.assertEqualsToFile(file, "${getConstraintsText(fileText)}${resultingStatus}\n\n${result}\n")
     }
-
-    class MyConstraint(val kind: MyConstraintKind, val firstType: String, val secondType: String, val isWeak: Boolean)
-    enum class MyConstraintKind {
-        SUBTYPE, SUPERTYPE
-    }
-
-    private fun parseVariables(text: String): List<String> {
-        val matcher = variablesPattern.matcher(text)
-        if (matcher.find()) {
-            val variablesText = matcher.group(1)!!
-            val variables = variablesText.split(' ')
-            return variables.toList()
-        }
-        throw AssertionError("Type variable names should be declared")
-    }
-
-    private fun parseConstraints(text: String): List<MyConstraint> {
-        val constraints = ArrayList<MyConstraint>()
-        val matcher = constraintPattern.matcher(text)
-        while (matcher.find()) {
-            val kind = MyConstraintKind.valueOf(matcher.group(1)!!)
-            val firstType = matcher.group(2)!!
-            val secondType = matcher.group(3)!!
-            val isWeak = matcher.groupCount() == 4 && matcher.group(4) == "weak"
-            constraints.add(MyConstraint(kind, firstType, secondType, isWeak))
-        }
-        return constraints
-    }
-
-    private fun getConstraintsText(text: String) = text.substring(0, text.indexOf("type parameter bounds"))
 }
diff --git a/compiler/tests/org/jetbrains/kotlin/resolve/constraintSystem/ConstraintSystemTestData.kt b/compiler/tests/org/jetbrains/kotlin/resolve/constraintSystem/ConstraintSystemTestData.kt
index c47ab6ae95b..fecd1623b5c 100644
--- a/compiler/tests/org/jetbrains/kotlin/resolve/constraintSystem/ConstraintSystemTestData.kt
+++ b/compiler/tests/org/jetbrains/kotlin/resolve/constraintSystem/ConstraintSystemTestData.kt
@@ -52,7 +52,7 @@ public class ConstraintSystemTestData(
 
     fun getParameterDescriptor(name: String): TypeParameterDescriptor {
         return functionFoo.getTypeParameters().firstOrNull { it.getName().asString() == name } ?:
-               throw AssertionError("Unsupported type parameter name: " + name + ".")
+               throw AssertionError("Unsupported type parameter name: $name. You may add it to constraintSystem/declarations.kt")
     }
 
     fun getType(name: String): JetType {
diff --git a/compiler/tests/org/jetbrains/kotlin/resolve/constraintSystem/ConstraintSystemTestGenerated.java b/compiler/tests/org/jetbrains/kotlin/resolve/constraintSystem/ConstraintSystemTestGenerated.java
index ad46a55b788..4df6fba0cd3 100644
--- a/compiler/tests/org/jetbrains/kotlin/resolve/constraintSystem/ConstraintSystemTestGenerated.java
+++ b/compiler/tests/org/jetbrains/kotlin/resolve/constraintSystem/ConstraintSystemTestGenerated.java
@@ -32,7 +32,7 @@ import java.util.regex.Pattern;
 @RunWith(JUnit3RunnerWithInners.class)
 public class ConstraintSystemTestGenerated extends AbstractConstraintSystemTest {
     public void testAllFilesPresentInConstraintSystem() throws Exception {
-        JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/constraintSystem"), Pattern.compile("^(.+)\\.bounds$"), true);
+        JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/constraintSystem"), Pattern.compile("^(.+)\\.constraints$"), true);
     }
 
     @TestMetadata("compiler/testData/constraintSystem/checkStatus")
@@ -40,36 +40,30 @@ public class ConstraintSystemTestGenerated extends AbstractConstraintSystemTest
     @RunWith(JUnit3RunnerWithInners.class)
     public static class CheckStatus extends AbstractConstraintSystemTest {
         public void testAllFilesPresentInCheckStatus() throws Exception {
-            JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/constraintSystem/checkStatus"), Pattern.compile("^(.+)\\.bounds$"), true);
+            JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/constraintSystem/checkStatus"), Pattern.compile("^(.+)\\.constraints$"), true);
         }
 
-        @TestMetadata("conflictingConstraints.bounds")
+        @TestMetadata("conflictingConstraints.constraints")
         public void testConflictingConstraints() throws Exception {
-            String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/checkStatus/conflictingConstraints.bounds");
+            String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/checkStatus/conflictingConstraints.constraints");
             doTest(fileName);
         }
 
-        @TestMetadata("successful.bounds")
+        @TestMetadata("successful.constraints")
         public void testSuccessful() throws Exception {
-            String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/checkStatus/successful.bounds");
+            String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/checkStatus/successful.constraints");
             doTest(fileName);
         }
 
-        @TestMetadata("typeConstructorMismatch.bounds")
+        @TestMetadata("typeConstructorMismatch.constraints")
         public void testTypeConstructorMismatch() throws Exception {
-            String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/checkStatus/typeConstructorMismatch.bounds");
+            String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/checkStatus/typeConstructorMismatch.constraints");
             doTest(fileName);
         }
 
-        @TestMetadata("unknownParameters.bounds")
+        @TestMetadata("unknownParameters.constraints")
         public void testUnknownParameters() throws Exception {
-            String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/checkStatus/unknownParameters.bounds");
-            doTest(fileName);
-        }
-
-        @TestMetadata("violatedUpperBound.bounds")
-        public void testViolatedUpperBound() throws Exception {
-            String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/checkStatus/violatedUpperBound.bounds");
+            String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/checkStatus/unknownParameters.constraints");
             doTest(fileName);
         }
     }
@@ -79,30 +73,30 @@ public class ConstraintSystemTestGenerated extends AbstractConstraintSystemTest
     @RunWith(JUnit3RunnerWithInners.class)
     public static class ComputeValues extends AbstractConstraintSystemTest {
         public void testAllFilesPresentInComputeValues() throws Exception {
-            JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/constraintSystem/computeValues"), Pattern.compile("^(.+)\\.bounds$"), true);
+            JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/constraintSystem/computeValues"), Pattern.compile("^(.+)\\.constraints$"), true);
         }
 
-        @TestMetadata("contradiction.bounds")
+        @TestMetadata("contradiction.constraints")
         public void testContradiction() throws Exception {
-            String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/computeValues/contradiction.bounds");
+            String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/computeValues/contradiction.constraints");
             doTest(fileName);
         }
 
-        @TestMetadata("subTypeOfUpperBounds.bounds")
+        @TestMetadata("subTypeOfUpperBounds.constraints")
         public void testSubTypeOfUpperBounds() throws Exception {
-            String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/computeValues/subTypeOfUpperBounds.bounds");
+            String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/computeValues/subTypeOfUpperBounds.constraints");
             doTest(fileName);
         }
 
-        @TestMetadata("superTypeOfLowerBounds1.bounds")
+        @TestMetadata("superTypeOfLowerBounds1.constraints")
         public void testSuperTypeOfLowerBounds1() throws Exception {
-            String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/computeValues/superTypeOfLowerBounds1.bounds");
+            String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/computeValues/superTypeOfLowerBounds1.constraints");
             doTest(fileName);
         }
 
-        @TestMetadata("superTypeOfLowerBounds2.bounds")
+        @TestMetadata("superTypeOfLowerBounds2.constraints")
         public void testSuperTypeOfLowerBounds2() throws Exception {
-            String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/computeValues/superTypeOfLowerBounds2.bounds");
+            String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/computeValues/superTypeOfLowerBounds2.constraints");
             doTest(fileName);
         }
     }
@@ -112,54 +106,54 @@ public class ConstraintSystemTestGenerated extends AbstractConstraintSystemTest
     @RunWith(JUnit3RunnerWithInners.class)
     public static class IntegerValueTypes extends AbstractConstraintSystemTest {
         public void testAllFilesPresentInIntegerValueTypes() throws Exception {
-            JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/constraintSystem/integerValueTypes"), Pattern.compile("^(.+)\\.bounds$"), true);
+            JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/constraintSystem/integerValueTypes"), Pattern.compile("^(.+)\\.constraints$"), true);
         }
 
-        @TestMetadata("byteOverflow.bounds")
+        @TestMetadata("byteOverflow.constraints")
         public void testByteOverflow() throws Exception {
-            String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/integerValueTypes/byteOverflow.bounds");
+            String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/integerValueTypes/byteOverflow.constraints");
             doTest(fileName);
         }
 
-        @TestMetadata("defaultLong.bounds")
+        @TestMetadata("defaultLong.constraints")
         public void testDefaultLong() throws Exception {
-            String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/integerValueTypes/defaultLong.bounds");
+            String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/integerValueTypes/defaultLong.constraints");
             doTest(fileName);
         }
 
-        @TestMetadata("numberAndAny.bounds")
+        @TestMetadata("numberAndAny.constraints")
         public void testNumberAndAny() throws Exception {
-            String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/integerValueTypes/numberAndAny.bounds");
+            String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/integerValueTypes/numberAndAny.constraints");
             doTest(fileName);
         }
 
-        @TestMetadata("numberAndString.bounds")
+        @TestMetadata("numberAndString.constraints")
         public void testNumberAndString() throws Exception {
-            String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/integerValueTypes/numberAndString.bounds");
+            String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/integerValueTypes/numberAndString.constraints");
             doTest(fileName);
         }
 
-        @TestMetadata("severalNumbers.bounds")
+        @TestMetadata("severalNumbers.constraints")
         public void testSeveralNumbers() throws Exception {
-            String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/integerValueTypes/severalNumbers.bounds");
+            String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/integerValueTypes/severalNumbers.constraints");
             doTest(fileName);
         }
 
-        @TestMetadata("simpleByte.bounds")
+        @TestMetadata("simpleByte.constraints")
         public void testSimpleByte() throws Exception {
-            String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/integerValueTypes/simpleByte.bounds");
+            String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/integerValueTypes/simpleByte.constraints");
             doTest(fileName);
         }
 
-        @TestMetadata("simpleInt.bounds")
+        @TestMetadata("simpleInt.constraints")
         public void testSimpleInt() throws Exception {
-            String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/integerValueTypes/simpleInt.bounds");
+            String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/integerValueTypes/simpleInt.constraints");
             doTest(fileName);
         }
 
-        @TestMetadata("simpleShort.bounds")
+        @TestMetadata("simpleShort.constraints")
         public void testSimpleShort() throws Exception {
-            String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/integerValueTypes/simpleShort.bounds");
+            String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/integerValueTypes/simpleShort.constraints");
             doTest(fileName);
         }
     }
@@ -169,14 +163,773 @@ public class ConstraintSystemTestGenerated extends AbstractConstraintSystemTest
     @RunWith(JUnit3RunnerWithInners.class)
     public static class SeveralVariables extends AbstractConstraintSystemTest {
         public void testAllFilesPresentInSeveralVariables() throws Exception {
-            JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/constraintSystem/severalVariables"), Pattern.compile("^(.+)\\.bounds$"), true);
+            JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/constraintSystem/severalVariables"), Pattern.compile("^(.+)\\.constraints$"), true);
         }
 
-        @TestMetadata("simpleDependency.bounds")
+        @TestMetadata("simpleDependency.constraints")
         public void testSimpleDependency() throws Exception {
-            String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/severalVariables/simpleDependency.bounds");
+            String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/severalVariables/simpleDependency.constraints");
             doTest(fileName);
         }
+
+        @TestMetadata("simpleEquality.constraints")
+        public void testSimpleEquality() throws Exception {
+            String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/severalVariables/simpleEquality.constraints");
+            doTest(fileName);
+        }
+
+        @TestMetadata("simpleEquality1.constraints")
+        public void testSimpleEquality1() throws Exception {
+            String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/severalVariables/simpleEquality1.constraints");
+            doTest(fileName);
+        }
+
+        @TestMetadata("simpleReversedDependency.constraints")
+        public void testSimpleReversedDependency() throws Exception {
+            String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/severalVariables/simpleReversedDependency.constraints");
+            doTest(fileName);
+        }
+
+        @TestMetadata("simpleSubtype.constraints")
+        public void testSimpleSubtype() throws Exception {
+            String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/severalVariables/simpleSubtype.constraints");
+            doTest(fileName);
+        }
+
+        @TestMetadata("simpleSubtype1.constraints")
+        public void testSimpleSubtype1() throws Exception {
+            String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/severalVariables/simpleSubtype1.constraints");
+            doTest(fileName);
+        }
+
+        @TestMetadata("compiler/testData/constraintSystem/severalVariables/direct")
+        @TestDataPath("$PROJECT_ROOT")
+        @RunWith(JUnit3RunnerWithInners.class)
+        public static class Direct extends AbstractConstraintSystemTest {
+            public void testAllFilesPresentInDirect() throws Exception {
+                JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/constraintSystem/severalVariables/direct"), Pattern.compile("^(.+)\\.constraints$"), true);
+            }
+
+            @TestMetadata("compiler/testData/constraintSystem/severalVariables/direct/contravariant")
+            @TestDataPath("$PROJECT_ROOT")
+            @RunWith(JUnit3RunnerWithInners.class)
+            public static class Contravariant extends AbstractConstraintSystemTest {
+                public void testAllFilesPresentInContravariant() throws Exception {
+                    JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/constraintSystem/severalVariables/direct/contravariant"), Pattern.compile("^(.+)\\.constraints$"), true);
+                }
+
+                @TestMetadata("varEqDepEq.constraints")
+                public void testVarEqDepEq() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/severalVariables/direct/contravariant/varEqDepEq.constraints");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("varEqDepSub.constraints")
+                public void testVarEqDepSub() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/severalVariables/direct/contravariant/varEqDepSub.constraints");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("varEqDepSuper.constraints")
+                public void testVarEqDepSuper() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/severalVariables/direct/contravariant/varEqDepSuper.constraints");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("varSubDepEq.constraints")
+                public void testVarSubDepEq() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/severalVariables/direct/contravariant/varSubDepEq.constraints");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("varSubDepSub.constraints")
+                public void testVarSubDepSub() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/severalVariables/direct/contravariant/varSubDepSub.constraints");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("varSubDepSuper.constraints")
+                public void testVarSubDepSuper() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/severalVariables/direct/contravariant/varSubDepSuper.constraints");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("varSuperDepEq.constraints")
+                public void testVarSuperDepEq() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/severalVariables/direct/contravariant/varSuperDepEq.constraints");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("varSuperDepSub.constraints")
+                public void testVarSuperDepSub() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/severalVariables/direct/contravariant/varSuperDepSub.constraints");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("varSuperDepSuper.constraints")
+                public void testVarSuperDepSuper() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/severalVariables/direct/contravariant/varSuperDepSuper.constraints");
+                    doTest(fileName);
+                }
+            }
+
+            @TestMetadata("compiler/testData/constraintSystem/severalVariables/direct/covariant")
+            @TestDataPath("$PROJECT_ROOT")
+            @RunWith(JUnit3RunnerWithInners.class)
+            public static class Covariant extends AbstractConstraintSystemTest {
+                public void testAllFilesPresentInCovariant() throws Exception {
+                    JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/constraintSystem/severalVariables/direct/covariant"), Pattern.compile("^(.+)\\.constraints$"), true);
+                }
+
+                @TestMetadata("varEqDepEq.constraints")
+                public void testVarEqDepEq() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/severalVariables/direct/covariant/varEqDepEq.constraints");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("varEqDepSub.constraints")
+                public void testVarEqDepSub() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/severalVariables/direct/covariant/varEqDepSub.constraints");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("varEqDepSuper.constraints")
+                public void testVarEqDepSuper() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/severalVariables/direct/covariant/varEqDepSuper.constraints");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("varSubDepEq.constraints")
+                public void testVarSubDepEq() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/severalVariables/direct/covariant/varSubDepEq.constraints");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("varSubDepSub.constraints")
+                public void testVarSubDepSub() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/severalVariables/direct/covariant/varSubDepSub.constraints");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("varSubDepSuper.constraints")
+                public void testVarSubDepSuper() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/severalVariables/direct/covariant/varSubDepSuper.constraints");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("varSuperDepEq.constraints")
+                public void testVarSuperDepEq() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/severalVariables/direct/covariant/varSuperDepEq.constraints");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("varSuperDepSub.constraints")
+                public void testVarSuperDepSub() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/severalVariables/direct/covariant/varSuperDepSub.constraints");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("varSuperDepSuper.constraints")
+                public void testVarSuperDepSuper() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/severalVariables/direct/covariant/varSuperDepSuper.constraints");
+                    doTest(fileName);
+                }
+            }
+
+            @TestMetadata("compiler/testData/constraintSystem/severalVariables/direct/invariant")
+            @TestDataPath("$PROJECT_ROOT")
+            @RunWith(JUnit3RunnerWithInners.class)
+            public static class Invariant extends AbstractConstraintSystemTest {
+                public void testAllFilesPresentInInvariant() throws Exception {
+                    JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/constraintSystem/severalVariables/direct/invariant"), Pattern.compile("^(.+)\\.constraints$"), true);
+                }
+
+                @TestMetadata("varEqDepEq.constraints")
+                public void testVarEqDepEq() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/severalVariables/direct/invariant/varEqDepEq.constraints");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("varEqDepSub.constraints")
+                public void testVarEqDepSub() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/severalVariables/direct/invariant/varEqDepSub.constraints");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("varEqDepSuper.constraints")
+                public void testVarEqDepSuper() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/severalVariables/direct/invariant/varEqDepSuper.constraints");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("varSubDepEq.constraints")
+                public void testVarSubDepEq() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/severalVariables/direct/invariant/varSubDepEq.constraints");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("varSubDepSub.constraints")
+                public void testVarSubDepSub() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/severalVariables/direct/invariant/varSubDepSub.constraints");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("varSubDepSuper.constraints")
+                public void testVarSubDepSuper() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/severalVariables/direct/invariant/varSubDepSuper.constraints");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("varSuperDepEq.constraints")
+                public void testVarSuperDepEq() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/severalVariables/direct/invariant/varSuperDepEq.constraints");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("varSuperDepSub.constraints")
+                public void testVarSuperDepSub() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/severalVariables/direct/invariant/varSuperDepSub.constraints");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("varSuperDepSuper.constraints")
+                public void testVarSuperDepSuper() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/severalVariables/direct/invariant/varSuperDepSuper.constraints");
+                    doTest(fileName);
+                }
+            }
+        }
+
+        @TestMetadata("compiler/testData/constraintSystem/severalVariables/interdependency")
+        @TestDataPath("$PROJECT_ROOT")
+        @RunWith(JUnit3RunnerWithInners.class)
+        public static class Interdependency extends AbstractConstraintSystemTest {
+            public void testAllFilesPresentInInterdependency() throws Exception {
+                JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/constraintSystem/severalVariables/interdependency"), Pattern.compile("^(.+)\\.constraints$"), true);
+            }
+
+            @TestMetadata("interdependency1.constraints")
+            public void testInterdependency1() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/severalVariables/interdependency/interdependency1.constraints");
+                doTest(fileName);
+            }
+
+            @TestMetadata("interdependency2.constraints")
+            public void testInterdependency2() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/severalVariables/interdependency/interdependency2.constraints");
+                doTest(fileName);
+            }
+
+            @TestMetadata("interdependency3.constraints")
+            public void testInterdependency3() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/severalVariables/interdependency/interdependency3.constraints");
+                doTest(fileName);
+            }
+        }
+
+        @TestMetadata("compiler/testData/constraintSystem/severalVariables/nullable")
+        @TestDataPath("$PROJECT_ROOT")
+        @RunWith(JUnit3RunnerWithInners.class)
+        public static class Nullable extends AbstractConstraintSystemTest {
+            public void testAllFilesPresentInNullable() throws Exception {
+                JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/constraintSystem/severalVariables/nullable"), Pattern.compile("^(.+)\\.constraints$"), true);
+            }
+
+            @TestMetadata("compiler/testData/constraintSystem/severalVariables/nullable/contravariant")
+            @TestDataPath("$PROJECT_ROOT")
+            @RunWith(JUnit3RunnerWithInners.class)
+            public static class Contravariant extends AbstractConstraintSystemTest {
+                public void testAllFilesPresentInContravariant() throws Exception {
+                    JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/constraintSystem/severalVariables/nullable/contravariant"), Pattern.compile("^(.+)\\.constraints$"), true);
+                }
+
+                @TestMetadata("varEqDepEq.constraints")
+                public void testVarEqDepEq() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/severalVariables/nullable/contravariant/varEqDepEq.constraints");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("varEqDepSub.constraints")
+                public void testVarEqDepSub() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/severalVariables/nullable/contravariant/varEqDepSub.constraints");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("varEqDepSuper.constraints")
+                public void testVarEqDepSuper() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/severalVariables/nullable/contravariant/varEqDepSuper.constraints");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("varSubDepEq.constraints")
+                public void testVarSubDepEq() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/severalVariables/nullable/contravariant/varSubDepEq.constraints");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("varSubDepSub.constraints")
+                public void testVarSubDepSub() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/severalVariables/nullable/contravariant/varSubDepSub.constraints");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("varSubDepSuper.constraints")
+                public void testVarSubDepSuper() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/severalVariables/nullable/contravariant/varSubDepSuper.constraints");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("varSuperDepEq.constraints")
+                public void testVarSuperDepEq() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/severalVariables/nullable/contravariant/varSuperDepEq.constraints");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("varSuperDepSub.constraints")
+                public void testVarSuperDepSub() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/severalVariables/nullable/contravariant/varSuperDepSub.constraints");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("varSuperDepSuper.constraints")
+                public void testVarSuperDepSuper() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/severalVariables/nullable/contravariant/varSuperDepSuper.constraints");
+                    doTest(fileName);
+                }
+            }
+
+            @TestMetadata("compiler/testData/constraintSystem/severalVariables/nullable/covariant")
+            @TestDataPath("$PROJECT_ROOT")
+            @RunWith(JUnit3RunnerWithInners.class)
+            public static class Covariant extends AbstractConstraintSystemTest {
+                public void testAllFilesPresentInCovariant() throws Exception {
+                    JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/constraintSystem/severalVariables/nullable/covariant"), Pattern.compile("^(.+)\\.constraints$"), true);
+                }
+
+                @TestMetadata("varEqDepEq.constraints")
+                public void testVarEqDepEq() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/severalVariables/nullable/covariant/varEqDepEq.constraints");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("varEqDepSub.constraints")
+                public void testVarEqDepSub() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/severalVariables/nullable/covariant/varEqDepSub.constraints");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("varEqDepSuper.constraints")
+                public void testVarEqDepSuper() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/severalVariables/nullable/covariant/varEqDepSuper.constraints");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("varSubDepEq.constraints")
+                public void testVarSubDepEq() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/severalVariables/nullable/covariant/varSubDepEq.constraints");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("varSubDepSub.constraints")
+                public void testVarSubDepSub() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/severalVariables/nullable/covariant/varSubDepSub.constraints");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("varSubDepSuper.constraints")
+                public void testVarSubDepSuper() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/severalVariables/nullable/covariant/varSubDepSuper.constraints");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("varSuperDepEq.constraints")
+                public void testVarSuperDepEq() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/severalVariables/nullable/covariant/varSuperDepEq.constraints");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("varSuperDepSub.constraints")
+                public void testVarSuperDepSub() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/severalVariables/nullable/covariant/varSuperDepSub.constraints");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("varSuperDepSuper.constraints")
+                public void testVarSuperDepSuper() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/severalVariables/nullable/covariant/varSuperDepSuper.constraints");
+                    doTest(fileName);
+                }
+            }
+
+            @TestMetadata("compiler/testData/constraintSystem/severalVariables/nullable/invariant")
+            @TestDataPath("$PROJECT_ROOT")
+            @RunWith(JUnit3RunnerWithInners.class)
+            public static class Invariant extends AbstractConstraintSystemTest {
+                public void testAllFilesPresentInInvariant() throws Exception {
+                    JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/constraintSystem/severalVariables/nullable/invariant"), Pattern.compile("^(.+)\\.constraints$"), true);
+                }
+
+                @TestMetadata("varEqDepEq.constraints")
+                public void testVarEqDepEq() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/severalVariables/nullable/invariant/varEqDepEq.constraints");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("varEqDepSub.constraints")
+                public void testVarEqDepSub() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/severalVariables/nullable/invariant/varEqDepSub.constraints");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("varEqDepSuper.constraints")
+                public void testVarEqDepSuper() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/severalVariables/nullable/invariant/varEqDepSuper.constraints");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("varSubDepEq.constraints")
+                public void testVarSubDepEq() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/severalVariables/nullable/invariant/varSubDepEq.constraints");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("varSubDepSub.constraints")
+                public void testVarSubDepSub() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/severalVariables/nullable/invariant/varSubDepSub.constraints");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("varSubDepSuper.constraints")
+                public void testVarSubDepSuper() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/severalVariables/nullable/invariant/varSubDepSuper.constraints");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("varSuperDepEq.constraints")
+                public void testVarSuperDepEq() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/severalVariables/nullable/invariant/varSuperDepEq.constraints");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("varSuperDepSub.constraints")
+                public void testVarSuperDepSub() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/severalVariables/nullable/invariant/varSuperDepSub.constraints");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("varSuperDepSuper.constraints")
+                public void testVarSuperDepSuper() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/severalVariables/nullable/invariant/varSuperDepSuper.constraints");
+                    doTest(fileName);
+                }
+            }
+        }
+
+        @TestMetadata("compiler/testData/constraintSystem/severalVariables/other")
+        @TestDataPath("$PROJECT_ROOT")
+        @RunWith(JUnit3RunnerWithInners.class)
+        public static class Other extends AbstractConstraintSystemTest {
+            public void testAllFilesPresentInOther() throws Exception {
+                JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/constraintSystem/severalVariables/other"), Pattern.compile("^(.+)\\.constraints$"), true);
+            }
+
+            @TestMetadata("constraintForNullables.constraints")
+            public void testConstraintForNullables() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/severalVariables/other/constraintForNullables.constraints");
+                doTest(fileName);
+            }
+
+            @TestMetadata("nestedConsumer.constraints")
+            public void testNestedConsumer() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/severalVariables/other/nestedConsumer.constraints");
+                doTest(fileName);
+            }
+
+            @TestMetadata("nestedConsumer1.constraints")
+            public void testNestedConsumer1() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/severalVariables/other/nestedConsumer1.constraints");
+                doTest(fileName);
+            }
+
+            @TestMetadata("nestedInvConsumer.constraints")
+            public void testNestedInvConsumer() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/severalVariables/other/nestedInvConsumer.constraints");
+                doTest(fileName);
+            }
+
+            @TestMetadata("nestedInvProducer.constraints")
+            public void testNestedInvProducer() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/severalVariables/other/nestedInvProducer.constraints");
+                doTest(fileName);
+            }
+
+            @TestMetadata("nestedProducer.constraints")
+            public void testNestedProducer() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/severalVariables/other/nestedProducer.constraints");
+                doTest(fileName);
+            }
+
+            @TestMetadata("nestedProducerAndConsumer.constraints")
+            public void testNestedProducerAndConsumer() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/severalVariables/other/nestedProducerAndConsumer.constraints");
+                doTest(fileName);
+            }
+
+            @TestMetadata("severalOccurrences.constraints")
+            public void testSeveralOccurrences() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/severalVariables/other/severalOccurrences.constraints");
+                doTest(fileName);
+            }
+
+            @TestMetadata("simpleFun.constraints")
+            public void testSimpleFun() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/severalVariables/other/simpleFun.constraints");
+                doTest(fileName);
+            }
+
+            @TestMetadata("simpleThreeVars.constraints")
+            public void testSimpleThreeVars() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/severalVariables/other/simpleThreeVars.constraints");
+                doTest(fileName);
+            }
+
+            @TestMetadata("simpleThreeVarsNoIncorporation.constraints")
+            public void testSimpleThreeVarsNoIncorporation() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/severalVariables/other/simpleThreeVarsNoIncorporation.constraints");
+                doTest(fileName);
+            }
+
+            @TestMetadata("simpleThreeVarsNoIncorporationFixed.constraints")
+            public void testSimpleThreeVarsNoIncorporationFixed() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/severalVariables/other/simpleThreeVarsNoIncorporationFixed.constraints");
+                doTest(fileName);
+            }
+        }
+
+        @TestMetadata("compiler/testData/constraintSystem/severalVariables/recursive")
+        @TestDataPath("$PROJECT_ROOT")
+        @RunWith(JUnit3RunnerWithInners.class)
+        public static class Recursive extends AbstractConstraintSystemTest {
+            public void testAllFilesPresentInRecursive() throws Exception {
+                JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/constraintSystem/severalVariables/recursive"), Pattern.compile("^(.+)\\.constraints$"), true);
+            }
+
+            @TestMetadata("implicitlyRecursive.constraints")
+            public void testImplicitlyRecursive() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/severalVariables/recursive/implicitlyRecursive.constraints");
+                doTest(fileName);
+            }
+
+            @TestMetadata("mutuallyRecursive.constraints")
+            public void testMutuallyRecursive() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/severalVariables/recursive/mutuallyRecursive.constraints");
+                doTest(fileName);
+            }
+
+            @TestMetadata("simpleRecursive.constraints")
+            public void testSimpleRecursive() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/severalVariables/recursive/simpleRecursive.constraints");
+                doTest(fileName);
+            }
+        }
+
+        @TestMetadata("compiler/testData/constraintSystem/severalVariables/reversed")
+        @TestDataPath("$PROJECT_ROOT")
+        @RunWith(JUnit3RunnerWithInners.class)
+        public static class Reversed extends AbstractConstraintSystemTest {
+            public void testAllFilesPresentInReversed() throws Exception {
+                JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/constraintSystem/severalVariables/reversed"), Pattern.compile("^(.+)\\.constraints$"), true);
+            }
+
+            @TestMetadata("compiler/testData/constraintSystem/severalVariables/reversed/contravariant")
+            @TestDataPath("$PROJECT_ROOT")
+            @RunWith(JUnit3RunnerWithInners.class)
+            public static class Contravariant extends AbstractConstraintSystemTest {
+                public void testAllFilesPresentInContravariant() throws Exception {
+                    JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/constraintSystem/severalVariables/reversed/contravariant"), Pattern.compile("^(.+)\\.constraints$"), true);
+                }
+
+                @TestMetadata("varEqDepEq.constraints")
+                public void testVarEqDepEq() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/severalVariables/reversed/contravariant/varEqDepEq.constraints");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("varEqDepSub.constraints")
+                public void testVarEqDepSub() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/severalVariables/reversed/contravariant/varEqDepSub.constraints");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("varEqDepSuper.constraints")
+                public void testVarEqDepSuper() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/severalVariables/reversed/contravariant/varEqDepSuper.constraints");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("varSubDepEq.constraints")
+                public void testVarSubDepEq() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/severalVariables/reversed/contravariant/varSubDepEq.constraints");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("varSubDepSub.constraints")
+                public void testVarSubDepSub() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/severalVariables/reversed/contravariant/varSubDepSub.constraints");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("varSubDepSuper.constraints")
+                public void testVarSubDepSuper() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/severalVariables/reversed/contravariant/varSubDepSuper.constraints");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("varSuperDepEq.constraints")
+                public void testVarSuperDepEq() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/severalVariables/reversed/contravariant/varSuperDepEq.constraints");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("varSuperDepSub.constraints")
+                public void testVarSuperDepSub() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/severalVariables/reversed/contravariant/varSuperDepSub.constraints");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("varSuperDepSuper.constraints")
+                public void testVarSuperDepSuper() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/severalVariables/reversed/contravariant/varSuperDepSuper.constraints");
+                    doTest(fileName);
+                }
+            }
+
+            @TestMetadata("compiler/testData/constraintSystem/severalVariables/reversed/covariant")
+            @TestDataPath("$PROJECT_ROOT")
+            @RunWith(JUnit3RunnerWithInners.class)
+            public static class Covariant extends AbstractConstraintSystemTest {
+                public void testAllFilesPresentInCovariant() throws Exception {
+                    JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/constraintSystem/severalVariables/reversed/covariant"), Pattern.compile("^(.+)\\.constraints$"), true);
+                }
+
+                @TestMetadata("varEqDepEq.constraints")
+                public void testVarEqDepEq() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/severalVariables/reversed/covariant/varEqDepEq.constraints");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("varEqDepSub.constraints")
+                public void testVarEqDepSub() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/severalVariables/reversed/covariant/varEqDepSub.constraints");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("varEqDepSuper.constraints")
+                public void testVarEqDepSuper() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/severalVariables/reversed/covariant/varEqDepSuper.constraints");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("varSubDepEq.constraints")
+                public void testVarSubDepEq() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/severalVariables/reversed/covariant/varSubDepEq.constraints");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("varSubDepSub.constraints")
+                public void testVarSubDepSub() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/severalVariables/reversed/covariant/varSubDepSub.constraints");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("varSubDepSuper.constraints")
+                public void testVarSubDepSuper() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/severalVariables/reversed/covariant/varSubDepSuper.constraints");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("varSuperDepEq.constraints")
+                public void testVarSuperDepEq() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/severalVariables/reversed/covariant/varSuperDepEq.constraints");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("varSuperDepSub.constraints")
+                public void testVarSuperDepSub() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/severalVariables/reversed/covariant/varSuperDepSub.constraints");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("varSuperDepSuper.constraints")
+                public void testVarSuperDepSuper() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/severalVariables/reversed/covariant/varSuperDepSuper.constraints");
+                    doTest(fileName);
+                }
+            }
+
+            @TestMetadata("compiler/testData/constraintSystem/severalVariables/reversed/invariant")
+            @TestDataPath("$PROJECT_ROOT")
+            @RunWith(JUnit3RunnerWithInners.class)
+            public static class Invariant extends AbstractConstraintSystemTest {
+                public void testAllFilesPresentInInvariant() throws Exception {
+                    JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/constraintSystem/severalVariables/reversed/invariant"), Pattern.compile("^(.+)\\.constraints$"), true);
+                }
+
+                @TestMetadata("varEqDepEq.constraints")
+                public void testVarEqDepEq() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/severalVariables/reversed/invariant/varEqDepEq.constraints");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("varEqDepSub.constraints")
+                public void testVarEqDepSub() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/severalVariables/reversed/invariant/varEqDepSub.constraints");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("varEqDepSuper.constraints")
+                public void testVarEqDepSuper() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/severalVariables/reversed/invariant/varEqDepSuper.constraints");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("varSubDepEq.constraints")
+                public void testVarSubDepEq() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/severalVariables/reversed/invariant/varSubDepEq.constraints");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("varSubDepSub.constraints")
+                public void testVarSubDepSub() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/severalVariables/reversed/invariant/varSubDepSub.constraints");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("varSubDepSuper.constraints")
+                public void testVarSubDepSuper() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/severalVariables/reversed/invariant/varSubDepSuper.constraints");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("varSuperDepEq.constraints")
+                public void testVarSuperDepEq() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/severalVariables/reversed/invariant/varSuperDepEq.constraints");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("varSuperDepSub.constraints")
+                public void testVarSuperDepSub() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/severalVariables/reversed/invariant/varSuperDepSub.constraints");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("varSuperDepSuper.constraints")
+                public void testVarSuperDepSuper() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/severalVariables/reversed/invariant/varSuperDepSuper.constraints");
+                    doTest(fileName);
+                }
+            }
+        }
     }
 
     @TestMetadata("compiler/testData/constraintSystem/variance")
@@ -184,24 +937,24 @@ public class ConstraintSystemTestGenerated extends AbstractConstraintSystemTest
     @RunWith(JUnit3RunnerWithInners.class)
     public static class Variance extends AbstractConstraintSystemTest {
         public void testAllFilesPresentInVariance() throws Exception {
-            JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/constraintSystem/variance"), Pattern.compile("^(.+)\\.bounds$"), true);
+            JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/constraintSystem/variance"), Pattern.compile("^(.+)\\.constraints$"), true);
         }
 
-        @TestMetadata("consumer.bounds")
+        @TestMetadata("consumer.constraints")
         public void testConsumer() throws Exception {
-            String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/variance/consumer.bounds");
+            String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/variance/consumer.constraints");
             doTest(fileName);
         }
 
-        @TestMetadata("invariant.bounds")
+        @TestMetadata("invariant.constraints")
         public void testInvariant() throws Exception {
-            String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/variance/invariant.bounds");
+            String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/variance/invariant.constraints");
             doTest(fileName);
         }
 
-        @TestMetadata("producer.bounds")
+        @TestMetadata("producer.constraints")
         public void testProducer() throws Exception {
-            String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/variance/producer.bounds");
+            String fileName = JetTestUtils.navigationMetadata("compiler/testData/constraintSystem/variance/producer.constraints");
             doTest(fileName);
         }
     }
diff --git a/compiler/tests/org/jetbrains/kotlin/resolve/typeApproximation/CapturedTypeApproximationTest.kt b/compiler/tests/org/jetbrains/kotlin/resolve/typeApproximation/CapturedTypeApproximationTest.kt
index d7fac45ef9f..78f8c707c04 100644
--- a/compiler/tests/org/jetbrains/kotlin/resolve/typeApproximation/CapturedTypeApproximationTest.kt
+++ b/compiler/tests/org/jetbrains/kotlin/resolve/typeApproximation/CapturedTypeApproximationTest.kt
@@ -106,7 +106,7 @@ public class CapturedTypeApproximationTest() : JetLiteFixture() {
                 val testSubstitutions = createTestSubstitutions(typeParameters)
                 for (testSubstitution in testSubstitutions) {
                     val typeSubstitutor = createTestSubstitutor(testSubstitution)
-                    val typeWithCapturedType = typeSubstitutor.substituteWithoutApproximation(TypeProjectionImpl(INVARIANT, type))!!.getType()
+                    val typeWithCapturedType = typeSubstitutor.substituteWithoutApproximation(TypeProjectionImpl(INVARIANT, type!!))!!.getType()
 
                     val (lower, upper) = approximateCapturedTypes(typeWithCapturedType)
                     val substitution = approximateCapturedTypesIfNecessary(TypeProjectionImpl(INVARIANT, typeWithCapturedType))
diff --git a/compiler/tests/org/jetbrains/kotlin/serialization/DebugProtoBuf.java b/compiler/tests/org/jetbrains/kotlin/serialization/DebugProtoBuf.java
index a5d2c1021e2..c5b70508134 100644
--- a/compiler/tests/org/jetbrains/kotlin/serialization/DebugProtoBuf.java
+++ b/compiler/tests/org/jetbrains/kotlin/serialization/DebugProtoBuf.java
@@ -9435,9 +9435,9 @@ public final class DebugProtoBuf {
     org.jetbrains.kotlin.serialization.DebugProtoBuf.TypeOrBuilder getSupertypeOrBuilder(
         int index);
 
-    // repeated int32 nested_class_name = 7;
+    // repeated int32 nested_class_name = 7 [packed = true];
     /**
-     * <code>repeated int32 nested_class_name = 7;</code>
+     * <code>repeated int32 nested_class_name = 7 [packed = true];</code>
      *
      * <pre>
      * we store only names, because the actual information must reside in the corresponding .class files,
@@ -9446,7 +9446,7 @@ public final class DebugProtoBuf {
      */
     java.util.List<java.lang.Integer> getNestedClassNameList();
     /**
-     * <code>repeated int32 nested_class_name = 7;</code>
+     * <code>repeated int32 nested_class_name = 7 [packed = true];</code>
      *
      * <pre>
      * we store only names, because the actual information must reside in the corresponding .class files,
@@ -9455,7 +9455,7 @@ public final class DebugProtoBuf {
      */
     int getNestedClassNameCount();
     /**
-     * <code>repeated int32 nested_class_name = 7;</code>
+     * <code>repeated int32 nested_class_name = 7 [packed = true];</code>
      *
      * <pre>
      * we store only names, because the actual information must reside in the corresponding .class files,
@@ -9489,17 +9489,17 @@ public final class DebugProtoBuf {
     org.jetbrains.kotlin.serialization.DebugProtoBuf.CallableOrBuilder getMemberOrBuilder(
         int index);
 
-    // repeated int32 enum_entry = 12;
+    // repeated int32 enum_entry = 12 [packed = true];
     /**
-     * <code>repeated int32 enum_entry = 12;</code>
+     * <code>repeated int32 enum_entry = 12 [packed = true];</code>
      */
     java.util.List<java.lang.Integer> getEnumEntryList();
     /**
-     * <code>repeated int32 enum_entry = 12;</code>
+     * <code>repeated int32 enum_entry = 12 [packed = true];</code>
      */
     int getEnumEntryCount();
     /**
-     * <code>repeated int32 enum_entry = 12;</code>
+     * <code>repeated int32 enum_entry = 12 [packed = true];</code>
      */
     int getEnumEntry(int index);
 
@@ -10655,11 +10655,11 @@ public final class DebugProtoBuf {
       return supertype_.get(index);
     }
 
-    // repeated int32 nested_class_name = 7;
+    // repeated int32 nested_class_name = 7 [packed = true];
     public static final int NESTED_CLASS_NAME_FIELD_NUMBER = 7;
     private java.util.List<java.lang.Integer> nestedClassName_;
     /**
-     * <code>repeated int32 nested_class_name = 7;</code>
+     * <code>repeated int32 nested_class_name = 7 [packed = true];</code>
      *
      * <pre>
      * we store only names, because the actual information must reside in the corresponding .class files,
@@ -10671,7 +10671,7 @@ public final class DebugProtoBuf {
       return nestedClassName_;
     }
     /**
-     * <code>repeated int32 nested_class_name = 7;</code>
+     * <code>repeated int32 nested_class_name = 7 [packed = true];</code>
      *
      * <pre>
      * we store only names, because the actual information must reside in the corresponding .class files,
@@ -10682,7 +10682,7 @@ public final class DebugProtoBuf {
       return nestedClassName_.size();
     }
     /**
-     * <code>repeated int32 nested_class_name = 7;</code>
+     * <code>repeated int32 nested_class_name = 7 [packed = true];</code>
      *
      * <pre>
      * we store only names, because the actual information must reside in the corresponding .class files,
@@ -10692,6 +10692,7 @@ public final class DebugProtoBuf {
     public int getNestedClassName(int index) {
       return nestedClassName_.get(index);
     }
+    private int nestedClassNameMemoizedSerializedSize = -1;
 
     // repeated .org.jetbrains.kotlin.serialization.Callable member = 11;
     public static final int MEMBER_FIELD_NUMBER = 11;
@@ -10729,28 +10730,29 @@ public final class DebugProtoBuf {
       return member_.get(index);
     }
 
-    // repeated int32 enum_entry = 12;
+    // repeated int32 enum_entry = 12 [packed = true];
     public static final int ENUM_ENTRY_FIELD_NUMBER = 12;
     private java.util.List<java.lang.Integer> enumEntry_;
     /**
-     * <code>repeated int32 enum_entry = 12;</code>
+     * <code>repeated int32 enum_entry = 12 [packed = true];</code>
      */
     public java.util.List<java.lang.Integer>
         getEnumEntryList() {
       return enumEntry_;
     }
     /**
-     * <code>repeated int32 enum_entry = 12;</code>
+     * <code>repeated int32 enum_entry = 12 [packed = true];</code>
      */
     public int getEnumEntryCount() {
       return enumEntry_.size();
     }
     /**
-     * <code>repeated int32 enum_entry = 12;</code>
+     * <code>repeated int32 enum_entry = 12 [packed = true];</code>
      */
     public int getEnumEntry(int index) {
       return enumEntry_.get(index);
     }
+    private int enumEntryMemoizedSerializedSize = -1;
 
     // optional .org.jetbrains.kotlin.serialization.Class.PrimaryConstructor primary_constructor = 13;
     public static final int PRIMARY_CONSTRUCTOR_FIELD_NUMBER = 13;
@@ -10902,14 +10904,22 @@ public final class DebugProtoBuf {
       for (int i = 0; i < supertype_.size(); i++) {
         output.writeMessage(6, supertype_.get(i));
       }
+      if (getNestedClassNameList().size() > 0) {
+        output.writeRawVarint32(58);
+        output.writeRawVarint32(nestedClassNameMemoizedSerializedSize);
+      }
       for (int i = 0; i < nestedClassName_.size(); i++) {
-        output.writeInt32(7, nestedClassName_.get(i));
+        output.writeInt32NoTag(nestedClassName_.get(i));
       }
       for (int i = 0; i < member_.size(); i++) {
         output.writeMessage(11, member_.get(i));
       }
+      if (getEnumEntryList().size() > 0) {
+        output.writeRawVarint32(98);
+        output.writeRawVarint32(enumEntryMemoizedSerializedSize);
+      }
       for (int i = 0; i < enumEntry_.size(); i++) {
-        output.writeInt32(12, enumEntry_.get(i));
+        output.writeInt32NoTag(enumEntry_.get(i));
       }
       if (((bitField0_ & 0x00000008) == 0x00000008)) {
         output.writeMessage(13, primaryConstructor_);
@@ -10954,7 +10964,12 @@ public final class DebugProtoBuf {
             .computeInt32SizeNoTag(nestedClassName_.get(i));
         }
         size += dataSize;
-        size += 1 * getNestedClassNameList().size();
+        if (!getNestedClassNameList().isEmpty()) {
+          size += 1;
+          size += com.google.protobuf.CodedOutputStream
+              .computeInt32SizeNoTag(dataSize);
+        }
+        nestedClassNameMemoizedSerializedSize = dataSize;
       }
       for (int i = 0; i < member_.size(); i++) {
         size += com.google.protobuf.CodedOutputStream
@@ -10967,7 +10982,12 @@ public final class DebugProtoBuf {
             .computeInt32SizeNoTag(enumEntry_.get(i));
         }
         size += dataSize;
-        size += 1 * getEnumEntryList().size();
+        if (!getEnumEntryList().isEmpty()) {
+          size += 1;
+          size += com.google.protobuf.CodedOutputStream
+              .computeInt32SizeNoTag(dataSize);
+        }
+        enumEntryMemoizedSerializedSize = dataSize;
       }
       if (((bitField0_ & 0x00000008) == 0x00000008)) {
         size += com.google.protobuf.CodedOutputStream
@@ -12082,7 +12102,7 @@ public final class DebugProtoBuf {
         return supertypeBuilder_;
       }
 
-      // repeated int32 nested_class_name = 7;
+      // repeated int32 nested_class_name = 7 [packed = true];
       private java.util.List<java.lang.Integer> nestedClassName_ = java.util.Collections.emptyList();
       private void ensureNestedClassNameIsMutable() {
         if (!((bitField0_ & 0x00000020) == 0x00000020)) {
@@ -12091,7 +12111,7 @@ public final class DebugProtoBuf {
          }
       }
       /**
-       * <code>repeated int32 nested_class_name = 7;</code>
+       * <code>repeated int32 nested_class_name = 7 [packed = true];</code>
        *
        * <pre>
        * we store only names, because the actual information must reside in the corresponding .class files,
@@ -12103,7 +12123,7 @@ public final class DebugProtoBuf {
         return java.util.Collections.unmodifiableList(nestedClassName_);
       }
       /**
-       * <code>repeated int32 nested_class_name = 7;</code>
+       * <code>repeated int32 nested_class_name = 7 [packed = true];</code>
        *
        * <pre>
        * we store only names, because the actual information must reside in the corresponding .class files,
@@ -12114,7 +12134,7 @@ public final class DebugProtoBuf {
         return nestedClassName_.size();
       }
       /**
-       * <code>repeated int32 nested_class_name = 7;</code>
+       * <code>repeated int32 nested_class_name = 7 [packed = true];</code>
        *
        * <pre>
        * we store only names, because the actual information must reside in the corresponding .class files,
@@ -12125,7 +12145,7 @@ public final class DebugProtoBuf {
         return nestedClassName_.get(index);
       }
       /**
-       * <code>repeated int32 nested_class_name = 7;</code>
+       * <code>repeated int32 nested_class_name = 7 [packed = true];</code>
        *
        * <pre>
        * we store only names, because the actual information must reside in the corresponding .class files,
@@ -12140,7 +12160,7 @@ public final class DebugProtoBuf {
         return this;
       }
       /**
-       * <code>repeated int32 nested_class_name = 7;</code>
+       * <code>repeated int32 nested_class_name = 7 [packed = true];</code>
        *
        * <pre>
        * we store only names, because the actual information must reside in the corresponding .class files,
@@ -12154,7 +12174,7 @@ public final class DebugProtoBuf {
         return this;
       }
       /**
-       * <code>repeated int32 nested_class_name = 7;</code>
+       * <code>repeated int32 nested_class_name = 7 [packed = true];</code>
        *
        * <pre>
        * we store only names, because the actual information must reside in the corresponding .class files,
@@ -12169,7 +12189,7 @@ public final class DebugProtoBuf {
         return this;
       }
       /**
-       * <code>repeated int32 nested_class_name = 7;</code>
+       * <code>repeated int32 nested_class_name = 7 [packed = true];</code>
        *
        * <pre>
        * we store only names, because the actual information must reside in the corresponding .class files,
@@ -12423,7 +12443,7 @@ public final class DebugProtoBuf {
         return memberBuilder_;
       }
 
-      // repeated int32 enum_entry = 12;
+      // repeated int32 enum_entry = 12 [packed = true];
       private java.util.List<java.lang.Integer> enumEntry_ = java.util.Collections.emptyList();
       private void ensureEnumEntryIsMutable() {
         if (!((bitField0_ & 0x00000080) == 0x00000080)) {
@@ -12432,26 +12452,26 @@ public final class DebugProtoBuf {
          }
       }
       /**
-       * <code>repeated int32 enum_entry = 12;</code>
+       * <code>repeated int32 enum_entry = 12 [packed = true];</code>
        */
       public java.util.List<java.lang.Integer>
           getEnumEntryList() {
         return java.util.Collections.unmodifiableList(enumEntry_);
       }
       /**
-       * <code>repeated int32 enum_entry = 12;</code>
+       * <code>repeated int32 enum_entry = 12 [packed = true];</code>
        */
       public int getEnumEntryCount() {
         return enumEntry_.size();
       }
       /**
-       * <code>repeated int32 enum_entry = 12;</code>
+       * <code>repeated int32 enum_entry = 12 [packed = true];</code>
        */
       public int getEnumEntry(int index) {
         return enumEntry_.get(index);
       }
       /**
-       * <code>repeated int32 enum_entry = 12;</code>
+       * <code>repeated int32 enum_entry = 12 [packed = true];</code>
        */
       public Builder setEnumEntry(
           int index, int value) {
@@ -12461,7 +12481,7 @@ public final class DebugProtoBuf {
         return this;
       }
       /**
-       * <code>repeated int32 enum_entry = 12;</code>
+       * <code>repeated int32 enum_entry = 12 [packed = true];</code>
        */
       public Builder addEnumEntry(int value) {
         ensureEnumEntryIsMutable();
@@ -12470,7 +12490,7 @@ public final class DebugProtoBuf {
         return this;
       }
       /**
-       * <code>repeated int32 enum_entry = 12;</code>
+       * <code>repeated int32 enum_entry = 12 [packed = true];</code>
        */
       public Builder addAllEnumEntry(
           java.lang.Iterable<? extends java.lang.Integer> values) {
@@ -12480,7 +12500,7 @@ public final class DebugProtoBuf {
         return this;
       }
       /**
-       * <code>repeated int32 enum_entry = 12;</code>
+       * <code>repeated int32 enum_entry = 12 [packed = true];</code>
        */
       public Builder clearEnumEntry() {
         enumEntry_ = java.util.Collections.emptyList();
@@ -17064,48 +17084,48 @@ public final class DebugProtoBuf {
       "eParameter.Variance:\003INV\022=\n\013upper_bound\030",
       "\005 \003(\0132(.org.jetbrains.kotlin.serializati" +
       "on.Type\"$\n\010Variance\022\006\n\002IN\020\000\022\007\n\003OUT\020\001\022\007\n\003" +
-      "INV\020\002\"\261\005\n\005Class\022\020\n\005flags\030\001 \001(\005:\0010\022\017\n\007fq_" +
+      "INV\020\002\"\271\005\n\005Class\022\020\n\005flags\030\001 \001(\005:\0010\022\017\n\007fq_" +
       "name\030\003 \002(\005\022\035\n\025companion_object_name\030\004 \001(" +
       "\005\022I\n\016type_parameter\030\005 \003(\01321.org.jetbrain" +
       "s.kotlin.serialization.TypeParameter\022;\n\t" +
       "supertype\030\006 \003(\0132(.org.jetbrains.kotlin.s" +
-      "erialization.Type\022\031\n\021nested_class_name\030\007" +
-      " \003(\005\022<\n\006member\030\013 \003(\0132,.org.jetbrains.kot" +
-      "lin.serialization.Callable\022\022\n\nenum_entry",
-      "\030\014 \003(\005\022Y\n\023primary_constructor\030\r \001(\0132<.or" +
-      "g.jetbrains.kotlin.serialization.Class.P" +
-      "rimaryConstructor\022K\n\025secondary_construct" +
-      "or\030\016 \003(\0132,.org.jetbrains.kotlin.serializ" +
-      "ation.Callable\032P\n\022PrimaryConstructor\022:\n\004" +
-      "data\030\001 \001(\0132,.org.jetbrains.kotlin.serial" +
-      "ization.Callable\"p\n\004Kind\022\t\n\005CLASS\020\000\022\t\n\005T" +
-      "RAIT\020\001\022\016\n\nENUM_CLASS\020\002\022\016\n\nENUM_ENTRY\020\003\022\024" +
-      "\n\020ANNOTATION_CLASS\020\004\022\n\n\006OBJECT\020\005\022\020\n\014CLAS" +
-      "S_OBJECT\020\006*\005\010d\020\310\001\"N\n\007Package\022<\n\006member\030\001",
-      " \003(\0132,.org.jetbrains.kotlin.serializatio" +
-      "n.Callable*\005\010d\020\310\001\"\300\005\n\010Callable\022\r\n\005flags\030" +
-      "\001 \001(\005\022\024\n\014getter_flags\030\t \001(\005\022\024\n\014setter_fl" +
-      "ags\030\n \001(\005\022I\n\016type_parameter\030\004 \003(\01321.org." +
-      "jetbrains.kotlin.serialization.TypeParam" +
-      "eter\022?\n\rreceiver_type\030\005 \001(\0132(.org.jetbra" +
-      "ins.kotlin.serialization.Type\022\014\n\004name\030\006 " +
-      "\002(\005\022T\n\017value_parameter\030\007 \003(\0132;.org.jetbr" +
-      "ains.kotlin.serialization.Callable.Value" +
-      "Parameter\022=\n\013return_type\030\010 \002(\0132(.org.jet",
-      "brains.kotlin.serialization.Type\032\263\001\n\016Val" +
-      "ueParameter\022\r\n\005flags\030\001 \001(\005\022\014\n\004name\030\002 \002(\005" +
-      "\0226\n\004type\030\003 \002(\0132(.org.jetbrains.kotlin.se" +
-      "rialization.Type\022E\n\023vararg_element_type\030" +
-      "\004 \001(\0132(.org.jetbrains.kotlin.serializati" +
-      "on.Type*\005\010d\020\310\001\"Q\n\nMemberKind\022\017\n\013DECLARAT" +
-      "ION\020\000\022\021\n\rFAKE_OVERRIDE\020\001\022\016\n\nDELEGATION\020\002" +
-      "\022\017\n\013SYNTHESIZED\020\003\":\n\014CallableKind\022\007\n\003FUN" +
-      "\020\000\022\007\n\003VAL\020\001\022\007\n\003VAR\020\002\022\017\n\013CONSTRUCTOR\020\003*\005\010" +
-      "d\020\310\001*9\n\010Modality\022\t\n\005FINAL\020\000\022\010\n\004OPEN\020\001\022\014\n",
-      "\010ABSTRACT\020\002\022\n\n\006SEALED\020\003*b\n\nVisibility\022\014\n" +
-      "\010INTERNAL\020\000\022\013\n\007PRIVATE\020\001\022\r\n\tPROTECTED\020\002\022" +
-      "\n\n\006PUBLIC\020\003\022\023\n\017PRIVATE_TO_THIS\020\004\022\t\n\005LOCA" +
-      "L\020\005B\022B\rDebugProtoBuf\210\001\000"
+      "erialization.Type\022\035\n\021nested_class_name\030\007" +
+      " \003(\005B\002\020\001\022<\n\006member\030\013 \003(\0132,.org.jetbrains" +
+      ".kotlin.serialization.Callable\022\026\n\nenum_e",
+      "ntry\030\014 \003(\005B\002\020\001\022Y\n\023primary_constructor\030\r " +
+      "\001(\0132<.org.jetbrains.kotlin.serialization" +
+      ".Class.PrimaryConstructor\022K\n\025secondary_c" +
+      "onstructor\030\016 \003(\0132,.org.jetbrains.kotlin." +
+      "serialization.Callable\032P\n\022PrimaryConstru" +
+      "ctor\022:\n\004data\030\001 \001(\0132,.org.jetbrains.kotli" +
+      "n.serialization.Callable\"p\n\004Kind\022\t\n\005CLAS" +
+      "S\020\000\022\t\n\005TRAIT\020\001\022\016\n\nENUM_CLASS\020\002\022\016\n\nENUM_E" +
+      "NTRY\020\003\022\024\n\020ANNOTATION_CLASS\020\004\022\n\n\006OBJECT\020\005" +
+      "\022\020\n\014CLASS_OBJECT\020\006*\005\010d\020\310\001\"N\n\007Package\022<\n\006",
+      "member\030\001 \003(\0132,.org.jetbrains.kotlin.seri" +
+      "alization.Callable*\005\010d\020\310\001\"\300\005\n\010Callable\022\r" +
+      "\n\005flags\030\001 \001(\005\022\024\n\014getter_flags\030\t \001(\005\022\024\n\014s" +
+      "etter_flags\030\n \001(\005\022I\n\016type_parameter\030\004 \003(" +
+      "\01321.org.jetbrains.kotlin.serialization.T" +
+      "ypeParameter\022?\n\rreceiver_type\030\005 \001(\0132(.or" +
+      "g.jetbrains.kotlin.serialization.Type\022\014\n" +
+      "\004name\030\006 \002(\005\022T\n\017value_parameter\030\007 \003(\0132;.o" +
+      "rg.jetbrains.kotlin.serialization.Callab" +
+      "le.ValueParameter\022=\n\013return_type\030\010 \002(\0132(",
+      ".org.jetbrains.kotlin.serialization.Type" +
+      "\032\263\001\n\016ValueParameter\022\r\n\005flags\030\001 \001(\005\022\014\n\004na" +
+      "me\030\002 \002(\005\0226\n\004type\030\003 \002(\0132(.org.jetbrains.k" +
+      "otlin.serialization.Type\022E\n\023vararg_eleme" +
+      "nt_type\030\004 \001(\0132(.org.jetbrains.kotlin.ser" +
+      "ialization.Type*\005\010d\020\310\001\"Q\n\nMemberKind\022\017\n\013" +
+      "DECLARATION\020\000\022\021\n\rFAKE_OVERRIDE\020\001\022\016\n\nDELE" +
+      "GATION\020\002\022\017\n\013SYNTHESIZED\020\003\":\n\014CallableKin" +
+      "d\022\007\n\003FUN\020\000\022\007\n\003VAL\020\001\022\007\n\003VAR\020\002\022\017\n\013CONSTRUC" +
+      "TOR\020\003*\005\010d\020\310\001*9\n\010Modality\022\t\n\005FINAL\020\000\022\010\n\004O",
+      "PEN\020\001\022\014\n\010ABSTRACT\020\002\022\n\n\006SEALED\020\003*b\n\nVisib" +
+      "ility\022\014\n\010INTERNAL\020\000\022\013\n\007PRIVATE\020\001\022\r\n\tPROT" +
+      "ECTED\020\002\022\n\n\006PUBLIC\020\003\022\023\n\017PRIVATE_TO_THIS\020\004" +
+      "\022\t\n\005LOCAL\020\005B\022B\rDebugProtoBuf\210\001\000"
     };
     com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner assigner =
       new com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner() {
diff --git a/compiler/tests/org/jetbrains/kotlin/test/util/RecursiveDescriptorComparator.java b/compiler/tests/org/jetbrains/kotlin/test/util/RecursiveDescriptorComparator.java
index 6fe0cfe2c58..7d4d4802e98 100644
--- a/compiler/tests/org/jetbrains/kotlin/test/util/RecursiveDescriptorComparator.java
+++ b/compiler/tests/org/jetbrains/kotlin/test/util/RecursiveDescriptorComparator.java
@@ -40,20 +40,28 @@ import org.jetbrains.kotlin.utils.Printer;
 import org.junit.Assert;
 
 import java.io.File;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.List;
+import java.lang.annotation.Retention;
+import java.lang.annotation.Target;
+import java.util.*;
 
 import static org.jetbrains.kotlin.resolve.DescriptorUtils.isEnumEntry;
 import static org.jetbrains.kotlin.test.util.DescriptorValidator.ValidationVisitor.errorTypesForbidden;
 
 public class RecursiveDescriptorComparator {
+
+    private static final Set<FqName> excludedAnnotations = new HashSet<FqName>();
+    static {
+        excludedAnnotations.add(new FqName(ExpectedLoadErrorsUtil.ANNOTATION_CLASS_NAME));
+        excludedAnnotations.add(new FqName(Retention.class.getName()));
+        excludedAnnotations.add(new FqName(Target.class.getName()));
+    }
+
     private static final DescriptorRenderer DEFAULT_RENDERER = DescriptorRenderer.Companion.withOptions(
             new Function1<DescriptorRendererOptions, Unit>() {
                 @Override
                 public Unit invoke(DescriptorRendererOptions options) {
                     options.setWithDefinedIn(false);
-                    options.setExcludedAnnotationClasses(Collections.singleton(new FqName(ExpectedLoadErrorsUtil.ANNOTATION_CLASS_NAME)));
+                    options.setExcludedAnnotationClasses(excludedAnnotations);
                     options.setOverrideRenderingPolicy(OverrideRenderingPolicy.RENDER_OPEN_OVERRIDE);
                     options.setIncludePropertyConstant(true);
                     options.setNameShortness(NameShortness.FULLY_QUALIFIED);
diff --git a/compiler/tests/org/jetbrains/kotlin/tests/di/injection.kt b/compiler/tests/org/jetbrains/kotlin/tests/di/injection.kt
index 37e60cb697d..b1e1da7070b 100644
--- a/compiler/tests/org/jetbrains/kotlin/tests/di/injection.kt
+++ b/compiler/tests/org/jetbrains/kotlin/tests/di/injection.kt
@@ -34,7 +34,7 @@ import org.jetbrains.kotlin.types.expressions.FakeCallResolver
 
 public fun createContainerForTests(project: Project, module: ModuleDescriptor): ContainerForTests {
     return ContainerForTests(createContainer("Tests") {
-        configureModule(ModuleContext(module, project), KotlinJvmCheckerProvider)
+        configureModule(ModuleContext(module, project), KotlinJvmCheckerProvider(module))
         useImpl<ExpressionTypingServices>()
     })
 }
diff --git a/compiler/tests/org/jetbrains/kotlin/types/JetTypeCheckerTest.java b/compiler/tests/org/jetbrains/kotlin/types/JetTypeCheckerTest.java
index 7f99415756d..608c06c003b 100644
--- a/compiler/tests/org/jetbrains/kotlin/types/JetTypeCheckerTest.java
+++ b/compiler/tests/org/jetbrains/kotlin/types/JetTypeCheckerTest.java
@@ -23,8 +23,10 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment;
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor;
+import org.jetbrains.kotlin.descriptors.PackageFragmentProvider;
 import org.jetbrains.kotlin.descriptors.PackageViewDescriptor;
 import org.jetbrains.kotlin.descriptors.ReceiverParameterDescriptor;
+import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl;
 import org.jetbrains.kotlin.descriptors.impl.ReceiverParameterDescriptorImpl;
 import org.jetbrains.kotlin.name.FqName;
 import org.jetbrains.kotlin.name.Name;
@@ -73,7 +75,10 @@ public class JetTypeCheckerTest extends JetLiteFixture {
 
         builtIns = KotlinBuiltIns.getInstance();
 
-        ContainerForTests container = DiPackage.createContainerForTests(getProject(), JetTestUtils.createEmptyModule());
+        ModuleDescriptorImpl module = JetTestUtils.createEmptyModule();
+        ContainerForTests container = DiPackage.createContainerForTests(getProject(), module);
+        module.setDependencies(Collections.singletonList(module));
+        module.initialize(PackageFragmentProvider.Empty.INSTANCE$);
         typeResolver = container.getTypeResolver();
         expressionTypingServices = container.getExpressionTypingServices();
 
@@ -434,11 +439,9 @@ public class JetTypeCheckerTest extends JetLiteFixture {
         assertType("1.plus(1.toLong())", "Long");
         assertType("1.plus(1)", "Int");
 
-        assertType("'1'.plus(1.toDouble())", "Double");
-        assertType("'1'.plus(1.toFloat())", "Float");
-        assertType("'1'.plus(1.toLong())", "Long");
-        assertType("'1'.plus(1)", "Int");
-        assertType("'1'.minus('1')", "Int"); // Plus is not available for char
+        assertType("'1'.plus(1)", "Char");
+        assertType("'1'.minus(1)", "Char");
+        assertType("'1'.minus('1')", "Int");
 
         assertType("(1:Short).plus(1.toDouble())", "Double");
         assertType("(1:Short).plus(1.toFloat())", "Float");
@@ -571,7 +574,6 @@ public class JetTypeCheckerTest extends JetLiteFixture {
             public List<ReceiverParameterDescriptor> getImplicitReceiversHierarchy() {
                 return Lists.<ReceiverParameterDescriptor>newArrayList(new ReceiverParameterDescriptorImpl(
                         getContainingDeclaration(),
-                        thisType,
                         new ExpressionReceiver(JetPsiFactory(getProject()).createExpression(expression), thisType)
                 ));
             }
diff --git a/core/builtins/builtins.iml b/core/builtins/builtins.iml
index ef582b1af94..c90834f2d60 100644
--- a/core/builtins/builtins.iml
+++ b/core/builtins/builtins.iml
@@ -2,9 +2,10 @@
 <module type="JAVA_MODULE" version="4">
   <component name="NewModuleRootManager" inherit-compiler-output="true">
     <exclude-output />
-    <content url="file://$MODULE_DIR$" />
+    <content url="file://$MODULE_DIR$">
+      <sourceFolder url="file://$MODULE_DIR$/src" isTestSource="false" />
+    </content>
     <orderEntry type="inheritedJdk" />
     <orderEntry type="sourceFolder" forTests="false" />
   </component>
-</module>
-
+</module>
\ No newline at end of file
diff --git a/core/builtins/native/kotlin/Char.kt b/core/builtins/native/kotlin/Char.kt
index e9d618dffed..140094a91d3 100644
--- a/core/builtins/native/kotlin/Char.kt
+++ b/core/builtins/native/kotlin/Char.kt
@@ -23,162 +23,25 @@ package kotlin
 public class Char private () : Comparable<Char> {
     companion object {}
 
-    /**
-     * Compares the character code of this character with the specified value for order.
-     * Returns zero if this value is equal to the specified other value, a negative number if its less than other,
-     * or a positive number if its greater than other.
-     */
-    deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int or other operand to Char.")
-    public fun compareTo(other: Byte): Int
     /**
      * Compares this value with the specified value for order.
      * Returns zero if this value is equal to the specified other value, a negative number if its less than other,
      * or a positive number if its greater than other.
      */
     public override fun compareTo(other: Char): Int
-    /**
-     * Compares the character code of this character with the specified value for order.
-     * Returns zero if this value is equal to the specified other value, a negative number if its less than other,
-     * or a positive number if its greater than other.
-     */
-    deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int or other operand to Char.")
-    public fun compareTo(other: Short): Int
-    /**
-     * Compares the character code of this character with the specified value for order.
-     * Returns zero if this value is equal to the specified other value, a negative number if its less than other,
-     * or a positive number if its greater than other.
-     */
-    deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int or other operand to Char.")
-    public fun compareTo(other: Int): Int
-    /**
-     * Compares the character code of this character with the specified value for order.
-     * Returns zero if this value is equal to the specified other value, a negative number if its less than other,
-     * or a positive number if its greater than other.
-     */
-    deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int or other operand to Char.")
-    public fun compareTo(other: Long): Int
-    /**
-     * Compares the character code of this character with the specified value for order.
-     * Returns zero if this value is equal to the specified other value, a negative number if its less than other,
-     * or a positive number if its greater than other.
-     */
-    deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
-    public fun compareTo(other: Float): Int
-    /**
-     * Compares the character code of this character with the specified value for order.
-     * Returns zero if this value is equal to the specified other value, a negative number if its less than other,
-     * or a positive number if its greater than other.
-     */
-    deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
-    public fun compareTo(other: Double): Int
 
-    /** Adds the other value to this value. */
-    deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
-    public fun plus(other: Byte): Int
-    /** Adds the other value to this value. */
-    deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
-    public fun plus(other: Short): Int
-    /** Adds the other value to this value. */
-    deprecated("This operation will change return type to Char in M13. Either call toInt or toChar on return value or convert Char operand to Int.")
-    public fun plus(other: Int): Int
-    /** Adds the other value to this value. */
-    deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
-    public fun plus(other: Long): Long
-    /** Adds the other value to this value. */
-    deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
-    public fun plus(other: Float): Float
-    /** Adds the other value to this value. */
-    deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
-    public fun plus(other: Double): Double
+    /** Adds the other Int value to this value resulting a Char. */
+    public fun plus(other: Int): Char
 
-    /** Subtracts the other value from this value. */
-    deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
-    public fun minus(other: Byte): Int
-    /** Subtracts the other value from this value. */
+    /** Subtracts the other Char value from this value resulting an Int. */
     public fun minus(other: Char): Int
-    /** Subtracts the other value from this value. */
-    deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
-    public fun minus(other: Short): Int
-    /** Subtracts the other value from this value. */
-    deprecated("This operation will change return type to Char in M13. Either call toInt or toChar on return value or convert Char operand to Int.")
-    public fun minus(other: Int): Int
-    /** Subtracts the other value from this value. */
-    deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
-    public fun minus(other: Long): Long
-    /** Subtracts the other value from this value. */
-    deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
-    public fun minus(other: Float): Float
-    /** Subtracts the other value from this value. */
-    deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
-    public fun minus(other: Double): Double
-
-    /** Multiplies this value by the other value. */
-    deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
-    public fun times(other: Byte): Int
-    /** Multiplies this value by the other value. */
-    deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
-    public fun times(other: Short): Int
-    /** Multiplies this value by the other value. */
-    deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
-    public fun times(other: Int): Int
-    /** Multiplies this value by the other value. */
-    deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
-    public fun times(other: Long): Long
-    /** Multiplies this value by the other value. */
-    deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
-    public fun times(other: Float): Float
-    /** Multiplies this value by the other value. */
-    deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
-    public fun times(other: Double): Double
-
-    /** Divides this value by the other value. */
-    deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
-    public fun div(other: Byte): Int
-    /** Divides this value by the other value. */
-    deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
-    public fun div(other: Short): Int
-    /** Divides this value by the other value. */
-    deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
-    public fun div(other: Int): Int
-    /** Divides this value by the other value. */
-    deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
-    public fun div(other: Long): Long
-    /** Divides this value by the other value. */
-    deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
-    public fun div(other: Float): Float
-    /** Divides this value by the other value. */
-    deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
-    public fun div(other: Double): Double
-
-    /** Calculates the remainder of dividing this value by the other value. */
-    deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
-    public fun mod(other: Byte): Int
-    /** Calculates the remainder of dividing this value by the other value. */
-    deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
-    public fun mod(other: Short): Int
-    /** Calculates the remainder of dividing this value by the other value. */
-    deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
-    public fun mod(other: Int): Int
-    /** Calculates the remainder of dividing this value by the other value. */
-    deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
-    public fun mod(other: Long): Long
-    /** Calculates the remainder of dividing this value by the other value. */
-    deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
-    public fun mod(other: Float): Float
-    /** Calculates the remainder of dividing this value by the other value. */
-    deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
-    public fun mod(other: Double): Double
+    /** Subtracts the other Int value from this value resulting a Char. */
+    public fun minus(other: Int): Char
 
     /** Increments this value. */
     public fun inc(): Char
     /** Decrements this value. */
     public fun dec(): Char
-    /** Returns this value. */
-    deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
-    public fun plus(): Int
-    /** Returns the negative of this value. */
-    deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
-    public fun minus(): Int
 
     /** Creates a range from this value to the specified [other] value. */
     public fun rangeTo(other: Char): CharRange
diff --git a/core/builtins/native/kotlin/Collections.kt b/core/builtins/native/kotlin/Collections.kt
index 884cb0a2ad8..43516037603 100644
--- a/core/builtins/native/kotlin/Collections.kt
+++ b/core/builtins/native/kotlin/Collections.kt
@@ -86,7 +86,8 @@ public interface MutableCollection<E> : Collection<E>, MutableIterable<E> {
     public fun add(e: E): Boolean
 
     /**
-     * Removes the specified element from the collection.
+     * Removes a single instance of the specified element from this
+     * collection, if it is present.
      *
      * @return `true` if the element has been successfully removed; `false` if it was not present in the collection.
      */
@@ -101,14 +102,14 @@ public interface MutableCollection<E> : Collection<E>, MutableIterable<E> {
     public fun addAll(c: Collection<E>): Boolean
 
     /**
-     * Removes all of the elements in the specified collection from this collection.
+     * Removes all of this collection's elements that are also contained in the specified collection.
      *
      * @return `true` if any of the specified elements was removed from the collection, `false` if the collection was not modified.
      */
     public fun removeAll(c: Collection<Any?>): Boolean
 
     /**
-     * Removes all of the elements not contained in the specified collection from this collection.
+     * Retains only the elements in this collection that are contained in the specified collection.
      *
      * @return `true` if any element was removed from the collection, `false` if the collection was not modified.
      */
diff --git a/core/builtins/native/kotlin/Primitives.kt b/core/builtins/native/kotlin/Primitives.kt
index 1f4bbc8b09d..c0f93d7577f 100644
--- a/core/builtins/native/kotlin/Primitives.kt
+++ b/core/builtins/native/kotlin/Primitives.kt
@@ -31,13 +31,6 @@ public class Byte private () : Number, Comparable<Byte> {
  * or a positive number if its greater than other.
  */
     public override fun compareTo(other: Byte): Int
-/**
- * Compares this value with the character code of the specified character for order.
- * Returns zero if this value is equal to the specified other value, a negative number if its less than other, 
- * or a positive number if its greater than other.
- */
-    deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
-    public fun compareTo(other: Char): Int
 /**
  * Compares this value with the specified value for order.
  * Returns zero if this value is equal to the specified other value, a negative number if its less than other, 
@@ -72,9 +65,6 @@ public class Byte private () : Number, Comparable<Byte> {
     /** Adds the other value to this value. */
     public fun plus(other: Byte): Int
     /** Adds the other value to this value. */
-    deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
-    public fun plus(other: Char): Int
-    /** Adds the other value to this value. */
     public fun plus(other: Short): Int
     /** Adds the other value to this value. */
     public fun plus(other: Int): Int
@@ -88,9 +78,6 @@ public class Byte private () : Number, Comparable<Byte> {
     /** Subtracts the other value from this value. */
     public fun minus(other: Byte): Int
     /** Subtracts the other value from this value. */
-    deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
-    public fun minus(other: Char): Int
-    /** Subtracts the other value from this value. */
     public fun minus(other: Short): Int
     /** Subtracts the other value from this value. */
     public fun minus(other: Int): Int
@@ -104,9 +91,6 @@ public class Byte private () : Number, Comparable<Byte> {
     /** Multiplies this value by the other value. */
     public fun times(other: Byte): Int
     /** Multiplies this value by the other value. */
-    deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
-    public fun times(other: Char): Int
-    /** Multiplies this value by the other value. */
     public fun times(other: Short): Int
     /** Multiplies this value by the other value. */
     public fun times(other: Int): Int
@@ -120,9 +104,6 @@ public class Byte private () : Number, Comparable<Byte> {
     /** Divides this value by the other value. */
     public fun div(other: Byte): Int
     /** Divides this value by the other value. */
-    deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
-    public fun div(other: Char): Int
-    /** Divides this value by the other value. */
     public fun div(other: Short): Int
     /** Divides this value by the other value. */
     public fun div(other: Int): Int
@@ -136,9 +117,6 @@ public class Byte private () : Number, Comparable<Byte> {
     /** Calculates the remainder of dividing this value by the other value. */
     public fun mod(other: Byte): Int
     /** Calculates the remainder of dividing this value by the other value. */
-    deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
-    public fun mod(other: Char): Int
-    /** Calculates the remainder of dividing this value by the other value. */
     public fun mod(other: Short): Int
     /** Calculates the remainder of dividing this value by the other value. */
     public fun mod(other: Int): Int
@@ -161,9 +139,6 @@ public class Byte private () : Number, Comparable<Byte> {
      /** Creates a range from this value to the specified [other] value. */
     public fun rangeTo(other: Byte): ByteRange
      /** Creates a range from this value to the specified [other] value. */
-    deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
-    public fun rangeTo(other: Char): CharRange
-     /** Creates a range from this value to the specified [other] value. */
     public fun rangeTo(other: Short): ShortRange
      /** Creates a range from this value to the specified [other] value. */
     public fun rangeTo(other: Int): IntRange
@@ -196,13 +171,6 @@ public class Short private () : Number, Comparable<Short> {
  * or a positive number if its greater than other.
  */
     public fun compareTo(other: Byte): Int
-/**
- * Compares this value with the character code of the specified character for order.
- * Returns zero if this value is equal to the specified other value, a negative number if its less than other, 
- * or a positive number if its greater than other.
- */
-    deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
-    public fun compareTo(other: Char): Int
 /**
  * Compares this value with the specified value for order.
  * Returns zero if this value is equal to the specified other value, a negative number if its less than other, 
@@ -237,9 +205,6 @@ public class Short private () : Number, Comparable<Short> {
     /** Adds the other value to this value. */
     public fun plus(other: Byte): Int
     /** Adds the other value to this value. */
-    deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
-    public fun plus(other: Char): Int
-    /** Adds the other value to this value. */
     public fun plus(other: Short): Int
     /** Adds the other value to this value. */
     public fun plus(other: Int): Int
@@ -253,9 +218,6 @@ public class Short private () : Number, Comparable<Short> {
     /** Subtracts the other value from this value. */
     public fun minus(other: Byte): Int
     /** Subtracts the other value from this value. */
-    deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
-    public fun minus(other: Char): Int
-    /** Subtracts the other value from this value. */
     public fun minus(other: Short): Int
     /** Subtracts the other value from this value. */
     public fun minus(other: Int): Int
@@ -269,9 +231,6 @@ public class Short private () : Number, Comparable<Short> {
     /** Multiplies this value by the other value. */
     public fun times(other: Byte): Int
     /** Multiplies this value by the other value. */
-    deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
-    public fun times(other: Char): Int
-    /** Multiplies this value by the other value. */
     public fun times(other: Short): Int
     /** Multiplies this value by the other value. */
     public fun times(other: Int): Int
@@ -285,9 +244,6 @@ public class Short private () : Number, Comparable<Short> {
     /** Divides this value by the other value. */
     public fun div(other: Byte): Int
     /** Divides this value by the other value. */
-    deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
-    public fun div(other: Char): Int
-    /** Divides this value by the other value. */
     public fun div(other: Short): Int
     /** Divides this value by the other value. */
     public fun div(other: Int): Int
@@ -301,9 +257,6 @@ public class Short private () : Number, Comparable<Short> {
     /** Calculates the remainder of dividing this value by the other value. */
     public fun mod(other: Byte): Int
     /** Calculates the remainder of dividing this value by the other value. */
-    deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
-    public fun mod(other: Char): Int
-    /** Calculates the remainder of dividing this value by the other value. */
     public fun mod(other: Short): Int
     /** Calculates the remainder of dividing this value by the other value. */
     public fun mod(other: Int): Int
@@ -326,9 +279,6 @@ public class Short private () : Number, Comparable<Short> {
      /** Creates a range from this value to the specified [other] value. */
     public fun rangeTo(other: Byte): ShortRange
      /** Creates a range from this value to the specified [other] value. */
-    deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
-    public fun rangeTo(other: Char): ShortRange
-     /** Creates a range from this value to the specified [other] value. */
     public fun rangeTo(other: Short): ShortRange
      /** Creates a range from this value to the specified [other] value. */
     public fun rangeTo(other: Int): IntRange
@@ -361,13 +311,6 @@ public class Int private () : Number, Comparable<Int> {
  * or a positive number if its greater than other.
  */
     public fun compareTo(other: Byte): Int
-/**
- * Compares this value with the character code of the specified character for order.
- * Returns zero if this value is equal to the specified other value, a negative number if its less than other, 
- * or a positive number if its greater than other.
- */
-    deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
-    public fun compareTo(other: Char): Int
 /**
  * Compares this value with the specified value for order.
  * Returns zero if this value is equal to the specified other value, a negative number if its less than other, 
@@ -402,9 +345,6 @@ public class Int private () : Number, Comparable<Int> {
     /** Adds the other value to this value. */
     public fun plus(other: Byte): Int
     /** Adds the other value to this value. */
-    deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
-    public fun plus(other: Char): Int
-    /** Adds the other value to this value. */
     public fun plus(other: Short): Int
     /** Adds the other value to this value. */
     public fun plus(other: Int): Int
@@ -418,9 +358,6 @@ public class Int private () : Number, Comparable<Int> {
     /** Subtracts the other value from this value. */
     public fun minus(other: Byte): Int
     /** Subtracts the other value from this value. */
-    deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
-    public fun minus(other: Char): Int
-    /** Subtracts the other value from this value. */
     public fun minus(other: Short): Int
     /** Subtracts the other value from this value. */
     public fun minus(other: Int): Int
@@ -434,9 +371,6 @@ public class Int private () : Number, Comparable<Int> {
     /** Multiplies this value by the other value. */
     public fun times(other: Byte): Int
     /** Multiplies this value by the other value. */
-    deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
-    public fun times(other: Char): Int
-    /** Multiplies this value by the other value. */
     public fun times(other: Short): Int
     /** Multiplies this value by the other value. */
     public fun times(other: Int): Int
@@ -450,9 +384,6 @@ public class Int private () : Number, Comparable<Int> {
     /** Divides this value by the other value. */
     public fun div(other: Byte): Int
     /** Divides this value by the other value. */
-    deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
-    public fun div(other: Char): Int
-    /** Divides this value by the other value. */
     public fun div(other: Short): Int
     /** Divides this value by the other value. */
     public fun div(other: Int): Int
@@ -466,9 +397,6 @@ public class Int private () : Number, Comparable<Int> {
     /** Calculates the remainder of dividing this value by the other value. */
     public fun mod(other: Byte): Int
     /** Calculates the remainder of dividing this value by the other value. */
-    deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
-    public fun mod(other: Char): Int
-    /** Calculates the remainder of dividing this value by the other value. */
     public fun mod(other: Short): Int
     /** Calculates the remainder of dividing this value by the other value. */
     public fun mod(other: Int): Int
@@ -491,9 +419,6 @@ public class Int private () : Number, Comparable<Int> {
      /** Creates a range from this value to the specified [other] value. */
     public fun rangeTo(other: Byte): IntRange
      /** Creates a range from this value to the specified [other] value. */
-    deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
-    public fun rangeTo(other: Char): IntRange
-     /** Creates a range from this value to the specified [other] value. */
     public fun rangeTo(other: Short): IntRange
      /** Creates a range from this value to the specified [other] value. */
     public fun rangeTo(other: Int): IntRange
@@ -541,13 +466,6 @@ public class Long private () : Number, Comparable<Long> {
  * or a positive number if its greater than other.
  */
     public fun compareTo(other: Byte): Int
-/**
- * Compares this value with the character code of the specified character for order.
- * Returns zero if this value is equal to the specified other value, a negative number if its less than other, 
- * or a positive number if its greater than other.
- */
-    deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
-    public fun compareTo(other: Char): Int
 /**
  * Compares this value with the specified value for order.
  * Returns zero if this value is equal to the specified other value, a negative number if its less than other, 
@@ -582,9 +500,6 @@ public class Long private () : Number, Comparable<Long> {
     /** Adds the other value to this value. */
     public fun plus(other: Byte): Long
     /** Adds the other value to this value. */
-    deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
-    public fun plus(other: Char): Long
-    /** Adds the other value to this value. */
     public fun plus(other: Short): Long
     /** Adds the other value to this value. */
     public fun plus(other: Int): Long
@@ -598,9 +513,6 @@ public class Long private () : Number, Comparable<Long> {
     /** Subtracts the other value from this value. */
     public fun minus(other: Byte): Long
     /** Subtracts the other value from this value. */
-    deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
-    public fun minus(other: Char): Long
-    /** Subtracts the other value from this value. */
     public fun minus(other: Short): Long
     /** Subtracts the other value from this value. */
     public fun minus(other: Int): Long
@@ -614,9 +526,6 @@ public class Long private () : Number, Comparable<Long> {
     /** Multiplies this value by the other value. */
     public fun times(other: Byte): Long
     /** Multiplies this value by the other value. */
-    deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
-    public fun times(other: Char): Long
-    /** Multiplies this value by the other value. */
     public fun times(other: Short): Long
     /** Multiplies this value by the other value. */
     public fun times(other: Int): Long
@@ -630,9 +539,6 @@ public class Long private () : Number, Comparable<Long> {
     /** Divides this value by the other value. */
     public fun div(other: Byte): Long
     /** Divides this value by the other value. */
-    deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
-    public fun div(other: Char): Long
-    /** Divides this value by the other value. */
     public fun div(other: Short): Long
     /** Divides this value by the other value. */
     public fun div(other: Int): Long
@@ -646,9 +552,6 @@ public class Long private () : Number, Comparable<Long> {
     /** Calculates the remainder of dividing this value by the other value. */
     public fun mod(other: Byte): Long
     /** Calculates the remainder of dividing this value by the other value. */
-    deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
-    public fun mod(other: Char): Long
-    /** Calculates the remainder of dividing this value by the other value. */
     public fun mod(other: Short): Long
     /** Calculates the remainder of dividing this value by the other value. */
     public fun mod(other: Int): Long
@@ -671,9 +574,6 @@ public class Long private () : Number, Comparable<Long> {
      /** Creates a range from this value to the specified [other] value. */
     public fun rangeTo(other: Byte): LongRange
      /** Creates a range from this value to the specified [other] value. */
-    deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
-    public fun rangeTo(other: Char): LongRange
-     /** Creates a range from this value to the specified [other] value. */
     public fun rangeTo(other: Short): LongRange
      /** Creates a range from this value to the specified [other] value. */
     public fun rangeTo(other: Int): LongRange
@@ -721,13 +621,6 @@ public class Float private () : Number, Comparable<Float> {
  * or a positive number if its greater than other.
  */
     public fun compareTo(other: Byte): Int
-/**
- * Compares this value with the character code of the specified character for order.
- * Returns zero if this value is equal to the specified other value, a negative number if its less than other, 
- * or a positive number if its greater than other.
- */
-    deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
-    public fun compareTo(other: Char): Int
 /**
  * Compares this value with the specified value for order.
  * Returns zero if this value is equal to the specified other value, a negative number if its less than other, 
@@ -762,9 +655,6 @@ public class Float private () : Number, Comparable<Float> {
     /** Adds the other value to this value. */
     public fun plus(other: Byte): Float
     /** Adds the other value to this value. */
-    deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
-    public fun plus(other: Char): Float
-    /** Adds the other value to this value. */
     public fun plus(other: Short): Float
     /** Adds the other value to this value. */
     public fun plus(other: Int): Float
@@ -778,9 +668,6 @@ public class Float private () : Number, Comparable<Float> {
     /** Subtracts the other value from this value. */
     public fun minus(other: Byte): Float
     /** Subtracts the other value from this value. */
-    deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
-    public fun minus(other: Char): Float
-    /** Subtracts the other value from this value. */
     public fun minus(other: Short): Float
     /** Subtracts the other value from this value. */
     public fun minus(other: Int): Float
@@ -794,9 +681,6 @@ public class Float private () : Number, Comparable<Float> {
     /** Multiplies this value by the other value. */
     public fun times(other: Byte): Float
     /** Multiplies this value by the other value. */
-    deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
-    public fun times(other: Char): Float
-    /** Multiplies this value by the other value. */
     public fun times(other: Short): Float
     /** Multiplies this value by the other value. */
     public fun times(other: Int): Float
@@ -810,9 +694,6 @@ public class Float private () : Number, Comparable<Float> {
     /** Divides this value by the other value. */
     public fun div(other: Byte): Float
     /** Divides this value by the other value. */
-    deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
-    public fun div(other: Char): Float
-    /** Divides this value by the other value. */
     public fun div(other: Short): Float
     /** Divides this value by the other value. */
     public fun div(other: Int): Float
@@ -826,9 +707,6 @@ public class Float private () : Number, Comparable<Float> {
     /** Calculates the remainder of dividing this value by the other value. */
     public fun mod(other: Byte): Float
     /** Calculates the remainder of dividing this value by the other value. */
-    deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
-    public fun mod(other: Char): Float
-    /** Calculates the remainder of dividing this value by the other value. */
     public fun mod(other: Short): Float
     /** Calculates the remainder of dividing this value by the other value. */
     public fun mod(other: Int): Float
@@ -851,9 +729,6 @@ public class Float private () : Number, Comparable<Float> {
      /** Creates a range from this value to the specified [other] value. */
     public fun rangeTo(other: Byte): FloatRange
      /** Creates a range from this value to the specified [other] value. */
-    deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
-    public fun rangeTo(other: Char): FloatRange
-     /** Creates a range from this value to the specified [other] value. */
     public fun rangeTo(other: Short): FloatRange
      /** Creates a range from this value to the specified [other] value. */
     public fun rangeTo(other: Int): FloatRange
@@ -886,13 +761,6 @@ public class Double private () : Number, Comparable<Double> {
  * or a positive number if its greater than other.
  */
     public fun compareTo(other: Byte): Int
-/**
- * Compares this value with the character code of the specified character for order.
- * Returns zero if this value is equal to the specified other value, a negative number if its less than other, 
- * or a positive number if its greater than other.
- */
-    deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
-    public fun compareTo(other: Char): Int
 /**
  * Compares this value with the specified value for order.
  * Returns zero if this value is equal to the specified other value, a negative number if its less than other, 
@@ -927,9 +795,6 @@ public class Double private () : Number, Comparable<Double> {
     /** Adds the other value to this value. */
     public fun plus(other: Byte): Double
     /** Adds the other value to this value. */
-    deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
-    public fun plus(other: Char): Double
-    /** Adds the other value to this value. */
     public fun plus(other: Short): Double
     /** Adds the other value to this value. */
     public fun plus(other: Int): Double
@@ -943,9 +808,6 @@ public class Double private () : Number, Comparable<Double> {
     /** Subtracts the other value from this value. */
     public fun minus(other: Byte): Double
     /** Subtracts the other value from this value. */
-    deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
-    public fun minus(other: Char): Double
-    /** Subtracts the other value from this value. */
     public fun minus(other: Short): Double
     /** Subtracts the other value from this value. */
     public fun minus(other: Int): Double
@@ -959,9 +821,6 @@ public class Double private () : Number, Comparable<Double> {
     /** Multiplies this value by the other value. */
     public fun times(other: Byte): Double
     /** Multiplies this value by the other value. */
-    deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
-    public fun times(other: Char): Double
-    /** Multiplies this value by the other value. */
     public fun times(other: Short): Double
     /** Multiplies this value by the other value. */
     public fun times(other: Int): Double
@@ -975,9 +834,6 @@ public class Double private () : Number, Comparable<Double> {
     /** Divides this value by the other value. */
     public fun div(other: Byte): Double
     /** Divides this value by the other value. */
-    deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
-    public fun div(other: Char): Double
-    /** Divides this value by the other value. */
     public fun div(other: Short): Double
     /** Divides this value by the other value. */
     public fun div(other: Int): Double
@@ -991,9 +847,6 @@ public class Double private () : Number, Comparable<Double> {
     /** Calculates the remainder of dividing this value by the other value. */
     public fun mod(other: Byte): Double
     /** Calculates the remainder of dividing this value by the other value. */
-    deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
-    public fun mod(other: Char): Double
-    /** Calculates the remainder of dividing this value by the other value. */
     public fun mod(other: Short): Double
     /** Calculates the remainder of dividing this value by the other value. */
     public fun mod(other: Int): Double
@@ -1016,9 +869,6 @@ public class Double private () : Number, Comparable<Double> {
      /** Creates a range from this value to the specified [other] value. */
     public fun rangeTo(other: Byte): DoubleRange
      /** Creates a range from this value to the specified [other] value. */
-    deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
-    public fun rangeTo(other: Char): DoubleRange
-     /** Creates a range from this value to the specified [other] value. */
     public fun rangeTo(other: Short): DoubleRange
      /** Creates a range from this value to the specified [other] value. */
     public fun rangeTo(other: Int): DoubleRange
diff --git a/core/builtins/src/kotlin/Annotations.kt b/core/builtins/src/kotlin/Annotations.kt
index f5ac5a9a719..99fa0869d91 100644
--- a/core/builtins/src/kotlin/Annotations.kt
+++ b/core/builtins/src/kotlin/Annotations.kt
@@ -16,20 +16,26 @@
 
 package kotlin
 
+import kotlin.annotation.*
+import kotlin.annotation.AnnotationTarget.*
+
 /**
  * Marks the annotated class as a data class. The compiler automatically generates
  * equals()/hashCode(), toString(), componentN() and copy() functions for data classes.
  * See [the Kotlin language documentation](http://kotlinlang.org/docs/reference/data-classes.html)
  * for more information.
  */
+target(CLASSIFIER)
 public annotation class data
 
 /**
- * Marks the annotated class, function or property as deprecated.
+ * Marks the annotated class, function, property, variable or parameter as deprecated.
  * @property value the message explaining the deprecation and recommending an alternative API to use.
  * @property replaceWith if present, specifies a code fragment which should be used as a replacement for
  *     the deprecated API usage.
  */
+target(CLASSIFIER, FUNCTION, PROPERTY, ANNOTATION_CLASS, CONSTRUCTOR, PROPERTY_SETTER, PROPERTY_GETTER,
+       LOCAL_VARIABLE, FIELD, VALUE_PARAMETER)
 public annotation class deprecated(val value: String, val replaceWith: ReplaceWith = ReplaceWith(""))
 
 /**
@@ -50,12 +56,15 @@ public annotation class ReplaceWith(val expression: String, vararg val imports:
 /**
  * Signifies that the annotated functional type represents an extension function.
  */
+target(TYPE)
 public annotation class extension
 
 /**
  * Suppresses the given compilation warnings in the annotated element.
  * @property names names of the compiler diagnostics to suppress.
  */
+target(CLASSIFIER, ANNOTATION_CLASS, PROPERTY, FIELD, LOCAL_VARIABLE, VALUE_PARAMETER,
+       CONSTRUCTOR, FUNCTION, PROPERTY_GETTER, PROPERTY_SETTER, TYPE, EXPRESSION, FILE)
 public annotation class suppress(vararg val names: String)
 
 /**
@@ -64,4 +73,5 @@ public annotation class suppress(vararg val names: String)
  * growing the stack depth. Tail call optimization is currently only supported by the JVM
  * backend.
  */
+target(FUNCTION)
 public annotation class tailRecursive
diff --git a/core/builtins/src/kotlin/Function.kt b/core/builtins/src/kotlin/Function.kt
index 4002a56dabb..3234657a686 100644
--- a/core/builtins/src/kotlin/Function.kt
+++ b/core/builtins/src/kotlin/Function.kt
@@ -18,5 +18,7 @@ package kotlin
 
 /**
  * Represents a value of a functional type, such as a lambda, a function expression or a function reference.
+ *
+ * @param R return type of the function.
  */
 public interface Function<out R>
diff --git a/core/builtins/src/kotlin/Progressions.kt b/core/builtins/src/kotlin/Progressions.kt
index a64cee8c46b..15b45025bd7 100644
--- a/core/builtins/src/kotlin/Progressions.kt
+++ b/core/builtins/src/kotlin/Progressions.kt
@@ -40,7 +40,7 @@ public class ByteProgression(
         start == other.start && end == other.end && increment == other.increment)
 
     override fun hashCode(): Int =
-        if (isEmpty()) -1 else (31 * (31 * start.toInt() + end) + increment)
+        if (isEmpty()) -1 else (31 * (31 * start.toInt() + end.toInt()) + increment)
 
     override fun toString(): String = if (increment > 0) "$start..$end step $increment" else "$start downTo $end step ${-increment}"
 }
@@ -67,7 +67,7 @@ public class CharProgression(
         start == other.start && end == other.end && increment == other.increment)
 
     override fun hashCode(): Int =
-        if (isEmpty()) -1 else (31 * (31 * start.toInt() + end) + increment)
+        if (isEmpty()) -1 else (31 * (31 * start.toInt() + end.toInt()) + increment)
 
     override fun toString(): String = if (increment > 0) "$start..$end step $increment" else "$start downTo $end step ${-increment}"
 }
@@ -94,7 +94,7 @@ public class ShortProgression(
         start == other.start && end == other.end && increment == other.increment)
 
     override fun hashCode(): Int =
-        if (isEmpty()) -1 else (31 * (31 * start.toInt() + end) + increment)
+        if (isEmpty()) -1 else (31 * (31 * start.toInt() + end.toInt()) + increment)
 
     override fun toString(): String = if (increment > 0) "$start..$end step $increment" else "$start downTo $end step ${-increment}"
 }
diff --git a/core/builtins/src/kotlin/Ranges.kt b/core/builtins/src/kotlin/Ranges.kt
index b957723d37f..bda8c7e6551 100644
--- a/core/builtins/src/kotlin/Ranges.kt
+++ b/core/builtins/src/kotlin/Ranges.kt
@@ -36,7 +36,7 @@ public class ByteRange(override val start: Byte, override val end: Byte) : Range
         start == other.start && end == other.end)
 
     override fun hashCode(): Int =
-        if (isEmpty()) -1 else (31 * start.toInt() + end)
+        if (isEmpty()) -1 else (31 * start.toInt() + end.toInt())
 
     companion object {
         /** An empty range of values of type Byte. */
@@ -62,7 +62,7 @@ public class CharRange(override val start: Char, override val end: Char) : Range
         start == other.start && end == other.end)
 
     override fun hashCode(): Int =
-        if (isEmpty()) -1 else (31 * start.toInt() + end)
+        if (isEmpty()) -1 else (31 * start.toInt() + end.toInt())
 
     companion object {
         /** An empty range of values of type Char. */
@@ -88,7 +88,7 @@ public class ShortRange(override val start: Short, override val end: Short) : Ra
         start == other.start && end == other.end)
 
     override fun hashCode(): Int =
-        if (isEmpty()) -1 else (31 * start.toInt() + end)
+        if (isEmpty()) -1 else (31 * start.toInt() + end.toInt())
 
     companion object {
         /** An empty range of values of type Short. */
diff --git a/core/builtins/src/kotlin/annotation/Annotations.kt b/core/builtins/src/kotlin/annotation/Annotations.kt
new file mode 100644
index 00000000000..c23799585bc
--- /dev/null
+++ b/core/builtins/src/kotlin/annotation/Annotations.kt
@@ -0,0 +1,91 @@
+/*
+ * Copyright 2010-2015 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.annotation
+
+/**
+ * Contains the list of code elements which are the possible annotation targets
+ */
+public enum class AnnotationTarget {
+    /** Package directive */
+    PACKAGE,
+    /** Class, interface or object, annotation class is also included */
+    CLASSIFIER,
+    /** Annotation class only */
+    ANNOTATION_CLASS,
+    /** Generic type parameter (unsupported yet) */
+    TYPE_PARAMETER,
+    /** Property */
+    PROPERTY,
+    /** Field, including property's backing field */
+    FIELD,
+    /** Local variable */
+    LOCAL_VARIABLE,
+    /** Value parameter of a function or a constructor */
+    VALUE_PARAMETER,
+    /** Constructor only (primary or secondary) */
+    CONSTRUCTOR,
+    /** Function (constructors are not included) */
+    FUNCTION,
+    /** Property getter only */
+    PROPERTY_GETTER,
+    /** Property setter only */
+    PROPERTY_SETTER,
+    /** Type usage */
+    TYPE,
+    /** Any expression */
+    EXPRESSION,
+    /** File */
+    FILE
+}
+
+/**
+ * Contains the list of possible annotation's retentions.
+ *
+ * Determines how an annotation is stored in binary output.
+ */
+public enum class AnnotationRetention {
+    /** Annotation isn't stored in binary output */
+    SOURCE,
+    /** Annotation is stored in binary output, but invisible for reflection */
+    BINARY,
+    /** Annotation is stored in binary output and visible for reflection (default retention) */
+    RUNTIME
+}
+
+/**
+ * This meta-annotation indicates the kinds of code elements which are possible targets of an annotation.
+ *
+ * If the target meta-annotation is not present on an annotation declaration, the annotation
+ * is applicable to any code element, except type parameters, type usages, expressions, and files.
+ *
+ * @property allowedTargets list of allowed annotation targets
+ */
+target(AnnotationTarget.ANNOTATION_CLASS)
+public annotation class target(vararg val allowedTargets: AnnotationTarget)
+
+/**
+ * This special meta-annotation is used to declare an annotation and to set its base properties.
+ * So a class in Kotlin is an annotation if and only if it has the "annotation" meta-annotation.
+ *
+ * @property retention determines whether the annotation is stored in binary output and visible for reflection. By default, both are true.
+ * @property repeatable true if annotation is repeatable (applicable twice or more on a single code element), otherwise false (default)
+ */
+target(AnnotationTarget.ANNOTATION_CLASS)
+public annotation class annotation (
+        val retention: AnnotationRetention = AnnotationRetention.RUNTIME,
+        val repeatable: Boolean = false
+)
diff --git a/core/builtins/src/kotlin/reflect/KCallable.kt b/core/builtins/src/kotlin/reflect/KCallable.kt
index 554d3d46fbb..b5e23954ab4 100644
--- a/core/builtins/src/kotlin/reflect/KCallable.kt
+++ b/core/builtins/src/kotlin/reflect/KCallable.kt
@@ -24,6 +24,11 @@ package kotlin.reflect
 public interface KCallable<out R> {
     /**
      * The name of this callable as it was declared in the source code.
+     * If the callable has no name, a special invented name is created.
+     * Nameless callables include:
+     * - constructors have the name "<init>",
+     * - property accessors: the getter for a property named "foo" will have the name "<get-foo>",
+     *   the setter, similarly, will have the name "<set-foo>".
      */
     public val name: String
 }
diff --git a/core/builtins/src/kotlin/reflect/KClass.kt b/core/builtins/src/kotlin/reflect/KClass.kt
index 3a89c246fdb..965a5470f47 100644
--- a/core/builtins/src/kotlin/reflect/KClass.kt
+++ b/core/builtins/src/kotlin/reflect/KClass.kt
@@ -24,20 +24,27 @@ package kotlin.reflect
  *
  * @param T the type of the class.
  */
-public interface KClass<T> {
+public interface KClass<T> : KDeclarationContainer {
     /**
      * The simple name of the class as it was declared in the source code,
-     * or `null` if the class has no name (e.g. anonymous object literals).
+     * or `null` if the class has no name (if, for example, it is an anonymous object literal).
      */
     public val simpleName: String?
 
+    /**
+     * The fully qualified name of the class which consists of names of the declaring package,
+     * all outer classes of this class and the class itself separated by dots,
+     * or `null` if the class is local or it is an anonymous object literal.
+     */
+    public val qualifiedName: String?
+
     /**
      * Returns non-extension properties declared in this class and all of its superclasses.
      */
-    public val properties: Collection<KMemberProperty<T, *>>
+    public val properties: Collection<KProperty1<T, *>>
 
     /**
      * Returns extension properties declared in this class and all of its superclasses.
      */
-    public val extensionProperties: Collection<KMemberExtensionProperty<T, *, *>>
+    public val extensionProperties: Collection<KProperty2<T, *, *>>
 }
diff --git a/core/builtins/src/kotlin/reflect/KLocalFunction.kt b/core/builtins/src/kotlin/reflect/KDeclarationContainer.kt
similarity index 80%
rename from core/builtins/src/kotlin/reflect/KLocalFunction.kt
rename to core/builtins/src/kotlin/reflect/KDeclarationContainer.kt
index 31a9aae20ee..89e02989564 100644
--- a/core/builtins/src/kotlin/reflect/KLocalFunction.kt
+++ b/core/builtins/src/kotlin/reflect/KDeclarationContainer.kt
@@ -17,8 +17,7 @@
 package kotlin.reflect
 
 /**
- * Represents a local function.
- *
- * @param R the return type of the function.
+ * Represents an entity which may contain declarations of any other entities,
+ * such as a class or a package.
  */
-public interface KLocalFunction<out R> : KFunction<R>
+public interface KDeclarationContainer
diff --git a/core/builtins/src/kotlin/reflect/KExtensionFunction.kt b/core/builtins/src/kotlin/reflect/KExtensionFunction.kt
deleted file mode 100644
index d2b861e14e7..00000000000
--- a/core/builtins/src/kotlin/reflect/KExtensionFunction.kt
+++ /dev/null
@@ -1,27 +0,0 @@
-/*
- * Copyright 2010-2015 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.reflect
-
-/**
- * Represents an extension function.
- * See the [Kotlin language documentation](http://kotlinlang.org/docs/reference/extensions.html#extension-functions)
- * for more information.
- *
- * @param E the type of the extension receiver.
- * @param R the return type of the function.
- */
-public interface KExtensionFunction<in E, out R> : KFunction<R>
diff --git a/core/builtins/src/kotlin/reflect/KExtensionProperty.kt b/core/builtins/src/kotlin/reflect/KExtensionProperty.kt
deleted file mode 100644
index 817e1c3c216..00000000000
--- a/core/builtins/src/kotlin/reflect/KExtensionProperty.kt
+++ /dev/null
@@ -1,47 +0,0 @@
-/*
- * Copyright 2010-2015 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.reflect
-
-/**
- * Represents an extension property.
- * See the [Kotlin language documentation](http://kotlinlang.org/docs/reference/extensions.html#extension-properties)
- * for more information.
- *
- * @param E the type of the extension receiver.
- * @param R the type of the property.
- */
-public interface KExtensionProperty<E, out R> : KProperty<R> {
-    /**
-     * Returns the current value of the property.
-     *
-     * @param receiver the instance of the extension receiver.
-     */
-    public fun get(receiver: E): R
-}
-
-/**
- * Represents an extension property declared as a `var`.
- */
-public interface KMutableExtensionProperty<E, R> : KExtensionProperty<E, R>, KMutableProperty<R> {
-    /**
-     * Modifies the value of the property.
-     *
-     * @param receiver the instance of the extension receiver.
-     * @param value the new value to be assigned to this property.
-     */
-    public fun set(receiver: E, value: R)
-}
diff --git a/core/builtins/src/kotlin/reflect/KFunction.kt b/core/builtins/src/kotlin/reflect/KFunction.kt
index 127496163cc..a6c21632060 100644
--- a/core/builtins/src/kotlin/reflect/KFunction.kt
+++ b/core/builtins/src/kotlin/reflect/KFunction.kt
@@ -19,4 +19,4 @@ package kotlin.reflect
 /**
  * Represents a function with introspection capabilities.
  */
-public interface KFunction<out R> : Function<R>
+public interface KFunction<out R> : KCallable<R>, Function<R>
diff --git a/core/builtins/src/kotlin/reflect/KMemberExtensionProperty.kt b/core/builtins/src/kotlin/reflect/KMemberExtensionProperty.kt
deleted file mode 100644
index a99c19a4f9f..00000000000
--- a/core/builtins/src/kotlin/reflect/KMemberExtensionProperty.kt
+++ /dev/null
@@ -1,51 +0,0 @@
-/*
- * Copyright 2010-2015 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.reflect
-
-/**
- * Represents an extension property declared in a class.
- * See the [Kotlin language documentation](http://kotlinlang.org/docs/reference/extensions.html#extension-properties)
- * for more information.
- *
- * @param T the type of the instance which should be used to obtain the value of the property.
- *          Must be derived either from a class declaring this property, or any subclass of that class.
- * @param E the type of the extension receiver.
- * @param R the type of the property.
- */
-public interface KMemberExtensionProperty<T : Any, E, out R> : KProperty<R> {
-    /**
-     * Returns the current value of the property.
-     *
-     * @param instance the instance to obtain the value of the property from.
-     * @param extensionReceiver the instance of the extension receiver.
-     */
-    public fun get(instance: T, extensionReceiver: E): R
-}
-
-/**
- * Represents a `var` extension property declared in a class.
- */
-public interface KMutableMemberExtensionProperty<T : Any, E, R> : KMemberExtensionProperty<T, E, R>, KMutableProperty<R> {
-    /**
-     * Modifies the value of the property.
-     *
-     * @param instance the instance to obtain the value of the property from.
-     * @param extensionReceiver the instance of the extension receiver.
-     * @param value the new value to be assigned to this property.
-     */
-    public fun set(instance: T, extensionReceiver: E, value: R)
-}
diff --git a/core/builtins/src/kotlin/reflect/KMemberFunction.kt b/core/builtins/src/kotlin/reflect/KMemberFunction.kt
deleted file mode 100644
index 70a1c36faef..00000000000
--- a/core/builtins/src/kotlin/reflect/KMemberFunction.kt
+++ /dev/null
@@ -1,26 +0,0 @@
-/*
- * Copyright 2010-2015 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.reflect
-
-/**
- * Represents a member function.
- *
- * @param T the type of the instance which should be used to call the function.
- *          Must be derived either from a class declaring this function, or any subclass of that class.
- * @param R the return type of the function.
- */
-public interface KMemberFunction<in T : Any, out R> : KFunction<R>
diff --git a/core/builtins/src/kotlin/reflect/KMemberProperty.kt b/core/builtins/src/kotlin/reflect/KMemberProperty.kt
deleted file mode 100644
index 58c4d9f2ab1..00000000000
--- a/core/builtins/src/kotlin/reflect/KMemberProperty.kt
+++ /dev/null
@@ -1,46 +0,0 @@
-/*
- * Copyright 2010-2015 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.reflect
-
-/**
- * Represents a property declared in a class.
- *
- * @param T the type of the instance which should be used to obtain the value of the property.
- *          Must be derived either from a class declaring this property, or any subclass of that class.
- * @param R the type of the property.
- */
-public interface KMemberProperty<T : Any, out R> : KProperty<R> {
-    /**
-     * Returns the current value of the property.
-     *
-     * @param instance the instance to obtain the value of the property from.
-     */
-    public fun get(instance: T): R
-}
-
-/**
- * Represents a `var` property declared in a class.
- */
-public interface KMutableMemberProperty<T : Any, R> : KMemberProperty<T, R>, KMutableProperty<R> {
-    /**
-     * Modifies the value of the property.
-     *
-     * @param instance the instance to obtain the value of the property from.
-     * @param value the new value to be assigned to this property.
-     */
-    public fun set(instance: T, value: R)
-}
diff --git a/core/builtins/src/kotlin/reflect/KPackage.kt b/core/builtins/src/kotlin/reflect/KPackage.kt
index 1f26a51565b..a2788d14ac9 100644
--- a/core/builtins/src/kotlin/reflect/KPackage.kt
+++ b/core/builtins/src/kotlin/reflect/KPackage.kt
@@ -19,4 +19,4 @@ package kotlin.reflect
 /**
  * Represents a package and provides introspection capabilities.
  */
-public interface KPackage
+public interface KPackage : KDeclarationContainer
diff --git a/core/builtins/src/kotlin/reflect/KProperty.kt b/core/builtins/src/kotlin/reflect/KProperty.kt
index 10f4a3508a2..32cca5e069d 100644
--- a/core/builtins/src/kotlin/reflect/KProperty.kt
+++ b/core/builtins/src/kotlin/reflect/KProperty.kt
@@ -24,9 +24,155 @@ package kotlin.reflect
  *
  * @param R the type of the property.
  */
-public interface KProperty<out R> : KCallable<R>
+public interface KProperty<out R> : KCallable<R> {
+    /** The getter of this property, used to obtain the value of the property. */
+    public val getter: Getter<R>
+
+    /**
+     * Represents a property accessor, which is a `get` or `set` method declared alongside the property.
+     * See the [Kotlin language documentation](http://kotlinlang.org/docs/reference/properties.html#getters-and-setters)
+     * for more information.
+     *
+     * @param R the type of the property, which it is an accessor of.
+     */
+    public interface Accessor<out R> {
+        /** The property which this accessor is originated from. */
+        public val property: KProperty<R>
+    }
+
+    /**
+     * Getter of the property is a `get` method declared alongside the property.
+     */
+    public interface Getter<out R> : Accessor<R>, KFunction<R>
+}
 
 /**
  * Represents a property declared as a `var`.
  */
-public interface KMutableProperty<R> : KProperty<R>
+public interface KMutableProperty<R> : KProperty<R> {
+    /** The setter of this mutable property, used to change the value of the property. */
+    public val setter: Setter<R>
+
+    /**
+     * Setter of the property is a `set` method declared alongside the property.
+     */
+    public interface Setter<R> : KProperty.Accessor<R>, KFunction<Unit>
+}
+
+
+/**
+ * Represents a property without any kind of receiver.
+ * Such property is either originally declared in a receiverless context such as a package,
+ * or has the receiver bound to it.
+ */
+public interface KProperty0<out R> : KProperty<R> {
+    /**
+     * Returns the current value of the property.
+     */
+    public fun get(): R
+
+    override val getter: Getter<R>
+
+    public interface Getter<out R> : KProperty.Getter<R>, () -> R
+}
+
+/**
+ * Represents a `var`-property without any kind of receiver.
+ */
+public interface KMutableProperty0<R> : KProperty0<R>, KMutableProperty<R> {
+    /**
+     * Modifies the value of the property.
+     *
+     * @param value the new value to be assigned to this property.
+     */
+    public fun set(value: R)
+
+    override val setter: Setter<R>
+
+    public interface Setter<R> : KMutableProperty.Setter<R>, (R) -> Unit
+}
+
+
+/**
+ * Represents a property, operations on which take one receiver as a parameter.
+ *
+ * @param T the type of the receiver which should be used to obtain the value of the property.
+ * @param R the type of the property.
+ */
+public interface KProperty1<T, out R> : KProperty<R> {
+    /**
+     * Returns the current value of the property.
+     *
+     * @param receiver the receiver which is used to obtain the value of the property.
+     *                 For example, it should be a class instance if this is a member property of that class,
+     *                 or an extension receiver if this is a top level extension property.
+     */
+    public fun get(receiver: T): R
+
+    override val getter: Getter<T, R>
+
+    public interface Getter<T, out R> : KProperty.Getter<R>, (T) -> R
+}
+
+/**
+ * Represents a `var`-property, operations on which take one receiver as a parameter.
+ */
+public interface KMutableProperty1<T, R> : KProperty1<T, R>, KMutableProperty<R> {
+    /**
+     * Modifies the value of the property.
+     *
+     * @param receiver the receiver which is used to modify the value of the property.
+     *                 For example, it should be a class instance if this is a member property of that class,
+     *                 or an extension receiver if this is a top level extension property.
+     * @param value the new value to be assigned to this property.
+     */
+    public fun set(receiver: T, value: R)
+
+    override val setter: Setter<T, R>
+
+    public interface Setter<T, R> : KMutableProperty.Setter<R>, (T, R) -> Unit
+}
+
+
+/**
+ * Represents a property, operations on which take two receivers as parameters,
+ * such as an extension property declared in a class.
+ *
+ * @param D the type of the first receiver. In case of the extension property in a class this is
+ *        the type of the declaring class of the property, or any subclass of that class.
+ * @param E the type of the second receiver. In case of the extension property in a class this is
+ *        the type of the extension receiver.
+ * @param R the type of the property.
+ */
+public interface KProperty2<D, E, out R> : KProperty<R> {
+    /**
+     * Returns the current value of the property. In case of the extension property in a class,
+     * the instance of the class should be passed first and the instance of the extension receiver second.
+     *
+     * @param receiver1 the instance of the first receiver.
+     * @param receiver2 the instance of the second receiver.
+     */
+    public fun get(receiver1: D, receiver2: E): R
+
+    override val getter: Getter<D, E, R>
+
+    public interface Getter<D, E, out R> : KProperty.Getter<R>, (D, E) -> R
+}
+
+/**
+ * Represents a `var`-property, operations on which take two receivers as parameters.
+ */
+public interface KMutableProperty2<D, E, R> : KProperty2<D, E, R>, KMutableProperty<R> {
+    /**
+     * Modifies the value of the property.
+     *
+     * @param receiver1 the instance of the first receiver.
+     * @param receiver2 the instance of the second receiver.
+     * @param value the new value to be assigned to this property.
+     */
+    public fun set(receiver1: D, receiver2: E, value: R)
+
+    override val setter: Setter<D, E, R>
+
+    public interface Setter<D, E, R> : KMutableProperty.Setter<R>, (D, E, R) -> Unit
+}
diff --git a/core/builtins/src/kotlin/reflect/KVariable.kt b/core/builtins/src/kotlin/reflect/KVariable.kt
deleted file mode 100644
index 100e149a5c0..00000000000
--- a/core/builtins/src/kotlin/reflect/KVariable.kt
+++ /dev/null
@@ -1,41 +0,0 @@
-/*
- * Copyright 2010-2015 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.reflect
-
-/**
- * Represents a property without any kind of receiver.
- * Such property is either originally declared in a receiverless context such as a package,
- * or has the receiver bound to it.
- */
-public interface KVariable<out R> : KProperty<R> {
-    /**
-     * Returns the current value of the variable.
-     */
-    public fun get(): R
-}
-
-/**
- * Represents a variable declared as a `var`.
- */
-public interface KMutableVariable<R> : KVariable<R>, KMutableProperty<R> {
-    /**
-     * Modifies the value of the variable.
-     *
-     * @param value the new value to be assigned to this variable.
-     */
-    public fun set(value: R)
-}
diff --git a/core/builtins/src/kotlin/reflect/_Deprecated.kt b/core/builtins/src/kotlin/reflect/_Deprecated.kt
new file mode 100644
index 00000000000..04a023bbf52
--- /dev/null
+++ b/core/builtins/src/kotlin/reflect/_Deprecated.kt
@@ -0,0 +1,29 @@
+/*
+ * Copyright 2010-2015 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.reflect
+
+@deprecated("This class will be dropped in M13 because it was a part of an overly complex API. Use KFunction instead")
+public interface KTopLevelFunction<out R> : KFunction<R>
+
+@deprecated("This class will be dropped in M13 because it was a part of an overly complex API. Use KFunction instead")
+public interface KTopLevelExtensionFunction<in E, out R>
+
+@deprecated("This class will be dropped in M13 because it was a part of an overly complex API. Use KFunction instead")
+public interface KMemberFunction<in T, out R> : KFunction<R>
+
+@deprecated("This class will be dropped in M13 because it was a part of an overly complex API. Use KFunction instead")
+public interface KLocalFunction<out R> : KFunction<R>
diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/FakePureImplementationsProvider.kt b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/FakePureImplementationsProvider.kt
new file mode 100644
index 00000000000..b416ae514f7
--- /dev/null
+++ b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/FakePureImplementationsProvider.kt
@@ -0,0 +1,47 @@
+/*
+ * Copyright 2010-2015 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.kotlin.load.java
+
+import org.jetbrains.kotlin.builtins.KotlinBuiltIns
+import org.jetbrains.kotlin.name.FqName
+import org.jetbrains.kotlin.resolve.DescriptorUtils
+
+public object FakePureImplementationsProvider {
+    public fun getPurelyImplementedInterface(classFqName: FqName): FqName? = when(classFqName) {
+        in MUTABLE_LISTS_IMPLEMENTATIONS -> MUTABLE_LIST_FQ_NAME
+        in MUTABLE_MAPS_IMPLEMENTATIONS -> MUTABLE_MAP_FQ_NAME
+        in MUTABLE_SETS_IMPLEMENTATIONS -> MUTABLE_SET_FQ_NAME
+        else -> null
+    }
+
+    private val kotlinBuiltins = KotlinBuiltIns.getInstance()
+
+    private val MUTABLE_LIST_FQ_NAME = DescriptorUtils.getFqNameSafe(kotlinBuiltins.getMutableList())
+    private val MUTABLE_SET_FQ_NAME = DescriptorUtils.getFqNameSafe(kotlinBuiltins.getMutableSet())
+    private val MUTABLE_MAP_FQ_NAME = DescriptorUtils.getFqNameSafe(kotlinBuiltins.getMutableMap())
+
+    private val MUTABLE_LISTS_IMPLEMENTATIONS = setOfFqNames("java.util.ArrayList", "java.util.LinkedList")
+    private val MUTABLE_MAPS_IMPLEMENTATIONS = setOfFqNames(
+            "java.util.HashMap", "java.util.TreeMap", "java.util.LinkedHashMap",
+            "java.util.concurrent.ConcurrentHashMap", "java.util.concurrent.ConcurrentSkipListMap"
+    )
+    private val MUTABLE_SETS_IMPLEMENTATIONS = setOfFqNames(
+            "java.util.HashSet", "java.util.TreeSet", "java.util.LinkedHashSet"
+    )
+}
+
+private fun setOfFqNames(vararg names: String) = names.map { FqName(it) }.toSet()
diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/JvmAbi.java b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/JvmAbi.java
index 5fe52492bad..b0afee8d1dc 100644
--- a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/JvmAbi.java
+++ b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/JvmAbi.java
@@ -16,6 +16,7 @@
 
 package org.jetbrains.kotlin.load.java;
 
+import kotlin.KotlinPackage;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.name.ClassId;
 import org.jetbrains.kotlin.name.FqName;
@@ -45,10 +46,6 @@ public final class JvmAbi {
     public static final String KOTLIN_PACKAGE_FIELD_NAME = "$kotlinPackage";
     public static final ClassId REFLECTION_FACTORY_IMPL = ClassId.topLevel(new FqName("kotlin.reflect.jvm.internal.ReflectionFactoryImpl"));
 
-    //TODO: To be removed after kotlin M11
-    @Deprecated
-    public static final String DEPRECATED_COMPANION_OBJECT_FIELD = "OBJECT$";
-
     @NotNull
     public static String getSyntheticMethodNameForAnnotatedProperty(@NotNull Name propertyName) {
         return propertyName.asString() + ANNOTATED_PROPERTY_METHOD_NAME_SUFFIX;
@@ -59,10 +56,21 @@ public final class JvmAbi {
         return isDelegated ? propertyName.asString() + DELEGATED_PROPERTY_NAME_SUFFIX : propertyName.asString();
     }
 
-    public static boolean isAccessorName(String name) {
-        return name.startsWith(GETTER_PREFIX) || name.startsWith(SETTER_PREFIX);
+    @NotNull
+    public static String getterName(@NotNull String propertyName) {
+        return GETTER_PREFIX + capitalizeWithJavaBeanConvention(propertyName);
     }
 
-    private JvmAbi() {
+    @NotNull
+    public static String setterName(@NotNull String propertyName) {
+        return SETTER_PREFIX + capitalizeWithJavaBeanConvention(propertyName);
+    }
+
+    /**
+     * @see com.intellij.openapi.util.text.StringUtil#capitalizeWithJavaBeanConvention(String)
+     */
+    @NotNull
+    private static String capitalizeWithJavaBeanConvention(@NotNull String s) {
+        return s.length() > 1 && Character.isUpperCase(s.charAt(1)) ? s : KotlinPackage.capitalize(s);
     }
 }
diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/JvmAnnotationNames.java b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/JvmAnnotationNames.java
index 7ff48a45ae4..c3ff64321d4 100644
--- a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/JvmAnnotationNames.java
+++ b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/JvmAnnotationNames.java
@@ -44,6 +44,12 @@ public final class JvmAnnotationNames {
     public static final FqName JETBRAINS_MUTABLE_ANNOTATION = new FqName("org.jetbrains.annotations.Mutable");
     public static final FqName JETBRAINS_READONLY_ANNOTATION = new FqName("org.jetbrains.annotations.ReadOnly");
 
+    public static final FqName PURELY_IMPLEMENTS_ANNOTATION = new FqName("kotlin.jvm.PurelyImplements");
+
+    // Just for internal use: there is no such real classes in bytecode
+    public static final FqName ENHANCED_NULLABILITY_ANNOTATION = new FqName("kotlin.jvm.internal.EnhancedNullability");
+    public static final FqName ENHANCED_MUTABILITY_ANNOTATION = new FqName("kotlin.jvm.internal.EnhancedMutability");
+
     public static class KotlinClass {
         public static final JvmClassName CLASS_NAME = JvmClassName.byInternalName("kotlin/jvm/internal/KotlinClass");
         public static final ClassId KIND_CLASS_ID =
diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/components/DescriptorResolverUtils.java b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/components/DescriptorResolverUtils.java
index 5339279af47..bc930f714a6 100644
--- a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/components/DescriptorResolverUtils.java
+++ b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/components/DescriptorResolverUtils.java
@@ -54,7 +54,7 @@ public final class DescriptorResolverUtils {
                 new OverridingUtil.DescriptorSink() {
                     @Override
                     @SuppressWarnings("unchecked")
-                    public void addToScope(@NotNull CallableMemberDescriptor fakeOverride) {
+                    public void addFakeOverride(@NotNull CallableMemberDescriptor fakeOverride) {
                         OverridingUtil.resolveUnknownVisibilityForMember(fakeOverride, new Function1<CallableMemberDescriptor, Unit>() {
                             @Override
                             public Unit invoke(@NotNull CallableMemberDescriptor descriptor) {
diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/descriptors/JavaCallableMemberDescriptor.java b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/descriptors/JavaCallableMemberDescriptor.java
index 83381073306..c64326a2bf3 100644
--- a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/descriptors/JavaCallableMemberDescriptor.java
+++ b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/descriptors/JavaCallableMemberDescriptor.java
@@ -16,7 +16,19 @@
 
 package org.jetbrains.kotlin.load.java.descriptors;
 
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor;
+import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor;
+import org.jetbrains.kotlin.types.JetType;
+
+import java.util.List;
 
 public interface JavaCallableMemberDescriptor extends CallableMemberDescriptor {
+    @NotNull
+    JavaCallableMemberDescriptor enhance(
+            @Nullable JetType enhancedReceiverType,
+            @NotNull List<JetType> enhancedValueParametersTypes,
+            @NotNull JetType enhancedReturnType
+    );
 }
diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/descriptors/JavaConstructorDescriptor.java b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/descriptors/JavaConstructorDescriptor.java
index 562e767dff2..4343f749847 100644
--- a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/descriptors/JavaConstructorDescriptor.java
+++ b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/descriptors/JavaConstructorDescriptor.java
@@ -18,12 +18,12 @@ package org.jetbrains.kotlin.load.java.descriptors;
 
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.descriptors.ClassDescriptor;
-import org.jetbrains.kotlin.descriptors.DeclarationDescriptor;
-import org.jetbrains.kotlin.descriptors.FunctionDescriptor;
-import org.jetbrains.kotlin.descriptors.SourceElement;
+import org.jetbrains.kotlin.descriptors.*;
 import org.jetbrains.kotlin.descriptors.annotations.Annotations;
 import org.jetbrains.kotlin.descriptors.impl.ConstructorDescriptorImpl;
+import org.jetbrains.kotlin.types.JetType;
+
+import java.util.List;
 
 public class JavaConstructorDescriptor extends ConstructorDescriptorImpl implements JavaCallableMemberDescriptor {
     private Boolean hasStableParameterNames = null;
@@ -92,4 +92,27 @@ public class JavaConstructorDescriptor extends ConstructorDescriptorImpl impleme
         result.setHasSynthesizedParameterNames(hasSynthesizedParameterNames());
         return result;
     }
+
+    @Override
+    @NotNull
+    public JavaConstructorDescriptor enhance(
+            @Nullable JetType enhancedReceiverType,
+            @NotNull List<JetType> enhancedValueParametersTypes,
+            @NotNull JetType enhancedReturnType
+    ) {
+        JavaConstructorDescriptor enhanced = createSubstitutedCopy(getContainingDeclaration(), getOriginal(), getKind());
+        // We do not use doSubstitute here as in JavaMethodDescriptor.enhance because type parameters of constructor belongs to class
+        enhanced.initialize(
+                enhancedReceiverType,
+                getDispatchReceiverParameter(),
+                getTypeParameters(),
+                DescriptorsPackage.createEnhancedValueParameters(enhancedValueParametersTypes, getValueParameters(), enhanced),
+                enhancedReturnType,
+                getModality(),
+                getVisibility()
+        );
+
+        return enhanced;
+    }
+
 }
diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/descriptors/JavaMethodDescriptor.java b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/descriptors/JavaMethodDescriptor.java
index 92bb1269271..e9f9b2aa4b8 100644
--- a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/descriptors/JavaMethodDescriptor.java
+++ b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/descriptors/JavaMethodDescriptor.java
@@ -18,14 +18,14 @@ package org.jetbrains.kotlin.load.java.descriptors;
 
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.descriptors.DeclarationDescriptor;
-import org.jetbrains.kotlin.descriptors.FunctionDescriptor;
-import org.jetbrains.kotlin.descriptors.SimpleFunctionDescriptor;
-import org.jetbrains.kotlin.descriptors.SourceElement;
+import org.jetbrains.kotlin.descriptors.*;
 import org.jetbrains.kotlin.descriptors.annotations.Annotations;
-import org.jetbrains.kotlin.descriptors.impl.FunctionDescriptorImpl;
 import org.jetbrains.kotlin.descriptors.impl.SimpleFunctionDescriptorImpl;
 import org.jetbrains.kotlin.name.Name;
+import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.TypeSubstitutor;
+
+import java.util.List;
 
 public class JavaMethodDescriptor extends SimpleFunctionDescriptorImpl implements JavaCallableMemberDescriptor {
     private Boolean hasStableParameterNames = null;
@@ -74,7 +74,7 @@ public class JavaMethodDescriptor extends SimpleFunctionDescriptorImpl implement
 
     @NotNull
     @Override
-    protected FunctionDescriptorImpl createSubstitutedCopy(
+    protected JavaMethodDescriptor createSubstitutedCopy(
             @NotNull DeclarationDescriptor newOwner,
             @Nullable FunctionDescriptor original,
             @NotNull Kind kind
@@ -91,4 +91,34 @@ public class JavaMethodDescriptor extends SimpleFunctionDescriptorImpl implement
         result.setHasSynthesizedParameterNames(hasSynthesizedParameterNames());
         return result;
     }
+
+
+
+    @Override
+    @NotNull
+    public JavaMethodDescriptor enhance(
+            @Nullable JetType enhancedReceiverType,
+            @NotNull List<JetType> enhancedValueParametersTypes,
+            @NotNull JetType enhancedReturnType
+    ) {
+        List<ValueParameterDescriptor> enhancedValueParameters =
+                DescriptorsPackage.createEnhancedValueParameters(enhancedValueParametersTypes, getValueParameters(), this);
+
+        // We use `doSubstitute` here because it does exactly what we need:
+        // 1. creates full copy of descriptor
+        // 2. copies method's type parameters (with new containing declaration) and properly substitute to them in value parameters, return type and etc.
+        JavaMethodDescriptor enhancedMethod = (JavaMethodDescriptor) doSubstitute(
+                TypeSubstitutor.EMPTY, getContainingDeclaration(), getModality(), getVisibility(), getOriginal(),
+                /* copyOverrides = */ false, getKind(),
+                enhancedValueParameters, enhancedReceiverType, enhancedReturnType
+        );
+
+        assert enhancedMethod != null : "null after substitution while enhancing " + toString();
+
+        for (FunctionDescriptor overridden : getOverriddenDescriptors()) {
+            enhancedMethod.addOverriddenDescriptor(overridden);
+        }
+
+        return enhancedMethod;
+    }
 }
diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/descriptors/JavaPropertyDescriptor.java b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/descriptors/JavaPropertyDescriptor.java
index 0fff0babcb1..5bcfa77bde4 100644
--- a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/descriptors/JavaPropertyDescriptor.java
+++ b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/descriptors/JavaPropertyDescriptor.java
@@ -17,13 +17,14 @@
 package org.jetbrains.kotlin.load.java.descriptors;
 
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.kotlin.descriptors.DeclarationDescriptor;
-import org.jetbrains.kotlin.descriptors.Modality;
-import org.jetbrains.kotlin.descriptors.SourceElement;
-import org.jetbrains.kotlin.descriptors.Visibility;
+import org.jetbrains.annotations.Nullable;
+import org.jetbrains.kotlin.descriptors.*;
 import org.jetbrains.kotlin.descriptors.annotations.Annotations;
 import org.jetbrains.kotlin.descriptors.impl.PropertyDescriptorImpl;
 import org.jetbrains.kotlin.name.Name;
+import org.jetbrains.kotlin.types.JetType;
+
+import java.util.List;
 
 public class JavaPropertyDescriptor extends PropertyDescriptorImpl implements JavaCallableMemberDescriptor {
     public JavaPropertyDescriptor(
@@ -32,13 +33,46 @@ public class JavaPropertyDescriptor extends PropertyDescriptorImpl implements Ja
             @NotNull Visibility visibility,
             boolean isVar,
             @NotNull Name name,
-            @NotNull SourceElement source
+            @NotNull SourceElement source,
+            @Nullable PropertyDescriptor original
     ) {
-        super(containingDeclaration, null, annotations, Modality.FINAL, visibility, isVar, name, Kind.DECLARATION, source);
+        super(containingDeclaration, original, annotations, Modality.FINAL, visibility, isVar, name, Kind.DECLARATION, source);
     }
 
     @Override
     public boolean hasSynthesizedParameterNames() {
         return false;
     }
+
+    @NotNull
+    @Override
+    public JavaCallableMemberDescriptor enhance(
+            @Nullable JetType enhancedReceiverType,
+            @NotNull List<JetType> enhancedValueParametersTypes,
+            @NotNull JetType enhancedReturnType
+    ) {
+        JavaPropertyDescriptor enhanced = new JavaPropertyDescriptor(
+                getContainingDeclaration(),
+                getAnnotations(),
+                getVisibility(),
+                isVar(),
+                getName(),
+                getSource(),
+                getOriginal()
+        );
+        assert getGetter() == null : "Field must not have a getter: " + this;
+        assert getSetter() == null : "Field must not have a setter: " + this;
+        enhanced.initialize(null, null);
+        enhanced.setSetterProjectedOut(isSetterProjectedOut());
+        if (compileTimeInitializer != null) {
+            enhanced.setCompileTimeInitializer(compileTimeInitializer);
+        }
+        enhanced.setType(
+                enhancedReturnType,
+                getTypeParameters(), // TODO
+                getDispatchReceiverParameter(),
+                enhancedReceiverType
+        );
+        return enhanced;
+    }
 }
diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/descriptors/SamConstructorDescriptor.kt b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/descriptors/SamConstructorDescriptor.kt
index aa76c4a5ac8..5d755f6c8fc 100644
--- a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/descriptors/SamConstructorDescriptor.kt
+++ b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/descriptors/SamConstructorDescriptor.kt
@@ -35,4 +35,6 @@ public class SamConstructorDescriptor(
 
 public object SamConstructorDescriptorKindExclude : DescriptorKindExclude {
     override fun matches(descriptor: DeclarationDescriptor) = descriptor is SamConstructorDescriptor
+
+    override val fullyExcludedDescriptorKinds: Int get() = 0
 }
diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/descriptors/util.kt b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/descriptors/util.kt
new file mode 100644
index 00000000000..870c29cc493
--- /dev/null
+++ b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/descriptors/util.kt
@@ -0,0 +1,49 @@
+/*
+ * Copyright 2010-2015 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.kotlin.load.java.descriptors
+
+import org.jetbrains.kotlin.descriptors.CallableDescriptor
+import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor
+import org.jetbrains.kotlin.descriptors.impl.ValueParameterDescriptorImpl
+import org.jetbrains.kotlin.resolve.descriptorUtil.module
+import org.jetbrains.kotlin.types.JetType
+
+fun createEnhancedValueParameters(
+        enhancedTypes: Collection<JetType>,
+        oldValueParameters: Collection<ValueParameterDescriptor>,
+        newOwner: CallableDescriptor
+): List<ValueParameterDescriptor> {
+    assert(enhancedTypes.size() == oldValueParameters.size()) {
+        "Different value parameters sizes: Enhanced = ${enhancedTypes.size()}, Old = ${oldValueParameters.size()}"
+    }
+
+    return enhancedTypes.zip(oldValueParameters).map {
+        pair ->
+        val (newType, oldParameter) = pair
+        ValueParameterDescriptorImpl(
+                newOwner,
+                null,
+                oldParameter.getIndex(),
+                oldParameter.getAnnotations(),
+                oldParameter.getName(),
+                newType,
+                oldParameter.declaresDefaultValue(),
+                if (oldParameter.getVarargElementType() != null) newOwner.module.builtIns.getArrayElementType(newType) else null,
+                oldParameter.getSource()
+        )
+    }
+}
diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/LazyJavaAnnotations.kt b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/LazyJavaAnnotations.kt
index 3c5ab696ad9..af921d85906 100644
--- a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/LazyJavaAnnotations.kt
+++ b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/LazyJavaAnnotations.kt
@@ -44,29 +44,5 @@ class LazyJavaAnnotations(
     override fun isEmpty() = !iterator().hasNext()
 }
 
-class FilteredAnnotations(
-        private val delegate: Annotations,
-        private val fqNameFilter: (FqName) -> Boolean
-) : Annotations {
-    override fun findAnnotation(fqName: FqName) =
-            if (fqNameFilter(fqName)) delegate.findAnnotation(fqName)
-            else null
-
-    override fun findExternalAnnotation(fqName: FqName) =
-            if (fqNameFilter(fqName)) delegate.findExternalAnnotation(fqName)
-            else null
-
-    override fun iterator() = delegate.asSequence()
-            .filter { annotation ->
-                val descriptor = annotation.getType().getConstructor().getDeclarationDescriptor()
-                descriptor != null && DescriptorUtils.getFqName(descriptor).let { fqName ->
-                    fqName.isSafe() && fqNameFilter(fqName.toSafe())
-                }
-            }
-            .iterator()
-
-    override fun isEmpty() = !iterator().hasNext()
-}
-
 fun LazyJavaResolverContext.resolveAnnotations(annotationsOwner: JavaAnnotationOwner): Annotations
         = LazyJavaAnnotations(this, annotationsOwner)
diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/ModuleClassResolver.kt b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/ModuleClassResolver.kt
index cba15f0dfba..3d1653726aa 100644
--- a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/ModuleClassResolver.kt
+++ b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/ModuleClassResolver.kt
@@ -32,6 +32,7 @@ public class SingleModuleClassResolver() : ModuleClassResolver {
         return resolver!!.resolveClass(javaClass)
     }
 
+    // component dependency cycle
     var resolver: JavaDescriptorResolver? = null
         @Inject set
 }
diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaAnnotationDescriptor.kt b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaAnnotationDescriptor.kt
index 09027521512..7be9187d8cb 100644
--- a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaAnnotationDescriptor.kt
+++ b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaAnnotationDescriptor.kt
@@ -30,7 +30,8 @@ import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.platform.JavaToKotlinClassMap
 import org.jetbrains.kotlin.renderer.DescriptorRenderer
-import org.jetbrains.kotlin.resolve.constants.*
+import org.jetbrains.kotlin.resolve.constants.ConstantValue
+import org.jetbrains.kotlin.resolve.constants.ConstantValueFactory
 import org.jetbrains.kotlin.resolve.descriptorUtil.resolveTopLevelClass
 import org.jetbrains.kotlin.resolve.jvm.PLATFORM_TYPES
 import org.jetbrains.kotlin.types.*
@@ -64,6 +65,8 @@ class LazyJavaAnnotationDescriptor(
         annotationClass?.getDefaultType() ?: ErrorUtils.createErrorType(fqName.asString())
     }
 
+    private val factory = ConstantValueFactory(c.module.builtIns)
+
     override fun getType(): JetType = type()
 
     private val allValueArguments = c.storageManager.createLazyValue {
@@ -72,7 +75,7 @@ class LazyJavaAnnotationDescriptor(
 
     override fun getAllValueArguments() = allValueArguments()
 
-    private fun computeValueArguments(): Map<ValueParameterDescriptor, CompileTimeConstant<*>> {
+    private fun computeValueArguments(): Map<ValueParameterDescriptor, ConstantValue<*>> {
         val constructors = getAnnotationClass().getConstructors()
         if (constructors.isEmpty()) return mapOf()
 
@@ -98,9 +101,9 @@ class LazyJavaAnnotationDescriptor(
 
     private fun getAnnotationClass() = getType().getConstructor().getDeclarationDescriptor() as ClassDescriptor
 
-    private fun resolveAnnotationArgument(argument: JavaAnnotationArgument?): CompileTimeConstant<*>? {
+    private fun resolveAnnotationArgument(argument: JavaAnnotationArgument?): ConstantValue<*>? {
         return when (argument) {
-            is JavaLiteralAnnotationArgument -> createCompileTimeConstant(argument.value, true, false, false, null)
+            is JavaLiteralAnnotationArgument -> factory.createConstantValue(argument.value)
             is JavaEnumValueAnnotationArgument -> resolveFromEnumValue(argument.resolve())
             is JavaArrayAnnotationArgument -> resolveFromArray(argument.name ?: DEFAULT_ANNOTATION_MEMBER_NAME, argument.getElements())
             is JavaAnnotationAsAnnotationArgument -> resolveFromAnnotation(argument.getAnnotation())
@@ -109,41 +112,38 @@ class LazyJavaAnnotationDescriptor(
         }
     }
 
-    private fun resolveFromAnnotation(javaAnnotation: JavaAnnotation): CompileTimeConstant<*>? {
-        val descriptor = c.resolveAnnotation(javaAnnotation)
-        if (descriptor == null) return null
+    private fun resolveFromAnnotation(javaAnnotation: JavaAnnotation): ConstantValue<*>? {
+        val descriptor = c.resolveAnnotation(javaAnnotation) ?: return null
 
-        return AnnotationValue(descriptor)
+        return factory.createAnnotationValue(descriptor)
     }
 
-    private fun resolveFromArray(argumentName: Name, elements: List<JavaAnnotationArgument>): CompileTimeConstant<*>? {
+    private fun resolveFromArray(argumentName: Name, elements: List<JavaAnnotationArgument>): ConstantValue<*>? {
         if (getType().isError()) return null
 
-        val valueParameter = DescriptorResolverUtils.getAnnotationParameterByName(argumentName, getAnnotationClass())
-        if (valueParameter == null) return null
+        val valueParameter = DescriptorResolverUtils.getAnnotationParameterByName(argumentName, getAnnotationClass()) ?: return null
 
         val values = elements.map {
-            argument -> resolveAnnotationArgument(argument) ?: NullValue.NULL
+            argument -> resolveAnnotationArgument(argument) ?: factory.createNullValue()
         }
-        return ArrayValue(values, valueParameter.getType(), true, values.any { it.usesVariableAsConstant() })
+        return factory.createArrayValue(values, valueParameter.getType())
     }
 
-    private fun resolveFromEnumValue(element: JavaField?): CompileTimeConstant<*>? {
+    private fun resolveFromEnumValue(element: JavaField?): ConstantValue<*>? {
         if (element == null || !element.isEnumEntry()) return null
 
         val containingJavaClass = element.getContainingClass()
 
         //TODO: (module refactoring) moduleClassResolver should be used here
-        val enumClass = c.javaClassResolver.resolveClass(containingJavaClass)
-        if (enumClass == null) return null
+        val enumClass = c.javaClassResolver.resolveClass(containingJavaClass) ?: return null
 
         val classifier = enumClass.getUnsubstitutedInnerClassesScope().getClassifier(element.getName())
         if (classifier !is ClassDescriptor) return null
 
-        return EnumValue(classifier, false)
+        return factory.createEnumValue(classifier)
     }
 
-    private fun resolveFromJavaClassObjectType(javaType: JavaType): CompileTimeConstant<*>? {
+    private fun resolveFromJavaClassObjectType(javaType: JavaType): ConstantValue<*>? {
         // Class type is never nullable in 'Foo.class' in Java
         val type = TypeUtils.makeNotNullable(c.typeResolver.transformJavaType(
                 javaType,
@@ -160,7 +160,7 @@ class LazyJavaAnnotationDescriptor(
             override fun computeMemberScope() = jlClass.getMemberScope(arguments)
         }
 
-        return KClassValue(javaClassObjectType)
+        return factory.createKClassValue(javaClassObjectType)
     }
 
     override fun toString(): String {
diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaClassDescriptor.kt b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaClassDescriptor.kt
index 3005f1a847b..a14dcc2e89c 100644
--- a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaClassDescriptor.kt
+++ b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaClassDescriptor.kt
@@ -20,6 +20,8 @@ import org.jetbrains.kotlin.builtins.KotlinBuiltIns
 import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.descriptors.annotations.Annotations
 import org.jetbrains.kotlin.descriptors.impl.ClassDescriptorBase
+import org.jetbrains.kotlin.load.java.FakePureImplementationsProvider
+import org.jetbrains.kotlin.load.java.JvmAnnotationNames
 import org.jetbrains.kotlin.load.java.components.TypeUsage
 import org.jetbrains.kotlin.load.java.descriptors.JavaClassDescriptor
 import org.jetbrains.kotlin.load.java.lazy.LazyJavaResolverContext
@@ -30,11 +32,12 @@ import org.jetbrains.kotlin.load.java.structure.JavaClass
 import org.jetbrains.kotlin.load.java.structure.JavaClassifierType
 import org.jetbrains.kotlin.load.java.structure.JavaType
 import org.jetbrains.kotlin.name.FqName
+import org.jetbrains.kotlin.name.isValidJavaFqName
+import org.jetbrains.kotlin.resolve.constants.StringValue
 import org.jetbrains.kotlin.resolve.scopes.InnerClassesScopeWrapper
 import org.jetbrains.kotlin.resolve.scopes.JetScope
-import org.jetbrains.kotlin.types.AbstractClassTypeConstructor
-import org.jetbrains.kotlin.types.JetType
-import org.jetbrains.kotlin.types.TypeConstructor
+import org.jetbrains.kotlin.types.*
+import org.jetbrains.kotlin.utils.addIfNotNull
 import org.jetbrains.kotlin.utils.toReadOnlyList
 import java.util.ArrayList
 
@@ -74,10 +77,10 @@ class LazyJavaClassDescriptor(
     private val typeConstructor = c.storageManager.createLazyValue { LazyJavaClassTypeConstructor() }
     override fun getTypeConstructor(): TypeConstructor = typeConstructor()
 
-    private val scopeForMemberLookup = LazyJavaClassMemberScope(c, this, jClass)
-    override fun getScopeForMemberLookup() = scopeForMemberLookup
+    private val unsubstitutedMemberScope = LazyJavaClassMemberScope(c, this, jClass)
+    override fun getUnsubstitutedMemberScope() = unsubstitutedMemberScope
 
-    private val innerClassesScope = InnerClassesScopeWrapper(getScopeForMemberLookup())
+    private val innerClassesScope = InnerClassesScopeWrapper(getUnsubstitutedMemberScope())
     override fun getUnsubstitutedInnerClassesScope(): JetScope = innerClassesScope
 
     private val staticScope = LazyJavaStaticClassScope(c, jClass, this)
@@ -87,14 +90,14 @@ class LazyJavaClassDescriptor(
 
     override fun getCompanionObjectDescriptor(): ClassDescriptor? = null
 
-    override fun getConstructors() = scopeForMemberLookup.constructors()
+    override fun getConstructors() = unsubstitutedMemberScope.constructors()
 
     private val annotations = c.storageManager.createLazyValue { c.resolveAnnotations(jClass) }
     override fun getAnnotations() = annotations()
 
     private val functionTypeForSamInterface = c.storageManager.createNullableLazyValue {
         c.samConversionResolver.resolveFunctionTypeIfSamInterface(this) { method ->
-            scopeForMemberLookup.resolveMethodToFunctionDescriptor(method, false)
+            unsubstitutedMemberScope.resolveMethodToFunctionDescriptor(method, false)
         }
     }
 
@@ -121,17 +124,26 @@ class LazyJavaClassDescriptor(
             val result = ArrayList<JetType>(javaTypes.size())
             val incomplete = ArrayList<JavaType>(0)
 
+            val purelyImplementedSupertype: JetType? = getPurelyImplementedSupertype()
+
             for (javaType in javaTypes) {
                 val jetType = c.typeResolver.transformJavaType(javaType, TypeUsage.SUPERTYPE.toAttributes())
                 if (jetType.isError()) {
                     incomplete.add(javaType)
                     continue
                 }
+
+                if (jetType.getConstructor() == purelyImplementedSupertype?.getConstructor()) {
+                    continue
+                }
+
                 if (!KotlinBuiltIns.isAnyOrNullableAny(jetType)) {
                     result.add(jetType)
                 }
             }
 
+            result.addIfNotNull(purelyImplementedSupertype)
+
             if (incomplete.isNotEmpty()) {
                 c.errorReporter.reportIncompleteHierarchy(getDeclarationDescriptor(), incomplete.map { javaType ->
                     (javaType as JavaClassifierType).getPresentableText()
@@ -141,6 +153,40 @@ class LazyJavaClassDescriptor(
             if (result.isNotEmpty()) result.toReadOnlyList() else listOf(c.module.builtIns.getAnyType())
         }
 
+        private fun getPurelyImplementedSupertype(): JetType? {
+            val purelyImplementedFqName = getPurelyImplementsFqNameFromAnnotation()
+                                          ?: FakePureImplementationsProvider.getPurelyImplementedInterface(fqName)
+                                          ?: return null
+
+            if (purelyImplementedFqName.parent() != KotlinBuiltIns.BUILT_INS_PACKAGE_FQ_NAME) return null
+
+            val classDescriptor = KotlinBuiltIns.getInstance().getBuiltInClassByNameNullable(purelyImplementedFqName.shortName())
+                                  ?: return null
+
+            if (classDescriptor.getTypeConstructor().getParameters().size() != getParameters().size()) return null
+
+            val parametersAsTypeProjections = getParameters().map {
+                parameter -> TypeProjectionImpl(Variance.INVARIANT, parameter.getDefaultType())
+            }
+
+            return JetTypeImpl(
+                    Annotations.EMPTY, classDescriptor.getTypeConstructor(),
+                    /* nullable =*/ false, parametersAsTypeProjections,
+                    classDescriptor.getMemberScope(parametersAsTypeProjections)
+            )
+        }
+
+        private fun getPurelyImplementsFqNameFromAnnotation(): FqName? {
+            val annotation = this@LazyJavaClassDescriptor.
+                    getAnnotations().
+                    findAnnotation(JvmAnnotationNames.PURELY_IMPLEMENTS_ANNOTATION) ?: return null
+
+            val fqNameString = (annotation.getAllValueArguments().values().singleOrNull() as? StringValue)?.value ?: return null
+            if (!isValidJavaFqName(fqNameString)) return null
+
+            return FqName(fqNameString)
+        }
+
         override fun getSupertypes(): Collection<JetType> = supertypes()
 
         override fun getAnnotations() = Annotations.EMPTY
diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaClassMemberScope.kt b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaClassMemberScope.kt
index ff353cf30bf..90951433e91 100644
--- a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaClassMemberScope.kt
+++ b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaClassMemberScope.kt
@@ -31,7 +31,12 @@ import org.jetbrains.kotlin.load.java.lazy.LazyJavaResolverContext
 import org.jetbrains.kotlin.load.java.lazy.child
 import org.jetbrains.kotlin.load.java.lazy.resolveAnnotations
 import org.jetbrains.kotlin.load.java.lazy.types.toAttributes
+import org.jetbrains.kotlin.load.java.structure.JavaArrayType
+import org.jetbrains.kotlin.load.java.structure.JavaClass
+import org.jetbrains.kotlin.load.java.structure.JavaConstructor
+import org.jetbrains.kotlin.load.java.structure.JavaMethod
 import org.jetbrains.kotlin.load.java.structure.*
+import org.jetbrains.kotlin.load.java.typeEnhacement.enhanceSignatures
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.resolve.DescriptorFactory
 import org.jetbrains.kotlin.resolve.DescriptorUtils
@@ -65,7 +70,10 @@ public class LazyJavaClassMemberScope(
             result.add(descriptor)
             result.addIfNotNull(c.samConversionResolver.resolveSamAdapter(descriptor))
         }
-        result ifEmpty { emptyOrSingletonList(createDefaultConstructor()) }
+        
+        enhanceSignatures(
+                result ifEmpty { emptyOrSingletonList(createDefaultConstructor()) }
+        ).toReadOnlyList()
     }
 
     override fun computeNonDeclaredFunctions(result: MutableCollection<SimpleFunctionDescriptor>, name: Name) {
@@ -96,7 +104,7 @@ public class LazyJavaClassMemberScope(
 
         val propertyDescriptor = JavaPropertyDescriptor(
                 getContainingDeclaration(), annotations, method.getVisibility(),
-                /* isVar = */ false, method.getName(), c.sourceElementFactory.source(method)
+                /* isVar = */ false, method.getName(), c.sourceElementFactory.source(method), /* original */ null
         )
 
         // default getter is necessary because there is no real field in annotation
@@ -204,7 +212,7 @@ public class LazyJavaClassMemberScope(
         assert(methodsNamedValue.size() <= 1) { "There can't be more than one method named 'value' in annotation class: $jClass" }
         val methodNamedValue = methodsNamedValue.firstOrNull()
         if (methodNamedValue != null) {
-            val parameterNamedValueJavaType = methodNamedValue.getAnnotationMethodReturnJavaType()
+            val parameterNamedValueJavaType = methodNamedValue.getReturnType()
             val (parameterType, varargType) =
                     if (parameterNamedValueJavaType is JavaArrayType)
                         Pair(c.typeResolver.transformArrayType(parameterNamedValueJavaType, attr, isVararg = true),
@@ -217,18 +225,13 @@ public class LazyJavaClassMemberScope(
 
         val startIndex = if (methodNamedValue != null) 1 else 0
         for ((index, method) in otherMethods.withIndex()) {
-            val parameterType = c.typeResolver.transformJavaType(method.getAnnotationMethodReturnJavaType(), attr)
+            val parameterType = c.typeResolver.transformJavaType(method.getReturnType(), attr)
             result.addAnnotationValueParameter(constructor, index + startIndex, method, parameterType, null)
         }
 
         return result
     }
 
-    private fun JavaMethod.getAnnotationMethodReturnJavaType(): JavaType {
-        assert(getValueParameters().isEmpty()) { "Annotation method can't have parameters: $this" }
-        return getReturnType() ?: throw AssertionError("Annotation method has no return type: $this")
-    }
-
     private fun MutableList<ValueParameterDescriptor>.addAnnotationValueParameter(
             constructor: ConstructorDescriptor,
             index: Int,
diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaMemberScope.kt b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaMemberScope.kt
index 556890a9074..0628b88ac3f 100644
--- a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaMemberScope.kt
+++ b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaMemberScope.kt
@@ -16,7 +16,6 @@
 
 package org.jetbrains.kotlin.load.java.lazy.descriptors
 
-import org.jetbrains.kotlin.builtins.KotlinBuiltIns
 import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.descriptors.annotations.Annotations
 import org.jetbrains.kotlin.descriptors.impl.PropertyDescriptorImpl
@@ -33,12 +32,14 @@ import org.jetbrains.kotlin.load.java.structure.JavaArrayType
 import org.jetbrains.kotlin.load.java.structure.JavaField
 import org.jetbrains.kotlin.load.java.structure.JavaMethod
 import org.jetbrains.kotlin.load.java.structure.JavaValueParameter
+import org.jetbrains.kotlin.load.java.typeEnhacement.enhanceSignatures
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.resolve.DescriptorUtils
 import org.jetbrains.kotlin.resolve.jvm.PLATFORM_TYPES
 import org.jetbrains.kotlin.resolve.scopes.DescriptorKindExclude.NonExtensions
 import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter
 import org.jetbrains.kotlin.resolve.scopes.JetScope
+import org.jetbrains.kotlin.resolve.scopes.JetScopeImpl
 import org.jetbrains.kotlin.storage.NotNullLazyValue
 import org.jetbrains.kotlin.types.JetType
 import org.jetbrains.kotlin.types.TypeUtils
@@ -51,7 +52,7 @@ import java.util.LinkedHashSet
 public abstract class LazyJavaMemberScope(
         protected val c: LazyJavaResolverContext,
         private val containingDeclaration: DeclarationDescriptor
-) : JetScope {
+) : JetScopeImpl() {
     // this lazy value is not used at all in LazyPackageFragmentScopeForJavaPackage because we do not use caching there
     // but is placed in the base class to not duplicate code
     private val allDescriptors = c.storageManager.createRecursionTolerantLazyValue<Collection<DeclarationDescriptor>>(
@@ -86,14 +87,16 @@ public abstract class LazyJavaMemberScope(
 
         computeNonDeclaredFunctions(result, name)
 
+        val enhancedResult = enhanceSignatures(result)
+
         // Make sure that lazy things are computed before we release the lock
-        for (f in result) {
+        for (f in enhancedResult) {
             for (p in f.getValueParameters()) {
                 p.hasDefaultValue()
             }
         }
 
-        result.toReadOnlyList()
+        enhancedResult.toReadOnlyList()
     }
 
     protected data class MethodSignatureData(
@@ -153,9 +156,8 @@ public abstract class LazyJavaMemberScope(
                 allowFlexible = !annotationMethod,
                 isForAnnotationParameter = annotationMethod
         )
-        val returnJavaType = method.getReturnType() ?: throw IllegalStateException("Constructor passed as method: $method")
-        // Annotation arguments are never null in Java
-        return c.typeResolver.transformJavaType(returnJavaType, returnTypeAttrs).let {
+        return c.typeResolver.transformJavaType(method.getReturnType(), returnTypeAttrs).let {
+            // Annotation arguments are never null in Java
             if (annotationMethod) TypeUtils.makeNotNullable(it) else it
         }
     }
@@ -178,7 +180,7 @@ public abstract class LazyJavaMemberScope(
                         val paramType = javaParameter.getType() as? JavaArrayType
                                         ?: throw AssertionError("Vararg parameter should be an array: $javaParameter")
                         val outType = c.typeResolver.transformArrayType(paramType, typeUsage, true)
-                        outType to KotlinBuiltIns.getInstance().getArrayElementType(outType)
+                        outType to c.module.builtIns.getArrayElementType(outType)
                     }
                     else {
                         c.typeResolver.transformJavaType(javaParameter.getType(), typeUsage) to null
@@ -186,7 +188,7 @@ public abstract class LazyJavaMemberScope(
 
             val name = if (function.getName().asString() == "equals" &&
                            jValueParameters.size() == 1 &&
-                           KotlinBuiltIns.getInstance().getNullableAnyType() == outType) {
+                           c.module.builtIns.getNullableAnyType() == outType) {
                 // This is a hack to prevent numerous warnings on Kotlin classes that inherit Java classes: if you override "equals" in such
                 // class without this hack, you'll be warned that in the superclass the name is "p0" (regardless of the fact that it's
                 // "other" in Any)
@@ -235,7 +237,10 @@ public abstract class LazyJavaMemberScope(
 
         computeNonDeclaredProperties(name, properties)
 
-        properties.toReadOnlyList()
+        if (DescriptorUtils.isAnnotationClass(containingDeclaration))
+            properties.toReadOnlyList()
+        else
+            enhanceSignatures(properties).toReadOnlyList()
     }
 
     private fun resolveProperty(field: JavaField): PropertyDescriptor {
@@ -271,7 +276,7 @@ public abstract class LazyJavaMemberScope(
         val propertyName = field.getName()
 
         return JavaPropertyDescriptor(containingDeclaration, annotations, visibility, isVar, propertyName,
-                                      c.sourceElementFactory.source(field))
+                                      c.sourceElementFactory.source(field), /* original = */ null)
     }
 
     private fun getPropertyType(field: JavaField, annotations: Annotations): JetType {
@@ -293,9 +298,6 @@ public abstract class LazyJavaMemberScope(
 
     override fun getProperties(name: Name): Collection<VariableDescriptor> = properties(name)
 
-    override fun getLocalVariable(name: Name): VariableDescriptor? = null
-    override fun getDeclarationsByLabel(labelName: Name) = listOf<DeclarationDescriptor>()
-
     override fun getOwnDeclaredDescriptors() = getDescriptors()
 
     override fun getDescriptors(kindFilter: DescriptorKindFilter,
@@ -349,7 +351,7 @@ public abstract class LazyJavaMemberScope(
         p.println(javaClass.getSimpleName(), " {")
         p.pushIndent()
 
-        p.println("containigDeclaration: ${getContainingDeclaration()}")
+        p.println("containingDeclaration: ${getContainingDeclaration()}")
 
         p.popIndent()
         p.println("}")
diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/types/LazyJavaTypeResolver.kt b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/types/LazyJavaTypeResolver.kt
index 4d46b4913be..c53b66ebf50 100644
--- a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/types/LazyJavaTypeResolver.kt
+++ b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/types/LazyJavaTypeResolver.kt
@@ -20,10 +20,12 @@ import org.jetbrains.kotlin.builtins.KotlinBuiltIns
 import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor
 import org.jetbrains.kotlin.descriptors.annotations.Annotations
+import org.jetbrains.kotlin.descriptors.annotations.CompositeAnnotations
+import org.jetbrains.kotlin.descriptors.annotations.FilteredAnnotations
 import org.jetbrains.kotlin.load.java.JvmAnnotationNames.*
 import org.jetbrains.kotlin.load.java.components.TypeUsage
 import org.jetbrains.kotlin.load.java.components.TypeUsage.*
-import org.jetbrains.kotlin.load.java.lazy.FilteredAnnotations
+import org.jetbrains.kotlin.load.java.lazy.LazyJavaAnnotations
 import org.jetbrains.kotlin.load.java.lazy.LazyJavaResolverContext
 import org.jetbrains.kotlin.load.java.lazy.TypeParameterResolver
 import org.jetbrains.kotlin.load.java.lazy.types.JavaTypeFlexibility.FLEXIBLE_LOWER_BOUND
@@ -110,6 +112,7 @@ class LazyJavaTypeResolver(
             private val javaType: JavaClassifierType,
             private val attr: JavaTypeAttributes
     ) : AbstractLazyType(c.storageManager) {
+        private val annotations = CompositeAnnotations(listOf(LazyJavaAnnotations(c, javaType), attr.typeAnnotations))
 
         private val classifier = c.storageManager.createNullableLazyValue { javaType.getClassifier() }
 
@@ -162,7 +165,7 @@ class LazyJavaTypeResolver(
             val kotlinDescriptor = javaToKotlin.mapJavaToKotlin(fqName) ?: return null
 
             if (howThisTypeIsUsedEffectively == MEMBER_SIGNATURE_COVARIANT || howThisTypeIsUsedEffectively == SUPERTYPE) {
-                if (javaToKotlin.isReadOnlyCollection(kotlinDescriptor)) {
+                if (javaToKotlin.isReadOnly(kotlinDescriptor)) {
                     return javaToKotlin.convertReadOnlyToMutable(kotlinDescriptor)
                 }
             }
@@ -291,7 +294,7 @@ class LazyJavaTypeResolver(
 
         override fun isMarkedNullable(): Boolean = nullable()
 
-        override fun getAnnotations() = attr.typeAnnotations
+        override fun getAnnotations() = annotations
     }
 
     public object FlexibleJavaClassifierTypeCapabilities : FlexibleTypeCapabilities {
diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/structure/JavaClassifierType.java b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/structure/JavaClassifierType.java
index d776e0de3c8..02711b38a9b 100644
--- a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/structure/JavaClassifierType.java
+++ b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/structure/JavaClassifierType.java
@@ -23,7 +23,7 @@ import org.jetbrains.annotations.ReadOnly;
 import java.util.Collection;
 import java.util.List;
 
-public interface JavaClassifierType extends JavaType {
+public interface JavaClassifierType extends JavaType, JavaAnnotationOwner {
     @Nullable
     JavaClassifier getClassifier();
 
diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/structure/JavaMethod.java b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/structure/JavaMethod.java
index 1511b7bbc2d..def254fe374 100644
--- a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/structure/JavaMethod.java
+++ b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/structure/JavaMethod.java
@@ -29,6 +29,6 @@ public interface JavaMethod extends JavaMember, JavaTypeParameterListOwner {
 
     boolean hasAnnotationParameterDefaultValue();
 
-    @Nullable
+    @NotNull
     JavaType getReturnType();
 }
diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/structure/JavaPropertyInitializerEvaluator.java b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/structure/JavaPropertyInitializerEvaluator.java
deleted file mode 100644
index 712bcb5c2a4..00000000000
--- a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/structure/JavaPropertyInitializerEvaluator.java
+++ /dev/null
@@ -1,42 +0,0 @@
-/*
- * Copyright 2010-2015 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.kotlin.load.java.structure;
-
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.descriptors.PropertyDescriptor;
-import org.jetbrains.kotlin.resolve.constants.CompileTimeConstant;
-
-public interface JavaPropertyInitializerEvaluator {
-    JavaPropertyInitializerEvaluator DO_NOTHING = new JavaPropertyInitializerEvaluator() {
-        @Nullable
-        @Override
-        public CompileTimeConstant<?> getInitializerConstant(@NotNull JavaField field, @NotNull PropertyDescriptor descriptor) {
-            return null;
-        }
-
-        @Override
-        public boolean isNotNullCompileTimeConstant(@NotNull JavaField field) {
-            return false;
-        }
-    };
-
-    @Nullable
-    CompileTimeConstant<?> getInitializerConstant(@NotNull JavaField field, @NotNull PropertyDescriptor descriptor);
-
-    boolean isNotNullCompileTimeConstant(@NotNull JavaField field);
-}
diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/structure/JavaPropertyInitializerEvaluator.kt b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/structure/JavaPropertyInitializerEvaluator.kt
new file mode 100644
index 00000000000..44f2be2af9d
--- /dev/null
+++ b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/structure/JavaPropertyInitializerEvaluator.kt
@@ -0,0 +1,32 @@
+/*
+ * Copyright 2010-2015 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.kotlin.load.java.structure
+
+import org.jetbrains.kotlin.descriptors.PropertyDescriptor
+import org.jetbrains.kotlin.resolve.constants.ConstantValue
+
+public interface JavaPropertyInitializerEvaluator {
+    public fun getInitializerConstant(field: JavaField, descriptor: PropertyDescriptor): ConstantValue<*>?
+
+    public fun isNotNullCompileTimeConstant(field: JavaField): Boolean
+
+    public object DoNothing : JavaPropertyInitializerEvaluator {
+        override fun getInitializerConstant(field: JavaField, descriptor: PropertyDescriptor) = null
+
+        override fun isNotNullCompileTimeConstant(field: JavaField) = false
+    }
+}
diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/typeEnhacement/signatureEnhancement.kt b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/typeEnhacement/signatureEnhancement.kt
new file mode 100644
index 00000000000..fdce10f2176
--- /dev/null
+++ b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/typeEnhacement/signatureEnhancement.kt
@@ -0,0 +1,79 @@
+/*
+ * Copyright 2010-2015 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.kotlin.load.java.typeEnhacement
+
+import org.jetbrains.kotlin.builtins.KotlinBuiltIns
+import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor
+import org.jetbrains.kotlin.descriptors.ParameterDescriptor
+import org.jetbrains.kotlin.descriptors.ReceiverParameterDescriptor
+import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor
+import org.jetbrains.kotlin.descriptors.impl.ValueParameterDescriptorImpl
+import org.jetbrains.kotlin.load.java.typeEnhacement.computeIndexedQualifiersForOverride
+import org.jetbrains.kotlin.load.java.descriptors.JavaCallableMemberDescriptor
+import org.jetbrains.kotlin.types.JetType
+
+public fun <D : CallableMemberDescriptor> enhanceSignatures(platformSignatures: Collection<D>): Collection<D> {
+    return platformSignatures.map {
+        it.enhance()
+    }
+}
+
+private fun <D : CallableMemberDescriptor> D.enhance(): D {
+    // TODO type parameters
+    // TODO use new type parameters while enhancing other types
+    // TODO Propagation into generic type arguments
+
+    val enhancedReceiverType =
+            if (getExtensionReceiverParameter() != null)
+                parts(isCovariant = false) { it.getExtensionReceiverParameter()!!.getType() }.enhance()
+            else null
+
+    val enhancedValueParametersTypes = getValueParameters().map {
+        p -> parts(isCovariant = false) { it.getValueParameters()[p.getIndex()].getType() }.enhance()
+    }
+
+    val enhancedReturnType = parts(isCovariant = true) { it.getReturnType()!! }.enhance()
+
+    if (this is JavaCallableMemberDescriptor) {
+        @suppress("UNCHECKED_CAST")
+        return this.enhance(enhancedReceiverType, enhancedValueParametersTypes, enhancedReturnType) as D
+    }
+
+    return this
+}
+
+private class SignatureParts(
+    val fromOverride: JetType,
+    val fromOverridden: Collection<JetType>,
+    val isCovariant: Boolean
+) {
+    fun enhance(): JetType {
+        val qualifiers = fromOverride.computeIndexedQualifiersForOverride(this.fromOverridden, isCovariant)
+        return fromOverride.enhance(qualifiers)
+    }
+}
+
+private fun <D : CallableMemberDescriptor> D.parts(isCovariant: Boolean, collector: (D) -> JetType): SignatureParts {
+    return SignatureParts(
+            collector(this),
+            this.getOverriddenDescriptors().map {
+                @suppress("UNCHECKED_CAST")
+                collector(it as D)
+            },
+            isCovariant
+    )
+}
\ No newline at end of file
diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/typeEnhacement/typeEnhancement.kt b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/typeEnhacement/typeEnhancement.kt
new file mode 100644
index 00000000000..b1d2eb30f36
--- /dev/null
+++ b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/typeEnhacement/typeEnhancement.kt
@@ -0,0 +1,184 @@
+/*
+ * Copyright 2010-2015 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.kotlin.load.java.typeEnhacement
+
+import org.jetbrains.kotlin.descriptors.ClassDescriptor
+import org.jetbrains.kotlin.descriptors.ClassifierDescriptor
+import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor
+import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptor
+import org.jetbrains.kotlin.descriptors.annotations.Annotations
+import org.jetbrains.kotlin.descriptors.annotations.CompositeAnnotations
+import org.jetbrains.kotlin.load.java.JvmAnnotationNames
+import org.jetbrains.kotlin.load.java.typeEnhacement.JavaTypeQualifiers
+import org.jetbrains.kotlin.load.java.typeEnhacement.MutabilityQualifier.MUTABLE
+import org.jetbrains.kotlin.load.java.typeEnhacement.MutabilityQualifier.READ_ONLY
+import org.jetbrains.kotlin.load.java.typeEnhacement.NullabilityQualifier.NOT_NULL
+import org.jetbrains.kotlin.load.java.typeEnhacement.NullabilityQualifier.NULLABLE
+import org.jetbrains.kotlin.name.FqName
+import org.jetbrains.kotlin.platform.JavaToKotlinClassMap
+import org.jetbrains.kotlin.resolve.constants.CompileTimeConstant
+import org.jetbrains.kotlin.types.*
+
+// The index in the lambda is the position of the type component:
+// Example: for `A<B, C<D, E>>`, indices go as follows: `0 - A<...>, 1 - B, 2 - C<D, E>, 3 - D, 4 - E`,
+// which corresponds to the left-to-right breadth-first walk of the tree representation of the type.
+// For flexible types, both bounds are indexed in the same way: `(A<B>..C<D>)` gives `0 - (A<B>..C<D>), 1 - B and D`.
+fun JetType.enhance(qualifiers: (Int) -> JavaTypeQualifiers) = this.enhancePossiblyFlexible(qualifiers, 0).type
+
+
+private enum class TypeComponentPosition {
+    FLEXIBLE_LOWER,
+    FLEXIBLE_UPPER,
+    INFLEXIBLE
+}
+
+private data class Result(val type: JetType, val subtreeSize: Int)
+
+private fun JetType.enhancePossiblyFlexible(qualifiers: (Int) -> JavaTypeQualifiers, index: Int): Result {
+    if (this.isError()) return Result(this, 1)
+    return if (this.isFlexible()) {
+        with(this.flexibility()) {
+            val lowerResult = lowerBound.enhanceInflexible(qualifiers, index, TypeComponentPosition.FLEXIBLE_LOWER)
+            val upperResult = upperBound.enhanceInflexible(qualifiers, index, TypeComponentPosition.FLEXIBLE_UPPER)
+            assert(lowerResult.subtreeSize == upperResult.subtreeSize) {
+                "Different tree sizes of bounds: " +
+                "lower = ($lowerBound, ${lowerResult.subtreeSize}), " +
+                "upper = ($upperBound, ${upperResult.subtreeSize})"
+            }
+            Result(
+                DelegatingFlexibleType.create(lowerResult.type, upperResult.type, extraCapabilities), lowerResult.subtreeSize
+            )
+        }
+    }
+    else this.enhanceInflexible(qualifiers, index, TypeComponentPosition.INFLEXIBLE)
+}
+
+private fun JetType.enhanceInflexible(qualifiers: (Int) -> JavaTypeQualifiers, index: Int, position: TypeComponentPosition): Result {
+    val shouldEnhance = position.shouldEnhance()
+    if (!shouldEnhance && getArguments().isEmpty()) return Result(this, 1)
+
+    val originalClass = getConstructor().getDeclarationDescriptor()
+                        ?: return Result(this, 1)
+
+    val effectiveQualifiers = qualifiers(index)
+    val (enhancedClassifier, enhancedMutabilityAnnotations) = originalClass.enhanceMutability(effectiveQualifiers, position)
+
+    var globalArgIndex = index + 1
+    val enhancedArguments = getArguments().mapIndexed {
+        localArgIndex, arg ->
+        if (arg.isStarProjection()) {
+            globalArgIndex++
+            TypeUtils.makeStarProjection(enhancedClassifier.getTypeConstructor().getParameters()[localArgIndex])
+        }
+        else {
+            val (enhancedType, subtreeSize) = arg.getType().enhancePossiblyFlexible(qualifiers, globalArgIndex)
+            globalArgIndex += subtreeSize
+            TypeProjectionImpl(
+                    arg.getProjectionKind(),
+                    enhancedType
+            )
+        }
+    }
+
+    val (enhancedNullability, enhancedNullabilityAnnotations) = this.getEnhancedNullability(effectiveQualifiers, position)
+    val newAnnotations = listOf(
+            getAnnotations(),
+            enhancedMutabilityAnnotations,
+            enhancedNullabilityAnnotations
+    ).filterNotNull().compositeAnnotationsOrSingle()
+
+    val enhancedType = JetTypeImpl(
+            newAnnotations,
+            enhancedClassifier.getTypeConstructor(),
+            enhancedNullability,
+            enhancedArguments,
+            if (enhancedClassifier is ClassDescriptor)
+                enhancedClassifier.getMemberScope(enhancedArguments)
+            else enhancedClassifier.getDefaultType().getMemberScope()
+    )
+    return Result(enhancedType, globalArgIndex - index)
+}
+
+private fun List<Annotations>.compositeAnnotationsOrSingle() = when (size()) {
+    0 -> error("At least one Annotations object expected")
+    1 -> single()
+    else -> CompositeAnnotations(this)
+}
+
+private fun TypeComponentPosition.shouldEnhance() = this != TypeComponentPosition.INFLEXIBLE
+
+private data class EnhancementResult<T>(val result: T, val enhancementAnnotations: Annotations?)
+private fun <T> T.noChange() = EnhancementResult(this, null)
+private fun <T> T.enhancedNullability() = EnhancementResult(this, ENHANCED_NULLABILITY_ANNOTATIONS)
+private fun <T> T.enhancedMutability() = EnhancementResult(this, ENHANCED_MUTABILITY_ANNOTATIONS)
+
+private fun ClassifierDescriptor.enhanceMutability(qualifiers: JavaTypeQualifiers, position: TypeComponentPosition): EnhancementResult<ClassifierDescriptor> {
+    if (!position.shouldEnhance()) return this.noChange()
+    if (this !is ClassDescriptor) return this.noChange() // mutability is not applicable for type parameters
+
+    val mapping = JavaToKotlinClassMap.INSTANCE
+
+    when (qualifiers.mutability) {
+        READ_ONLY -> {
+            if (position == TypeComponentPosition.FLEXIBLE_LOWER && mapping.isMutable(this)) {
+                return mapping.convertMutableToReadOnly(this).enhancedMutability()
+            }
+        }
+        MUTABLE -> {
+            if (position == TypeComponentPosition.FLEXIBLE_UPPER && mapping.isReadOnly(this) ) {
+                return mapping.convertReadOnlyToMutable(this).enhancedMutability()
+            }
+        }
+    }
+
+    return this.noChange()
+}
+
+private fun JetType.getEnhancedNullability(qualifiers: JavaTypeQualifiers, position: TypeComponentPosition): EnhancementResult<Boolean> {
+    if (!position.shouldEnhance()) return this.isMarkedNullable().noChange()
+
+    return when (qualifiers.nullability) {
+        NULLABLE -> true.enhancedNullability()
+        NOT_NULL -> false.enhancedNullability()
+        else -> this.isMarkedNullable().noChange()
+    }
+}
+
+private val ENHANCED_NULLABILITY_ANNOTATIONS = EnhancedTypeAnnotations(JvmAnnotationNames.ENHANCED_NULLABILITY_ANNOTATION)
+private val ENHANCED_MUTABILITY_ANNOTATIONS = EnhancedTypeAnnotations(JvmAnnotationNames.ENHANCED_MUTABILITY_ANNOTATION)
+
+private class EnhancedTypeAnnotations(private val fqNameToMatch: FqName) : Annotations {
+    override fun isEmpty() = false
+
+    override fun findAnnotation(fqName: FqName) = when (fqName) {
+        fqNameToMatch -> EnhancedTypeAnnotationDescriptor
+        else -> null
+    }
+
+    override fun findExternalAnnotation(fqName: FqName) = null
+
+    // Note, that this class may break Annotations contract (!isEmpty && iterator.isEmpty())
+    // It's a hack that we need unless we have stable "user data" in JetType
+    override fun iterator(): Iterator<AnnotationDescriptor> = emptyList<AnnotationDescriptor>().iterator()
+}
+
+private object EnhancedTypeAnnotationDescriptor : AnnotationDescriptor {
+    private fun throwError() = error("No methods should be called on this descriptor. Only it's presence matters")
+    override fun getType() = throwError()
+    override fun getAllValueArguments() = throwError()
+    override fun toString() = "[EnhancedType]"
+}
diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/typeEnhacement/typeQualifiers.kt b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/typeEnhacement/typeQualifiers.kt
new file mode 100644
index 00000000000..5c46b8e4d9f
--- /dev/null
+++ b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/typeEnhacement/typeQualifiers.kt
@@ -0,0 +1,165 @@
+/*
+ * Copyright 2010-2015 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.kotlin.load.java.typeEnhacement
+
+import org.jetbrains.kotlin.descriptors.annotations.Annotations
+import org.jetbrains.kotlin.load.java.JvmAnnotationNames
+import org.jetbrains.kotlin.load.java.typeEnhacement.MutabilityQualifier.MUTABLE
+import org.jetbrains.kotlin.load.java.typeEnhacement.MutabilityQualifier.READ_ONLY
+import org.jetbrains.kotlin.load.java.typeEnhacement.NullabilityQualifier.NOT_NULL
+import org.jetbrains.kotlin.load.java.typeEnhacement.NullabilityQualifier.NULLABLE
+import org.jetbrains.kotlin.name.FqName
+import org.jetbrains.kotlin.platform.JavaToKotlinClassMap
+import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.checker.JetTypeChecker
+import org.jetbrains.kotlin.types.flexibility
+import org.jetbrains.kotlin.types.isFlexible
+import java.util.ArrayList
+
+enum class NullabilityQualifier {
+    NULLABLE,
+    NOT_NULL
+}
+
+private val NULLABLE_ANNOTATIONS = listOf(
+        JvmAnnotationNames.JETBRAINS_NULLABLE_ANNOTATION
+)
+
+private val NOT_NULL_ANNOTATIONS = listOf(
+        JvmAnnotationNames.JETBRAINS_NOT_NULL_ANNOTATION
+)
+
+enum class MutabilityQualifier {
+    READ_ONLY,
+    MUTABLE
+}
+
+private val READ_ONLY_ANNOTATIONS = listOf(
+        JvmAnnotationNames.JETBRAINS_READONLY_ANNOTATION
+)
+
+private val MUTABLE_ANNOTATIONS = listOf(
+        JvmAnnotationNames.JETBRAINS_MUTABLE_ANNOTATION
+)
+
+class JavaTypeQualifiers(
+        val nullability: NullabilityQualifier?,
+        val mutability: MutabilityQualifier?
+) {
+    companion object {
+        val NONE = JavaTypeQualifiers(null, null)
+    }
+}
+
+private fun JetType.extractQualifiers(): JavaTypeQualifiers {
+    val (lower, upper) =
+            if (this.isFlexible())
+                flexibility().let { Pair(it.lowerBound, it.upperBound) }
+            else Pair(this, this)
+
+    val mapping = JavaToKotlinClassMap.INSTANCE
+    return JavaTypeQualifiers(
+            if (lower.isMarkedNullable()) NULLABLE else if (!upper.isMarkedNullable()) NOT_NULL else null,
+            if (mapping.isReadOnly(lower)) READ_ONLY else if (mapping.isMutable(upper)) MUTABLE else null
+    )
+}
+
+private fun Annotations.extractQualifiers(): JavaTypeQualifiers {
+    fun <T: Any> List<FqName>.ifPresent(qualifier: T) = if (any { findAnnotation(it) != null}) qualifier else null
+    fun <T: Any> singleNotNull(x: T?, y: T?) = if (x == null || y == null) x ?: y else null
+
+    return JavaTypeQualifiers(
+            singleNotNull(NULLABLE_ANNOTATIONS.ifPresent(NULLABLE), NOT_NULL_ANNOTATIONS.ifPresent(NOT_NULL)),
+            singleNotNull(READ_ONLY_ANNOTATIONS.ifPresent(READ_ONLY), MUTABLE_ANNOTATIONS.ifPresent(MUTABLE))
+    )
+}
+
+fun JetType.computeIndexedQualifiersForOverride(fromSupertypes: Collection<JetType>, isCovariant: Boolean): (Int) -> JavaTypeQualifiers {
+    fun JetType.toIndexed(): List<JetType> {
+        val list = ArrayList<JetType>(1)
+
+        fun add(type: JetType) {
+            list.add(type)
+            for (arg in type.getArguments()) {
+                if (arg.isStarProjection()) {
+                    list.add(arg.getType())
+                }
+                else {
+                    add(arg.getType())
+                }
+            }
+        }
+
+        add(this)
+        return list
+    }
+
+    val indexedFromSupertypes = fromSupertypes.map { it.toIndexed() }
+    val indexedThisType = this.toIndexed()
+
+    // The covariant case may be hard, e.g. in the superclass the return may be Super<T>, but in the subclass it may be Derived, which
+    // is declared to extend Super<T>, and propagating data here is highly non-trivial, so we only look at the head type constructor
+    // (outermost type), unless the type in the subclass is interchangeable with the all the types in superclasses:
+    // e.g. we have (Mutable)List<String!>! in the subclass and { List<String!>, (Mutable)List<String>! } from superclasses
+    // Note that `this` is flexible here, so it's equal to it's bounds
+    val onlyHeadTypeConstructor = isCovariant && fromSupertypes.any { !JetTypeChecker.DEFAULT.equalTypes(it, this) }
+
+    val treeSize = if (onlyHeadTypeConstructor) 1 else indexedThisType.size()
+    val computedResult = Array(treeSize) {
+        index ->
+        val isHeadTypeConstructor = index == 0
+        assert(isHeadTypeConstructor || !onlyHeadTypeConstructor) { "Only head type constructors should be computed" }
+
+        val qualifiers = indexedThisType[index]
+        val verticalSlice = indexedFromSupertypes.map { it.getOrElse(index, { null }) }.filterNotNull()
+
+        // Only the head type constructor is safely co-variant
+        qualifiers.computeQualifiersForOverride(verticalSlice, isCovariant && isHeadTypeConstructor)
+    }
+
+    return { index -> computedResult.getOrElse(index) { JavaTypeQualifiers.NONE } }
+}
+
+private fun JetType.computeQualifiersForOverride(fromSupertypes: Collection<JetType>, isCovariant: Boolean): JavaTypeQualifiers {
+    val nullabilityFromSupertypes = fromSupertypes.map { it.extractQualifiers().nullability }.filterNotNull().toSet()
+    val mutabilityFromSupertypes = fromSupertypes.map { it.extractQualifiers().mutability }.filterNotNull().toSet()
+    val own = getAnnotations().extractQualifiers()
+
+    if (isCovariant) {
+        fun <T : Any> Set<T>.selectCovariantly(low: T, high: T, own: T?): T? {
+            val supertypeQualifier = if (low in this) low else if (high in this) high else null
+            return if (supertypeQualifier == low && own == high) null else own ?: supertypeQualifier
+        }
+        return JavaTypeQualifiers(
+                nullabilityFromSupertypes.selectCovariantly(NOT_NULL, NULLABLE, own.nullability),
+                mutabilityFromSupertypes.selectCovariantly(MUTABLE, READ_ONLY, own.mutability)
+        )
+    }
+    else {
+        fun <T : Any> Set<T>.selectInvariantly(own: T?): T? {
+            val effectiveSet = own?.let { (this + own).toSet() } ?: this
+            // if this set contains exactly one element, it is the qualifier everybody agrees upon,
+            // otherwise (no qualifiers, or multiple qualifiers), there's no single such qualifier
+            // and all qualifiers are discarded
+            return effectiveSet.singleOrNull()
+        }
+        return JavaTypeQualifiers(
+                nullabilityFromSupertypes.selectInvariantly(own.nullability),
+                mutabilityFromSupertypes.selectInvariantly(own.mutability)
+        )
+    }
+}
diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/kotlin/BinaryClassAnnotationAndConstantLoaderImpl.kt b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/kotlin/BinaryClassAnnotationAndConstantLoaderImpl.kt
index 78504d9db8b..a867de852c4 100644
--- a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/kotlin/BinaryClassAnnotationAndConstantLoaderImpl.kt
+++ b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/kotlin/BinaryClassAnnotationAndConstantLoaderImpl.kt
@@ -26,7 +26,9 @@ import org.jetbrains.kotlin.load.java.components.DescriptorResolverUtils
 import org.jetbrains.kotlin.load.kotlin.KotlinJvmBinaryClass.AnnotationArrayArgumentVisitor
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.Name
-import org.jetbrains.kotlin.resolve.constants.*
+import org.jetbrains.kotlin.resolve.constants.AnnotationValue
+import org.jetbrains.kotlin.resolve.constants.ConstantValue
+import org.jetbrains.kotlin.resolve.constants.ConstantValueFactory
 import org.jetbrains.kotlin.serialization.ProtoBuf
 import org.jetbrains.kotlin.serialization.deserialization.AnnotationDeserializer
 import org.jetbrains.kotlin.serialization.deserialization.ErrorReporter
@@ -42,15 +44,16 @@ public class BinaryClassAnnotationAndConstantLoaderImpl(
         storageManager: StorageManager,
         kotlinClassFinder: KotlinClassFinder,
         errorReporter: ErrorReporter
-) : AbstractBinaryClassAnnotationAndConstantLoader<AnnotationDescriptor, CompileTimeConstant<*>>(
+) : AbstractBinaryClassAnnotationAndConstantLoader<AnnotationDescriptor, ConstantValue<*>>(
         storageManager, kotlinClassFinder, errorReporter
 ) {
     private val annotationDeserializer = AnnotationDeserializer(module)
+    private val factory = ConstantValueFactory(module.builtIns)
 
     override fun loadTypeAnnotation(proto: ProtoBuf.Annotation, nameResolver: NameResolver): AnnotationDescriptor =
             annotationDeserializer.deserializeAnnotation(proto, nameResolver)
 
-    override fun loadConstant(desc: String, initializer: Any): CompileTimeConstant<*>? {
+    override fun loadConstant(desc: String, initializer: Any): ConstantValue<*>? {
         val normalizedValue: Any = if (desc in "ZBCS") {
             val intValue = initializer as Int
             when (desc) {
@@ -65,11 +68,7 @@ public class BinaryClassAnnotationAndConstantLoaderImpl(
             initializer
         }
 
-        val compileTimeConstant = createCompileTimeConstant(
-                normalizedValue, canBeUsedInAnnotation = true, isPureIntConstant = true,
-                usesVariableAsConstant = true, expectedType = null
-        )
-        return compileTimeConstant
+        return factory.createConstantValue(normalizedValue)
     }
 
     override fun loadAnnotation(
@@ -79,7 +78,7 @@ public class BinaryClassAnnotationAndConstantLoaderImpl(
         val annotationClass = resolveClass(annotationClassId)
 
         return object : KotlinJvmBinaryClass.AnnotationArgumentVisitor {
-            private val arguments = HashMap<ValueParameterDescriptor, CompileTimeConstant<*>>()
+            private val arguments = HashMap<ValueParameterDescriptor, ConstantValue<*>>()
 
             override fun visit(name: Name?, value: Any?) {
                 if (name != null) {
@@ -93,7 +92,7 @@ public class BinaryClassAnnotationAndConstantLoaderImpl(
 
             override fun visitArray(name: Name): AnnotationArrayArgumentVisitor? {
                 return object : KotlinJvmBinaryClass.AnnotationArrayArgumentVisitor {
-                    private val elements = ArrayList<CompileTimeConstant<*>>()
+                    private val elements = ArrayList<ConstantValue<*>>()
 
                     override fun visit(value: Any?) {
                         elements.add(createConstant(name, value))
@@ -107,7 +106,7 @@ public class BinaryClassAnnotationAndConstantLoaderImpl(
                         val parameter = DescriptorResolverUtils.getAnnotationParameterByName(name, annotationClass)
                         if (parameter != null) {
                             elements.trimToSize()
-                            arguments[parameter] = ArrayValue(elements, parameter.getType(), true, false)
+                            arguments[parameter] = factory.createArrayValue(elements, parameter.getType())
                         }
                     }
                 }
@@ -125,28 +124,27 @@ public class BinaryClassAnnotationAndConstantLoaderImpl(
             }
 
             // NOTE: see analogous code in AnnotationDeserializer
-            private fun enumEntryValue(enumClassId: ClassId, name: Name): CompileTimeConstant<*> {
+            private fun enumEntryValue(enumClassId: ClassId, name: Name): ConstantValue<*> {
                 val enumClass = resolveClass(enumClassId)
                 if (enumClass.getKind() == ClassKind.ENUM_CLASS) {
                     val classifier = enumClass.getUnsubstitutedInnerClassesScope().getClassifier(name)
                     if (classifier is ClassDescriptor) {
-                        return EnumValue(classifier, false)
+                        return factory.createEnumValue(classifier)
                     }
                 }
-                return ErrorValue.create("Unresolved enum entry: $enumClassId.$name")
+                return factory.createErrorValue("Unresolved enum entry: $enumClassId.$name")
             }
 
             override fun visitEnd() {
                 result.add(AnnotationDescriptorImpl(annotationClass.getDefaultType(), arguments))
             }
 
-            private fun createConstant(name: Name?, value: Any?): CompileTimeConstant<*> {
-                return createCompileTimeConstant(value, canBeUsedInAnnotation = true, isPureIntConstant = false,
-                                                 usesVariableAsConstant = false, expectedType = null)
-                       ?: ErrorValue.create("Unsupported annotation argument: $name")
+            private fun createConstant(name: Name?, value: Any?): ConstantValue<*> {
+                return factory.createConstantValue(value) ?:
+                       factory.createErrorValue("Unsupported annotation argument: $name")
             }
 
-            private fun setArgumentValueByName(name: Name, argumentValue: CompileTimeConstant<*>) {
+            private fun setArgumentValueByName(name: Name, argumentValue: ConstantValue<*>) {
                 val parameter = DescriptorResolverUtils.getAnnotationParameterByName(name, annotationClass)
                 if (parameter != null) {
                     arguments[parameter] = argumentValue
diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/kotlin/DeserializedDescriptorResolver.java b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/kotlin/DeserializedDescriptorResolver.java
index 1738a9a12ea..29cfa72a0f9 100644
--- a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/kotlin/DeserializedDescriptorResolver.java
+++ b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/kotlin/DeserializedDescriptorResolver.java
@@ -45,6 +45,7 @@ public final class DeserializedDescriptorResolver {
         this.errorReporter = errorReporter;
     }
 
+    // component dependency cycle
     @Inject
     public void setComponents(@NotNull DeserializationComponentsForJava context) {
         this.components = context.getComponents();
diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/kotlin/header/ReadKotlinClassHeaderAnnotationVisitor.java b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/kotlin/header/ReadKotlinClassHeaderAnnotationVisitor.java
index 8d378365ded..1365f6a39b9 100644
--- a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/kotlin/header/ReadKotlinClassHeaderAnnotationVisitor.java
+++ b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/kotlin/header/ReadKotlinClassHeaderAnnotationVisitor.java
@@ -68,6 +68,11 @@ public class ReadKotlinClassHeaderAnnotationVisitor implements AnnotationVisitor
             return null;
         }
 
+        if (headerKind == CLASS && classKind == null) {
+            // Default class kind is Kind.CLASS
+            classKind = KotlinClass.Kind.CLASS;
+        }
+
         if (!AbiVersionUtil.isAbiVersionCompatible(version)) {
             return new KotlinClassHeader(headerKind, version, null, classKind, syntheticClassKind);
         }
diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/platform/JavaToKotlinClassMap.java b/core/descriptor.loader.java/src/org/jetbrains/kotlin/platform/JavaToKotlinClassMap.java
index 51100339bc1..f60e27cb0e5 100644
--- a/core/descriptor.loader.java/src/org/jetbrains/kotlin/platform/JavaToKotlinClassMap.java
+++ b/core/descriptor.loader.java/src/org/jetbrains/kotlin/platform/JavaToKotlinClassMap.java
@@ -29,6 +29,8 @@ import org.jetbrains.kotlin.name.FqNameUnsafe;
 import org.jetbrains.kotlin.name.Name;
 import org.jetbrains.kotlin.resolve.DescriptorUtils;
 import org.jetbrains.kotlin.resolve.jvm.JvmPrimitiveType;
+import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.TypeUtils;
 
 import java.lang.annotation.Annotation;
 import java.util.*;
@@ -78,10 +80,9 @@ public class JavaToKotlinClassMap implements PlatformToKotlinClassMap {
         for (int i = 0; i < 23; i++) {
             add(ClassId.topLevel(new FqName("kotlin.jvm.functions.Function" + i)), builtIns.getFunction(i));
 
-            for (FunctionClassDescriptor.Kind kind : FunctionClassDescriptor.Kinds.KFunctions) {
-                String kFun = kind.getPackageFqName() + "." + kind.getClassNamePrefix();
-                addKotlinToJava(new FqNameUnsafe(kFun + i), ClassId.topLevel(new FqName(kFun)));
-            }
+            FunctionClassDescriptor.Kind kFunction = FunctionClassDescriptor.Kind.KFunction;
+            String kFun = kFunction.getPackageFqName() + "." + kFunction.getClassNamePrefix();
+            addKotlinToJava(new FqNameUnsafe(kFun + i), ClassId.topLevel(new FqName(kFun)));
         }
 
         addJavaToKotlin(classId(Deprecated.class), builtIns.getDeprecatedAnnotation());
@@ -182,14 +183,24 @@ public class JavaToKotlinClassMap implements PlatformToKotlinClassMap {
         return className.isSafe() ? mapPlatformClass(className.toSafe()) : Collections.<ClassDescriptor>emptySet();
     }
 
-    public boolean isMutableCollection(@NotNull ClassDescriptor mutable) {
+    public boolean isMutable(@NotNull ClassDescriptor mutable) {
         return mutableToReadOnly.containsKey(mutable);
     }
 
-    public boolean isReadOnlyCollection(@NotNull ClassDescriptor readOnly) {
+    public boolean isMutable(@NotNull JetType type) {
+        ClassDescriptor classDescriptor = TypeUtils.getClassDescriptor(type);
+        return classDescriptor != null && isMutable(classDescriptor);
+    }
+
+    public boolean isReadOnly(@NotNull ClassDescriptor readOnly) {
         return readOnlyToMutable.containsKey(readOnly);
     }
 
+    public boolean isReadOnly(@NotNull JetType type) {
+        ClassDescriptor classDescriptor = TypeUtils.getClassDescriptor(type);
+        return classDescriptor != null && isReadOnly(classDescriptor);
+    }
+
     @NotNull
     public ClassDescriptor convertMutableToReadOnly(@NotNull ClassDescriptor mutable) {
         ClassDescriptor readOnly = mutableToReadOnly.get(mutable);
diff --git a/core/descriptors.runtime/src/org/jetbrains/kotlin/load/java/structure/reflect/ReflectJavaClass.kt b/core/descriptors.runtime/src/org/jetbrains/kotlin/load/java/structure/reflect/ReflectJavaClass.kt
index 77677a82328..5c916d36c06 100644
--- a/core/descriptors.runtime/src/org/jetbrains/kotlin/load/java/structure/reflect/ReflectJavaClass.kt
+++ b/core/descriptors.runtime/src/org/jetbrains/kotlin/load/java/structure/reflect/ReflectJavaClass.kt
@@ -29,7 +29,7 @@ import java.util.Arrays
 public class ReflectJavaClass(
         private val klass: Class<*>
 ) : ReflectJavaElement(), ReflectJavaAnnotationOwner, ReflectJavaModifierListOwner, JavaClass {
-    override val element: AnnotatedElement get() = klass
+    override val element: Class<*> get() = klass
 
     override val modifiers: Int get() = klass.getModifiers()
 
diff --git a/core/descriptors.runtime/src/org/jetbrains/kotlin/load/java/structure/reflect/ReflectJavaClassifierType.kt b/core/descriptors.runtime/src/org/jetbrains/kotlin/load/java/structure/reflect/ReflectJavaClassifierType.kt
index f18d036a06f..f7e863fe164 100644
--- a/core/descriptors.runtime/src/org/jetbrains/kotlin/load/java/structure/reflect/ReflectJavaClassifierType.kt
+++ b/core/descriptors.runtime/src/org/jetbrains/kotlin/load/java/structure/reflect/ReflectJavaClassifierType.kt
@@ -16,10 +16,8 @@
 
 package org.jetbrains.kotlin.load.java.structure.reflect
 
-import org.jetbrains.kotlin.load.java.structure.JavaClassifier
-import org.jetbrains.kotlin.load.java.structure.JavaClassifierType
-import org.jetbrains.kotlin.load.java.structure.JavaType
-import org.jetbrains.kotlin.load.java.structure.JavaTypeSubstitutor
+import org.jetbrains.kotlin.load.java.structure.*
+import org.jetbrains.kotlin.name.FqName
 import java.lang.reflect.ParameterizedType
 import java.lang.reflect.Type
 import java.lang.reflect.TypeVariable
@@ -48,4 +46,12 @@ public class ReflectJavaClassifierType(public override val type: Type) : Reflect
     override fun getTypeArguments(): List<JavaType> {
         return (type as? ParameterizedType)?.getActualTypeArguments()?.map { ReflectJavaType.create(it) } ?: listOf()
     }
+
+    override fun getAnnotations(): Collection<JavaAnnotation> {
+        return emptyList() // TODO
+    }
+
+    override fun findAnnotation(fqName: FqName): JavaAnnotation? {
+        return null // TODO
+    }
 }
diff --git a/core/descriptors.runtime/src/org/jetbrains/kotlin/load/java/structure/reflect/ReflectJavaTypeParameter.kt b/core/descriptors.runtime/src/org/jetbrains/kotlin/load/java/structure/reflect/ReflectJavaTypeParameter.kt
index dee11701869..28b7ccf8587 100644
--- a/core/descriptors.runtime/src/org/jetbrains/kotlin/load/java/structure/reflect/ReflectJavaTypeParameter.kt
+++ b/core/descriptors.runtime/src/org/jetbrains/kotlin/load/java/structure/reflect/ReflectJavaTypeParameter.kt
@@ -26,7 +26,7 @@ import java.lang.reflect.Method
 import java.lang.reflect.TypeVariable
 
 public class ReflectJavaTypeParameter(
-        private val typeVariable: TypeVariable<*>
+        public val typeVariable: TypeVariable<*>
 ) : ReflectJavaElement(), JavaTypeParameter {
     override fun getUpperBounds(): List<ReflectJavaClassifierType> {
         val bounds = typeVariable.getBounds().map { bound -> ReflectJavaClassifierType(bound) }
diff --git a/core/descriptors.runtime/src/org/jetbrains/kotlin/load/kotlin/reflect/RuntimeModuleData.kt b/core/descriptors.runtime/src/org/jetbrains/kotlin/load/kotlin/reflect/RuntimeModuleData.kt
index b581f3b1c5c..49bbc961aaf 100644
--- a/core/descriptors.runtime/src/org/jetbrains/kotlin/load/kotlin/reflect/RuntimeModuleData.kt
+++ b/core/descriptors.runtime/src/org/jetbrains/kotlin/load/kotlin/reflect/RuntimeModuleData.kt
@@ -50,7 +50,7 @@ public class RuntimeModuleData private constructor(public val module: ModuleDesc
             val globalJavaResolverContext = GlobalJavaResolverContext(
                     storageManager, ReflectJavaClassFinder(classLoader), reflectKotlinClassFinder, deserializedDescriptorResolver,
                     ExternalAnnotationResolver.EMPTY, ExternalSignatureResolver.DO_NOTHING, RuntimeErrorReporter, JavaResolverCache.EMPTY,
-                    JavaPropertyInitializerEvaluator.DO_NOTHING, SamConversionResolver, RuntimeSourceElementFactory, singleModuleClassResolver
+                    JavaPropertyInitializerEvaluator.DoNothing, SamConversionResolver, RuntimeSourceElementFactory, singleModuleClassResolver
             )
             val lazyJavaPackageFragmentProvider = LazyJavaPackageFragmentProvider(globalJavaResolverContext, module, ReflectionTypes(module))
             val javaDescriptorResolver = JavaDescriptorResolver(lazyJavaPackageFragmentProvider, module)
diff --git a/core/descriptors/src/org/jetbrains/kotlin/builtins/BuiltInsAnnotationAndConstantLoader.kt b/core/descriptors/src/org/jetbrains/kotlin/builtins/BuiltInsAnnotationAndConstantLoader.kt
index 25a8f685cd1..dbf23ac2dc0 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/builtins/BuiltInsAnnotationAndConstantLoader.kt
+++ b/core/descriptors/src/org/jetbrains/kotlin/builtins/BuiltInsAnnotationAndConstantLoader.kt
@@ -18,7 +18,7 @@ package org.jetbrains.kotlin.builtins
 
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor
 import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptor
-import org.jetbrains.kotlin.resolve.constants.CompileTimeConstant
+import org.jetbrains.kotlin.resolve.constants.ConstantValue
 import org.jetbrains.kotlin.serialization.ProtoBuf
 import org.jetbrains.kotlin.serialization.builtins.BuiltInsProtoBuf
 import org.jetbrains.kotlin.serialization.deserialization.*
@@ -26,7 +26,7 @@ import org.jetbrains.kotlin.types.JetType
 
 class BuiltInsAnnotationAndConstantLoader(
         module: ModuleDescriptor
-) : AnnotationAndConstantLoader<AnnotationDescriptor, CompileTimeConstant<*>> {
+) : AnnotationAndConstantLoader<AnnotationDescriptor, ConstantValue<*>> {
     private val deserializer = AnnotationDeserializer(module)
 
     override fun loadClassAnnotations(
@@ -68,7 +68,7 @@ class BuiltInsAnnotationAndConstantLoader(
             proto: ProtoBuf.Callable,
             nameResolver: NameResolver,
             expectedType: JetType
-    ): CompileTimeConstant<*>? {
+    ): ConstantValue<*>? {
         val value = proto.getExtension(BuiltInsProtoBuf.compileTimeValue)
         return deserializer.resolveValue(expectedType, value, nameResolver)
     }
diff --git a/core/descriptors/src/org/jetbrains/kotlin/builtins/BuiltInsSerializedResourcePaths.kt b/core/descriptors/src/org/jetbrains/kotlin/builtins/BuiltInsSerializedResourcePaths.kt
index 8665aadb694..5531c86eb65 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/builtins/BuiltInsSerializedResourcePaths.kt
+++ b/core/descriptors/src/org/jetbrains/kotlin/builtins/BuiltInsSerializedResourcePaths.kt
@@ -23,11 +23,11 @@ import org.jetbrains.kotlin.serialization.SerializedResourcePaths
 import org.jetbrains.kotlin.serialization.builtins.BuiltInsProtoBuf
 
 public object BuiltInsSerializedResourcePaths : SerializedResourcePaths() {
-    public override val EXTENSION_REGISTRY: ExtensionRegistryLite
+    public override val extensionRegistry: ExtensionRegistryLite
 
     init {
-        EXTENSION_REGISTRY = ExtensionRegistryLite.newInstance()
-        BuiltInsProtoBuf.registerAllExtensions(EXTENSION_REGISTRY)
+        extensionRegistry = ExtensionRegistryLite.newInstance()
+        BuiltInsProtoBuf.registerAllExtensions(extensionRegistry)
     }
 
     private val CLASS_METADATA_FILE_EXTENSION = "kotlin_class"
diff --git a/core/descriptors/src/org/jetbrains/kotlin/builtins/BuiltinsPackageFragment.kt b/core/descriptors/src/org/jetbrains/kotlin/builtins/BuiltinsPackageFragment.kt
index 4d25cb09c4d..d745744f919 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/builtins/BuiltinsPackageFragment.kt
+++ b/core/descriptors/src/org/jetbrains/kotlin/builtins/BuiltinsPackageFragment.kt
@@ -16,12 +16,12 @@
 
 package org.jetbrains.kotlin.builtins
 
-import org.jetbrains.kotlin.serialization.deserialization.DeserializedPackageFragment
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.serialization.ProtoBuf
 import org.jetbrains.kotlin.serialization.builtins.BuiltInsProtoBuf
+import org.jetbrains.kotlin.serialization.deserialization.DeserializedPackageFragment
 import org.jetbrains.kotlin.storage.StorageManager
 import java.io.InputStream
 
@@ -32,7 +32,7 @@ public class BuiltinsPackageFragment(
         loadResource: (path: String) -> InputStream?
 ) : DeserializedPackageFragment(fqName, storageManager, module, BuiltInsSerializedResourcePaths, loadResource) {
 
-    protected override fun loadClassNames(fqName: FqName, packageProto: ProtoBuf.Package): Collection<Name> {
+    protected override fun loadClassNames(packageProto: ProtoBuf.Package): Collection<Name> {
         return packageProto.getExtension(BuiltInsProtoBuf.className)?.map { id -> nameResolver.getName(id) } ?: listOf()
     }
 }
diff --git a/core/descriptors/src/org/jetbrains/kotlin/builtins/KotlinBuiltIns.java b/core/descriptors/src/org/jetbrains/kotlin/builtins/KotlinBuiltIns.java
index f7c80e56a14..5b519332cdd 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/builtins/KotlinBuiltIns.java
+++ b/core/descriptors/src/org/jetbrains/kotlin/builtins/KotlinBuiltIns.java
@@ -32,7 +32,7 @@ import org.jetbrains.kotlin.name.FqName;
 import org.jetbrains.kotlin.name.FqNameUnsafe;
 import org.jetbrains.kotlin.name.Name;
 import org.jetbrains.kotlin.resolve.DescriptorUtils;
-import org.jetbrains.kotlin.resolve.constants.CompileTimeConstant;
+import org.jetbrains.kotlin.resolve.constants.ConstantValue;
 import org.jetbrains.kotlin.resolve.scopes.JetScope;
 import org.jetbrains.kotlin.storage.LockBasedStorageManager;
 import org.jetbrains.kotlin.types.*;
@@ -48,6 +48,7 @@ import static org.jetbrains.kotlin.resolve.DescriptorUtils.getFqName;
 public class KotlinBuiltIns {
     public static final Name BUILT_INS_PACKAGE_NAME = Name.identifier("kotlin");
     public static final FqName BUILT_INS_PACKAGE_FQ_NAME = FqName.topLevel(BUILT_INS_PACKAGE_NAME);
+    public static final FqName ANNOTATION_PACKAGE_FQ_NAME = BUILT_INS_PACKAGE_FQ_NAME.child(Name.identifier("annotation"));
 
     ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
@@ -110,12 +111,12 @@ public class KotlinBuiltIns {
     private KotlinBuiltIns() {
         LockBasedStorageManager storageManager = new LockBasedStorageManager();
         builtInsModule = new ModuleDescriptorImpl(
-                Name.special("<built-ins module>"), storageManager, ModuleParameters.Empty.INSTANCE$
+                Name.special("<built-ins module>"), storageManager, ModuleParameters.Empty.INSTANCE$, this
         );
 
         PackageFragmentProvider packageFragmentProvider = BuiltinsPackage.createBuiltInPackageFragmentProvider(
                 storageManager, builtInsModule,
-                setOf(BUILT_INS_PACKAGE_FQ_NAME, BuiltinsPackage.getKOTLIN_REFLECT_FQ_NAME()),
+                setOf(BUILT_INS_PACKAGE_FQ_NAME, ANNOTATION_PACKAGE_FQ_NAME, BuiltinsPackage.getKOTLIN_REFLECT_FQ_NAME()),
                 new BuiltInFictitiousFunctionClassFactory(storageManager, builtInsModule),
                 new Function1<String, InputStream>() {
                     @Override
@@ -175,6 +176,8 @@ public class KotlinBuiltIns {
         public final FqName noinline = fqName("noinline");
         public final FqName inlineOptions = fqName("inlineOptions");
         public final FqName extension = fqName("extension");
+        public final FqName target = annotationName("target");
+        public final FqName annotation = annotationName("annotation");
 
         public final FqNameUnsafe kClass = new FqName("kotlin.reflect.KClass").toUnsafe();
 
@@ -198,6 +201,11 @@ public class KotlinBuiltIns {
         private static FqName fqName(@NotNull String simpleName) {
             return BUILT_INS_PACKAGE_FQ_NAME.child(Name.identifier(simpleName));
         }
+
+        @NotNull
+        private static FqName annotationName(@NotNull String simpleName) {
+            return ANNOTATION_PACKAGE_FQ_NAME.child(Name.identifier(simpleName));
+        }
     }
 
     ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -225,8 +233,16 @@ public class KotlinBuiltIns {
 
     @NotNull
     public ClassDescriptor getBuiltInClassByName(@NotNull Name simpleName) {
+        ClassDescriptor classDescriptor = getBuiltInClassByNameNullable(simpleName);
+        assert classDescriptor != null : "Must be a class descriptor " + simpleName + ", but was null";
+        return classDescriptor;
+    }
+
+    @Nullable
+    public ClassDescriptor getBuiltInClassByNameNullable(@NotNull Name simpleName) {
         ClassifierDescriptor classifier = getBuiltInsPackageFragment().getMemberScope().getClassifier(simpleName);
-        assert classifier instanceof ClassDescriptor : "Must be a class descriptor " + simpleName + ", but was " + classifier;
+        assert classifier == null ||
+               classifier instanceof ClassDescriptor : "Must be a class descriptor " + simpleName + ", but was " + classifier;
         return (ClassDescriptor) classifier;
     }
 
@@ -643,7 +659,7 @@ public class KotlinBuiltIns {
     @NotNull
     public AnnotationDescriptor createExtensionAnnotation() {
         return new AnnotationDescriptorImpl(getBuiltInClassByName("extension").getDefaultType(),
-                                            Collections.<ValueParameterDescriptor, CompileTimeConstant<?>>emptyMap());
+                                            Collections.<ValueParameterDescriptor, ConstantValue<?>>emptyMap());
     }
 
     private static boolean isTypeAnnotatedWithExtension(@NotNull JetType type) {
diff --git a/core/descriptors/src/org/jetbrains/kotlin/builtins/ReflectionTypes.kt b/core/descriptors/src/org/jetbrains/kotlin/builtins/ReflectionTypes.kt
index c3e81262a4c..787d7a775da 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/builtins/ReflectionTypes.kt
+++ b/core/descriptors/src/org/jetbrains/kotlin/builtins/ReflectionTypes.kt
@@ -18,20 +18,19 @@ package org.jetbrains.kotlin.builtins
 
 import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor
+import org.jetbrains.kotlin.descriptors.PackageFragmentDescriptor
 import org.jetbrains.kotlin.descriptors.annotations.Annotations
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
-import org.jetbrains.kotlin.name.isSubpackageOf
 import org.jetbrains.kotlin.resolve.DescriptorUtils
 import org.jetbrains.kotlin.resolve.scopes.JetScope
 import org.jetbrains.kotlin.types.*
 import java.util.ArrayList
-import kotlin.properties.Delegates
 
 val KOTLIN_REFLECT_FQ_NAME = FqName("kotlin.reflect")
 
 public class ReflectionTypes(private val module: ModuleDescriptor) {
-    private val kotlinReflectScope: JetScope by Delegates.lazy {
+    private val kotlinReflectScope: JetScope by lazy {
         module.getPackage(KOTLIN_REFLECT_FQ_NAME).memberScope
     }
 
@@ -48,16 +47,13 @@ public class ReflectionTypes(private val module: ModuleDescriptor) {
     }
 
     public fun getKFunction(n: Int): ClassDescriptor = find("KFunction$n")
-    public fun getKExtensionFunction(n: Int): ClassDescriptor = find("KExtensionFunction$n")
-    public fun getKMemberFunction(n: Int): ClassDescriptor = find("KMemberFunction$n")
 
     public val kClass: ClassDescriptor by ClassLookup
-    public val kTopLevelVariable: ClassDescriptor by ClassLookup
-    public val kMutableTopLevelVariable: ClassDescriptor by ClassLookup
-    public val kMemberProperty: ClassDescriptor by ClassLookup
-    public val kMutableMemberProperty: ClassDescriptor by ClassLookup
-    public val kTopLevelExtensionProperty: ClassDescriptor by ClassLookup
-    public val kMutableTopLevelExtensionProperty: ClassDescriptor by ClassLookup
+    public val kProperty0: ClassDescriptor by ClassLookup
+    public val kProperty1: ClassDescriptor by ClassLookup
+    public val kProperty2: ClassDescriptor by ClassLookup
+    public val kMutableProperty0: ClassDescriptor by ClassLookup
+    public val kMutableProperty1: ClassDescriptor by ClassLookup
 
     public fun getKClassType(annotations: Annotations, type: JetType): JetType {
         val descriptor = kClass
@@ -73,40 +69,31 @@ public class ReflectionTypes(private val module: ModuleDescriptor) {
             annotations: Annotations,
             receiverType: JetType?,
             parameterTypes: List<JetType>,
-            returnType: JetType,
-            extensionFunction: Boolean
+            returnType: JetType
     ): JetType {
-        val arity = parameterTypes.size()
-        val classDescriptor =
-                if (extensionFunction) getKExtensionFunction(arity)
-                else if (receiverType != null) getKMemberFunction(arity)
-                else getKFunction(arity)
+        val arguments = KotlinBuiltIns.getFunctionTypeArgumentProjections(receiverType, parameterTypes, returnType)
+
+        val classDescriptor = getKFunction(arguments.size() - 1 /* return type */)
 
         if (ErrorUtils.isError(classDescriptor)) {
             return classDescriptor.getDefaultType()
         }
 
-        val arguments = KotlinBuiltIns.getFunctionTypeArgumentProjections(receiverType, parameterTypes, returnType)
         return JetTypeImpl(annotations, classDescriptor.getTypeConstructor(), false, arguments, classDescriptor.getMemberScope(arguments))
     }
 
-    public fun getKPropertyType(
-            annotations: Annotations,
-            receiverType: JetType?,
-            returnType: JetType,
-            extensionProperty: Boolean,
-            mutable: Boolean
-    ): JetType {
-        val classDescriptor = if (mutable) when {
-            extensionProperty -> kMutableTopLevelExtensionProperty
-            receiverType != null -> kMutableMemberProperty
-            else -> kMutableTopLevelVariable
-        }
-        else when {
-            extensionProperty -> kTopLevelExtensionProperty
-            receiverType != null -> kMemberProperty
-            else -> kTopLevelVariable
-        }
+    public fun getKPropertyType(annotations: Annotations, receiverType: JetType?, returnType: JetType, mutable: Boolean): JetType {
+        val classDescriptor =
+                when {
+                    receiverType != null -> when {
+                        mutable -> kMutableProperty1
+                        else -> kProperty1
+                    }
+                    else -> when {
+                        mutable -> kMutableProperty0
+                        else -> kProperty0
+                    }
+                }
 
         if (ErrorUtils.isError(classDescriptor)) {
             return classDescriptor.getDefaultType()
@@ -121,10 +108,9 @@ public class ReflectionTypes(private val module: ModuleDescriptor) {
     }
 
     companion object {
-        public fun isReflectionType(type: JetType): Boolean {
-            val descriptor = type.getConstructor().getDeclarationDescriptor() ?: return false
-            val fqName = DescriptorUtils.getFqName(descriptor)
-            return fqName.isSafe() && fqName.toSafe().isSubpackageOf(KOTLIN_REFLECT_FQ_NAME)
+        public fun isReflectionClass(descriptor: ClassDescriptor): Boolean {
+            val containingPackage = DescriptorUtils.getParentOfType(descriptor, javaClass<PackageFragmentDescriptor>())
+            return containingPackage != null && containingPackage.fqName == KOTLIN_REFLECT_FQ_NAME
         }
     }
 }
diff --git a/core/descriptors/src/org/jetbrains/kotlin/builtins/functions/BuiltInFictitiousFunctionClassFactory.kt b/core/descriptors/src/org/jetbrains/kotlin/builtins/functions/BuiltInFictitiousFunctionClassFactory.kt
index 14208047b9e..335003c5aef 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/builtins/functions/BuiltInFictitiousFunctionClassFactory.kt
+++ b/core/descriptors/src/org/jetbrains/kotlin/builtins/functions/BuiltInFictitiousFunctionClassFactory.kt
@@ -16,6 +16,7 @@
 
 package org.jetbrains.kotlin.builtins.functions
 
+import org.jetbrains.kotlin.builtins.KotlinBuiltIns
 import org.jetbrains.kotlin.builtins.functions.FunctionClassDescriptor.Kind
 import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor
@@ -26,7 +27,7 @@ import org.jetbrains.kotlin.storage.StorageManager
 import kotlin.platform.platformStatic
 
 /**
- * Produces descriptors representing the fictitious classes for function types, such as kotlin.Function1 or kotlin.reflect.KMemberFunction0.
+ * Produces descriptors representing the fictitious classes for function types, such as kotlin.Function1 or kotlin.reflect.KFunction2.
  */
 public class BuiltInFictitiousFunctionClassFactory(
         private val storageManager: StorageManager,
@@ -37,17 +38,17 @@ public class BuiltInFictitiousFunctionClassFactory(
 
     companion object {
         platformStatic public fun parseClassName(className: String, packageFqName: FqName): KindWithArity? {
-            for (kind in FunctionClassDescriptor.Kinds.byPackage(packageFqName)) {
-                val prefix = kind.classNamePrefix
-                if (!className.startsWith(prefix)) continue
+            // There is no functions in kotlin.annotation package
+            if (packageFqName == KotlinBuiltIns.ANNOTATION_PACKAGE_FQ_NAME) return null
+            val kind = FunctionClassDescriptor.Kind.byPackage(packageFqName) ?: return null
 
-                val arity = toInt(className.substring(prefix.length())) ?: continue
+            val prefix = kind.classNamePrefix
+            if (!className.startsWith(prefix)) return null
 
-                // TODO: validate arity, should be <= 255 for functions, <= 254 for members/extensions
-                return KindWithArity(kind, arity)
-            }
+            val arity = toInt(className.substring(prefix.length())) ?: return null
 
-            return null
+            // TODO: validate arity, should be <= 255
+            return KindWithArity(kind, arity)
         }
 
         private fun toInt(s: String): Int? {
@@ -70,8 +71,7 @@ public class BuiltInFictitiousFunctionClassFactory(
         if ("Function" !in className) return null // An optimization
 
         val packageFqName = classId.getPackageFqName()
-        val kindWithArity = parseClassName(className, packageFqName) ?: return null
-        val (kind, arity) = kindWithArity // KT-5100
+        val (kind, arity) = parseClassName(className, packageFqName) ?: return null
 
         val containingPackageFragment = module.getPackage(packageFqName).fragments.single()
 
diff --git a/core/descriptors/src/org/jetbrains/kotlin/builtins/functions/FunctionClassDescriptor.kt b/core/descriptors/src/org/jetbrains/kotlin/builtins/functions/FunctionClassDescriptor.kt
index 8708c36cdac..5b013d923de 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/builtins/functions/FunctionClassDescriptor.kt
+++ b/core/descriptors/src/org/jetbrains/kotlin/builtins/functions/FunctionClassDescriptor.kt
@@ -17,12 +17,10 @@
 package org.jetbrains.kotlin.builtins.functions
 
 import org.jetbrains.kotlin.builtins.KOTLIN_REFLECT_FQ_NAME
-import org.jetbrains.kotlin.builtins.KotlinBuiltIns
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns.BUILT_INS_PACKAGE_FQ_NAME
 import org.jetbrains.kotlin.builtins.functions.FunctionClassDescriptor.Kind
 import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.descriptors.annotations.Annotations
-import org.jetbrains.kotlin.descriptors.annotations.AnnotationsImpl
 import org.jetbrains.kotlin.descriptors.impl.AbstractClassDescriptor
 import org.jetbrains.kotlin.descriptors.impl.TypeParameterDescriptorImpl
 import org.jetbrains.kotlin.name.FqName
@@ -32,18 +30,14 @@ import org.jetbrains.kotlin.storage.StorageManager
 import org.jetbrains.kotlin.types.*
 import org.jetbrains.kotlin.utils.toReadOnlyList
 import java.util.ArrayList
-import java.util.EnumSet
 
 /**
- * A [ClassDescriptor] representing the fictitious class for a function type, such as kotlin.Function1 or kotlin.reflect.KMemberFunction0.
+ * A [ClassDescriptor] representing the fictitious class for a function type, such as kotlin.Function1 or kotlin.reflect.KFunction2.
  *
- * Classes which are represented by this descriptor include (with supertypes):
+ * If the class represents kotlin.Function1, its only supertype is kotlin.Function.
  *
- * Function1 : Function
- * KFunction1 : Function1, KFunction
- * KMemberFunction1 : Function2, KMemberFunction
- * KExtensionFunction1 : Function2, KExtensionFunction
- * (TODO) KMemberExtensionFunction1 : Function3, KMemberExtensionFunction
+ * If the class represents kotlin.reflect.KFunction1, it has two supertypes: kotlin.Function1 and kotlin.reflect.KFunction.
+ * This allows to use both 'invoke' and reflection API on function references obtained by '::'.
  */
 public class FunctionClassDescriptor(
         private val storageManager: StorageManager,
@@ -54,24 +48,16 @@ public class FunctionClassDescriptor(
 
     public enum class Kind(val packageFqName: FqName, val classNamePrefix: String) {
         Function(BUILT_INS_PACKAGE_FQ_NAME, "Function"),
-        KFunction(KOTLIN_REFLECT_FQ_NAME, "KFunction"),
-        KMemberFunction(KOTLIN_REFLECT_FQ_NAME, "KMemberFunction"),
-        KExtensionFunction(KOTLIN_REFLECT_FQ_NAME, "KExtensionFunction");
-        // TODO: KMemberExtensionFunction
+        KFunction(KOTLIN_REFLECT_FQ_NAME, "KFunction");
 
         fun numberedClassName(arity: Int) = Name.identifier("$classNamePrefix$arity")
-        val hasDispatchReceiver: Boolean get() = this == KMemberFunction
-        val hasExtensionReceiver: Boolean get() = this == KExtensionFunction
-    }
 
-    public object Kinds {
-        val Functions = EnumSet.of(Kind.Function)
-        val KFunctions = EnumSet.complementOf(Functions)
-
-        fun byPackage(fqName: FqName) = when (fqName) {
-            BUILT_INS_PACKAGE_FQ_NAME -> Functions
-            KOTLIN_REFLECT_FQ_NAME -> KFunctions
-            else -> error(fqName)
+        companion object {
+            fun byPackage(fqName: FqName) = when (fqName) {
+                BUILT_INS_PACKAGE_FQ_NAME -> Function
+                KOTLIN_REFLECT_FQ_NAME -> KFunction
+                else -> null
+            }
         }
     }
 
@@ -85,7 +71,7 @@ public class FunctionClassDescriptor(
 
     override fun getTypeConstructor(): TypeConstructor = typeConstructor
 
-    override fun getScopeForMemberLookup() = memberScope
+    override fun getUnsubstitutedMemberScope() = memberScope
 
     override fun getCompanionObjectDescriptor() = null
     override fun getConstructors() = emptyList<ConstructorDescriptor>()
@@ -110,13 +96,6 @@ public class FunctionClassDescriptor(
                 ))
             }
 
-            if (functionKind.hasDispatchReceiver) {
-                typeParameter(Variance.IN_VARIANCE, "T")
-            }
-            if (functionKind.hasExtensionReceiver) {
-                typeParameter(Variance.IN_VARIANCE, "E")
-            }
-
             (1..arity).map { i ->
                 typeParameter(Variance.IN_VARIANCE, "P$i")
             }
@@ -129,48 +108,29 @@ public class FunctionClassDescriptor(
         private val supertypes = storageManager.createLazyValue {
             val result = ArrayList<JetType>(2)
 
-            fun add(
-                    packageFragment: PackageFragmentDescriptor,
-                    name: Name,
-                    annotations: Annotations,
-                    supertypeArguments: (superParameters: List<TypeParameterDescriptor>) -> List<TypeProjection>
-            ) {
+            fun add(packageFragment: PackageFragmentDescriptor, name: Name) {
                 val descriptor = packageFragment.getMemberScope().getClassifier(name) as? ClassDescriptor
                                  ?: error("Class $name not found in $packageFragment")
 
                 val typeConstructor = descriptor.getTypeConstructor()
-                val arguments = supertypeArguments(typeConstructor.getParameters())
 
-                result.add(JetTypeImpl(annotations, typeConstructor, false, arguments, descriptor.getMemberScope(arguments)))
+                // Substitute all type parameters of the super class with our last type parameters
+                val arguments = getParameters().takeLast(typeConstructor.getParameters().size()).map {
+                    TypeProjectionImpl(it.getDefaultType())
+                }
+
+                result.add(JetTypeImpl(Annotations.EMPTY, typeConstructor, false, arguments, descriptor.getMemberScope(arguments)))
             }
 
-            // Add unnumbered base class, e.g. KMemberFunction for KMemberFunction5, or Function for Function0
-            add(containingDeclaration, Name.identifier(functionKind.classNamePrefix), Annotations.EMPTY) { superParameters ->
-                // Substitute type parameters of the super class with our type parameters with the same names
-                val parametersByName = getParameters().toMap { it.getName() }
-                superParameters.map { TypeProjectionImpl(parametersByName[it.getName()]!!.getDefaultType()) }
-            }
-
-            // For K*Functions, add corresponding numbered Function class, e.g. Function2 for KMemberFunction1
-            if (functionKind in Kinds.KFunctions) {
-                var functionArity = arity
-                if (functionKind.hasDispatchReceiver) functionArity++
-                if (functionKind.hasExtensionReceiver) functionArity++
+            // Add unnumbered base class, e.g. Function for Function{n}, KFunction for KFunction{n}
+            add(containingDeclaration, Name.identifier(functionKind.classNamePrefix))
 
+            // For KFunction{n}, add corresponding numbered Function{n} class, e.g. Function2 for KFunction2
+            if (functionKind == Kind.KFunction) {
                 val module = containingDeclaration.getContainingDeclaration()
                 val kotlinPackageFragment = module.getPackage(BUILT_INS_PACKAGE_FQ_NAME).fragments.single()
 
-                // If this is a KMemberFunction{n} or KExtensionFunction{n}, it extends Function{n} with the annotation kotlin.extension,
-                // so that the value of this type is callable as an extension function, with the receiver before the dot
-                val annotations =
-                        if (functionKind.hasDispatchReceiver || functionKind.hasExtensionReceiver)
-                            AnnotationsImpl(listOf(KotlinBuiltIns.getInstance().createExtensionAnnotation()))
-                        else Annotations.EMPTY
-
-                add(kotlinPackageFragment, Kind.Function.numberedClassName(functionArity), annotations) {
-                    // Substitute all type parameters of the super class with all our type parameters
-                    getParameters().map { TypeProjectionImpl(it.getDefaultType()) }
-                }
+                add(kotlinPackageFragment, Kind.Function.numberedClassName(arity))
             }
 
             result.toReadOnlyList()
diff --git a/core/descriptors/src/org/jetbrains/kotlin/builtins/functions/FunctionClassScope.kt b/core/descriptors/src/org/jetbrains/kotlin/builtins/functions/FunctionClassScope.kt
index 13b68e0d240..97468a9311d 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/builtins/functions/FunctionClassScope.kt
+++ b/core/descriptors/src/org/jetbrains/kotlin/builtins/functions/FunctionClassScope.kt
@@ -16,9 +16,7 @@
 
 package org.jetbrains.kotlin.builtins.functions
 
-import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor
-import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
-import org.jetbrains.kotlin.descriptors.FunctionDescriptor
+import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.resolve.OverridingUtil
 import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter
@@ -32,7 +30,7 @@ class FunctionClassScope(
         private val storageManager: StorageManager,
         private val functionClass: FunctionClassDescriptor
 ) : JetScopeImpl() {
-    private val allFunctions = storageManager.createLazyValue {
+    private val allDescriptors = storageManager.createLazyValue {
         if (functionClass.functionKind == FunctionClassDescriptor.Kind.Function) {
             val invoke = FunctionInvokeDescriptor.create(functionClass)
             (listOf(invoke) + createFakeOverrides(invoke)).toReadOnlyList()
@@ -45,35 +43,42 @@ class FunctionClassScope(
     override fun getContainingDeclaration() = functionClass
 
     override fun getDescriptors(kindFilter: DescriptorKindFilter, nameFilter: (Name) -> Boolean): Collection<DeclarationDescriptor> {
-        if (!kindFilter.acceptsKinds(DescriptorKindFilter.FUNCTIONS_MASK)) return listOf()
-        return allFunctions()
+        if (!kindFilter.acceptsKinds(DescriptorKindFilter.CALLABLES.kindMask)) return listOf()
+        return allDescriptors()
     }
 
     override fun getFunctions(name: Name): Collection<FunctionDescriptor> {
-        return allFunctions().filter { it.getName() == name }
+        return allDescriptors().filterIsInstance<FunctionDescriptor>().filter { it.getName() == name }
     }
 
-    private fun createFakeOverrides(invoke: FunctionDescriptor?): List<FunctionDescriptor> {
-        val result = ArrayList<FunctionDescriptor>(3)
-        val allSuperDescriptors = functionClass.getTypeConstructor().getSupertypes().flatMap { it.getMemberScope().getAllDescriptors() }
-        for ((name, descriptors) in allSuperDescriptors.groupBy { it.getName() }) {
-            @suppress("UNCHECKED_CAST")
-            OverridingUtil.generateOverridesInFunctionGroup(
-                    name,
-                    /* membersFromSupertypes = */ descriptors as Collection<FunctionDescriptor>,
-                    /* membersFromCurrent = */ if (name == invoke?.getName()) listOf(invoke) else listOf(),
-                    functionClass,
-                    object : OverridingUtil.DescriptorSink {
-                        override fun addToScope(fakeOverride: CallableMemberDescriptor) {
-                            OverridingUtil.resolveUnknownVisibilityForMember(fakeOverride, null)
-                            result.add(fakeOverride as FunctionDescriptor)
-                        }
+    override fun getProperties(name: Name): Collection<VariableDescriptor> {
+        return allDescriptors().filterIsInstance<PropertyDescriptor>().filter { it.getName() == name }
+    }
 
-                        override fun conflict(fromSuper: CallableMemberDescriptor, fromCurrent: CallableMemberDescriptor) {
-                            error("Conflict in scope of ${getContainingDeclaration()}: $fromSuper vs $fromCurrent")
+    private fun createFakeOverrides(invoke: FunctionDescriptor?): List<DeclarationDescriptor> {
+        val result = ArrayList<DeclarationDescriptor>(3)
+        val allSuperDescriptors = functionClass.getTypeConstructor().getSupertypes()
+                .flatMap { it.getMemberScope().getAllDescriptors() }
+                .filterIsInstance<CallableMemberDescriptor>()
+        for ((name, group) in allSuperDescriptors.groupBy { it.getName() }) {
+            for ((isFunction, descriptors) in group.groupBy { it is FunctionDescriptor }) {
+                OverridingUtil.generateOverridesInFunctionGroup(
+                        name,
+                        /* membersFromSupertypes = */ descriptors,
+                        /* membersFromCurrent = */ if (isFunction && name == invoke?.getName()) listOf(invoke) else listOf(),
+                        functionClass,
+                        object : OverridingUtil.DescriptorSink {
+                            override fun addFakeOverride(fakeOverride: CallableMemberDescriptor) {
+                                OverridingUtil.resolveUnknownVisibilityForMember(fakeOverride, null)
+                                result.add(fakeOverride)
+                            }
+
+                            override fun conflict(fromSuper: CallableMemberDescriptor, fromCurrent: CallableMemberDescriptor) {
+                                error("Conflict in scope of ${getContainingDeclaration()}: $fromSuper vs $fromCurrent")
+                            }
                         }
-                    }
-            )
+                )
+            }
         }
 
         return result
diff --git a/core/descriptors/src/org/jetbrains/kotlin/descriptors/ClassDescriptor.java b/core/descriptors/src/org/jetbrains/kotlin/descriptors/ClassDescriptor.java
index 8a5b89a5d8a..7d5c79af2c8 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/descriptors/ClassDescriptor.java
+++ b/core/descriptors/src/org/jetbrains/kotlin/descriptors/ClassDescriptor.java
@@ -31,6 +31,9 @@ public interface ClassDescriptor extends ClassifierDescriptor, MemberDescriptor,
     @NotNull
     JetScope getMemberScope(@NotNull List<? extends TypeProjection> typeArguments);
 
+    @NotNull
+    JetScope getUnsubstitutedMemberScope();
+
     @NotNull
     JetScope getUnsubstitutedInnerClassesScope();
 
diff --git a/core/descriptors/src/org/jetbrains/kotlin/descriptors/DeclarationDescriptorWithSource.java b/core/descriptors/src/org/jetbrains/kotlin/descriptors/DeclarationDescriptorWithSource.java
index 3fb6c5c672b..8da3c734972 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/descriptors/DeclarationDescriptorWithSource.java
+++ b/core/descriptors/src/org/jetbrains/kotlin/descriptors/DeclarationDescriptorWithSource.java
@@ -21,4 +21,8 @@ import org.jetbrains.annotations.NotNull;
 public interface DeclarationDescriptorWithSource extends DeclarationDescriptor {
     @NotNull
     SourceElement getSource();
+
+    @Override
+    @NotNull
+    DeclarationDescriptorWithSource getOriginal();
 }
diff --git a/core/descriptors/src/org/jetbrains/kotlin/descriptors/ValueParameterDescriptor.java b/core/descriptors/src/org/jetbrains/kotlin/descriptors/ValueParameterDescriptor.java
index ff5b4515c9e..d50adb66272 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/descriptors/ValueParameterDescriptor.java
+++ b/core/descriptors/src/org/jetbrains/kotlin/descriptors/ValueParameterDescriptor.java
@@ -24,6 +24,10 @@ import org.jetbrains.kotlin.types.JetType;
 import java.util.Set;
 
 public interface ValueParameterDescriptor extends VariableDescriptor, ParameterDescriptor {
+    @NotNull
+    @Override
+    CallableDescriptor getContainingDeclaration();
+
     /**
      * Returns the 0-based index of the value parameter in the parameter list of its containing function.
      *
@@ -53,7 +57,7 @@ public interface ValueParameterDescriptor extends VariableDescriptor, ParameterD
     ValueParameterDescriptor getOriginal();
 
     @NotNull
-    ValueParameterDescriptor copy(@NotNull DeclarationDescriptor newOwner, @NotNull Name newName);
+    ValueParameterDescriptor copy(@NotNull CallableDescriptor newOwner, @NotNull Name newName);
 
     /**
      * Parameter p1 overrides p2 iff
diff --git a/core/descriptors/src/org/jetbrains/kotlin/descriptors/VariableDescriptor.java b/core/descriptors/src/org/jetbrains/kotlin/descriptors/VariableDescriptor.java
index cfe8ebb6056..0cc1b7c6080 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/descriptors/VariableDescriptor.java
+++ b/core/descriptors/src/org/jetbrains/kotlin/descriptors/VariableDescriptor.java
@@ -18,7 +18,7 @@ package org.jetbrains.kotlin.descriptors;
 
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.resolve.constants.CompileTimeConstant;
+import org.jetbrains.kotlin.resolve.constants.ConstantValue;
 import org.jetbrains.kotlin.types.JetType;
 import org.jetbrains.kotlin.types.TypeSubstitutor;
 
@@ -36,5 +36,5 @@ public interface VariableDescriptor extends CallableDescriptor {
     boolean isVar();
 
     @Nullable
-    CompileTimeConstant<?> getCompileTimeInitializer();
+    ConstantValue<?> getCompileTimeInitializer();
 }
diff --git a/core/descriptors/src/org/jetbrains/kotlin/descriptors/annotations/AnnotationArgumentVisitor.java b/core/descriptors/src/org/jetbrains/kotlin/descriptors/annotations/AnnotationArgumentVisitor.java
index 80e4162a899..b8038c25956 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/descriptors/annotations/AnnotationArgumentVisitor.java
+++ b/core/descriptors/src/org/jetbrains/kotlin/descriptors/annotations/AnnotationArgumentVisitor.java
@@ -50,6 +50,4 @@ public interface AnnotationArgumentVisitor<R, D> {
     R visitAnnotationValue(AnnotationValue value, D data);
 
     R visitKClassValue(KClassValue value, D data);
-
-    R visitNumberTypeValue(IntegerValueTypeConstant value, D data);
 }
diff --git a/core/descriptors/src/org/jetbrains/kotlin/descriptors/annotations/AnnotationDescriptor.java b/core/descriptors/src/org/jetbrains/kotlin/descriptors/annotations/AnnotationDescriptor.java
index 90332148026..f0a8e72179d 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/descriptors/annotations/AnnotationDescriptor.java
+++ b/core/descriptors/src/org/jetbrains/kotlin/descriptors/annotations/AnnotationDescriptor.java
@@ -19,7 +19,7 @@ package org.jetbrains.kotlin.descriptors.annotations;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.ReadOnly;
 import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor;
-import org.jetbrains.kotlin.resolve.constants.CompileTimeConstant;
+import org.jetbrains.kotlin.resolve.constants.ConstantValue;
 import org.jetbrains.kotlin.types.JetType;
 
 import java.util.Map;
@@ -30,5 +30,5 @@ public interface AnnotationDescriptor {
 
     @NotNull
     @ReadOnly
-    Map<ValueParameterDescriptor, CompileTimeConstant<?>> getAllValueArguments();
+    Map<ValueParameterDescriptor, ConstantValue<?>> getAllValueArguments();
 }
diff --git a/core/descriptors/src/org/jetbrains/kotlin/descriptors/annotations/AnnotationDescriptorImpl.java b/core/descriptors/src/org/jetbrains/kotlin/descriptors/annotations/AnnotationDescriptorImpl.java
index 44479d70dcd..aca2732e1d6 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/descriptors/annotations/AnnotationDescriptorImpl.java
+++ b/core/descriptors/src/org/jetbrains/kotlin/descriptors/annotations/AnnotationDescriptorImpl.java
@@ -19,7 +19,7 @@ package org.jetbrains.kotlin.descriptors.annotations;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor;
 import org.jetbrains.kotlin.renderer.DescriptorRenderer;
-import org.jetbrains.kotlin.resolve.constants.CompileTimeConstant;
+import org.jetbrains.kotlin.resolve.constants.ConstantValue;
 import org.jetbrains.kotlin.types.JetType;
 
 import java.util.Collections;
@@ -27,11 +27,11 @@ import java.util.Map;
 
 public class AnnotationDescriptorImpl implements AnnotationDescriptor {
     private final JetType annotationType;
-    private final Map<ValueParameterDescriptor, CompileTimeConstant<?>> valueArguments;
+    private final Map<ValueParameterDescriptor, ConstantValue<?>> valueArguments;
 
     public AnnotationDescriptorImpl(
             @NotNull JetType annotationType,
-            @NotNull Map<ValueParameterDescriptor, CompileTimeConstant<?>> valueArguments
+            @NotNull Map<ValueParameterDescriptor, ConstantValue<?>> valueArguments
     ) {
         this.annotationType = annotationType;
         this.valueArguments = Collections.unmodifiableMap(valueArguments);
@@ -45,7 +45,7 @@ public class AnnotationDescriptorImpl implements AnnotationDescriptor {
 
     @Override
     @NotNull
-    public Map<ValueParameterDescriptor, CompileTimeConstant<?>> getAllValueArguments() {
+    public Map<ValueParameterDescriptor, ConstantValue<?>> getAllValueArguments() {
         return valueArguments;
     }
 
diff --git a/core/descriptors/src/org/jetbrains/kotlin/descriptors/annotations/AnnotationTarget.kt b/core/descriptors/src/org/jetbrains/kotlin/descriptors/annotations/AnnotationTarget.kt
new file mode 100644
index 00000000000..b28ae42d64e
--- /dev/null
+++ b/core/descriptors/src/org/jetbrains/kotlin/descriptors/annotations/AnnotationTarget.kt
@@ -0,0 +1,57 @@
+/*
+ * Copyright 2010-2015 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.kotlin.descriptors.annotations
+
+import java.util.*
+import kotlin.annotation
+
+// NOTE: this enum must have the same entries with kotlin.annotation.AnnotationTarget
+public enum class AnnotationTarget(val description: String, val isDefault: Boolean = true) {
+    PACKAGE("package"),
+    CLASSIFIER("classifier"),
+    ANNOTATION_CLASS("annotation class"),
+    TYPE_PARAMETER("type parameter", false),
+    PROPERTY("property"),
+    FIELD("field"),
+    LOCAL_VARIABLE("local variable"),
+    VALUE_PARAMETER("value parameter"),
+    CONSTRUCTOR("constructor"),
+    FUNCTION("function"),
+    PROPERTY_GETTER("getter"),
+    PROPERTY_SETTER("setter"),
+    TYPE("type usage", false),
+    EXPRESSION("expression", false),
+    FILE("file", false);
+
+    companion object {
+
+        private val map = HashMap<String, AnnotationTarget>()
+
+        init {
+            for (target in AnnotationTarget.values()) {
+                map[target.name()] = target
+            }
+        }
+
+        public fun valueOrNull(name: String): AnnotationTarget? = map[name]
+
+        public val DEFAULT_TARGET_SET: Set<AnnotationTarget> = values().filter { it.isDefault }.toSet()
+
+        public val ALL_TARGET_SET: Set<AnnotationTarget> = values().toSet()
+
+    }
+}
\ No newline at end of file
diff --git a/core/descriptors/src/org/jetbrains/kotlin/descriptors/annotations/Annotations.kt b/core/descriptors/src/org/jetbrains/kotlin/descriptors/annotations/Annotations.kt
index c008c9559d3..03a1cc364d5 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/descriptors/annotations/Annotations.kt
+++ b/core/descriptors/src/org/jetbrains/kotlin/descriptors/annotations/Annotations.kt
@@ -17,6 +17,7 @@
 package org.jetbrains.kotlin.descriptors.annotations
 
 import org.jetbrains.kotlin.name.FqName
+import org.jetbrains.kotlin.resolve.DescriptorUtils
 
 public trait Annotations : Iterable<AnnotationDescriptor> {
 
@@ -40,3 +41,41 @@ public trait Annotations : Iterable<AnnotationDescriptor> {
         }
     }
 }
+
+class FilteredAnnotations(
+        private val delegate: Annotations,
+        private val fqNameFilter: (FqName) -> Boolean
+) : Annotations {
+    override fun findAnnotation(fqName: FqName) =
+            if (fqNameFilter(fqName)) delegate.findAnnotation(fqName)
+            else null
+
+    override fun findExternalAnnotation(fqName: FqName) =
+            if (fqNameFilter(fqName)) delegate.findExternalAnnotation(fqName)
+            else null
+
+    override fun iterator() = delegate.sequence()
+            .filter { annotation ->
+                val descriptor = annotation.getType().getConstructor().getDeclarationDescriptor()
+                descriptor != null && DescriptorUtils.getFqName(descriptor).let { fqName ->
+                    fqName.isSafe() && fqNameFilter(fqName.toSafe())
+                }
+            }
+            .iterator()
+
+    override fun isEmpty() = !iterator().hasNext()
+}
+
+class CompositeAnnotations(
+        private val delegates: List<Annotations>
+) : Annotations {
+    constructor(vararg delegates: Annotations): this(delegates.toList())
+
+    override fun isEmpty() = delegates.all { it.isEmpty() }
+
+    override fun findAnnotation(fqName: FqName) = delegates.asSequence().map { it.findAnnotation(fqName) }.filterNotNull().firstOrNull()
+
+    override fun findExternalAnnotation(fqName: FqName) = delegates.asSequence().map { it.findExternalAnnotation(fqName) }.filterNotNull().firstOrNull()
+
+    override fun iterator() = delegates.asSequence().flatMap { it.asSequence() }.iterator()
+}
\ No newline at end of file
diff --git a/core/descriptors/src/org/jetbrains/kotlin/descriptors/annotations/DefaultAnnotationArgumentVisitor.java b/core/descriptors/src/org/jetbrains/kotlin/descriptors/annotations/DefaultAnnotationArgumentVisitor.java
index 96cbcb6da63..b9322932867 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/descriptors/annotations/DefaultAnnotationArgumentVisitor.java
+++ b/core/descriptors/src/org/jetbrains/kotlin/descriptors/annotations/DefaultAnnotationArgumentVisitor.java
@@ -21,7 +21,7 @@ import org.jetbrains.kotlin.resolve.constants.*;
 import org.jetbrains.kotlin.resolve.constants.StringValue;
 
 public abstract class DefaultAnnotationArgumentVisitor<R, D> implements AnnotationArgumentVisitor<R, D> {
-    public abstract R visitValue(@NotNull CompileTimeConstant<?> value, D data);
+    public abstract R visitValue(@NotNull ConstantValue<?> value, D data);
 
     @Override
     public R visitLongValue(@NotNull LongValue value, D data) {
@@ -92,9 +92,4 @@ public abstract class DefaultAnnotationArgumentVisitor<R, D> implements Annotati
     public R visitAnnotationValue(AnnotationValue value, D data) {
         return visitValue(value, data);
     }
-
-    @Override
-    public R visitNumberTypeValue(IntegerValueTypeConstant value, D data) {
-        return visitValue(value, data);
-    }
 }
diff --git a/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/AbstractClassDescriptor.java b/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/AbstractClassDescriptor.java
index 336195d6f3d..5ed6bfc0e36 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/AbstractClassDescriptor.java
+++ b/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/AbstractClassDescriptor.java
@@ -41,13 +41,13 @@ public abstract class AbstractClassDescriptor implements ClassDescriptor {
         this.defaultType = storageManager.createLazyValue(new Function0<JetType>() {
             @Override
             public JetType invoke() {
-                return TypeUtils.makeUnsubstitutedType(AbstractClassDescriptor.this, getScopeForMemberLookup());
+                return TypeUtils.makeUnsubstitutedType(AbstractClassDescriptor.this, getUnsubstitutedMemberScope());
             }
         });
         this.unsubstitutedInnerClassesScope = storageManager.createLazyValue(new Function0<JetScope>() {
             @Override
             public JetScope invoke() {
-                return new InnerClassesScopeWrapper(getScopeForMemberLookup());
+                return new InnerClassesScopeWrapper(getUnsubstitutedMemberScope());
             }
         });
         this.thisAsReceiverParameter = storageManager.createLazyValue(new Function0<ReceiverParameterDescriptor>() {
@@ -66,13 +66,10 @@ public abstract class AbstractClassDescriptor implements ClassDescriptor {
 
     @NotNull
     @Override
-    public DeclarationDescriptor getOriginal() {
+    public DeclarationDescriptorWithSource getOriginal() {
         return this;
     }
 
-    @NotNull
-    protected abstract JetScope getScopeForMemberLookup();
-
     @NotNull
     @Override
     public JetScope getUnsubstitutedInnerClassesScope() {
@@ -91,13 +88,13 @@ public abstract class AbstractClassDescriptor implements ClassDescriptor {
         assert typeArguments.size() == getTypeConstructor().getParameters().size() : "Illegal number of type arguments: expected "
                                                                                      + getTypeConstructor().getParameters().size() + " but was " + typeArguments.size()
                                                                                      + " for " + getTypeConstructor() + " " + getTypeConstructor().getParameters();
-        if (typeArguments.isEmpty()) return getScopeForMemberLookup();
+        if (typeArguments.isEmpty()) return getUnsubstitutedMemberScope();
 
         List<TypeParameterDescriptor> typeParameters = getTypeConstructor().getParameters();
         Map<TypeConstructor, TypeProjection> substitutionContext = TypeSubstitutor.buildSubstitutionContext(typeParameters, typeArguments);
 
         TypeSubstitutor substitutor = TypeSubstitutor.create(substitutionContext);
-        return new SubstitutingScope(getScopeForMemberLookup(), substitutor);
+        return new SubstitutingScope(getUnsubstitutedMemberScope(), substitutor);
     }
 
     @NotNull
diff --git a/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/AbstractReceiverParameterDescriptor.java b/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/AbstractReceiverParameterDescriptor.java
index 34e90c54d6f..2b9d78b72c2 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/AbstractReceiverParameterDescriptor.java
+++ b/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/AbstractReceiverParameterDescriptor.java
@@ -44,7 +44,7 @@ public abstract class AbstractReceiverParameterDescriptor extends DeclarationDes
         JetType substitutedType = substitutor.substitute(getType(), Variance.INVARIANT);
         if (substitutedType == null) return null;
 
-        return new ReceiverParameterDescriptorImpl(getContainingDeclaration(), substitutedType, new TransientReceiver(substitutedType));
+        return new ReceiverParameterDescriptorImpl(getContainingDeclaration(), new TransientReceiver(substitutedType));
     }
 
     @Override
@@ -76,6 +76,12 @@ public abstract class AbstractReceiverParameterDescriptor extends DeclarationDes
         return getType();
     }
 
+    @NotNull
+    @Override
+    public JetType getType() {
+        return getValue().getType();
+    }
+
     @NotNull
     @Override
     public List<ValueParameterDescriptor> getValueParameters() {
diff --git a/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/AbstractTypeParameterDescriptor.java b/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/AbstractTypeParameterDescriptor.java
index 0726e92893f..6a094e436d2 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/AbstractTypeParameterDescriptor.java
+++ b/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/AbstractTypeParameterDescriptor.java
@@ -19,7 +19,6 @@ package org.jetbrains.kotlin.descriptors.impl;
 import kotlin.jvm.functions.Function0;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.ReadOnly;
-import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor;
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptorVisitor;
 import org.jetbrains.kotlin.descriptors.SourceElement;
@@ -36,6 +35,8 @@ import org.jetbrains.kotlin.types.checker.JetTypeChecker;
 import java.util.Collections;
 import java.util.Set;
 
+import static org.jetbrains.kotlin.resolve.descriptorUtil.DescriptorUtilPackage.getBuiltIns;
+
 public abstract class AbstractTypeParameterDescriptor extends DeclarationDescriptorNonRootImpl implements TypeParameterDescriptor {
     private final Variance variance;
     private final boolean reified;
@@ -135,7 +136,7 @@ public abstract class AbstractTypeParameterDescriptor extends DeclarationDescrip
         Set<JetType> upperBounds = getUpperBounds();
         assert !upperBounds.isEmpty() : "Upper bound list is empty in " + getName();
         JetType upperBoundsAsType = TypeUtils.intersect(JetTypeChecker.DEFAULT, upperBounds);
-        return upperBoundsAsType != null ? upperBoundsAsType : KotlinBuiltIns.getInstance().getNothingType();
+        return upperBoundsAsType != null ? upperBoundsAsType : getBuiltIns(this).getNothingType();
     }
 
     @NotNull
@@ -153,7 +154,7 @@ public abstract class AbstractTypeParameterDescriptor extends DeclarationDescrip
     @NotNull
     @Override
     public Set<JetType> getLowerBounds() {
-        return Collections.singleton(KotlinBuiltIns.getInstance().getNothingType());
+        return Collections.singleton(getBuiltIns(this).getNothingType());
     }
 
     @NotNull
diff --git a/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/ClassDescriptorImpl.java b/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/ClassDescriptorImpl.java
index 430f05928eb..f67ab43650a 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/ClassDescriptorImpl.java
+++ b/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/ClassDescriptorImpl.java
@@ -37,7 +37,7 @@ public class ClassDescriptorImpl extends ClassDescriptorBase {
     private final TypeConstructor typeConstructor;
     private final JetScope staticScope = new StaticScopeForKotlinClass(this);
 
-    private JetScope scopeForMemberLookup;
+    private JetScope unsubstitutedMemberScope;
     private Set<ConstructorDescriptor> constructors;
     private ConstructorDescriptor primaryConstructor;
 
@@ -56,11 +56,11 @@ public class ClassDescriptorImpl extends ClassDescriptorBase {
     }
 
     public final void initialize(
-            @NotNull JetScope scopeForMemberLookup,
+            @NotNull JetScope unsubstitutedMemberScope,
             @NotNull Set<ConstructorDescriptor> constructors,
             @Nullable ConstructorDescriptor primaryConstructor
     ) {
-        this.scopeForMemberLookup = scopeForMemberLookup;
+        this.unsubstitutedMemberScope = unsubstitutedMemberScope;
         this.constructors = constructors;
         this.primaryConstructor = primaryConstructor;
     }
@@ -89,8 +89,8 @@ public class ClassDescriptorImpl extends ClassDescriptorBase {
 
     @NotNull
     @Override
-    protected JetScope getScopeForMemberLookup() {
-        return scopeForMemberLookup;
+    public JetScope getUnsubstitutedMemberScope() {
+        return unsubstitutedMemberScope;
     }
 
     @NotNull
diff --git a/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/DeclarationDescriptorNonRootImpl.java b/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/DeclarationDescriptorNonRootImpl.java
index 018cf921e16..6b83fd6d018 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/DeclarationDescriptorNonRootImpl.java
+++ b/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/DeclarationDescriptorNonRootImpl.java
@@ -19,6 +19,7 @@ package org.jetbrains.kotlin.descriptors.impl;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor;
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptorNonRoot;
+import org.jetbrains.kotlin.descriptors.DeclarationDescriptorWithSource;
 import org.jetbrains.kotlin.descriptors.SourceElement;
 import org.jetbrains.kotlin.descriptors.annotations.Annotations;
 import org.jetbrains.kotlin.name.Name;
@@ -45,6 +46,12 @@ public abstract class DeclarationDescriptorNonRootImpl
         this.source = source;
     }
 
+    @NotNull
+    @Override
+    public DeclarationDescriptorWithSource getOriginal() {
+        return (DeclarationDescriptorWithSource) super.getOriginal();
+    }
+
     @Override
     @NotNull
     public DeclarationDescriptor getContainingDeclaration() {
diff --git a/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/EnumEntrySyntheticClassDescriptor.java b/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/EnumEntrySyntheticClassDescriptor.java
index 9ea7d184fd2..7fe50931fc8 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/EnumEntrySyntheticClassDescriptor.java
+++ b/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/EnumEntrySyntheticClassDescriptor.java
@@ -91,7 +91,7 @@ public class EnumEntrySyntheticClassDescriptor extends ClassDescriptorBase {
 
     @NotNull
     @Override
-    protected JetScope getScopeForMemberLookup() {
+    public JetScope getUnsubstitutedMemberScope() {
         return scope;
     }
 
@@ -235,7 +235,7 @@ public class EnumEntrySyntheticClassDescriptor extends ClassDescriptorBase {
                     new OverridingUtil.DescriptorSink() {
                         @Override
                         @SuppressWarnings("unchecked")
-                        public void addToScope(@NotNull CallableMemberDescriptor fakeOverride) {
+                        public void addFakeOverride(@NotNull CallableMemberDescriptor fakeOverride) {
                             OverridingUtil.resolveUnknownVisibilityForMember(fakeOverride, null);
                             result.add((D) fakeOverride);
                         }
diff --git a/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/FunctionDescriptorImpl.java b/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/FunctionDescriptorImpl.java
index 3ce0941e14b..dfb6b614f3e 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/FunctionDescriptorImpl.java
+++ b/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/FunctionDescriptorImpl.java
@@ -197,6 +197,31 @@ public abstract class FunctionDescriptorImpl extends DeclarationDescriptorNonRoo
             @Nullable FunctionDescriptor original,
             boolean copyOverrides,
             @NotNull Kind kind
+    ) {
+        return doSubstitute(originalSubstitutor,
+                newOwner, newModality, newVisibility, original, copyOverrides, kind,
+                getValueParameters(), getExtensionReceiverParameterType(), getReturnType()
+        );
+    }
+
+    @Nullable
+    protected JetType getExtensionReceiverParameterType() {
+        if (extensionReceiverParameter == null) return null;
+        return extensionReceiverParameter.getType();
+    }
+
+
+    @Nullable
+    protected FunctionDescriptor doSubstitute(@NotNull TypeSubstitutor originalSubstitutor,
+            @NotNull DeclarationDescriptor newOwner,
+            @NotNull Modality newModality,
+            @NotNull Visibility newVisibility,
+            @Nullable FunctionDescriptor original,
+            boolean copyOverrides,
+            @NotNull Kind kind,
+            @NotNull List<ValueParameterDescriptor> newValueParameterDescriptors,
+            @Nullable JetType newExtensionReceiverParameterType,
+            @NotNull JetType newReturnType
     ) {
         FunctionDescriptorImpl substitutedDescriptor = createSubstitutedCopy(newOwner, original, kind);
 
@@ -207,8 +232,8 @@ public abstract class FunctionDescriptorImpl extends DeclarationDescriptorNonRoo
         );
 
         JetType substitutedReceiverParameterType = null;
-        if (extensionReceiverParameter != null) {
-            substitutedReceiverParameterType = substitutor.substitute(getExtensionReceiverParameter().getType(), Variance.IN_VARIANCE);
+        if (newExtensionReceiverParameterType != null) {
+            substitutedReceiverParameterType = substitutor.substitute(newExtensionReceiverParameterType, Variance.IN_VARIANCE);
             if (substitutedReceiverParameterType == null) {
                 return null;
             }
@@ -232,12 +257,14 @@ public abstract class FunctionDescriptorImpl extends DeclarationDescriptorNonRoo
             }
         }
 
-        List<ValueParameterDescriptor> substitutedValueParameters = getSubstitutedValueParameters(substitutedDescriptor, this, substitutor);
+        List<ValueParameterDescriptor> substitutedValueParameters = getSubstitutedValueParameters(
+                substitutedDescriptor, newValueParameterDescriptors, substitutor
+        );
         if (substitutedValueParameters == null) {
             return null;
         }
 
-        JetType substitutedReturnType = substitutor.substitute(getReturnType(), Variance.OUT_VARIANCE);
+        JetType substitutedReturnType = substitutor.substitute(newReturnType, Variance.OUT_VARIANCE);
         if (substitutedReturnType == null) {
             return null;
         }
@@ -272,9 +299,12 @@ public abstract class FunctionDescriptorImpl extends DeclarationDescriptorNonRoo
     }
 
     @Nullable
-    public static List<ValueParameterDescriptor> getSubstitutedValueParameters(FunctionDescriptor substitutedDescriptor, @NotNull FunctionDescriptor functionDescriptor, @NotNull TypeSubstitutor substitutor) {
+    public static List<ValueParameterDescriptor> getSubstitutedValueParameters(
+            FunctionDescriptor substitutedDescriptor,
+            @NotNull List<ValueParameterDescriptor> unsubstitutedValueParameters,
+            @NotNull TypeSubstitutor substitutor
+    ) {
         List<ValueParameterDescriptor> result = new ArrayList<ValueParameterDescriptor>();
-        List<ValueParameterDescriptor> unsubstitutedValueParameters = functionDescriptor.getValueParameters();
         for (ValueParameterDescriptor unsubstitutedValueParameter : unsubstitutedValueParameters) {
             // TODO : Lazy?
             JetType substitutedType = substitutor.substitute(unsubstitutedValueParameter.getType(), Variance.IN_VARIANCE);
diff --git a/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/LazyClassReceiverParameterDescriptor.java b/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/LazyClassReceiverParameterDescriptor.java
index f7dfdb12912..eacd090d67b 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/LazyClassReceiverParameterDescriptor.java
+++ b/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/LazyClassReceiverParameterDescriptor.java
@@ -21,7 +21,6 @@ import org.jetbrains.kotlin.descriptors.ClassDescriptor;
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor;
 import org.jetbrains.kotlin.resolve.scopes.receivers.ClassReceiver;
 import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue;
-import org.jetbrains.kotlin.types.JetType;
 
 public class LazyClassReceiverParameterDescriptor extends AbstractReceiverParameterDescriptor {
     private final ClassDescriptor descriptor;
@@ -32,12 +31,6 @@ public class LazyClassReceiverParameterDescriptor extends AbstractReceiverParame
         this.receiverValue = new ClassReceiver(descriptor);
     }
 
-    @NotNull
-    @Override
-    public JetType getType() {
-        return descriptor.getDefaultType();
-    }
-
     @NotNull
     @Override
     public ReceiverValue getValue() {
diff --git a/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/LazySubstitutingClassDescriptor.java b/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/LazySubstitutingClassDescriptor.java
index aeb3b18cbee..6783de5f75e 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/LazySubstitutingClassDescriptor.java
+++ b/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/LazySubstitutingClassDescriptor.java
@@ -97,6 +97,16 @@ public class LazySubstitutingClassDescriptor implements ClassDescriptor {
         return new SubstitutingScope(memberScope, getSubstitutor());
     }
 
+    @NotNull
+    @Override
+    public JetScope getUnsubstitutedMemberScope() {
+        JetScope memberScope = original.getUnsubstitutedMemberScope();
+        if (originalSubstitutor.isEmpty()) {
+            return memberScope;
+        }
+        return new SubstitutingScope(memberScope, getSubstitutor());
+    }
+
     @NotNull
     @Override
     public JetScope getStaticScope() {
@@ -146,7 +156,7 @@ public class LazySubstitutingClassDescriptor implements ClassDescriptor {
 
     @NotNull
     @Override
-    public DeclarationDescriptor getOriginal() {
+    public DeclarationDescriptorWithSource getOriginal() {
         return original.getOriginal();
     }
 
diff --git a/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/ModuleDescriptorImpl.kt b/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/ModuleDescriptorImpl.kt
index 6a337c85acc..d33fd496b39 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/ModuleDescriptorImpl.kt
+++ b/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/ModuleDescriptorImpl.kt
@@ -32,7 +32,8 @@ import kotlin.properties.Delegates
 public class ModuleDescriptorImpl(
         moduleName: Name,
         private val storageManager: StorageManager,
-        private val moduleParameters: ModuleParameters
+        private val moduleParameters: ModuleParameters,
+        override val builtIns: KotlinBuiltIns
 ) : DeclarationDescriptorImpl(Annotations.EMPTY, moduleName), ModuleDescriptor, ModuleParameters by moduleParameters {
     init {
         if (!moduleName.isSpecial()) {
@@ -40,6 +41,12 @@ public class ModuleDescriptorImpl(
         }
     }
 
+    public constructor(
+            moduleName: Name,
+            storageManager: StorageManager,
+            moduleParameters: ModuleParameters
+    ) : this(moduleName, storageManager, moduleParameters, KotlinBuiltIns.getInstance())
+
     private var dependencies: ModuleDependencies? = null
     private var packageFragmentProviderForModuleContent: PackageFragmentProvider? = null
 
@@ -102,9 +109,6 @@ public class ModuleDescriptorImpl(
         assert(friend != this) { "Attempt to make module $id a friend to itself" }
         friendModules.add(friend)
     }
-
-    override val builtIns: KotlinBuiltIns
-        get() = KotlinBuiltIns.getInstance()
 }
 
 public interface ModuleDependencies {
diff --git a/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/PropertyDescriptorImpl.java b/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/PropertyDescriptorImpl.java
index b03a1c84f8b..cd3c802a72d 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/PropertyDescriptorImpl.java
+++ b/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/PropertyDescriptorImpl.java
@@ -18,6 +18,7 @@ package org.jetbrains.kotlin.descriptors.impl;
 
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
+import org.jetbrains.annotations.ReadOnly;
 import org.jetbrains.kotlin.descriptors.*;
 import org.jetbrains.kotlin.descriptors.annotations.Annotations;
 import org.jetbrains.kotlin.name.Name;
@@ -82,7 +83,7 @@ public class PropertyDescriptorImpl extends VariableDescriptorImpl implements Pr
 
     public void setType(
             @NotNull JetType outType,
-            @NotNull List<? extends TypeParameterDescriptor> typeParameters,
+            @ReadOnly @NotNull List<? extends TypeParameterDescriptor> typeParameters,
             @Nullable ReceiverParameterDescriptor dispatchReceiverParameter,
             @Nullable JetType receiverType
     ) {
@@ -92,7 +93,7 @@ public class PropertyDescriptorImpl extends VariableDescriptorImpl implements Pr
 
     public void setType(
             @NotNull JetType outType,
-            @NotNull List<? extends TypeParameterDescriptor> typeParameters,
+            @ReadOnly @NotNull List<? extends TypeParameterDescriptor> typeParameters,
             @Nullable ReceiverParameterDescriptor dispatchReceiverParameter,
             @Nullable ReceiverParameterDescriptor extensionReceiverParameter
     ) {
@@ -255,7 +256,9 @@ public class PropertyDescriptorImpl extends VariableDescriptorImpl implements Pr
                 setter.hasBody(), setter.isDefault(), kind, original == null ? null : original.getSetter(), SourceElement.NO_SOURCE
         );
         if (newSetter != null) {
-            List<ValueParameterDescriptor> substitutedValueParameters = FunctionDescriptorImpl.getSubstitutedValueParameters(newSetter, setter, substitutor);
+            List<ValueParameterDescriptor> substitutedValueParameters = FunctionDescriptorImpl.getSubstitutedValueParameters(
+                    newSetter, setter.getValueParameters(), substitutor
+            );
             if (substitutedValueParameters == null) {
                 // The setter is projected out, e.g. in this case:
                 //     trait Tr<T> { var v: T }
diff --git a/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/ReceiverParameterDescriptorImpl.java b/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/ReceiverParameterDescriptorImpl.java
index 7a32f1b54f3..cbc87e8d9e7 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/ReceiverParameterDescriptorImpl.java
+++ b/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/ReceiverParameterDescriptorImpl.java
@@ -19,29 +19,16 @@ package org.jetbrains.kotlin.descriptors.impl;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor;
 import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue;
-import org.jetbrains.kotlin.types.JetType;
 
 public class ReceiverParameterDescriptorImpl extends AbstractReceiverParameterDescriptor {
     private final DeclarationDescriptor containingDeclaration;
-    private final JetType type;
     private final ReceiverValue value;
 
-    public ReceiverParameterDescriptorImpl(
-            @NotNull DeclarationDescriptor containingDeclaration,
-            @NotNull JetType type,
-            @NotNull ReceiverValue value
-    ) {
+    public ReceiverParameterDescriptorImpl(@NotNull DeclarationDescriptor containingDeclaration, @NotNull ReceiverValue value) {
         this.containingDeclaration = containingDeclaration;
-        this.type = type;
         this.value = value;
     }
 
-    @NotNull
-    @Override
-    public JetType getType() {
-        return type;
-    }
-
     @NotNull
     @Override
     public ReceiverValue getValue() {
diff --git a/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/ValueParameterDescriptorImpl.java b/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/ValueParameterDescriptorImpl.java
index 9d2b2909f1f..af4f31cc1d8 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/ValueParameterDescriptorImpl.java
+++ b/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/ValueParameterDescriptorImpl.java
@@ -39,7 +39,7 @@ public class ValueParameterDescriptorImpl extends VariableDescriptorImpl impleme
     private final Set<? extends ValueParameterDescriptor> readOnlyOverriddenDescriptors = Collections.unmodifiableSet(overriddenDescriptors);
 
     public ValueParameterDescriptorImpl(
-            @NotNull DeclarationDescriptor containingDeclaration,
+            @NotNull CallableDescriptor containingDeclaration,
             @Nullable ValueParameterDescriptor original,
             int index,
             @NotNull Annotations annotations,
@@ -56,6 +56,12 @@ public class ValueParameterDescriptorImpl extends VariableDescriptorImpl impleme
         this.varargElementType = varargElementType;
     }
 
+    @NotNull
+    @Override
+    public CallableDescriptor getContainingDeclaration() {
+        return (CallableDescriptor) super.getContainingDeclaration();
+    }
+
     public void setType(@NotNull JetType type) {
         setOutType(type);
     }
@@ -124,8 +130,11 @@ public class ValueParameterDescriptorImpl extends VariableDescriptorImpl impleme
 
     @NotNull
     @Override
-    public ValueParameterDescriptor copy(@NotNull DeclarationDescriptor newOwner, @NotNull Name newName) {
-        return new ValueParameterDescriptorImpl(newOwner, null, index, getAnnotations(), newName, getType(), declaresDefaultValue(), varargElementType, SourceElement.NO_SOURCE);
+    public ValueParameterDescriptor copy(@NotNull CallableDescriptor newOwner, @NotNull Name newName) {
+        return new ValueParameterDescriptorImpl(
+                newOwner, null, index, getAnnotations(), newName, getType(), declaresDefaultValue(), varargElementType,
+                SourceElement.NO_SOURCE
+        );
     }
 
     @NotNull
diff --git a/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/VariableDescriptorImpl.java b/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/VariableDescriptorImpl.java
index 74b418f1f80..45fc6153c27 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/VariableDescriptorImpl.java
+++ b/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/VariableDescriptorImpl.java
@@ -21,7 +21,7 @@ import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.descriptors.*;
 import org.jetbrains.kotlin.descriptors.annotations.Annotations;
 import org.jetbrains.kotlin.name.Name;
-import org.jetbrains.kotlin.resolve.constants.CompileTimeConstant;
+import org.jetbrains.kotlin.resolve.constants.ConstantValue;
 import org.jetbrains.kotlin.storage.NullableLazyValue;
 import org.jetbrains.kotlin.types.JetType;
 import org.jetbrains.kotlin.types.LazyType;
@@ -32,7 +32,7 @@ import java.util.Set;
 
 public abstract class VariableDescriptorImpl extends DeclarationDescriptorNonRootImpl implements VariableDescriptor {
     private JetType outType;
-    private NullableLazyValue<CompileTimeConstant<?>> compileTimeInitializer;
+    protected NullableLazyValue<ConstantValue<?>> compileTimeInitializer;
 
     public VariableDescriptorImpl(
             @NotNull DeclarationDescriptor containingDeclaration,
@@ -59,7 +59,7 @@ public abstract class VariableDescriptorImpl extends DeclarationDescriptorNonRoo
 
     @Nullable
     @Override
-    public CompileTimeConstant<?> getCompileTimeInitializer() {
+    public ConstantValue<?> getCompileTimeInitializer() {
         // Force computation and setting of compileTimeInitializer, if needed
         if (compileTimeInitializer == null && outType instanceof LazyType) {
             outType.getConstructor();
@@ -71,7 +71,7 @@ public abstract class VariableDescriptorImpl extends DeclarationDescriptorNonRoo
         return null;
     }
 
-    public void setCompileTimeInitializer(@NotNull NullableLazyValue<CompileTimeConstant<?>> compileTimeInitializer) {
+    public void setCompileTimeInitializer(@NotNull NullableLazyValue<ConstantValue<?>> compileTimeInitializer) {
         assert !isVar() : "Compile-time value for property initializer should be recorded only for final variables " + getName();
         this.compileTimeInitializer = compileTimeInitializer;
     }
diff --git a/core/descriptors/src/org/jetbrains/kotlin/renderer/DescriptorRenderer.kt b/core/descriptors/src/org/jetbrains/kotlin/renderer/DescriptorRenderer.kt
index 01a38387c11..422e3036d08 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/renderer/DescriptorRenderer.kt
+++ b/core/descriptors/src/org/jetbrains/kotlin/renderer/DescriptorRenderer.kt
@@ -140,7 +140,7 @@ public interface DescriptorRenderer : Renderer<DeclarationDescriptor> {
                 ClassKind.INTERFACE -> "interface"
                 ClassKind.ENUM_CLASS -> "enum class"
                 ClassKind.OBJECT -> "object"
-                ClassKind.ANNOTATION_CLASS -> "annotation class"
+                ClassKind.ANNOTATION_CLASS -> "class"
                 ClassKind.ENUM_ENTRY -> "enum entry"
             }
         }
@@ -176,6 +176,7 @@ public interface DescriptorRendererOptions {
     public var flexibleTypesForCode: Boolean
     public var secondaryConstructorsAsPrimary: Boolean
     public var renderAccessors: Boolean
+    public var renderDefaultAnnotationArguments: Boolean
 }
 
 public enum class RenderingFormat {
diff --git a/core/descriptors/src/org/jetbrains/kotlin/renderer/DescriptorRendererImpl.kt b/core/descriptors/src/org/jetbrains/kotlin/renderer/DescriptorRendererImpl.kt
index 6678fa46a11..9179d91944b 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/renderer/DescriptorRendererImpl.kt
+++ b/core/descriptors/src/org/jetbrains/kotlin/renderer/DescriptorRendererImpl.kt
@@ -20,23 +20,20 @@ import org.jetbrains.kotlin.builtins.KotlinBuiltIns
 import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.descriptors.annotations.Annotated
 import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptor
-import org.jetbrains.kotlin.descriptors.annotations.DefaultAnnotationArgumentVisitor
-import org.jetbrains.kotlin.descriptors.impl.DeclarationDescriptorVisitorEmptyBodies
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.FqNameBase
-import org.jetbrains.kotlin.name.FqNameUnsafe
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.resolve.DescriptorUtils
-import org.jetbrains.kotlin.resolve.constants.*
+import org.jetbrains.kotlin.resolve.DescriptorUtils.isCompanionObject
+import org.jetbrains.kotlin.resolve.constants.AnnotationValue
+import org.jetbrains.kotlin.resolve.constants.ArrayValue
+import org.jetbrains.kotlin.resolve.constants.ConstantValue
+import org.jetbrains.kotlin.resolve.constants.KClassValue
 import org.jetbrains.kotlin.types.*
 import org.jetbrains.kotlin.types.ErrorUtils.UninferredParameterTypeConstructor
-import org.jetbrains.kotlin.types.error.MissingDependencyErrorClass
-import org.jetbrains.kotlin.utils.*
-
-import java.util.*
-
-import org.jetbrains.kotlin.resolve.DescriptorUtils.isCompanionObject
 import org.jetbrains.kotlin.types.TypeUtils.CANT_INFER_FUNCTION_PARAM_TYPE
+import org.jetbrains.kotlin.types.error.MissingDependencyErrorClass
+import java.util.ArrayList
 
 internal class DescriptorRendererImpl(
         val options: DescriptorRendererOptionsImpl
@@ -366,20 +363,29 @@ internal class DescriptorRendererImpl(
     }
 
     private fun renderAndSortAnnotationArguments(descriptor: AnnotationDescriptor): List<String> {
-        return descriptor.getAllValueArguments().entrySet()
+        val allValueArguments = descriptor.getAllValueArguments()
+        val classDescriptor = if (renderDefaultAnnotationArguments) TypeUtils.getClassDescriptor(descriptor.getType()) else null
+        val parameterDescriptorsWithDefaultValue = classDescriptor?.getUnsubstitutedPrimaryConstructor()?.getValueParameters()?.filter {
+            it.declaresDefaultValue()
+        } ?: emptyList()
+        val defaultList = parameterDescriptorsWithDefaultValue.filter { !allValueArguments.containsKey(it) }.map {
+            "${it.getName().asString()} = ..."
+        }.sort()
+        val argumentList = allValueArguments.entrySet()
                 .map { entry ->
                     val name = entry.key.getName().asString()
-                    val value = renderConstant(entry.value)
+                    val value = if (!parameterDescriptorsWithDefaultValue.contains(entry.key)) renderConstant(entry.value) else "..."
                     "$name = $value"
                 }
                 .sort()
+        return (defaultList + argumentList).sort()
     }
 
-    private fun renderConstant(value: CompileTimeConstant<*>): String {
+    private fun renderConstant(value: ConstantValue<*>): String {
         return when (value) {
-            is ArrayValue -> value.getValue().map { renderConstant(it) }.joinToString(", ", "{", "}")
-            is AnnotationValue -> renderAnnotation(value.getValue())
-            is KClassValue -> renderType(value.getValue()) + "::class"
+            is ArrayValue -> value.value.map { renderConstant(it) }.joinToString(", ", "{", "}")
+            is AnnotationValue -> renderAnnotation(value.value)
+            is KClassValue -> renderType(value.value) + "::class"
             else -> value.toString()
         }
     }
@@ -700,9 +706,8 @@ internal class DescriptorRendererImpl(
 
     private fun renderInitializer(variable: VariableDescriptor, builder: StringBuilder) {
         if (includePropertyConstant) {
-            val initializer = variable.getCompileTimeInitializer()
-            if (initializer != null) {
-                builder.append(" = ").append(escape(renderConstant(initializer)))
+            variable.getCompileTimeInitializer()?.let { constant ->
+                builder.append(" = ").append(escape(renderConstant(constant)))
             }
         }
     }
@@ -870,8 +875,13 @@ internal class DescriptorRendererImpl(
     private fun replacePrefixes(lowerRendered: String, lowerPrefix: String, upperRendered: String, upperPrefix: String, foldedPrefix: String): String? {
         if (lowerRendered.startsWith(lowerPrefix) && upperRendered.startsWith(upperPrefix)) {
             val lowerWithoutPrefix = lowerRendered.substring(lowerPrefix.length())
-            if (differsOnlyInNullability(lowerWithoutPrefix, upperRendered.substring(upperPrefix.length()))) {
-                return foldedPrefix + lowerWithoutPrefix + "!"
+            val upperWithoutPrefix = upperRendered.substring(upperPrefix.length())
+            val flexibleCollectionName = foldedPrefix + lowerWithoutPrefix
+
+            if (lowerWithoutPrefix == upperWithoutPrefix) return flexibleCollectionName
+
+            if (differsOnlyInNullability(lowerWithoutPrefix, upperWithoutPrefix)) {
+                return flexibleCollectionName + "!"
             }
         }
         return null
diff --git a/core/descriptors/src/org/jetbrains/kotlin/renderer/DescriptorRendererOptionsImpl.kt b/core/descriptors/src/org/jetbrains/kotlin/renderer/DescriptorRendererOptionsImpl.kt
index 51c0b33739d..29613c13b51 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/renderer/DescriptorRendererOptionsImpl.kt
+++ b/core/descriptors/src/org/jetbrains/kotlin/renderer/DescriptorRendererOptionsImpl.kt
@@ -85,6 +85,7 @@ internal class DescriptorRendererOptionsImpl : DescriptorRendererOptions {
     override var receiverAfterName by property(false)
     override var renderCompanionObjectName by property(false)
     override var renderAccessors by property(false)
+    override var renderDefaultAnnotationArguments by property(false)
 
     override var excludedAnnotationClasses by property(emptySet<FqName>())
 
diff --git a/core/descriptors/src/org/jetbrains/kotlin/resolve/DescriptorFactory.java b/core/descriptors/src/org/jetbrains/kotlin/resolve/DescriptorFactory.java
index a39f612201c..c5f382ecae9 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/resolve/DescriptorFactory.java
+++ b/core/descriptors/src/org/jetbrains/kotlin/resolve/DescriptorFactory.java
@@ -115,6 +115,6 @@ public class DescriptorFactory {
     ) {
         return receiverParameterType == null
                ? NO_RECEIVER_PARAMETER
-               : new ReceiverParameterDescriptorImpl(owner, receiverParameterType, new ExtensionReceiver(owner, receiverParameterType));
+               : new ReceiverParameterDescriptorImpl(owner, new ExtensionReceiver(owner, receiverParameterType));
     }
 }
diff --git a/core/descriptors/src/org/jetbrains/kotlin/resolve/OverridingUtil.java b/core/descriptors/src/org/jetbrains/kotlin/resolve/OverridingUtil.java
index 32dd748c5bd..ab6175cb5ad 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/resolve/OverridingUtil.java
+++ b/core/descriptors/src/org/jetbrains/kotlin/resolve/OverridingUtil.java
@@ -356,7 +356,7 @@ public class OverridingUtil {
         for (CallableMemberDescriptor descriptor : effectiveOverridden) {
             bindOverride(fakeOverride, descriptor);
         }
-        sink.addToScope(fakeOverride);
+        sink.addFakeOverride(fakeOverride);
     }
 
     @NotNull
@@ -569,7 +569,7 @@ public class OverridingUtil {
     }
 
     public interface DescriptorSink {
-        void addToScope(@NotNull CallableMemberDescriptor fakeOverride);
+        void addFakeOverride(@NotNull CallableMemberDescriptor fakeOverride);
 
         void conflict(@NotNull CallableMemberDescriptor fromSuper, @NotNull CallableMemberDescriptor fromCurrent);
     }
diff --git a/core/descriptors/src/org/jetbrains/kotlin/resolve/calls/inference/ConstraintError.kt b/core/descriptors/src/org/jetbrains/kotlin/resolve/calls/inference/ConstraintError.kt
index 5818c150f54..106a4194aed 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/resolve/calls/inference/ConstraintError.kt
+++ b/core/descriptors/src/org/jetbrains/kotlin/resolve/calls/inference/ConstraintError.kt
@@ -16,16 +16,19 @@
 
 package org.jetbrains.kotlin.resolve.calls.inference
 
-import org.jetbrains.kotlin.resolve.calls.inference.constraintPosition.ConstraintPosition
 import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor
+import org.jetbrains.kotlin.resolve.calls.inference.constraintPosition.CompoundConstraintPosition
+import org.jetbrains.kotlin.resolve.calls.inference.constraintPosition.ConstraintPosition
 
 open class ConstraintError(val constraintPosition: ConstraintPosition)
 
-class TypeConstructorMismatch(constraintPosition: ConstraintPosition): ConstraintError(constraintPosition)
+class ParameterConstraintError(constraintPosition: ConstraintPosition): ConstraintError(constraintPosition)
 
 class ErrorInConstrainingType(constraintPosition: ConstraintPosition): ConstraintError(constraintPosition)
 
+class TypeInferenceError(constraintPosition: ConstraintPosition): ConstraintError(constraintPosition)
+
 class CannotCapture(constraintPosition: ConstraintPosition, val typeVariable: TypeParameterDescriptor): ConstraintError(constraintPosition)
 
-fun ConstraintError.substituteTypeVariable(substitution: (TypeParameterDescriptor) -> TypeParameterDescriptor) =
-        if (this is CannotCapture) CannotCapture(constraintPosition, substitution(typeVariable)) else this
\ No newline at end of file
+fun newTypeInferenceOrParameterConstraintError(constraintPosition: ConstraintPosition) =
+        if (constraintPosition.isParameter()) ParameterConstraintError(constraintPosition) else TypeInferenceError(constraintPosition)
\ No newline at end of file
diff --git a/core/descriptors/src/org/jetbrains/kotlin/resolve/calls/inference/ConstraintPosition.kt b/core/descriptors/src/org/jetbrains/kotlin/resolve/calls/inference/ConstraintPosition.kt
index 169096171a0..3c454600843 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/resolve/calls/inference/ConstraintPosition.kt
+++ b/core/descriptors/src/org/jetbrains/kotlin/resolve/calls/inference/ConstraintPosition.kt
@@ -17,6 +17,7 @@
 package org.jetbrains.kotlin.resolve.calls.inference.constraintPosition
 
 import org.jetbrains.kotlin.resolve.calls.inference.constraintPosition.ConstraintPositionKind.*
+import java.util.*
 
 public enum class ConstraintPositionKind {
     RECEIVER_POSITION,
@@ -43,7 +44,7 @@ public trait ConstraintPosition {
 
     fun isStrong(): Boolean = kind != TYPE_BOUND_POSITION
 
-    fun isCaptureAllowed(): Boolean = kind in setOf(VALUE_PARAMETER_POSITION, RECEIVER_POSITION)
+    fun isParameter(): Boolean = kind in setOf(VALUE_PARAMETER_POSITION, RECEIVER_POSITION)
 }
 
 private open data class ConstraintPositionImpl(override val kind: ConstraintPositionKind) : ConstraintPosition {
@@ -56,9 +57,14 @@ private data class ConstraintPositionWithIndex(override val kind: ConstraintPosi
 class CompoundConstraintPosition(
         vararg positions: ConstraintPosition
 ) : ConstraintPositionImpl(ConstraintPositionKind.COMPOUND_CONSTRAINT_POSITION) {
-    val positions: Collection<ConstraintPosition> = positions.toList()
+    val positions: Collection<ConstraintPosition> =
+            positions.flatMap { if (it is CompoundConstraintPosition) it.positions else listOf(it) }.toSet()
 
     override fun isStrong() = positions.any { it.isStrong() }
 
-    override fun toString() = "$kind(${positions.joinToString()}"
+    override fun toString() = "$kind(${positions.joinToString()})"
 }
+
+fun ConstraintPosition.derivedFrom(kind: ConstraintPositionKind): Boolean {
+    return if (this !is CompoundConstraintPosition) this.kind == kind else positions.any { it.kind == kind }
+}
\ No newline at end of file
diff --git a/core/descriptors/src/org/jetbrains/kotlin/resolve/calls/inference/ConstraintSystem.kt b/core/descriptors/src/org/jetbrains/kotlin/resolve/calls/inference/ConstraintSystem.kt
index 8a41660f50d..1a0071ed007 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/resolve/calls/inference/ConstraintSystem.kt
+++ b/core/descriptors/src/org/jetbrains/kotlin/resolve/calls/inference/ConstraintSystem.kt
@@ -17,20 +17,26 @@
 package org.jetbrains.kotlin.resolve.calls.inference
 
 import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor
-import org.jetbrains.kotlin.types.Variance
+import org.jetbrains.kotlin.resolve.calls.inference.constraintPosition.ConstraintPosition
 import org.jetbrains.kotlin.types.JetType
 import org.jetbrains.kotlin.types.TypeSubstitutor
-import org.jetbrains.kotlin.resolve.calls.inference.constraintPosition.ConstraintPosition
+import org.jetbrains.kotlin.types.Variance
 
 public trait ConstraintSystem {
 
     /**
      * Registers variables in a constraint system.
+     * The type variables for the corresponding function are local, the type variables of inner arguments calls are non-local.
      */
-    public fun registerTypeVariables(typeVariables: Map<TypeParameterDescriptor, Variance>)
+    public fun registerTypeVariables(
+            typeVariables: Collection<TypeParameterDescriptor>,
+            variance: (TypeParameterDescriptor) -> Variance,
+            mapToOriginal: (TypeParameterDescriptor) -> TypeParameterDescriptor,
+            external: Boolean = false
+    )
 
     /**
-     * Returns a set of all registered type variables.
+     * Returns a set of all non-external registered type variables.
      */
     public fun getTypeVariables(): Set<TypeParameterDescriptor>
 
diff --git a/core/descriptors/src/org/jetbrains/kotlin/resolve/calls/inference/ConstraintSystemImpl.kt b/core/descriptors/src/org/jetbrains/kotlin/resolve/calls/inference/ConstraintSystemImpl.kt
index 43c9479c5a8..d8a20bd174d 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/resolve/calls/inference/ConstraintSystemImpl.kt
+++ b/core/descriptors/src/org/jetbrains/kotlin/resolve/calls/inference/ConstraintSystemImpl.kt
@@ -16,186 +16,214 @@
 
 package org.jetbrains.kotlin.resolve.calls.inference
 
-import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor
-import org.jetbrains.kotlin.types.TypeProjection
-import org.jetbrains.kotlin.types.JetType
-import org.jetbrains.kotlin.types.TypeUtils
-import org.jetbrains.kotlin.types.TypeUtils.DONT_CARE
-import org.jetbrains.kotlin.types.TypeProjectionImpl
-import org.jetbrains.kotlin.types.TypeSubstitutor
-import org.jetbrains.kotlin.types.ErrorUtils
-import org.jetbrains.kotlin.types.ErrorUtils.FunctionPlaceholderTypeConstructor
-import org.jetbrains.kotlin.types.Variance
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns
+import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor
 import org.jetbrains.kotlin.descriptors.annotations.Annotations
-import org.jetbrains.kotlin.resolve.calls.inference.ConstraintSystemImpl.ConstraintKind
+import org.jetbrains.kotlin.resolve.calls.inference.ConstraintSystemImpl.ConstraintKind.EQUAL
+import org.jetbrains.kotlin.resolve.calls.inference.ConstraintSystemImpl.ConstraintKind.SUB_TYPE
+import org.jetbrains.kotlin.resolve.calls.inference.TypeBounds.Bound
+import org.jetbrains.kotlin.resolve.calls.inference.TypeBounds.BoundKind.EXACT_BOUND
+import org.jetbrains.kotlin.resolve.calls.inference.TypeBounds.BoundKind.LOWER_BOUND
+import org.jetbrains.kotlin.resolve.calls.inference.TypeBounds.BoundKind.UPPER_BOUND
+import org.jetbrains.kotlin.resolve.calls.inference.constraintPosition.CompoundConstraintPosition
+import org.jetbrains.kotlin.resolve.calls.inference.constraintPosition.ConstraintPosition
+import org.jetbrains.kotlin.resolve.calls.inference.constraintPosition.ConstraintPositionKind
+import org.jetbrains.kotlin.resolve.calls.inference.constraintPosition.ConstraintPositionKind.TYPE_BOUND_POSITION
+import org.jetbrains.kotlin.resolve.calls.inference.constraintPosition.derivedFrom
+import org.jetbrains.kotlin.resolve.scopes.JetScope
+import org.jetbrains.kotlin.types.*
+import org.jetbrains.kotlin.types.ErrorUtils.FunctionPlaceholderTypeConstructor
+import org.jetbrains.kotlin.types.TypeUtils.DONT_CARE
+import org.jetbrains.kotlin.types.checker.JetTypeChecker
 import org.jetbrains.kotlin.types.checker.TypeCheckingProcedure
 import org.jetbrains.kotlin.types.checker.TypeCheckingProcedureCallbacks
-import org.jetbrains.kotlin.types.TypeConstructor
-import java.util.LinkedHashMap
-import org.jetbrains.kotlin.resolve.calls.inference.TypeBounds.BoundKind.*
-import org.jetbrains.kotlin.resolve.calls.inference.ConstraintSystemImpl.ConstraintKind.*
-import java.util.HashMap
+import org.jetbrains.kotlin.types.typeUtil.getNestedArguments
 import java.util.ArrayList
-import org.jetbrains.kotlin.resolve.calls.inference.constraintPosition.ConstraintPosition
-import org.jetbrains.kotlin.resolve.calls.inference.constraintPosition.ConstraintPositionKind.*
-import org.jetbrains.kotlin.resolve.calls.inference.constraintPosition.CompoundConstraintPosition
-import org.jetbrains.kotlin.types.getCustomTypeVariable
-import org.jetbrains.kotlin.types.isFlexible
-import org.jetbrains.kotlin.resolve.calls.inference.TypeBounds.Bound
-import org.jetbrains.kotlin.types.TypeSubstitution
-import org.jetbrains.kotlin.types.checker.JetTypeChecker
+import java.util.HashMap
+import java.util.HashSet
+import java.util.LinkedHashMap
 
 public class ConstraintSystemImpl : ConstraintSystem {
 
+    data class Constraint(val kind: ConstraintKind, val subtype: JetType, val superType: JetType, val position: ConstraintPosition)
+
     public enum class ConstraintKind {
         SUB_TYPE,
         EQUAL
     }
 
-    private val typeParameterBounds = LinkedHashMap<TypeParameterDescriptor, TypeBoundsImpl>()
+    fun ConstraintKind.toBound() = if (this == SUB_TYPE) UPPER_BOUND else EXACT_BOUND
+
+    private val allTypeParameterBounds = LinkedHashMap<TypeParameterDescriptor, TypeBoundsImpl>()
+    private val externalTypeParameters = HashSet<TypeParameterDescriptor>()
+    private val localTypeParameterBounds: Map<TypeParameterDescriptor, TypeBoundsImpl>
+        get() = if (externalTypeParameters.isEmpty()) allTypeParameterBounds
+            else allTypeParameterBounds.filter { !externalTypeParameters.contains(it.key) }
+
+    private val cachedTypeForVariable = HashMap<TypeParameterDescriptor, JetType>()
+
+    private val usedInBounds = HashMap<TypeParameterDescriptor, MutableList<TypeBounds.Bound>>()
 
     private val errors = ArrayList<ConstraintError>()
     public val constraintErrors: List<ConstraintError>
         get() = errors
 
+    private val initialConstraints = ArrayList<Constraint>()
+
+    private val originalToVariablesSubstitutor: TypeSubstitutor by lazy {
+        createTypeSubstitutor { originalToVariables[it] }
+    }
+    private val originalToVariables = LinkedHashMap<TypeParameterDescriptor, TypeParameterDescriptor>()
+    private val variablesToOriginal = LinkedHashMap<TypeParameterDescriptor, TypeParameterDescriptor>()
+
     private val constraintSystemStatus = object : ConstraintSystemStatus {
         // for debug ConstraintsUtil.getDebugMessageForStatus might be used
 
         override fun isSuccessful() = !hasContradiction() && !hasUnknownParameters()
 
-        override fun hasContradiction() = hasTypeConstructorMismatch() || hasConflictingConstraints() || hasCannotCaptureTypesError()
+        override fun hasContradiction() = hasParameterConstraintError() || hasConflictingConstraints()
+                                          || hasCannotCaptureTypesError() || hasTypeInferenceIncorporationError()
 
-        override fun hasViolatedUpperBound() = !isSuccessful() && getSystemWithoutWeakConstraints().getStatus().isSuccessful()
+        override fun hasViolatedUpperBound() = !isSuccessful() && filterConstraintsOut(TYPE_BOUND_POSITION).getStatus().isSuccessful()
 
-        override fun hasConflictingConstraints() = typeParameterBounds.values().any { it.getValues().size() > 1 }
+        override fun hasConflictingConstraints() = localTypeParameterBounds.values().any { it.values.size() > 1 }
 
-        override fun hasUnknownParameters() = typeParameterBounds.values().any { it.isEmpty() }
+        override fun hasUnknownParameters() = localTypeParameterBounds.values().any { it.values.isEmpty() }
 
-        override fun hasTypeConstructorMismatch() = errors.any { it is TypeConstructorMismatch }
+        override fun hasParameterConstraintError() = errors.any { it is ParameterConstraintError }
 
-        override fun hasOnlyErrorsFromPosition(constraintPosition: ConstraintPosition): Boolean {
+        override fun hasOnlyErrorsDerivedFrom(kind: ConstraintPositionKind): Boolean {
             if (isSuccessful()) return false
-            if (filterConstraintsOut(constraintPosition).getStatus().isSuccessful()) return true
-            return errors.isNotEmpty() && errors.all { it.constraintPosition == constraintPosition }
+            if (filterConstraintsOut(kind).getStatus().isSuccessful()) return true
+            return errors.isNotEmpty() && errors.all { it.constraintPosition.derivedFrom(kind) }
         }
 
         override fun hasErrorInConstrainingTypes() = errors.any { it is ErrorInConstrainingType }
 
         override fun hasCannotCaptureTypesError() = errors.any { it is CannotCapture }
+
+        override fun hasTypeInferenceIncorporationError() = errors.any { it is TypeInferenceError } || !satisfyInitialConstraints()
     }
 
     private fun getParameterToInferredValueMap(
             typeParameterBounds: Map<TypeParameterDescriptor, TypeBoundsImpl>,
-            getDefaultTypeProjection: (TypeParameterDescriptor) -> TypeProjection
+            getDefaultTypeProjection: (TypeParameterDescriptor) -> TypeProjection,
+            substituteOriginal: Boolean
     ): Map<TypeParameterDescriptor, TypeProjection> {
         val substitutionContext = HashMap<TypeParameterDescriptor, TypeProjection>()
         for ((typeParameter, typeBounds) in typeParameterBounds) {
             val typeProjection: TypeProjection
-            val value = typeBounds.getValue()
+            val value = typeBounds.value
             if (value != null && !TypeUtils.containsSpecialType(value, DONT_CARE)) {
                 typeProjection = TypeProjectionImpl(value)
             }
             else {
                 typeProjection = getDefaultTypeProjection(typeParameter)
             }
-            substitutionContext.put(typeParameter, typeProjection)
+            substitutionContext.put(if (substituteOriginal) variablesToOriginal[typeParameter]!! else typeParameter, typeProjection)
         }
         return substitutionContext
     }
 
-    private fun replaceUninferredBy(getDefaultValue: (TypeParameterDescriptor) -> TypeProjection): TypeSubstitutor {
-        return TypeUtils.makeSubstitutorForTypeParametersMap(getParameterToInferredValueMap(typeParameterBounds, getDefaultValue))
-    }
-
-    private fun replaceUninferredBy(defaultValue: JetType): TypeSubstitutor {
-        return replaceUninferredBy { TypeProjectionImpl(defaultValue) }
-    }
-
-    private fun replaceUninferredBySpecialErrorType(): TypeSubstitutor {
-        return replaceUninferredBy { TypeProjectionImpl(ErrorUtils.createUninferredParameterType(it)) }
+    private fun replaceUninferredBy(
+            getDefaultValue: (TypeParameterDescriptor) -> TypeProjection,
+            substituteOriginal: Boolean
+    ): TypeSubstitutor {
+        val parameterToInferredValueMap = getParameterToInferredValueMap(allTypeParameterBounds, getDefaultValue, substituteOriginal)
+        return TypeUtils.makeSubstitutorForTypeParametersMap(parameterToInferredValueMap)
     }
 
     override fun getStatus(): ConstraintSystemStatus = constraintSystemStatus
 
-    override fun registerTypeVariables(typeVariables: Map<TypeParameterDescriptor, Variance>) {
-        for ((typeVariable, positionVariance) in typeVariables) {
-            typeParameterBounds.put(typeVariable, TypeBoundsImpl(typeVariable, positionVariance))
+    override fun registerTypeVariables(
+            typeVariables: Collection<TypeParameterDescriptor>,
+            variance: (TypeParameterDescriptor) -> Variance,
+            mapToOriginal: (TypeParameterDescriptor) -> TypeParameterDescriptor,
+            external: Boolean
+    ) {
+        if (external) externalTypeParameters.addAll(typeVariables)
+
+        for (typeVariable in typeVariables) {
+            allTypeParameterBounds.put(typeVariable, TypeBoundsImpl(typeVariable, variance(typeVariable)))
+            val original = mapToOriginal(typeVariable)
+            originalToVariables[original] = typeVariable
+            variablesToOriginal[typeVariable] = original
         }
-        val constantSubstitutor = TypeUtils.makeConstantSubstitutor(typeParameterBounds.keySet(), DONT_CARE)
-        for ((typeVariable, typeBounds) in typeParameterBounds) {
+        for ((typeVariable, typeBounds) in allTypeParameterBounds) {
             for (declaredUpperBound in typeVariable.getUpperBounds()) {
-                if (KotlinBuiltIns.getInstance().getNullableAnyType() == declaredUpperBound) continue //todo remove this line (?)
-                val substitutedBound = constantSubstitutor?.substitute(declaredUpperBound, Variance.INVARIANT)
+                if (KotlinBuiltIns.isNullableAny(declaredUpperBound)) continue //todo remove this line (?)
                 val position = TYPE_BOUND_POSITION.position(typeVariable.getIndex())
-                if (substitutedBound != null && !isErrorOrSpecialType(substitutedBound, position)) {
-                    typeBounds.addBound(UPPER_BOUND, substitutedBound, position)
-                }
+                addBound(typeVariable, declaredUpperBound, UPPER_BOUND, position)
             }
         }
     }
 
-    public fun copy(): ConstraintSystem = createNewConstraintSystemFromThis({ it }, { it.copy() }, { true })
-
-    public fun substituteTypeVariables(typeVariablesMap: (TypeParameterDescriptor) -> TypeParameterDescriptor): ConstraintSystem {
-        // type bounds are proper types and don't contain other variables
-        return createNewConstraintSystemFromThis(typeVariablesMap, { it }, { true })
-    }
-
-    public fun filterConstraintsOut(vararg excludePositions: ConstraintPosition): ConstraintSystem {
-        val positions = excludePositions.toSet()
-        return filterConstraints { !positions.contains(it) }
-    }
-
-    public fun filterConstraints(condition: (ConstraintPosition) -> Boolean): ConstraintSystem {
-        return createNewConstraintSystemFromThis({ it }, { it.filter(condition) }, condition)
-    }
-
-    public fun getSystemWithoutWeakConstraints(): ConstraintSystem {
-        return filterConstraints {
-            constraintPosition ->
-            // 'isStrong' for compound means 'has some strong constraints'
-            // but for testing absence of weak constraints we need 'has only strong constraints' here
-            if (constraintPosition is CompoundConstraintPosition) {
-                constraintPosition.positions.all { it.isStrong() }
-            }
-            else {
-                constraintPosition.isStrong()
-            }
+    val TypeParameterDescriptor.correspondingType: JetType
+        get() = cachedTypeForVariable.getOrPut(this) {
+            JetTypeImpl(Annotations.EMPTY, this.getTypeConstructor(), false, listOf(), JetScope.Empty)
         }
+
+    fun JetType.isProper() = !TypeUtils.containsSpecialType(this) {
+        type -> type.getConstructor().getDeclarationDescriptor() in getAllTypeVariables()
+    }
+
+    fun JetType.getNestedTypeVariables(original: Boolean = true): List<TypeParameterDescriptor> {
+        return getNestedArguments().map { typeProjection ->
+            typeProjection.getType().getConstructor().getDeclarationDescriptor() as? TypeParameterDescriptor
+        }.filterNotNull().filter { if (original) it in originalToVariables.keySet() else it in getAllTypeVariables() }
+    }
+
+    public fun copy(): ConstraintSystem = createNewConstraintSystemFromThis { true }
+
+    public fun filterConstraintsOut(excludePositionKind: ConstraintPositionKind): ConstraintSystem {
+        return createNewConstraintSystemFromThis { !it.derivedFrom(excludePositionKind) }
     }
 
     private fun createNewConstraintSystemFromThis(
-            substituteTypeVariable: (TypeParameterDescriptor) -> TypeParameterDescriptor,
-            replaceTypeBounds: (TypeBoundsImpl) -> TypeBoundsImpl,
             filterConstraintPosition: (ConstraintPosition) -> Boolean
     ): ConstraintSystem {
         val newSystem = ConstraintSystemImpl()
-        for ((typeParameter, typeBounds) in typeParameterBounds) {
-            val newTypeParameter = substituteTypeVariable(typeParameter)
-            newSystem.typeParameterBounds.put(newTypeParameter, replaceTypeBounds(typeBounds))
+        for ((typeParameter, typeBounds) in allTypeParameterBounds) {
+            newSystem.allTypeParameterBounds.put(typeParameter, typeBounds.filter(filterConstraintPosition))
         }
-        newSystem.errors.addAll(errors.filter { filterConstraintPosition(it.constraintPosition) }.map { it.substituteTypeVariable(substituteTypeVariable) })
+        newSystem.usedInBounds.putAll(usedInBounds.map {
+            val (variable, bounds) = it
+            variable to bounds.filterTo(arrayListOf<Bound>()) { filterConstraintPosition(it.position )}
+        }.toMap())
+        newSystem.externalTypeParameters.addAll(externalTypeParameters )
+        newSystem.errors.addAll(errors.filter { filterConstraintPosition(it.constraintPosition) })
+
+        newSystem.initialConstraints.addAll(initialConstraints.filter { filterConstraintPosition(it.position) })
+        newSystem.originalToVariables.putAll(originalToVariables)
+        newSystem.variablesToOriginal.putAll(variablesToOriginal)
         return newSystem
     }
 
     override fun addSupertypeConstraint(constrainingType: JetType?, subjectType: JetType, constraintPosition: ConstraintPosition) {
         if (constrainingType != null && TypeUtils.noExpectedType(constrainingType)) return
 
-        addConstraint(SUB_TYPE, subjectType, constrainingType, constraintPosition)
+        val newSubjectType = originalToVariablesSubstitutor.substitute(subjectType, Variance.INVARIANT)
+        addConstraint(SUB_TYPE, newSubjectType, constrainingType, constraintPosition, topLevel = true)
     }
 
     override fun addSubtypeConstraint(constrainingType: JetType?, subjectType: JetType, constraintPosition: ConstraintPosition) {
-        addConstraint(SUB_TYPE, constrainingType, subjectType, constraintPosition)
+        val newSubjectType = originalToVariablesSubstitutor.substitute(subjectType, Variance.INVARIANT)
+        addConstraint(SUB_TYPE, constrainingType, newSubjectType, constraintPosition, topLevel = true)
     }
 
-    private fun addConstraint(constraintKind: ConstraintKind, subType: JetType?, superType: JetType?, constraintPosition: ConstraintPosition) {
+    fun addConstraint(
+            constraintKind: ConstraintKind,
+            subType: JetType?,
+            superType: JetType?,
+            constraintPosition: ConstraintPosition,
+            topLevel: Boolean
+    ) {
         val typeCheckingProcedure = TypeCheckingProcedure(object : TypeCheckingProcedureCallbacks {
             private var depth = 0
 
             override fun assertEqualTypes(a: JetType, b: JetType, typeCheckingProcedure: TypeCheckingProcedure): Boolean {
                 depth++
-                doAddConstraint(EQUAL, a, b, constraintPosition, typeCheckingProcedure)
+                doAddConstraint(EQUAL, a, b, constraintPosition, typeCheckingProcedure, topLevel = false)
                 depth--
                 return true
 
@@ -207,14 +235,16 @@ public class ConstraintSystemImpl : ConstraintSystem {
 
             override fun assertSubtype(subtype: JetType, supertype: JetType, typeCheckingProcedure: TypeCheckingProcedure): Boolean {
                 depth++
-                doAddConstraint(SUB_TYPE, subtype, supertype, constraintPosition, typeCheckingProcedure)
+                doAddConstraint(SUB_TYPE, subtype, supertype, constraintPosition, typeCheckingProcedure, topLevel = false)
                 depth--
                 return true
             }
 
             override fun capture(typeVariable: JetType, typeProjection: TypeProjection): Boolean {
+                if (isMyTypeVariable(typeProjection.getType())) return false
                 val myTypeVariable = getMyTypeVariable(typeVariable)
-                if (myTypeVariable != null && constraintPosition.isCaptureAllowed()) {
+
+                if (myTypeVariable != null && constraintPosition.isParameter()) {
                     if (depth > 0) {
                         errors.add(CannotCapture(constraintPosition, myTypeVariable))
                     }
@@ -225,11 +255,11 @@ public class ConstraintSystemImpl : ConstraintSystem {
             }
 
             override fun noCorrespondingSupertype(subtype: JetType, supertype: JetType): Boolean {
-                errors.add(TypeConstructorMismatch(constraintPosition))
+                errors.add(newTypeInferenceOrParameterConstraintError(constraintPosition))
                 return true
             }
         })
-        doAddConstraint(constraintKind, subType, superType, constraintPosition, typeCheckingProcedure)
+        doAddConstraint(constraintKind, subType, superType, constraintPosition, typeCheckingProcedure, topLevel)
     }
 
     private fun isErrorOrSpecialType(type: JetType?, constraintPosition: ConstraintPosition): Boolean {
@@ -249,7 +279,8 @@ public class ConstraintSystemImpl : ConstraintSystem {
             subType: JetType?,
             superType: JetType?,
             constraintPosition: ConstraintPosition,
-            typeCheckingProcedure: TypeCheckingProcedure
+            typeCheckingProcedure: TypeCheckingProcedure,
+            topLevel: Boolean
     ) {
         if (isErrorOrSpecialType(subType, constraintPosition) || isErrorOrSpecialType(superType, constraintPosition)) return
         if (subType == null || superType == null) return
@@ -266,47 +297,70 @@ public class ConstraintSystemImpl : ConstraintSystem {
                 // we don't add it without knowing whether it's a function type or an extension function type
                 return
             }
-            createCorrespondingFunctionTypeForFunctionPlaceholder(subType, superType)
+            createTypeForFunctionPlaceholder(subType, superType)
         }
         else {
             subType
         }
 
         fun simplifyConstraint(subType: JetType, superType: JetType) {
-            // can be equal for the recursive invocations: fun <T> foo(i: Int) : T { ... return foo(i); } => T <: T
-            // the right processing of constraints connecting type variables is not supported yet
-            if (isMyTypeVariable(subType) && isMyTypeVariable(superType)) return
-
             if (isMyTypeVariable(subType)) {
-                val boundKind = if (constraintKind == SUB_TYPE) UPPER_BOUND else EXACT_BOUND
-                generateTypeParameterConstraint(subType, superType, boundKind, constraintPosition)
+                generateTypeParameterBound(subType, superType, constraintKind.toBound(), constraintPosition)
                 return
             }
             if (isMyTypeVariable(superType)) {
-                val boundKind = if (constraintKind == SUB_TYPE) LOWER_BOUND else EXACT_BOUND
-                generateTypeParameterConstraint(superType, subType, boundKind, constraintPosition)
+                generateTypeParameterBound(superType, subType, constraintKind.toBound().reverse(), constraintPosition)
                 return
             }
-            // if superType is nullable and subType is not nullable, unsafe call or type mismatch error will be generated later,
+            // if subType is nullable and superType is not nullable, unsafe call or type mismatch error will be generated later,
             // but constraint system should be solved anyway
-            val subTypeNotNullable = TypeUtils.makeNotNullable(subType)
-            val superTypeNotNullable = TypeUtils.makeNotNullable(superType)
-            if (constraintKind == EQUAL) {
+            val subTypeNotNullable = if (topLevel) TypeUtils.makeNotNullable(subType) else subType
+            val superTypeNotNullable = if (topLevel) TypeUtils.makeNotNullable(superType) else superType
+            val result = if (constraintKind == EQUAL) {
                 typeCheckingProcedure.equalTypes(subTypeNotNullable, superTypeNotNullable)
             }
             else {
-                typeCheckingProcedure.isSubtypeOf(subTypeNotNullable, superTypeNotNullable)
+                typeCheckingProcedure.isSubtypeOf(subTypeNotNullable, superType)
             }
+            if (!result) errors.add(newTypeInferenceOrParameterConstraintError(constraintPosition))
+        }
+        if (topLevel) {
+            storeInitialConstraint(constraintKind, subType, superType, constraintPosition)
         }
         simplifyConstraint(newSubType, superType)
     }
 
-    private fun generateTypeParameterConstraint(
+    fun addBound(
+            typeVariable: TypeParameterDescriptor,
+            constrainingType: JetType,
+            kind: TypeBounds.BoundKind,
+            position: ConstraintPosition,
+            derivedFrom: Set<TypeParameterDescriptor> = emptySet()
+    ) {
+        val bound = Bound(typeVariable, constrainingType, kind, position, constrainingType.isProper(), derivedFrom)
+        val typeBounds = getTypeBounds(typeVariable)
+        if (typeBounds.bounds.contains(bound)) return
+
+        typeBounds.addBound(bound)
+
+        if (!bound.isProper) {
+            for (dependentTypeVariable in bound.constrainingType.getNestedTypeVariables(original = false)) {
+                val dependentBounds = usedInBounds.getOrPut(dependentTypeVariable) { arrayListOf() }
+                dependentBounds.add(bound)
+            }
+        }
+
+        incorporateBound(bound)
+    }
+
+    private fun generateTypeParameterBound(
             parameterType: JetType,
             constrainingType: JetType,
             boundKind: TypeBounds.BoundKind,
             constraintPosition: ConstraintPosition
     ) {
+        val typeVariable = getMyTypeVariable(parameterType)!!
+
         var newConstrainingType = constrainingType
 
         // Here we are handling the case when T! gets a bound Foo (or Foo?)
@@ -318,16 +372,14 @@ public class ConstraintSystemImpl : ConstraintSystem {
         //   Foo >: T!
         // both Foo and Foo? transform to Foo! here
         if (parameterType.isFlexible()) {
-            val typeVariable = parameterType.getCustomTypeVariable()
-            if (typeVariable != null) {
-                newConstrainingType = typeVariable.substitutionResult(constrainingType)
+            val customTypeVariable = parameterType.getCustomTypeVariable()
+            if (customTypeVariable != null) {
+                newConstrainingType = customTypeVariable.substitutionResult(constrainingType)
             }
         }
 
-        val typeBounds = getTypeBounds(parameterType)
-
         if (!parameterType.isMarkedNullable() || !TypeUtils.isNullableType(newConstrainingType)) {
-            typeBounds.addBound(boundKind, newConstrainingType, constraintPosition)
+            addBound(typeVariable, newConstrainingType, boundKind, constraintPosition)
             return
         }
         // For parameter type T:
@@ -337,11 +389,11 @@ public class ConstraintSystemImpl : ConstraintSystem {
         // constraints T? >: Int?; T? >: Int! should transform to T >: Int
         val notNullConstrainingType = TypeUtils.makeNotNullable(newConstrainingType)
         if (boundKind == EXACT_BOUND || boundKind == LOWER_BOUND) {
-            typeBounds.addBound(LOWER_BOUND, notNullConstrainingType, constraintPosition)
+            addBound(typeVariable, notNullConstrainingType, LOWER_BOUND, constraintPosition)
         }
         // constraints T? <: Int?; T? <: Int! should transform to T <: Int?; T <: Int! correspondingly
         if (boundKind == EXACT_BOUND || boundKind == UPPER_BOUND) {
-            typeBounds.addBound(UPPER_BOUND, newConstrainingType, constraintPosition)
+            addBound(typeVariable, newConstrainingType, UPPER_BOUND, constraintPosition)
         }
     }
 
@@ -355,7 +407,6 @@ public class ConstraintSystemImpl : ConstraintSystem {
             && constrainingTypeProjection.getProjectionKind() == Variance.IN_VARIANCE) {
             errors.add(CannotCapture(constraintPosition, typeVariable))
         }
-        val typeBounds = getTypeBounds(typeVariable)
         val typeProjection = if (parameterType.isMarkedNullable()) {
             TypeProjectionImpl(constrainingTypeProjection.getProjectionKind(), TypeUtils.makeNotNullable(constrainingTypeProjection.getType()))
         }
@@ -363,65 +414,92 @@ public class ConstraintSystemImpl : ConstraintSystem {
             constrainingTypeProjection
         }
         val capturedType = createCapturedType(typeProjection)
-        typeBounds.addBound(EXACT_BOUND, capturedType, constraintPosition)
+        addBound(typeVariable, capturedType, EXACT_BOUND, constraintPosition)
     }
 
-    public fun processDeclaredBoundConstraints() {
-        for ((typeParameterDescriptor, typeBounds) in typeParameterBounds) {
-            fun compoundPosition(bound: Bound) = CompoundConstraintPosition(
-                    TYPE_BOUND_POSITION.position(typeParameterDescriptor.getIndex()), bound.position)
+    override fun getTypeVariables() = originalToVariables.keySet()
 
-            // todo order matters here
-            // it's important to create a separate variable here,
-            // because the following code may add new elements to typeBounds.bounds collection
-            val bounds = ArrayList(typeBounds.bounds)
-            for (declaredUpperBound in typeParameterDescriptor.getUpperBounds()) {
-                bounds.filter { it.kind != UPPER_BOUND }.forEach {
-                    lowerOrExactBound ->
-                    addSubtypeConstraint(lowerOrExactBound.constrainingType, declaredUpperBound, compoundPosition(lowerOrExactBound))
-                }
-                if (!isMyTypeVariable(declaredUpperBound)) continue
-                getTypeBounds(declaredUpperBound).bounds.filter { it.kind != LOWER_BOUND }.forEach {
-                    upperOrExactBound ->
-                    typeBounds.addBound(UPPER_BOUND, upperOrExactBound.constrainingType, compoundPosition(upperOrExactBound))
-                }
-            }
-        }
-    }
+    fun getAllTypeVariables() = allTypeParameterBounds.keySet()
 
-    override fun getTypeVariables() = typeParameterBounds.keySet()
+    fun getBoundsUsedIn(typeVariable: TypeParameterDescriptor): List<Bound> = usedInBounds[typeVariable] ?: emptyList()
 
     override fun getTypeBounds(typeVariable: TypeParameterDescriptor): TypeBoundsImpl {
+        val variableForOriginal = originalToVariables[typeVariable]
+        if (variableForOriginal != null && variableForOriginal != typeVariable) {
+            return getTypeBounds(variableForOriginal)
+        }
         if (!isMyTypeVariable(typeVariable)) {
             throw IllegalArgumentException("TypeParameterDescriptor is not a type variable for constraint system: $typeVariable")
         }
-        return typeParameterBounds[typeVariable]!!
+        return allTypeParameterBounds[typeVariable]!!
     }
 
-    private fun getTypeBounds(parameterType: JetType): TypeBoundsImpl {
-        assert (isMyTypeVariable(parameterType)) { "Type is not a type variable for constraint system: $parameterType" }
-        return getTypeBounds(getMyTypeVariable(parameterType)!!)
-    }
+    fun isMyTypeVariable(typeVariable: TypeParameterDescriptor) = allTypeParameterBounds.contains(typeVariable)
 
-    private fun isMyTypeVariable(typeVariable: TypeParameterDescriptor) = typeParameterBounds.contains(typeVariable)
+    fun isMyTypeVariable(type: JetType): Boolean = getMyTypeVariable(type) != null
 
-    private fun isMyTypeVariable(type: JetType): Boolean = getMyTypeVariable(type) != null
-
-    private fun getMyTypeVariable(type: JetType): TypeParameterDescriptor? {
+    fun getMyTypeVariable(type: JetType): TypeParameterDescriptor? {
         val typeParameterDescriptor = type.getConstructor().getDeclarationDescriptor() as? TypeParameterDescriptor
         return if (typeParameterDescriptor != null && isMyTypeVariable(typeParameterDescriptor)) typeParameterDescriptor else null
     }
 
-    override fun getResultingSubstitutor() = replaceUninferredBySpecialErrorType().setApproximateCapturedTypes()
+    override fun getResultingSubstitutor() =
+            getSubstitutor(substituteOriginal = true) { TypeProjectionImpl(ErrorUtils.createUninferredParameterType(it)) }
+
+    override fun getCurrentSubstitutor() =
+            getSubstitutor(substituteOriginal = true) { TypeProjectionImpl(TypeUtils.DONT_CARE) }
+
+    private fun getSubstitutor(substituteOriginal: Boolean, getDefaultValue: (TypeParameterDescriptor) -> TypeProjection) =
+            replaceUninferredBy(getDefaultValue, substituteOriginal).setApproximateCapturedTypes()
+
+    private fun storeInitialConstraint(constraintKind: ConstraintKind, subType: JetType, superType: JetType, position: ConstraintPosition) {
+        initialConstraints.add(Constraint(constraintKind, subType, superType, position))
+    }
+
+    private fun satisfyInitialConstraints(): Boolean {
+        fun JetType.substituteAndMakeNotNullable(): JetType? {
+            val substitutor = getSubstitutor(substituteOriginal = false) { TypeProjectionImpl(ErrorUtils.createUninferredParameterType(it)) }
+            val result = substitutor.substitute(this, Variance.INVARIANT) ?: return null
+            return TypeUtils.makeNotNullable(result)
+        }
+        return initialConstraints.all {
+            val resultSubType = it.subtype.substituteAndMakeNotNullable() ?: return false
+            val resultSuperType = it.superType.substituteAndMakeNotNullable() ?: return false
+            when (it.kind) {
+                SUB_TYPE -> JetTypeChecker.DEFAULT.isSubtypeOf(resultSubType, resultSuperType)
+                EQUAL -> JetTypeChecker.DEFAULT.equalTypes(resultSubType, resultSuperType)
+            }
+        }
+    }
+
+    fun fixVariable(typeVariable: TypeParameterDescriptor) {
+        val typeBounds = getTypeBounds(typeVariable)
+        if (typeBounds.isFixed) return
+        typeBounds.setFixed()
+
+        val nestedTypeVariables = typeBounds.bounds.flatMap { it.constrainingType.getNestedTypeVariables(original = false) }
+        nestedTypeVariables.forEach { fixVariable(it) }
+
+        val value = typeBounds.value ?: return
+
+        addBound(typeVariable, value, TypeBounds.BoundKind.EXACT_BOUND, ConstraintPositionKind.FROM_COMPLETER.position())
+    }
+
+    fun fixVariables() {
+        // todo variables should be fixed in the right order
+        val (external, functionTypeParameters) = getAllTypeVariables().partition { externalTypeParameters.contains(it) }
+        external.forEach { fixVariable(it) }
+        functionTypeParameters.forEach { fixVariable(it) }
+    }
 
-    override fun getCurrentSubstitutor() = replaceUninferredBy(TypeUtils.DONT_CARE).setApproximateCapturedTypes()
 }
 
-fun createCorrespondingFunctionTypeForFunctionPlaceholder(
+fun createTypeForFunctionPlaceholder(
         functionPlaceholder: JetType,
         expectedType: JetType
 ): JetType {
-    assert(ErrorUtils.isFunctionPlaceholder(functionPlaceholder)) { "Function placeholder type expected: $functionPlaceholder" }
+    if (!ErrorUtils.isFunctionPlaceholder(functionPlaceholder)) return functionPlaceholder
+
     val functionPlaceholderTypeConstructor = functionPlaceholder.getConstructor() as FunctionPlaceholderTypeConstructor
 
     val isExtension = KotlinBuiltIns.isExtensionFunctionType(expectedType)
@@ -450,3 +528,27 @@ private class SubstitutionWithCapturedTypeApproximation(val substitution: TypeSu
     override fun isEmpty() = substitution.isEmpty()
     override fun approximateCapturedTypes() = true
 }
+
+public fun ConstraintSystemImpl.registerTypeVariables(typeVariables: Map<TypeParameterDescriptor, Variance>) {
+    registerTypeVariables(typeVariables.keySet(), { typeVariables[it]!! }, { it })
+}
+
+public fun ConstraintSystemImpl.registerTypeVariables(
+        typeVariables: Collection<TypeParameterDescriptor>,
+        variance: (TypeParameterDescriptor) -> Variance
+) {
+    registerTypeVariables(typeVariables, variance, { it })
+}
+
+public fun createTypeSubstitutor(conversion: (TypeParameterDescriptor) -> TypeParameterDescriptor?): TypeSubstitutor {
+    return TypeSubstitutor.create(object : TypeSubstitution() {
+        override fun get(key: TypeConstructor): TypeProjection? {
+            val descriptor = key.getDeclarationDescriptor()
+            if (descriptor !is TypeParameterDescriptor) return null
+            val typeParameterDescriptor = conversion(descriptor) ?: return null
+
+            val type = JetTypeImpl(Annotations.EMPTY, typeParameterDescriptor.getTypeConstructor(), false, listOf(), JetScope.Empty)
+            return TypeProjectionImpl(type)
+        }
+    })
+}
\ No newline at end of file
diff --git a/core/descriptors/src/org/jetbrains/kotlin/resolve/calls/inference/ConstraintSystemStatus.kt b/core/descriptors/src/org/jetbrains/kotlin/resolve/calls/inference/ConstraintSystemStatus.kt
index 367ec7c1479..2234da09b49 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/resolve/calls/inference/ConstraintSystemStatus.kt
+++ b/core/descriptors/src/org/jetbrains/kotlin/resolve/calls/inference/ConstraintSystemStatus.kt
@@ -16,7 +16,7 @@
 
 package org.jetbrains.kotlin.resolve.calls.inference
 
-import org.jetbrains.kotlin.resolve.calls.inference.constraintPosition.ConstraintPosition
+import org.jetbrains.kotlin.resolve.calls.inference.constraintPosition.ConstraintPositionKind
 
 public trait ConstraintSystemStatus {
     /**
@@ -63,13 +63,13 @@ public trait ConstraintSystemStatus {
      * For example, for <pre>fun &lt;R&gt; foo(t: List&lt;R&gt;) {}</pre> in invocation <tt>foo(hashSet("s"))</tt>
      * there is type constructor mismatch: <tt>"HashSet&lt;String&gt; cannot be a subtype of List&lt;R&gt;"</tt>.
      */
-    public fun hasTypeConstructorMismatch(): Boolean
+    public fun hasParameterConstraintError(): Boolean
 
     /**
      * Returns <tt>true</tt> if there is type constructor mismatch only in constraintPosition or
      * constraint system is successful without constraints from this position.
      */
-    public fun hasOnlyErrorsFromPosition(constraintPosition: ConstraintPosition): Boolean
+    public fun hasOnlyErrorsDerivedFrom(kind: ConstraintPositionKind): Boolean
 
     /**
      * Returns <tt>true</tt> if there is an error in constraining types. <p/>
@@ -84,4 +84,9 @@ public trait ConstraintSystemStatus {
      * in invocation <tt>foo(array)</tt> where array has type <tt>Array&lt;Array&lt;out Int&gt;&gt;</tt>.
      */
     public fun hasCannotCaptureTypesError(): Boolean
+
+    /**
+     * Returns <tt>true</tt> if there's an error in constraint system incorporation.
+     */
+    public fun hasTypeInferenceIncorporationError(): Boolean
 }
diff --git a/core/descriptors/src/org/jetbrains/kotlin/resolve/calls/inference/TypeBounds.kt b/core/descriptors/src/org/jetbrains/kotlin/resolve/calls/inference/TypeBounds.kt
index 5825ecac958..947cc001d9b 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/resolve/calls/inference/TypeBounds.kt
+++ b/core/descriptors/src/org/jetbrains/kotlin/resolve/calls/inference/TypeBounds.kt
@@ -16,10 +16,14 @@
 
 package org.jetbrains.kotlin.resolve.calls.inference
 
-import org.jetbrains.kotlin.types.Variance
 import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.resolve.calls.inference.TypeBounds.BoundKind
+import org.jetbrains.kotlin.resolve.calls.inference.TypeBounds.BoundKind.EXACT_BOUND
+import org.jetbrains.kotlin.resolve.calls.inference.TypeBounds.BoundKind.LOWER_BOUND
+import org.jetbrains.kotlin.resolve.calls.inference.TypeBounds.BoundKind.UPPER_BOUND
 import org.jetbrains.kotlin.resolve.calls.inference.constraintPosition.ConstraintPosition
+import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.Variance
 
 public trait TypeBounds {
     public val varianceOfPosition: Variance
@@ -28,17 +32,55 @@ public trait TypeBounds {
 
     public val bounds: Collection<Bound>
 
-    public fun isEmpty(): Boolean
+    public val value: JetType?
+        get() = if (values.size() == 1) values.first() else null
 
-    public fun getValue(): JetType?
-
-    public fun getValues(): Collection<JetType>
+    public val values: Collection<JetType>
 
     public enum class BoundKind {
         LOWER_BOUND,
-        UPPER_BOUND,
-        EXACT_BOUND
+        EXACT_BOUND,
+        UPPER_BOUND
     }
 
-    public class Bound(public val constrainingType: JetType, public val kind: BoundKind, public val position: ConstraintPosition)
+    public class Bound(
+            public val typeVariable: TypeParameterDescriptor,
+            public val constrainingType: JetType,
+            public val kind: BoundKind,
+            public val position: ConstraintPosition,
+            public val isProper: Boolean,
+            // to prevent infinite recursion in incorporation we store the variables that was substituted to derive this bound
+            public val derivedFrom: Set<TypeParameterDescriptor>
+    ) {
+        override fun equals(other: Any?): Boolean {
+            if (this === other) return true
+            if (other == null || javaClass != other.javaClass) return false
+
+            val bound = other as Bound
+
+            if (typeVariable != bound.typeVariable) return false
+            if (constrainingType != bound.constrainingType) return false
+            if (kind != bound.kind) return false
+
+            if (position.isStrong() != bound.position.isStrong()) return false
+
+            return true
+        }
+
+        override fun hashCode(): Int {
+            var result = typeVariable.hashCode();
+            result = 31 * result + constrainingType.hashCode()
+            result = 31 * result + kind.hashCode()
+            result = 31 * result + if (position.isStrong()) 1 else 0
+            return result
+        }
+
+        override fun toString() = "Bound($constrainingType, $kind, $position, isProper = $isProper)"
+    }
+}
+
+fun BoundKind.reverse() = when (this) {
+    LOWER_BOUND -> UPPER_BOUND
+    UPPER_BOUND -> LOWER_BOUND
+    EXACT_BOUND -> EXACT_BOUND
 }
diff --git a/core/descriptors/src/org/jetbrains/kotlin/resolve/calls/inference/TypeBoundsImpl.kt b/core/descriptors/src/org/jetbrains/kotlin/resolve/calls/inference/TypeBoundsImpl.kt
index dcfbedd4970..2be71975086 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/resolve/calls/inference/TypeBoundsImpl.kt
+++ b/core/descriptors/src/org/jetbrains/kotlin/resolve/calls/inference/TypeBoundsImpl.kt
@@ -17,36 +17,40 @@
 package org.jetbrains.kotlin.resolve.calls.inference
 
 import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor
-import org.jetbrains.kotlin.types.Variance
 import org.jetbrains.kotlin.resolve.calls.inference.TypeBounds.Bound
-import org.jetbrains.kotlin.types.JetType
 import org.jetbrains.kotlin.resolve.calls.inference.TypeBounds.BoundKind
-import org.jetbrains.kotlin.types.ErrorUtils
-import org.jetbrains.kotlin.types.CommonSupertypes
-import org.jetbrains.kotlin.types.TypeUtils
-import org.jetbrains.kotlin.types.checker.JetTypeChecker
-import org.jetbrains.kotlin.resolve.constants.IntegerValueTypeConstructor
-import java.util.LinkedHashSet
-import org.jetbrains.kotlin.resolve.calls.inference.TypeBounds.BoundKind.*
+import org.jetbrains.kotlin.resolve.calls.inference.TypeBounds.BoundKind.EXACT_BOUND
+import org.jetbrains.kotlin.resolve.calls.inference.TypeBounds.BoundKind.LOWER_BOUND
+import org.jetbrains.kotlin.resolve.calls.inference.TypeBounds.BoundKind.UPPER_BOUND
 import org.jetbrains.kotlin.resolve.calls.inference.constraintPosition.ConstraintPosition
+import org.jetbrains.kotlin.resolve.constants.IntegerValueTypeConstructor
+import org.jetbrains.kotlin.types.*
+import org.jetbrains.kotlin.types.checker.JetTypeChecker
 import org.jetbrains.kotlin.utils.addIfNotNull
-import org.jetbrains.kotlin.types.singleBestRepresentative
+import java.util.ArrayList
+import java.util.LinkedHashSet
 
 public class TypeBoundsImpl(
         override val typeVariable: TypeParameterDescriptor,
         override val varianceOfPosition: Variance
 ) : TypeBounds {
-    override val bounds = LinkedHashSet<Bound>()
+    override val bounds = ArrayList<Bound>()
 
     private var resultValues: Collection<JetType>? = null
 
-    public fun addBound(kind: BoundKind, constrainingType: JetType, position: ConstraintPosition) {
-        resultValues = null
-        bounds.add(Bound(constrainingType, kind, position))
+    var isFixed: Boolean = false
+        private set
+
+    public fun setFixed() {
+        isFixed = true
     }
 
-    override fun isEmpty(): Boolean {
-        return getValues().isEmpty()
+    public fun addBound(bound: Bound) {
+        resultValues = null
+        assert(bound.typeVariable == typeVariable) {
+            "$bound is added for incorrect type variable ${bound.typeVariable.getName()}. Expected: ${typeVariable.getName()}"
+        }
+        bounds.add(bound)
     }
 
     private fun filterBounds(bounds: Collection<Bound>, kind: BoundKind): Set<JetType> {
@@ -68,36 +72,24 @@ public class TypeBoundsImpl(
         return result
     }
 
-    fun copy(): TypeBoundsImpl {
-        val typeBounds = TypeBoundsImpl(typeVariable, varianceOfPosition)
-        typeBounds.bounds.addAll(bounds)
-        typeBounds.resultValues = resultValues
-        return typeBounds
-    }
-
     public fun filter(condition: (ConstraintPosition) -> Boolean): TypeBoundsImpl {
         val result = TypeBoundsImpl(typeVariable, varianceOfPosition)
         result.bounds.addAll(bounds.filter { condition(it.position) })
         return result
     }
 
-    override fun getValue(): JetType? {
-        val values = getValues()
-        if (values.size() == 1) {
-            return values.iterator().next()
+    override val values: Collection<JetType>
+        get() {
+            if (resultValues == null) {
+                resultValues = computeValues()
+            }
+            return resultValues!!
         }
-        return null
-    }
-
-    override fun getValues(): Collection<JetType> {
-        if (resultValues == null) {
-            resultValues = computeValues()
-        }
-        return resultValues!!
-    }
 
     private fun computeValues(): Collection<JetType> {
         val values = LinkedHashSet<JetType>()
+        val bounds = bounds.filter { it.isProper }
+
         if (bounds.isEmpty()) {
             return listOf()
         }
@@ -109,7 +101,7 @@ public class TypeBoundsImpl(
         val exactBounds = filterBounds(bounds, EXACT_BOUND, values)
         val bestFit = exactBounds.singleBestRepresentative()
         if (bestFit != null) {
-            if (tryPossibleAnswer(bestFit)) {
+            if (tryPossibleAnswer(bounds, bestFit)) {
                 return listOf(bestFit)
             }
         }
@@ -119,7 +111,7 @@ public class TypeBoundsImpl(
                 filterBounds(bounds, LOWER_BOUND, values).partition { it.getConstructor() is IntegerValueTypeConstructor }
 
         val superTypeOfLowerBounds = CommonSupertypes.commonSupertypeForNonDenotableTypes(generalLowerBounds)
-        if (tryPossibleAnswer(superTypeOfLowerBounds)) {
+        if (tryPossibleAnswer(bounds, superTypeOfLowerBounds)) {
             return setOf(superTypeOfLowerBounds!!)
         }
         values.addIfNotNull(superTypeOfLowerBounds)
@@ -129,14 +121,14 @@ public class TypeBoundsImpl(
         //foo(1, c: Consumer<Any>) - infer Int, not Any here
 
         val superTypeOfNumberLowerBounds = TypeUtils.commonSupertypeForNumberTypes(numberLowerBounds)
-        if (tryPossibleAnswer(superTypeOfNumberLowerBounds)) {
+        if (tryPossibleAnswer(bounds, superTypeOfNumberLowerBounds)) {
             return setOf(superTypeOfNumberLowerBounds!!)
         }
         values.addIfNotNull(superTypeOfNumberLowerBounds)
 
         if (superTypeOfLowerBounds != null && superTypeOfNumberLowerBounds != null) {
             val superTypeOfAllLowerBounds = CommonSupertypes.commonSupertypeForNonDenotableTypes(listOf(superTypeOfLowerBounds, superTypeOfNumberLowerBounds))
-            if (tryPossibleAnswer(superTypeOfAllLowerBounds)) {
+            if (tryPossibleAnswer(bounds, superTypeOfAllLowerBounds)) {
                 return setOf(superTypeOfAllLowerBounds!!)
             }
         }
@@ -144,7 +136,7 @@ public class TypeBoundsImpl(
         val upperBounds = filterBounds(bounds, TypeBounds.BoundKind.UPPER_BOUND, values)
         val intersectionOfUpperBounds = TypeUtils.intersect(JetTypeChecker.DEFAULT, upperBounds)
         if (!upperBounds.isEmpty() && intersectionOfUpperBounds != null) {
-            if (tryPossibleAnswer(intersectionOfUpperBounds)) {
+            if (tryPossibleAnswer(bounds, intersectionOfUpperBounds)) {
                 return setOf(intersectionOfUpperBounds)
             }
         }
@@ -154,7 +146,7 @@ public class TypeBoundsImpl(
         return values
     }
 
-    private fun tryPossibleAnswer(possibleAnswer: JetType?): Boolean {
+    private fun tryPossibleAnswer(bounds: Collection<Bound>, possibleAnswer: JetType?): Boolean {
         if (possibleAnswer == null) return false
         // a captured type might be an answer
         if (!possibleAnswer.getConstructor().isDenotable() && !possibleAnswer.isCaptured()) return false
@@ -176,4 +168,4 @@ public class TypeBoundsImpl(
         }
         return true
     }
-}
+}
\ No newline at end of file
diff --git a/core/descriptors/src/org/jetbrains/kotlin/resolve/calls/inference/constraintIncorporation.kt b/core/descriptors/src/org/jetbrains/kotlin/resolve/calls/inference/constraintIncorporation.kt
new file mode 100644
index 00000000000..3abccc2ffde
--- /dev/null
+++ b/core/descriptors/src/org/jetbrains/kotlin/resolve/calls/inference/constraintIncorporation.kt
@@ -0,0 +1,120 @@
+/*
+ * Copyright 2010-2015 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.kotlin.resolve.calls.inference
+
+import org.jetbrains.kotlin.resolve.calls.inference.ConstraintSystemImpl.ConstraintKind.EQUAL
+import org.jetbrains.kotlin.resolve.calls.inference.ConstraintSystemImpl.ConstraintKind.SUB_TYPE
+import org.jetbrains.kotlin.resolve.calls.inference.TypeBounds.Bound
+import org.jetbrains.kotlin.resolve.calls.inference.TypeBounds.BoundKind
+import org.jetbrains.kotlin.resolve.calls.inference.TypeBounds.BoundKind.EXACT_BOUND
+import org.jetbrains.kotlin.resolve.calls.inference.TypeBounds.BoundKind.LOWER_BOUND
+import org.jetbrains.kotlin.resolve.calls.inference.TypeBounds.BoundKind.UPPER_BOUND
+import org.jetbrains.kotlin.resolve.calls.inference.constraintPosition.CompoundConstraintPosition
+import org.jetbrains.kotlin.types.*
+import org.jetbrains.kotlin.types.Variance.INVARIANT
+import org.jetbrains.kotlin.types.typeUtil.getNestedArguments
+import org.jetbrains.kotlin.types.typesApproximation.approximateCapturedTypes
+import java.util.*
+
+fun ConstraintSystemImpl.incorporateBound(newBound: Bound) {
+    val typeVariable = newBound.typeVariable
+    val typeBounds = getTypeBounds(typeVariable)
+
+    for (oldBoundIndex in typeBounds.bounds.indices) {
+        addConstraintFromBounds(typeBounds.bounds[oldBoundIndex], newBound)
+    }
+    val boundsUsedIn = getBoundsUsedIn(typeVariable)
+    for (index in boundsUsedIn.indices) {
+        val boundUsedIn = boundsUsedIn[index]
+        generateNewBound(boundUsedIn, newBound)
+    }
+
+    val constrainingType = newBound.constrainingType
+    if (isMyTypeVariable(constrainingType)) {
+        addBound(getMyTypeVariable(constrainingType)!!, typeVariable.correspondingType, newBound.kind.reverse(), newBound.position)
+        return
+    }
+    constrainingType.getNestedTypeVariables().forEach {
+        val boundsForNestedVariable = getTypeBounds(it).bounds
+        for (index in boundsForNestedVariable.indices) {
+            generateNewBound(newBound, boundsForNestedVariable[index])
+        }
+    }
+}
+
+private fun ConstraintSystemImpl.addConstraintFromBounds(old: Bound, new: Bound) {
+    if (old == new) return
+
+    val oldType = old.constrainingType
+    val newType = new.constrainingType
+    val position = CompoundConstraintPosition(old.position, new.position)
+
+    when {
+        old.kind.ordinal() < new.kind.ordinal() -> addConstraint(SUB_TYPE, oldType, newType, position, topLevel = false)
+        old.kind.ordinal() > new.kind.ordinal() -> addConstraint(SUB_TYPE, newType, oldType, position, topLevel = false)
+        old.kind == new.kind && old.kind == EXACT_BOUND -> addConstraint(EQUAL, oldType, newType, position, topLevel = false)
+    }
+}
+
+private fun ConstraintSystemImpl.generateNewBound(bound: Bound, substitution: Bound) {
+    // Let's have a bound 'T <=> My<R>', and a substitution 'R <=> Type'.
+    // Here <=> means lower_bound, upper_bound or exact_bound constraint.
+    // Then a new bound 'T <=> My<_/in/out Type>' can be generated.
+
+    val substitutedType = when (substitution.kind) {
+        EXACT_BOUND -> substitution.constrainingType
+        UPPER_BOUND -> CapturedType(TypeProjectionImpl(Variance.OUT_VARIANCE, substitution.constrainingType))
+        LOWER_BOUND -> CapturedType(TypeProjectionImpl(Variance.IN_VARIANCE, substitution.constrainingType))
+    }
+
+    val newTypeProjection = TypeProjectionImpl(substitutedType)
+    val substitutor = TypeSubstitutor.create(mapOf(substitution.typeVariable.getTypeConstructor() to newTypeProjection))
+    val type = substitutor.substitute(bound.constrainingType, INVARIANT) ?: return
+
+    val position = CompoundConstraintPosition(bound.position, substitution.position)
+
+    fun addNewBound(newConstrainingType: JetType, newBoundKind: BoundKind) {
+        // We don't generate new recursive constraints
+        val nestedTypeVariables = newConstrainingType.getNestedTypeVariables(original = false)
+        if (nestedTypeVariables.contains(bound.typeVariable)) return
+
+        // We don't generate constraint if a type variable was substituted twice
+        val derivedFrom = HashSet(bound.derivedFrom + substitution.derivedFrom)
+        if (derivedFrom.contains(substitution.typeVariable)) return
+
+        derivedFrom.add(substitution.typeVariable)
+        addBound(bound.typeVariable, newConstrainingType, newBoundKind, position, derivedFrom)
+    }
+
+    if (substitution.kind == EXACT_BOUND) {
+        addNewBound(type, bound.kind)
+        return
+    }
+    val approximationBounds = approximateCapturedTypes(type)
+    // todo
+    // if we allow non-trivial type projections, we bump into errors like
+    // "Empty intersection for types [MutableCollection<in ('Int'..'Int?')>, MutableCollection<out Any?>, MutableCollection<in Int>]"
+    fun JetType.containsConstrainingTypeWithoutProjection() = this.getNestedArguments().any {
+        it.getType().getConstructor() == substitution.constrainingType.getConstructor() && it.getProjectionKind() == Variance.INVARIANT
+    }
+    if (approximationBounds.upper.containsConstrainingTypeWithoutProjection() && bound.kind != LOWER_BOUND) {
+        addNewBound(approximationBounds.upper, UPPER_BOUND)
+    }
+    if (approximationBounds.lower.containsConstrainingTypeWithoutProjection() && bound.kind != UPPER_BOUND) {
+        addNewBound(approximationBounds.lower, LOWER_BOUND)
+    }
+}
\ No newline at end of file
diff --git a/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/AnnotationValue.java b/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/AnnotationValue.java
deleted file mode 100644
index 551fc128936..00000000000
--- a/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/AnnotationValue.java
+++ /dev/null
@@ -1,54 +0,0 @@
-/*
- * Copyright 2010-2015 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.kotlin.resolve.constants;
-
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
-import org.jetbrains.kotlin.descriptors.annotations.AnnotationArgumentVisitor;
-import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptor;
-import org.jetbrains.kotlin.types.JetType;
-
-public class AnnotationValue extends CompileTimeConstant<AnnotationDescriptor> {
-    
-    public AnnotationValue(@NotNull AnnotationDescriptor value) {
-        super(value, true, false, false);
-    }
-
-    @NotNull
-    @Override
-    public AnnotationDescriptor getValue() {
-        AnnotationDescriptor value = super.getValue();
-        assert value != null : "Guaranteed by constructor";
-        return value;
-    }
-
-    @Override
-    @NotNull
-    public JetType getType(@NotNull KotlinBuiltIns kotlinBuiltIns) {
-        return value.getType();
-    }
-
-    @Override
-    public <R, D> R accept(AnnotationArgumentVisitor<R, D> visitor, D data) {
-        return visitor.visitAnnotationValue(this, data);
-    }
-
-    @Override
-    public String toString() {
-        return value.toString();
-    }
-}
diff --git a/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/ArrayValue.java b/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/ArrayValue.java
deleted file mode 100644
index afae9e14363..00000000000
--- a/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/ArrayValue.java
+++ /dev/null
@@ -1,96 +0,0 @@
-/*
- * Copyright 2010-2015 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.kotlin.resolve.constants;
-
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
-import org.jetbrains.kotlin.descriptors.annotations.AnnotationArgumentVisitor;
-import org.jetbrains.kotlin.types.JetType;
-
-import java.util.List;
-
-public class ArrayValue extends CompileTimeConstant<List<CompileTimeConstant<?>>> {
-
-    private final JetType type;
-
-    public ArrayValue(@NotNull List<CompileTimeConstant<?>> value,
-                      @NotNull JetType type,
-                      boolean canBeUsedInAnnotations,
-                      boolean usesVariableAsConstant) {
-        super(value, canBeUsedInAnnotations, false, usesVariableAsConstant);
-        assert KotlinBuiltIns.isArray(type) || KotlinBuiltIns.isPrimitiveArray(type)
-                : "Type should be an array, but was " + type + ": " + value;
-        this.type = type;
-    }
-
-    @NotNull
-    @Override
-    public List<CompileTimeConstant<?>> getValue() {
-        List<CompileTimeConstant<?>> value = super.getValue();
-        assert value != null : "Guaranteed by constructor";
-        return value;
-    }
-
-    @NotNull
-    @Override
-    public JetType getType(@NotNull KotlinBuiltIns kotlinBuiltIns) {
-        return type;
-    }
-
-    @Override
-    public <R, D> R accept(AnnotationArgumentVisitor<R, D> visitor, D data) {
-        return visitor.visitArrayValue(this, data);
-    }
-
-    @Override
-    public String toString() {
-       return value.toString();
-    }
-
-    @Override
-    public boolean equals(Object o) {
-        if (this == o) return true;
-        if (o == null || getClass() != o.getClass()) return false;
-
-        ArrayValue that = (ArrayValue) o;
-
-        if (value == null) {
-            return that.value == null;
-        }
-
-        int i = 0;
-        for (Object thisObject : value) {
-            if (!thisObject.equals(that.value.get(i))) {
-                return false;
-            }
-            i++;
-        }
-
-        return true;
-    }
-
-    @Override
-    public int hashCode() {
-        int hashCode = 0;
-        if (value == null) return hashCode;
-        for (Object o : value) {
-            hashCode += o.hashCode();
-        }
-        return hashCode;
-    }
-}
-
diff --git a/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/BooleanValue.java b/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/BooleanValue.java
deleted file mode 100644
index ce55cd6e45b..00000000000
--- a/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/BooleanValue.java
+++ /dev/null
@@ -1,46 +0,0 @@
-/*
- * Copyright 2010-2015 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.kotlin.resolve.constants;
-
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
-import org.jetbrains.kotlin.descriptors.annotations.AnnotationArgumentVisitor;
-import org.jetbrains.kotlin.types.JetType;
-
-public class BooleanValue extends CompileTimeConstant<Boolean> {
-
-    public BooleanValue(boolean value, boolean canBeUseInAnnotation, boolean usesVariableAsConstant) {
-        super(value, canBeUseInAnnotation, false, usesVariableAsConstant);
-    }
-
-    @NotNull
-    @Override
-    public JetType getType(@NotNull KotlinBuiltIns kotlinBuiltIns) {
-        return kotlinBuiltIns.getBooleanType();
-    }
-
-    @Override
-    public <R, D> R accept(AnnotationArgumentVisitor<R, D> visitor, D data) {
-        return visitor.visitBooleanValue(this, data);
-    }
-
-    @Override
-    public String toString() {
-        return String.valueOf(value);
-    }
-
-}
diff --git a/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/ByteValue.java b/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/ByteValue.java
deleted file mode 100644
index 26d036e42e8..00000000000
--- a/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/ByteValue.java
+++ /dev/null
@@ -1,45 +0,0 @@
-/*
- * Copyright 2010-2015 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.kotlin.resolve.constants;
-
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
-import org.jetbrains.kotlin.descriptors.annotations.AnnotationArgumentVisitor;
-import org.jetbrains.kotlin.types.JetType;
-
-public class ByteValue extends IntegerValueConstant<Byte> {
-
-    public ByteValue(byte value, boolean canBeUsedInAnnotations, boolean pure, boolean usesVaraiableAsConstant) {
-        super(value, canBeUsedInAnnotations, pure, usesVaraiableAsConstant);
-    }
-
-    @NotNull
-    @Override
-    public JetType getType(@NotNull KotlinBuiltIns kotlinBuiltIns) {
-        return kotlinBuiltIns.getByteType();
-    }
-
-    @Override
-    public <R, D> R accept(AnnotationArgumentVisitor<R, D> visitor, D data) {
-        return visitor.visitByteValue(this, data);
-    }
-
-    @Override
-    public String toString() {
-        return value + ".toByte()";
-    }
-}
diff --git a/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/CharValue.java b/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/CharValue.java
deleted file mode 100644
index 1ae5504827d..00000000000
--- a/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/CharValue.java
+++ /dev/null
@@ -1,68 +0,0 @@
-/*
- * Copyright 2010-2015 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.kotlin.resolve.constants;
-
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
-import org.jetbrains.kotlin.descriptors.annotations.AnnotationArgumentVisitor;
-import org.jetbrains.kotlin.types.JetType;
-
-public class CharValue extends IntegerValueConstant<Character> {
-
-    public CharValue(char value, boolean canBeUsedInAnnotations, boolean pure, boolean usesVariableAsConstant) {
-        super(value, canBeUsedInAnnotations, pure, usesVariableAsConstant);
-    }
-
-    @NotNull
-    @Override
-    public JetType getType(@NotNull KotlinBuiltIns kotlinBuiltIns) {
-        return kotlinBuiltIns.getCharType();
-    }
-
-    @Override
-    public <R, D> R accept(AnnotationArgumentVisitor<R, D> visitor, D data) {
-        return visitor.visitCharValue(this, data);
-    }
-
-    @Override
-    public String toString() {
-        return String.format("\\u%04X ('%s')", (int) value, getPrintablePart(value));
-    }
-
-    private static String getPrintablePart(char c) {
-        switch (c) {
-            case '\b':
-                return "\\b";
-            case '\t':
-                return "\\t";
-            case '\n':
-                return "\\n";
-            case '\f':
-                return "\\f";
-            case '\r':
-                return "\\r";
-            default:
-                return isPrintableUnicode(c) ? Character.toString(c) : "?";
-        }
-    }
-
-    private static boolean isPrintableUnicode(char c) {
-        int t = Character.getType(c);
-        return t != Character.UNASSIGNED && t != Character.LINE_SEPARATOR && t != Character.PARAGRAPH_SEPARATOR &&
-               t != Character.CONTROL && t != Character.FORMAT && t != Character.PRIVATE_USE && t != Character.SURROGATE;
-    }
-}
diff --git a/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/CompileTimeConstant.java b/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/CompileTimeConstant.java
deleted file mode 100644
index f51c8ef0e5f..00000000000
--- a/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/CompileTimeConstant.java
+++ /dev/null
@@ -1,70 +0,0 @@
-/*
- * Copyright 2010-2015 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.kotlin.resolve.constants;
-
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
-import org.jetbrains.kotlin.descriptors.annotations.AnnotationArgumentVisitor;
-import org.jetbrains.kotlin.types.JetType;
-
-public abstract class CompileTimeConstant<T> {
-    protected final T value;
-    private final int flags;
-
-   /*
-    * if is pure is false then constant type cannot be changed
-    * ex1. val a: Long = 1.toInt() (TYPE_MISMATCH error, 1.toInt() isn't pure)
-    * ex2. val b: Int = a (TYPE_MISMATCH error, a isn't pure)
-    *
-    */
-    private static final int IS_PURE_MASK = 1;
-    private static final int CAN_BE_USED_IN_ANNOTATIONS_MASK = 1 << 1;
-    private static final int USES_VARIABLE_AS_CONSTANT_MASK = 1 << 2;
-
-    protected CompileTimeConstant(T value,
-                                  boolean canBeUsedInAnnotations,
-                                  boolean isPure,
-                                  boolean usesVariableAsConstant) {
-        this.value = value;
-        flags = (isPure ? IS_PURE_MASK : 0) |
-                (canBeUsedInAnnotations ? CAN_BE_USED_IN_ANNOTATIONS_MASK : 0) |
-                (usesVariableAsConstant ? USES_VARIABLE_AS_CONSTANT_MASK : 0);
-    }
-
-    public boolean canBeUsedInAnnotations() {
-        return (flags & CAN_BE_USED_IN_ANNOTATIONS_MASK) != 0;
-    }
-
-    public boolean isPure() {
-        return (flags & IS_PURE_MASK) != 0;
-    }
-
-    public boolean usesVariableAsConstant() {
-        return (flags & USES_VARIABLE_AS_CONSTANT_MASK) != 0;
-    }
-
-    @Nullable
-    public T getValue() {
-        return value;
-    }
-
-    @NotNull
-    public abstract JetType getType(@NotNull KotlinBuiltIns kotlinBuiltIns);
-
-    public abstract <R, D> R accept(AnnotationArgumentVisitor<R, D> visitor, D data);
-}
diff --git a/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/CompileTimeConstant.kt b/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/CompileTimeConstant.kt
new file mode 100644
index 00000000000..c81dfbe4400
--- /dev/null
+++ b/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/CompileTimeConstant.kt
@@ -0,0 +1,90 @@
+/*
+ * Copyright 2010-2015 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.kotlin.resolve.constants
+
+import org.jetbrains.kotlin.builtins.KotlinBuiltIns
+import org.jetbrains.kotlin.descriptors.annotations.Annotations
+import org.jetbrains.kotlin.types.*
+
+public interface CompileTimeConstant<out T> {
+    public val isError: Boolean
+        get() = false
+
+    public val parameters: CompileTimeConstant.Parameters
+
+    public fun toConstantValue(expectedType: JetType): ConstantValue<T>
+
+    public fun getValue(expectedType: JetType): T = toConstantValue(expectedType).value
+
+    public val canBeUsedInAnnotations: Boolean get() = parameters.canBeUsedInAnnotation
+
+    public val usesVariableAsConstant: Boolean get() = parameters.usesVariableAsConstant
+
+    public val isPure: Boolean get() = parameters.isPure
+
+    public class Parameters(
+            public val canBeUsedInAnnotation: Boolean,
+            public val isPure: Boolean,
+            public val usesVariableAsConstant: Boolean
+    )
+}
+
+public class TypedCompileTimeConstant<out T>(
+        public val constantValue: ConstantValue<T>,
+        override val parameters: CompileTimeConstant.Parameters
+) : CompileTimeConstant<T> {
+    override val isError: Boolean
+        get() = constantValue is ErrorValue
+
+    public val type: JetType = constantValue.type
+
+    override fun toConstantValue(expectedType: JetType): ConstantValue<T> = constantValue
+}
+
+public class IntegerValueTypeConstant(
+        private val value: Number,
+        override val parameters: CompileTimeConstant.Parameters
+) : CompileTimeConstant<Number> {
+    private val typeConstructor = IntegerValueTypeConstructor(value.toLong())
+
+    override fun toConstantValue(expectedType: JetType): ConstantValue<Number> {
+        val factory = ConstantValueFactory(KotlinBuiltIns.getInstance())
+        return when (getType(expectedType)) {
+            KotlinBuiltIns.getInstance().getIntType() -> {
+                factory.createIntValue(value.toInt())
+            }
+            KotlinBuiltIns.getInstance().getByteType() -> {
+                factory.createByteValue(value.toByte())
+            }
+            KotlinBuiltIns.getInstance().getShortType() -> {
+                factory.createShortValue(value.toShort())
+            }
+            else -> {
+                factory.createLongValue(value.toLong())
+            }
+        }
+    }
+
+    val unknownIntegerType = JetTypeImpl(
+            Annotations.EMPTY, typeConstructor, false, emptyList<TypeProjection>(),
+            ErrorUtils.createErrorScope("Scope for number value type (" + typeConstructor.toString() + ")", true)
+    )
+
+    public fun getType(expectedType: JetType): JetType = TypeUtils.getPrimitiveNumberType(typeConstructor, expectedType)
+
+    override fun toString() = typeConstructor.toString()
+}
diff --git a/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/ConstantUtils.kt b/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/ConstantUtils.kt
deleted file mode 100644
index 0dff6a49e5f..00000000000
--- a/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/ConstantUtils.kt
+++ /dev/null
@@ -1,81 +0,0 @@
-/*
- * Copyright 2010-2015 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.kotlin.resolve.constants
-
-import org.jetbrains.kotlin.types.JetType
-import org.jetbrains.kotlin.builtins.KotlinBuiltIns
-import org.jetbrains.kotlin.types.TypeUtils
-
-public fun createCompileTimeConstant(
-        value: Any?,
-        canBeUsedInAnnotation: Boolean,
-        isPureIntConstant: Boolean,
-        usesVariableAsConstant: Boolean = false,
-        expectedType: JetType? = null
-): CompileTimeConstant<*>? {
-    // TODO: primitive arrays
-    if (expectedType == null) {
-        when(value) {
-            is Byte -> return ByteValue(value, canBeUsedInAnnotation, isPureIntConstant, usesVariableAsConstant)
-            is Short -> return ShortValue(value, canBeUsedInAnnotation, isPureIntConstant, usesVariableAsConstant)
-            is Int -> return IntValue(value, canBeUsedInAnnotation, isPureIntConstant, usesVariableAsConstant)
-            is Long -> return LongValue(value, canBeUsedInAnnotation, isPureIntConstant, usesVariableAsConstant)
-        }
-    }
-    return when(value) {
-        is Byte, is Short, is Int, is Long -> getIntegerValue((value as Number).toLong(), canBeUsedInAnnotation, isPureIntConstant, usesVariableAsConstant, expectedType)
-        is Char -> CharValue(value, canBeUsedInAnnotation, isPureIntConstant, usesVariableAsConstant)
-        is Float -> FloatValue(value, canBeUsedInAnnotation, usesVariableAsConstant)
-        is Double -> DoubleValue(value, canBeUsedInAnnotation, usesVariableAsConstant)
-        is Boolean -> BooleanValue(value, canBeUsedInAnnotation, usesVariableAsConstant)
-        is String -> StringValue(value, canBeUsedInAnnotation, usesVariableAsConstant)
-        null -> NullValue.NULL
-        else -> null
-    }
-}
-
-private fun getIntegerValue(
-        value: Long,
-        canBeUsedInAnnotation: Boolean,
-        isPureIntConstant: Boolean,
-        usesVariableAsConstant: Boolean,
-        expectedType: JetType
-): CompileTimeConstant<*>? {
-    fun defaultIntegerValue(value: Long) = when (value) {
-        value.toInt().toLong() -> IntValue(value.toInt(), canBeUsedInAnnotation, isPureIntConstant, usesVariableAsConstant)
-        else -> LongValue(value, canBeUsedInAnnotation, isPureIntConstant, usesVariableAsConstant)
-    }
-
-    if (TypeUtils.noExpectedType(expectedType) || expectedType.isError()) {
-        return IntegerValueTypeConstant(value, canBeUsedInAnnotation, usesVariableAsConstant)
-    }
-
-    val notNullExpected = TypeUtils.makeNotNullable(expectedType)
-    return when {
-        KotlinBuiltIns.isLong(notNullExpected) -> LongValue(value, canBeUsedInAnnotation, isPureIntConstant, usesVariableAsConstant)
-        KotlinBuiltIns.isShort(notNullExpected) -> when (value) {
-            value.toShort().toLong() -> ShortValue(value.toShort(), canBeUsedInAnnotation, isPureIntConstant, usesVariableAsConstant)
-            else -> defaultIntegerValue(value)
-        }
-        KotlinBuiltIns.isByte(notNullExpected) -> when (value) {
-            value.toByte().toLong() -> ByteValue(value.toByte(), canBeUsedInAnnotation, isPureIntConstant, usesVariableAsConstant)
-            else -> defaultIntegerValue(value)
-        }
-        KotlinBuiltIns.isChar(notNullExpected) -> IntValue(value.toInt(), canBeUsedInAnnotation, isPureIntConstant, usesVariableAsConstant)
-        else -> defaultIntegerValue(value)
-    }
-}
diff --git a/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/ConstantValueFactory.kt b/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/ConstantValueFactory.kt
new file mode 100644
index 00000000000..6fab30172fb
--- /dev/null
+++ b/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/ConstantValueFactory.kt
@@ -0,0 +1,95 @@
+/*
+ * Copyright 2010-2015 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.kotlin.resolve.constants
+
+import org.jetbrains.kotlin.builtins.KotlinBuiltIns
+import org.jetbrains.kotlin.descriptors.ClassDescriptor
+import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptor
+import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.TypeUtils
+
+public class ConstantValueFactory(
+        private val builtins: KotlinBuiltIns
+) {
+    fun createLongValue(value: Long) = LongValue(value, builtins)
+
+    fun createIntValue(value: Int) = IntValue(value, builtins)
+
+    fun createErrorValue(message: String) = ErrorValue.create(message)
+
+    fun createShortValue(value: Short) = ShortValue(value, builtins)
+
+    fun createByteValue(value: Byte) = ByteValue(value, builtins)
+
+    fun createDoubleValue(value: Double) = DoubleValue(value, builtins)
+
+    fun createFloatValue(value: Float) = FloatValue(value, builtins)
+
+    fun createBooleanValue(value: Boolean) = BooleanValue(value, builtins)
+
+    fun createCharValue(value: Char) = CharValue(value, builtins)
+
+    fun createStringValue(value: String) = StringValue(value, builtins)
+
+    fun createNullValue() = NullValue(builtins)
+
+    fun createEnumValue(enumEntryClass: ClassDescriptor): EnumValue = EnumValue(enumEntryClass)
+
+    fun createArrayValue(
+            value: List<ConstantValue<*>>,
+            type: JetType
+    ) = ArrayValue(value, type, builtins)
+
+    fun createAnnotationValue(value: AnnotationDescriptor) = AnnotationValue(value)
+
+    fun createKClassValue(type: JetType) = KClassValue(type)
+
+    fun createConstantValue(
+            value: Any?
+    ): ConstantValue<*>? {
+        // TODO: primitive arrays
+        return when (value) {
+            is Byte -> createByteValue(value)
+            is Short -> createShortValue(value)
+            is Int -> createIntValue(value)
+            is Long -> createLongValue(value)
+            is Char -> createCharValue(value)
+            is Float -> createFloatValue(value)
+            is Double -> createDoubleValue(value)
+            is Boolean -> createBooleanValue(value)
+            is String -> createStringValue(value)
+            null -> createNullValue()
+            else -> null
+        }
+    }
+
+    public fun createIntegerConstantValue(
+            value: Long,
+            expectedType: JetType
+    ): ConstantValue<*>? {
+        val notNullExpected = TypeUtils.makeNotNullable(expectedType)
+        return when {
+            KotlinBuiltIns.isLong(notNullExpected) -> createLongValue(value)
+            KotlinBuiltIns.isInt(notNullExpected) && value == value.toInt().toLong() -> createIntValue(value.toInt())
+            KotlinBuiltIns.isShort(notNullExpected) && value == value.toShort().toLong() -> createShortValue(value.toShort())
+            KotlinBuiltIns.isByte(notNullExpected) && value == value.toByte().toLong() -> createByteValue(value.toByte())
+            KotlinBuiltIns.isChar(notNullExpected) -> createIntValue(value.toInt())
+            else -> null
+        }
+    }
+}
+
diff --git a/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/DoubleValue.java b/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/DoubleValue.java
deleted file mode 100644
index f6a13def8ec..00000000000
--- a/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/DoubleValue.java
+++ /dev/null
@@ -1,45 +0,0 @@
-/*
- * Copyright 2010-2015 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.kotlin.resolve.constants;
-
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
-import org.jetbrains.kotlin.descriptors.annotations.AnnotationArgumentVisitor;
-import org.jetbrains.kotlin.types.JetType;
-
-public class DoubleValue extends CompileTimeConstant<Double> {
-
-    public DoubleValue(double value, boolean canBeUsedInAnnotations, boolean usesVariableAsConstant) {
-        super(value, canBeUsedInAnnotations, false, usesVariableAsConstant);
-    }
-
-    @NotNull
-    @Override
-    public JetType getType(@NotNull KotlinBuiltIns kotlinBuiltIns) {
-        return kotlinBuiltIns.getDoubleType();
-    }
-
-    @Override
-    public <R, D> R accept(AnnotationArgumentVisitor<R, D> visitor, D data) {
-        return visitor.visitDoubleValue(this, data);
-    }
-
-    @Override
-    public String toString() {
-        return value + ".toDouble()";
-    }
-}
diff --git a/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/EnumValue.java b/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/EnumValue.java
deleted file mode 100644
index 05a092cf9bc..00000000000
--- a/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/EnumValue.java
+++ /dev/null
@@ -1,77 +0,0 @@
-/*
- * Copyright 2010-2015 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.kotlin.resolve.constants;
-
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
-import org.jetbrains.kotlin.descriptors.ClassDescriptor;
-import org.jetbrains.kotlin.descriptors.annotations.AnnotationArgumentVisitor;
-import org.jetbrains.kotlin.types.JetType;
-
-import static org.jetbrains.kotlin.resolve.descriptorUtil.DescriptorUtilPackage.getClassObjectType;
-
-public class EnumValue extends CompileTimeConstant<ClassDescriptor> {
-
-    public EnumValue(@NotNull ClassDescriptor value, boolean usesVariableAsConstant) {
-        super(value, true, false, usesVariableAsConstant);
-    }
-
-    @NotNull
-    @Override
-    public JetType getType(@NotNull KotlinBuiltIns kotlinBuiltIns) {
-        return getType();
-    }
-
-    @NotNull
-    private JetType getType() {
-        JetType type = getClassObjectType(value);
-        assert type != null : "Enum entry must have a class object type: " + value;
-        return type;
-    }
-
-    @NotNull
-    @Override
-    public ClassDescriptor getValue() {
-        ClassDescriptor value = super.getValue();
-        assert value != null : "Guaranteed by constructor";
-        return value;
-    }
-
-    @Override
-    public <R, D> R accept(AnnotationArgumentVisitor<R, D> visitor, D data) {
-        return visitor.visitEnumValue(this, data);
-    }
-
-    @Override
-    public String toString() {
-        return getType() + "." + value.getName();
-    }
-
-    @Override
-    public boolean equals(Object o) {
-        if (this == o) return true;
-        if (o == null || getClass() != o.getClass()) return false;
-
-        return value.equals(((EnumValue) o).value);
-    }
-
-    @Override
-    public int hashCode() {
-        return value.hashCode();
-    }
-}
-
diff --git a/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/ErrorValue.java b/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/ErrorValue.java
deleted file mode 100644
index 980988ef74f..00000000000
--- a/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/ErrorValue.java
+++ /dev/null
@@ -1,69 +0,0 @@
-/*
- * Copyright 2010-2015 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.kotlin.resolve.constants;
-
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
-import org.jetbrains.kotlin.descriptors.annotations.AnnotationArgumentVisitor;
-import org.jetbrains.kotlin.types.ErrorUtils;
-import org.jetbrains.kotlin.types.JetType;
-
-public abstract class ErrorValue extends CompileTimeConstant<Void> {
-
-    public ErrorValue() {
-        super(null, true, false, false);
-    }
-
-    @Override
-    @Deprecated // Should not be called, for this is not a real value, but a indication of an error
-    public Void getValue() {
-        throw new UnsupportedOperationException();
-    }
-
-    @Override
-    public <R, D> R accept(AnnotationArgumentVisitor<R, D> visitor, D data) {
-        return visitor.visitErrorValue(this, data);
-    }
-
-    @NotNull
-    public static ErrorValue create(@NotNull String message) {
-        return new ErrorValueWithMessage(message);
-    }
-
-    public static class ErrorValueWithMessage extends ErrorValue {
-        private final String message;
-
-        public ErrorValueWithMessage(@NotNull String message) {
-            this.message = message;
-        }
-
-        public String getMessage() {
-            return message;
-        }
-
-        @NotNull
-        @Override
-        public JetType getType(@NotNull KotlinBuiltIns kotlinBuiltIns) {
-            return ErrorUtils.createErrorType(message);
-        }
-
-        @Override
-        public String toString() {
-            return getMessage();
-        }
-    }
-}
diff --git a/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/FloatValue.java b/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/FloatValue.java
deleted file mode 100644
index b541ecf0246..00000000000
--- a/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/FloatValue.java
+++ /dev/null
@@ -1,45 +0,0 @@
-/*
- * Copyright 2010-2015 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.kotlin.resolve.constants;
-
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
-import org.jetbrains.kotlin.descriptors.annotations.AnnotationArgumentVisitor;
-import org.jetbrains.kotlin.types.JetType;
-
-public class FloatValue extends CompileTimeConstant<Float> {
-
-    public FloatValue(float value, boolean canBeUsedInAnnotations, boolean usesVariableAsConstant) {
-        super(value, canBeUsedInAnnotations, false, usesVariableAsConstant);
-    }
-
-    @NotNull
-    @Override
-    public JetType getType(@NotNull KotlinBuiltIns kotlinBuiltIns) {
-        return kotlinBuiltIns.getFloatType();
-    }
-
-    @Override
-    public <R, D> R accept(AnnotationArgumentVisitor<R, D> visitor, D data) {
-        return visitor.visitFloatValue(this, data);
-    }
-
-    @Override
-    public String toString() {
-        return value + ".toFloat()";
-    }
-}
diff --git a/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/IntValue.java b/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/IntValue.java
deleted file mode 100644
index cb390098600..00000000000
--- a/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/IntValue.java
+++ /dev/null
@@ -1,62 +0,0 @@
-/*
- * Copyright 2010-2015 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.kotlin.resolve.constants;
-
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
-import org.jetbrains.kotlin.descriptors.annotations.AnnotationArgumentVisitor;
-import org.jetbrains.kotlin.types.JetType;
-
-public class IntValue extends IntegerValueConstant<Integer> {
-
-    public IntValue(int value, boolean canBeUsedInAnnotations, boolean pure, boolean usesVariableAsConstant) {
-        super(value, canBeUsedInAnnotations, pure, usesVariableAsConstant);
-    }
-
-    @NotNull
-    @Override
-    public JetType getType(@NotNull KotlinBuiltIns kotlinBuiltIns) {
-        return kotlinBuiltIns.getIntType();
-    }
-
-    @Override
-    public <R, D> R accept(AnnotationArgumentVisitor<R, D> visitor, D data) {
-        return visitor.visitIntValue(this, data);
-    }
-
-    @Override
-    public String toString() {
-        return value.toString();
-    }
-
-    @Override
-    public boolean equals(Object o) {
-        if (this == o) return true;
-        if (o == null || getClass() != o.getClass()) return false;
-
-        IntValue intValue = (IntValue) o;
-
-        if (value != intValue.value) return false;
-
-        return true;
-    }
-
-    @Override
-    public int hashCode() {
-        return value;
-    }
-}
diff --git a/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/IntegerValueTypeConstant.java b/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/IntegerValueTypeConstant.java
deleted file mode 100644
index 682a70b9265..00000000000
--- a/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/IntegerValueTypeConstant.java
+++ /dev/null
@@ -1,87 +0,0 @@
-/*
- * Copyright 2010-2015 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.kotlin.resolve.constants;
-
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
-import org.jetbrains.kotlin.descriptors.annotations.AnnotationArgumentVisitor;
-import org.jetbrains.kotlin.descriptors.annotations.Annotations;
-import org.jetbrains.kotlin.types.*;
-
-import java.util.Collections;
-
-public class IntegerValueTypeConstant extends IntegerValueConstant<Number> {
-
-    private final IntegerValueTypeConstructor typeConstructor;
-
-    public IntegerValueTypeConstant(@NotNull Number value, boolean canBeUsedInAnnotations, boolean usesVariableAsConstant) {
-        super(value, canBeUsedInAnnotations, true, usesVariableAsConstant);
-        this.typeConstructor = new IntegerValueTypeConstructor(value.longValue());
-    }
-
-    @NotNull
-    @Override
-    public JetType getType(@NotNull KotlinBuiltIns kotlinBuiltIns) {
-        return new JetTypeImpl(
-                Annotations.EMPTY, typeConstructor,
-                false, Collections.<TypeProjection>emptyList(),
-                ErrorUtils.createErrorScope("Scope for number value type (" + typeConstructor.toString() + ")", true));
-    }
-
-    @Nullable
-    @Override
-    @Deprecated
-    public Number getValue() {
-        throw new UnsupportedOperationException("Use IntegerValueTypeConstant.getValue(expectedType) instead");
-    }
-
-    @NotNull
-    public JetType getType(@NotNull JetType expectedType) {
-        return TypeUtils.getPrimitiveNumberType(typeConstructor, expectedType);
-    }
-
-    @NotNull
-    public Number getValue(@NotNull JetType expectedType) {
-        Number numberValue = typeConstructor.getValue();
-        KotlinBuiltIns builtIns = KotlinBuiltIns.getInstance();
-
-        JetType valueType = getType(expectedType);
-        if (valueType.equals(builtIns.getIntType())) {
-            return numberValue.intValue();
-        }
-        else if (valueType.equals(builtIns.getByteType())) {
-            return numberValue.byteValue();
-        }
-        else if (valueType.equals(builtIns.getShortType())) {
-            return numberValue.shortValue();
-        }
-        else {
-            return numberValue.longValue();
-        }
-    }
-
-    @Override
-    public <R, D> R accept(AnnotationArgumentVisitor<R, D> visitor, D data) {
-        return visitor.visitNumberTypeValue(this, data);
-    }
-
-    @Override
-    public String toString() {
-        return typeConstructor.toString();
-    }
-}
diff --git a/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/IntegerValueTypeConstructor.java b/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/IntegerValueTypeConstructor.java
deleted file mode 100644
index aaec9522e06..00000000000
--- a/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/IntegerValueTypeConstructor.java
+++ /dev/null
@@ -1,96 +0,0 @@
-/*
- * Copyright 2010-2015 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.kotlin.resolve.constants;
-
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
-import org.jetbrains.kotlin.descriptors.ClassifierDescriptor;
-import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor;
-import org.jetbrains.kotlin.descriptors.annotations.Annotations;
-import org.jetbrains.kotlin.types.JetType;
-import org.jetbrains.kotlin.types.TypeConstructor;
-
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.List;
-
-public class IntegerValueTypeConstructor implements TypeConstructor {
-    private final long value;
-    private final Collection<JetType> supertypes = new ArrayList<JetType>(4);
-
-    public IntegerValueTypeConstructor(long value) {
-        // order of types matters
-        // 'getPrimitiveNumberType' returns first of supertypes that is a subtype of expected type
-        // for expected type 'Any' result type 'Int' should be returned
-        this.value = value;
-        checkBoundsAndAddSuperType(value, (long) Integer.MIN_VALUE, (long) Integer.MAX_VALUE, KotlinBuiltIns.getInstance().getIntType());
-        checkBoundsAndAddSuperType(value, (long) Byte.MIN_VALUE, (long) Byte.MAX_VALUE, KotlinBuiltIns.getInstance().getByteType());
-        checkBoundsAndAddSuperType(value, (long) Short.MIN_VALUE, (long) Short.MAX_VALUE, KotlinBuiltIns.getInstance().getShortType());
-        supertypes.add(KotlinBuiltIns.getInstance().getLongType());
-    }
-
-    private void checkBoundsAndAddSuperType(long value, long minValue, long maxValue, JetType kotlinType) {
-        if (value >= minValue && value <= maxValue) {
-            supertypes.add(kotlinType);
-        }
-    }
-
-    @NotNull
-    @Override
-    public Collection<JetType> getSupertypes() {
-        return supertypes;
-    }
-
-    @NotNull
-    @Override
-    public List<TypeParameterDescriptor> getParameters() {
-        return Collections.emptyList();
-    }
-
-    @Override
-    public boolean isFinal() {
-        return false;
-    }
-
-    @Override
-    public boolean isDenotable() {
-        return false;
-    }
-
-    @Nullable
-    @Override
-    public ClassifierDescriptor getDeclarationDescriptor() {
-        return null;
-    }
-
-    @NotNull
-    @Override
-    public Annotations getAnnotations() {
-        return Annotations.EMPTY;
-    }
-
-    public Long getValue() {
-        return value;
-    }
-
-    @Override
-    public String toString() {
-        return "IntegerValueType(" + value + ")";
-    }
-}
diff --git a/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/IntegerValueTypeConstructor.kt b/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/IntegerValueTypeConstructor.kt
new file mode 100644
index 00000000000..92e9458bc7b
--- /dev/null
+++ b/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/IntegerValueTypeConstructor.kt
@@ -0,0 +1,63 @@
+/*
+ * Copyright 2010-2015 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.kotlin.resolve.constants
+
+import org.jetbrains.kotlin.builtins.KotlinBuiltIns
+import org.jetbrains.kotlin.descriptors.ClassifierDescriptor
+import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor
+import org.jetbrains.kotlin.descriptors.annotations.Annotations
+import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.TypeConstructor
+
+import java.util.ArrayList
+import java.util.Collections
+
+public class IntegerValueTypeConstructor(private val value: Long) : TypeConstructor {
+    private val supertypes = ArrayList<JetType>(4)
+
+    init {
+        // order of types matters
+        // 'getPrimitiveNumberType' returns first of supertypes that is a subtype of expected type
+        // for expected type 'Any' result type 'Int' should be returned
+        checkBoundsAndAddSuperType(value, Integer.MIN_VALUE.toLong(), Integer.MAX_VALUE.toLong(), KotlinBuiltIns.getInstance().getIntType())
+        checkBoundsAndAddSuperType(value, java.lang.Byte.MIN_VALUE.toLong(), java.lang.Byte.MAX_VALUE.toLong(), KotlinBuiltIns.getInstance().getByteType())
+        checkBoundsAndAddSuperType(value, java.lang.Short.MIN_VALUE.toLong(), java.lang.Short.MAX_VALUE.toLong(), KotlinBuiltIns.getInstance().getShortType())
+        supertypes.add(KotlinBuiltIns.getInstance().getLongType())
+    }
+
+    private fun checkBoundsAndAddSuperType(value: Long, minValue: Long, maxValue: Long, kotlinType: JetType) {
+        if (value >= minValue && value <= maxValue) {
+            supertypes.add(kotlinType)
+        }
+    }
+
+    override fun getSupertypes(): Collection<JetType> = supertypes
+
+    override fun getParameters(): List<TypeParameterDescriptor> = emptyList()
+
+    override fun isFinal() = false
+
+    override fun isDenotable() = false
+
+    override fun getDeclarationDescriptor() = null
+
+    override fun getAnnotations() = Annotations.EMPTY
+
+    public fun getValue(): Long = value
+
+    override fun toString() = "IntegerValueType(" + value + ")"
+}
diff --git a/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/LongValue.java b/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/LongValue.java
deleted file mode 100644
index 448dd6fab72..00000000000
--- a/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/LongValue.java
+++ /dev/null
@@ -1,45 +0,0 @@
-/*
- * Copyright 2010-2015 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.kotlin.resolve.constants;
-
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
-import org.jetbrains.kotlin.descriptors.annotations.AnnotationArgumentVisitor;
-import org.jetbrains.kotlin.types.JetType;
-
-public class LongValue extends IntegerValueConstant<Long> {
-
-    public LongValue(long value, boolean canBeUsedInAnnotations, boolean pure, boolean usesVariableAsConstant) {
-        super(value, canBeUsedInAnnotations, pure, usesVariableAsConstant);
-    }
-
-    @NotNull
-    @Override
-    public JetType getType(@NotNull KotlinBuiltIns kotlinBuiltIns) {
-        return kotlinBuiltIns.getLongType();
-    }
-
-    @Override
-    public <R, D> R accept(AnnotationArgumentVisitor<R, D> visitor, D data) {
-        return visitor.visitLongValue(this, data);
-    }
-
-    @Override
-    public String toString() {
-        return value + ".toLong()";
-    }
-}
diff --git a/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/NullValue.java b/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/NullValue.java
deleted file mode 100644
index a4ec8773aa7..00000000000
--- a/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/NullValue.java
+++ /dev/null
@@ -1,47 +0,0 @@
-/*
- * Copyright 2010-2015 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.kotlin.resolve.constants;
-
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
-import org.jetbrains.kotlin.descriptors.annotations.AnnotationArgumentVisitor;
-import org.jetbrains.kotlin.types.JetType;
-
-public class NullValue extends CompileTimeConstant<Void> {
-
-    public static final NullValue NULL = new NullValue();
-
-    private NullValue() {
-        super(null, false, false, false);
-    }
-
-    @NotNull
-    @Override
-    public JetType getType(@NotNull KotlinBuiltIns kotlinBuiltIns) {
-        return kotlinBuiltIns.getNullableNothingType();
-    }
-
-    @Override
-    public <R, D> R accept(AnnotationArgumentVisitor<R, D> visitor, D data) {
-        return visitor.visitNullValue(this, data);
-    }
-
-    @Override
-    public String toString() {
-        return "null";
-    }
-}
diff --git a/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/ShortValue.java b/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/ShortValue.java
deleted file mode 100644
index b32fcc2ceb1..00000000000
--- a/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/ShortValue.java
+++ /dev/null
@@ -1,46 +0,0 @@
-/*
- * Copyright 2010-2015 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.kotlin.resolve.constants;
-
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
-import org.jetbrains.kotlin.descriptors.annotations.AnnotationArgumentVisitor;
-import org.jetbrains.kotlin.types.JetType;
-
-public class ShortValue extends IntegerValueConstant<Short> {
-
-    public ShortValue(short value, boolean canBeUsedInAnnotations, boolean pure, boolean usesVariableAsConstant) {
-        super(value, canBeUsedInAnnotations, pure, usesVariableAsConstant);
-    }
-
-    @NotNull
-    @Override
-    public JetType getType(@NotNull KotlinBuiltIns kotlinBuiltIns) {
-        return kotlinBuiltIns.getShortType();
-    }
-
-    @Override
-    public <R, D> R accept(AnnotationArgumentVisitor<R, D> visitor, D data) {
-        return visitor.visitShortValue(this, data);
-    }
-
-    @Override
-    public String toString() {
-        return value + ".toShort()";
-    }
-
-}
diff --git a/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/StringValue.java b/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/StringValue.java
deleted file mode 100644
index d3367beb420..00000000000
--- a/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/StringValue.java
+++ /dev/null
@@ -1,62 +0,0 @@
-/*
- * Copyright 2010-2015 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.kotlin.resolve.constants;
-
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
-import org.jetbrains.kotlin.descriptors.annotations.AnnotationArgumentVisitor;
-import org.jetbrains.kotlin.types.JetType;
-
-public class StringValue extends CompileTimeConstant<String> {
-
-    public StringValue(String value, boolean canBeUsedInAnnotations, boolean usesVariableAsConstant) {
-        super(value, canBeUsedInAnnotations, false, usesVariableAsConstant);
-    }
-
-    @NotNull
-    @Override
-    public JetType getType(@NotNull KotlinBuiltIns kotlinBuiltIns) {
-        return kotlinBuiltIns.getStringType();
-    }
-
-    @Override
-    public <R, D> R accept(AnnotationArgumentVisitor<R, D> visitor, D data) {
-        return visitor.visitStringValue(this, data);
-    }
-
-    @Override
-    public String toString() {
-        return "\"" + value + "\"";
-    }
-
-    @Override
-    public boolean equals(Object o) {
-        if (this == o) return true;
-        if (o == null || getClass() != o.getClass()) return false;
-
-        StringValue that = (StringValue) o;
-
-        if (value != null ? !value.equals(that.value) : that.value != null) return false;
-
-        return true;
-    }
-
-    @Override
-    public int hashCode() {
-        return value != null ? value.hashCode() : 0;
-    }
-}
diff --git a/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/constantValues.kt b/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/constantValues.kt
new file mode 100644
index 00000000000..3122f021ebe
--- /dev/null
+++ b/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/constantValues.kt
@@ -0,0 +1,275 @@
+/*
+ * Copyright 2010-2015 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.kotlin.resolve.constants
+
+import org.jetbrains.kotlin.builtins.KotlinBuiltIns
+import org.jetbrains.kotlin.descriptors.ClassDescriptor
+import org.jetbrains.kotlin.descriptors.annotations.AnnotationArgumentVisitor
+import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptor
+import org.jetbrains.kotlin.resolve.descriptorUtil.classObjectType
+import org.jetbrains.kotlin.types.ErrorUtils
+import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.utils.sure
+
+public abstract class ConstantValue<out T>(public open val value: T) {
+    public abstract val type: JetType
+
+    public abstract fun <R, D> accept(visitor: AnnotationArgumentVisitor<R, D>, data: D): R
+
+    override fun toString() = value.toString()
+}
+
+public abstract class IntegerValueConstant<T> protected constructor(value: T) : ConstantValue<T>(value)
+
+public class AnnotationValue(value: AnnotationDescriptor) : ConstantValue<AnnotationDescriptor>(value) {
+
+    override val type: JetType
+        get() = value.getType()
+
+    override fun <R, D> accept(visitor: AnnotationArgumentVisitor<R, D>, data: D) = visitor.visitAnnotationValue(this, data)
+    override fun toString() = value.toString()
+}
+
+public class ArrayValue(
+        value: List<ConstantValue<*>>,
+        override val type: JetType,
+        private val builtIns: KotlinBuiltIns
+) : ConstantValue<List<ConstantValue<*>>>(value) {
+
+    init {
+        assert(KotlinBuiltIns.isArray(type) || KotlinBuiltIns.isPrimitiveArray(type)) { "Type should be an array, but was " + type + ": " + value }
+    }
+
+    override fun <R, D> accept(visitor: AnnotationArgumentVisitor<R, D>, data: D) = visitor.visitArrayValue(this, data)
+
+    public val elementType: JetType
+        get() = builtIns.getArrayElementType(type)
+
+    override fun equals(other: Any?): Boolean {
+        if (this === other) return true
+        if (javaClass != other?.javaClass) return false
+
+        return value == (other as ArrayValue).value
+    }
+
+    override fun hashCode() = value.hashCode()
+}
+
+public class BooleanValue(
+        value: Boolean,
+        builtIns: KotlinBuiltIns
+) : ConstantValue<Boolean>(value) {
+
+    override val type = builtIns.getBooleanType()
+    override fun <R, D> accept(visitor: AnnotationArgumentVisitor<R, D>, data: D) = visitor.visitBooleanValue(this, data)
+
+}
+
+public class ByteValue(
+        value: Byte,
+        builtIns: KotlinBuiltIns
+) : IntegerValueConstant<Byte>(value) {
+
+    override val type = builtIns.getByteType()
+
+    override fun <R, D> accept(visitor: AnnotationArgumentVisitor<R, D>, data: D) = visitor.visitByteValue(this, data)
+    override fun toString(): String = "$value.toByte()"
+}
+
+public class CharValue(
+        value: Char,
+        builtIns: KotlinBuiltIns
+) : IntegerValueConstant<Char>(value) {
+
+    override val type = builtIns.getCharType()
+
+    override fun <R, D> accept(visitor: AnnotationArgumentVisitor<R, D>, data: D) = visitor.visitCharValue(this, data)
+
+    override fun toString() = "\\u%04X ('%s')".format(value.toInt(), getPrintablePart(value))
+
+    private fun getPrintablePart(c: Char): String {
+        when (c) {
+            '\b' -> return "\\b"
+            '\t' -> return "\\t"
+            '\n' -> return "\\n"
+        //TODO: KT-8507
+            12.toChar() -> return "\\f"
+            '\r' -> return "\\r"
+            else -> return if (isPrintableUnicode(c)) Character.toString(c) else "?"
+        }
+    }
+
+    private fun isPrintableUnicode(c: Char): Boolean {
+        val t = Character.getType(c).toByte()
+        return t != Character.UNASSIGNED &&
+               t != Character.LINE_SEPARATOR &&
+               t != Character.PARAGRAPH_SEPARATOR &&
+               t != Character.CONTROL &&
+               t != Character.FORMAT &&
+               t != Character.PRIVATE_USE &&
+               t != Character.SURROGATE
+    }
+}
+
+public class DoubleValue(
+        value: Double,
+        builtIns: KotlinBuiltIns
+) : ConstantValue<Double>(value) {
+    override val type = builtIns.getDoubleType()
+
+    override fun <R, D> accept(visitor: AnnotationArgumentVisitor<R, D>, data: D) = visitor.visitDoubleValue(this, data)
+
+    override fun toString() = "$value.toDouble()"
+}
+
+public class EnumValue(
+        value: ClassDescriptor
+) : ConstantValue<ClassDescriptor>(value) {
+
+    override val type: JetType
+        get() = value.classObjectType.sure { "Enum entry must have a class object type: " + value }
+
+    override fun <R, D> accept(visitor: AnnotationArgumentVisitor<R, D>, data: D) = visitor.visitEnumValue(this, data)
+
+    override fun toString() = "$type.${value.getName()}"
+
+    override fun equals(other: Any?): Boolean {
+        if (this === other) return true
+        if (javaClass != other?.javaClass) return false
+
+        return value == (other as EnumValue).value
+    }
+
+    override fun hashCode() = value.hashCode()
+}
+
+public abstract class ErrorValue : ConstantValue<Unit>(Unit) {
+
+    deprecated("Should not be called, for this is not a real value, but a indication of an error")
+    override val value: Unit
+        get() = throw UnsupportedOperationException()
+
+    override fun <R, D> accept(visitor: AnnotationArgumentVisitor<R, D>, data: D) = visitor.visitErrorValue(this, data)
+
+    public class ErrorValueWithMessage(public val message: String) : ErrorValue() {
+
+        override val type = ErrorUtils.createErrorType(message)
+
+        override fun toString() = message
+    }
+
+    companion object {
+        public fun create(message: String): ErrorValue {
+            return ErrorValueWithMessage(message)
+        }
+    }
+}
+
+public class FloatValue(
+        value: Float,
+        builtIns: KotlinBuiltIns
+) : ConstantValue<Float>(value) {
+    override val type = builtIns.getFloatType()
+
+    override fun <R, D> accept(visitor: AnnotationArgumentVisitor<R, D>, data: D) = visitor.visitFloatValue(this, data)
+
+    override fun toString() = "$value.toFloat()"
+}
+
+public class IntValue(
+        value: Int,
+        builtIns: KotlinBuiltIns
+) : IntegerValueConstant<Int>(value) {
+
+    override val type = builtIns.getIntType()
+
+    override fun <R, D> accept(visitor: AnnotationArgumentVisitor<R, D>, data: D) = visitor.visitIntValue(this, data)
+
+    override fun equals(other: Any?): Boolean {
+        if (this === other) return true
+        if (javaClass != other?.javaClass) return false
+
+        val intValue = other as IntValue
+
+        return value == intValue.value
+    }
+
+    override fun hashCode() = value
+}
+
+public class KClassValue(override val type: JetType) :
+        ConstantValue<JetType>(type) {
+    override val value: JetType
+        get() = type.getArguments().single().getType()
+
+    override fun <R, D> accept(visitor: AnnotationArgumentVisitor<R, D>, data: D) = visitor.visitKClassValue(this, data)
+}
+
+public class LongValue(
+        value: Long,
+        builtIns: KotlinBuiltIns
+) : IntegerValueConstant<Long>(value) {
+
+    override val type = builtIns.getLongType()
+
+    override fun <R, D> accept(visitor: AnnotationArgumentVisitor<R, D>, data: D) = visitor.visitLongValue(this, data)
+
+    override fun toString() = "$value.toLong()"
+}
+
+public class NullValue(
+        builtIns: KotlinBuiltIns
+) : ConstantValue<Void?>(null) {
+
+    override val type = builtIns.getNullableNothingType()
+
+    override fun <R, D> accept(visitor: AnnotationArgumentVisitor<R, D>, data: D) = visitor.visitNullValue(this, data)
+
+    override fun toString() = "null"
+}
+
+public class ShortValue(
+        value: Short,
+        builtIns: KotlinBuiltIns
+) : IntegerValueConstant<Short>(value) {
+
+    override val type = builtIns.getShortType()
+
+    override fun <R, D> accept(visitor: AnnotationArgumentVisitor<R, D>, data: D) = visitor.visitShortValue(this, data)
+
+    override fun toString() = "$value.toShort()"
+}
+
+public class StringValue(
+        value: String,
+        builtIns: KotlinBuiltIns
+) : ConstantValue<String>(value) {
+    override val type = builtIns.getStringType()
+
+    override fun <R, D> accept(visitor: AnnotationArgumentVisitor<R, D>, data: D) = visitor.visitStringValue(this, data)
+
+    override fun toString() = "\"$value\""
+
+    override fun equals(other: Any?): Boolean {
+        if (this === other) return true
+        if (other == null || javaClass != other.javaClass) return false
+
+        return value != (other as StringValue).value
+    }
+
+    override fun hashCode() = value.hashCode()
+}
\ No newline at end of file
diff --git a/core/descriptors/src/org/jetbrains/kotlin/resolve/scopes/AbstractScopeAdapter.kt b/core/descriptors/src/org/jetbrains/kotlin/resolve/scopes/AbstractScopeAdapter.kt
index 549bb12dfe3..91712ae2867 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/resolve/scopes/AbstractScopeAdapter.kt
+++ b/core/descriptors/src/org/jetbrains/kotlin/resolve/scopes/AbstractScopeAdapter.kt
@@ -18,6 +18,7 @@ package org.jetbrains.kotlin.resolve.scopes
 
 import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.name.Name
+import org.jetbrains.kotlin.types.JetType
 import org.jetbrains.kotlin.utils.Printer
 
 /**
@@ -46,6 +47,14 @@ public abstract class AbstractScopeAdapter : JetScope {
         return workerScope.getProperties(name)
     }
 
+    override fun getSyntheticExtensionProperties(receiverTypes: Collection<JetType>, name: Name): Collection<PropertyDescriptor> {
+        return workerScope.getSyntheticExtensionProperties(receiverTypes, name)
+    }
+
+    override fun getSyntheticExtensionProperties(receiverTypes: Collection<JetType>): Collection<PropertyDescriptor> {
+        return workerScope.getSyntheticExtensionProperties(receiverTypes)
+    }
+
     override fun getLocalVariable(name: Name): VariableDescriptor? {
         return workerScope.getLocalVariable(name)
     }
diff --git a/core/descriptors/src/org/jetbrains/kotlin/resolve/scopes/ChainedScope.kt b/core/descriptors/src/org/jetbrains/kotlin/resolve/scopes/ChainedScope.kt
index 62b9938c8ca..276e6e68e57 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/resolve/scopes/ChainedScope.kt
+++ b/core/descriptors/src/org/jetbrains/kotlin/resolve/scopes/ChainedScope.kt
@@ -18,9 +18,11 @@ package org.jetbrains.kotlin.resolve.scopes
 
 import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.name.Name
-import org.jetbrains.kotlin.utils.Printer
+import org.jetbrains.kotlin.types.JetType
 import org.jetbrains.kotlin.util.collectionUtils.concat
-import java.util.*
+import org.jetbrains.kotlin.utils.Printer
+import java.util.ArrayList
+import java.util.LinkedHashSet
 
 public open class ChainedScope(
         private val containingDeclaration: DeclarationDescriptor?/* it's nullable as a hack for TypeUtils.intersect() */,
@@ -63,6 +65,12 @@ public open class ChainedScope(
     override fun getFunctions(name: Name): Collection<FunctionDescriptor>
             = getFromAllScopes { it.getFunctions(name) }
 
+    override fun getSyntheticExtensionProperties(receiverTypes: Collection<JetType>, name: Name): Collection<PropertyDescriptor>
+            = getFromAllScopes { it.getSyntheticExtensionProperties(receiverTypes, name) }
+
+    override fun getSyntheticExtensionProperties(receiverTypes: Collection<JetType>): Collection<PropertyDescriptor>
+            = getFromAllScopes { it.getSyntheticExtensionProperties(receiverTypes) }
+
     override fun getImplicitReceiversHierarchy(): List<ReceiverParameterDescriptor> {
         if (implicitReceiverHierarchy == null) {
             val result = ArrayList<ReceiverParameterDescriptor>()
@@ -77,12 +85,8 @@ public open class ChainedScope(
 
     override fun getDeclarationsByLabel(labelName: Name) = scopeChain.flatMap { it.getDeclarationsByLabel(labelName) }
 
-    override fun getDescriptors(kindFilter: DescriptorKindFilter,
-                                nameFilter: (Name) -> Boolean): Collection<DeclarationDescriptor> {
-        val result = LinkedHashSet<DeclarationDescriptor>()
-        scopeChain.flatMapTo(result) { it.getDescriptors(kindFilter, nameFilter) }
-        return result
-    }
+    override fun getDescriptors(kindFilter: DescriptorKindFilter, nameFilter: (Name) -> Boolean)
+            = getFromAllScopes { it.getDescriptors(kindFilter, nameFilter) }
 
     override fun getOwnDeclaredDescriptors(): Collection<DeclarationDescriptor> {
         throw UnsupportedOperationException()
diff --git a/core/descriptors/src/org/jetbrains/kotlin/resolve/scopes/ExplicitImportsScope.kt b/core/descriptors/src/org/jetbrains/kotlin/resolve/scopes/ExplicitImportsScope.kt
index a4338a758ca..55dadbd0179 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/resolve/scopes/ExplicitImportsScope.kt
+++ b/core/descriptors/src/org/jetbrains/kotlin/resolve/scopes/ExplicitImportsScope.kt
@@ -18,30 +18,23 @@ package org.jetbrains.kotlin.resolve.scopes
 
 import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.name.Name
+import org.jetbrains.kotlin.types.JetType
 import org.jetbrains.kotlin.utils.Printer
 import org.jetbrains.kotlin.utils.addToStdlib.firstIsInstanceOrNull
 
-public class ExplicitImportsScope(private val descriptors: Collection<DeclarationDescriptor>) : JetScope {
+public class ExplicitImportsScope(private val descriptors: Collection<DeclarationDescriptor>) : JetScopeImpl() {
     override fun getClassifier(name: Name) = descriptors.filter { it.getName() == name }.firstIsInstanceOrNull<ClassifierDescriptor>()
 
     override fun getPackage(name: Name)= descriptors.filter { it.getName() == name }.firstIsInstanceOrNull<PackageViewDescriptor>()
 
     override fun getProperties(name: Name) = descriptors.filter { it.getName() == name }.filterIsInstance<VariableDescriptor>()
 
-    override fun getLocalVariable(name: Name): VariableDescriptor? = null
-
     override fun getFunctions(name: Name) = descriptors.filter { it.getName() == name }.filterIsInstance<FunctionDescriptor>()
 
     override fun getContainingDeclaration() = throw UnsupportedOperationException()
 
-    override fun getDeclarationsByLabel(labelName: Name) = emptyList<DeclarationDescriptor>()
-
     override fun getDescriptors(kindFilter: DescriptorKindFilter, nameFilter: (Name) -> Boolean) = descriptors
 
-    override fun getImplicitReceiversHierarchy() = emptyList<ReceiverParameterDescriptor>()
-
-    override fun getOwnDeclaredDescriptors() = emptyList<DeclarationDescriptor>()
-
     override fun printScopeStructure(p: Printer) {
         p.println(javaClass.getName())
     }
diff --git a/core/descriptors/src/org/jetbrains/kotlin/resolve/scopes/FilteringScope.kt b/core/descriptors/src/org/jetbrains/kotlin/resolve/scopes/FilteringScope.kt
index bb245930cec..9bfe6e2b90f 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/resolve/scopes/FilteringScope.kt
+++ b/core/descriptors/src/org/jetbrains/kotlin/resolve/scopes/FilteringScope.kt
@@ -16,8 +16,10 @@
 
 package org.jetbrains.kotlin.resolve.scopes
 
-import org.jetbrains.kotlin.descriptors.*
+import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
+import org.jetbrains.kotlin.descriptors.PropertyDescriptor
 import org.jetbrains.kotlin.name.Name
+import org.jetbrains.kotlin.types.JetType
 import org.jetbrains.kotlin.utils.Printer
 
 public class FilteringScope(private val workerScope: JetScope, private val predicate: (DeclarationDescriptor) -> Boolean) : JetScope {
@@ -35,6 +37,10 @@ public class FilteringScope(private val workerScope: JetScope, private val predi
 
     override fun getProperties(name: Name) = workerScope.getProperties(name).filter(predicate)
 
+    override fun getSyntheticExtensionProperties(receiverTypes: Collection<JetType>, name: Name): Collection<PropertyDescriptor> = workerScope.getSyntheticExtensionProperties(receiverTypes, name).filter(predicate)
+
+    override fun getSyntheticExtensionProperties(receiverTypes: Collection<JetType>): Collection<PropertyDescriptor> = workerScope.getSyntheticExtensionProperties(receiverTypes).filter(predicate)
+
     override fun getLocalVariable(name: Name) = filterDescriptor(workerScope.getLocalVariable(name))
 
     override fun getDescriptors(kindFilter: DescriptorKindFilter,
diff --git a/core/descriptors/src/org/jetbrains/kotlin/resolve/scopes/JetScope.kt b/core/descriptors/src/org/jetbrains/kotlin/resolve/scopes/JetScope.kt
index 9fa86e94f1a..6735a8f95e0 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/resolve/scopes/JetScope.kt
+++ b/core/descriptors/src/org/jetbrains/kotlin/resolve/scopes/JetScope.kt
@@ -18,6 +18,7 @@ package org.jetbrains.kotlin.resolve.scopes
 
 import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.name.Name
+import org.jetbrains.kotlin.types.JetType
 import org.jetbrains.kotlin.utils.Printer
 import org.jetbrains.kotlin.utils.toReadOnlyList
 import java.lang.reflect.Modifier
@@ -34,6 +35,10 @@ public trait JetScope {
 
     public fun getFunctions(name: Name): Collection<FunctionDescriptor>
 
+    public fun getSyntheticExtensionProperties(receiverTypes: Collection<JetType>, name: Name): Collection<PropertyDescriptor>
+
+    public fun getSyntheticExtensionProperties(receiverTypes: Collection<JetType>): Collection<PropertyDescriptor>
+
     public fun getContainingDeclaration(): DeclarationDescriptor
 
     public fun getDeclarationsByLabel(labelName: Name): Collection<DeclarationDescriptor>
@@ -105,7 +110,7 @@ public class DescriptorKindFilter(
             = kindMask and kinds != 0
 
     public fun exclude(exclude: DescriptorKindExclude): DescriptorKindFilter
-            = DescriptorKindFilter(kindMask, excludes + listOf(exclude))
+            = DescriptorKindFilter(kindMask and exclude.fullyExcludedDescriptorKinds.inv(), excludes + listOf(exclude))
 
     public fun withoutKinds(kinds: Int): DescriptorKindFilter
             = DescriptorKindFilter(kindMask and kinds.inv(), excludes)
@@ -191,20 +196,29 @@ public class DescriptorKindFilter(
 public trait DescriptorKindExclude {
     public fun matches(descriptor: DeclarationDescriptor): Boolean
 
+    public val fullyExcludedDescriptorKinds: Int
+
     override fun toString() = this.javaClass.getSimpleName()
 
     public object Extensions : DescriptorKindExclude {
         override fun matches(descriptor: DeclarationDescriptor)
                 = descriptor is CallableDescriptor && descriptor.getExtensionReceiverParameter() != null
+
+        override val fullyExcludedDescriptorKinds: Int get() = 0
     }
 
     public object NonExtensions : DescriptorKindExclude {
         override fun matches(descriptor: DeclarationDescriptor)
                 = descriptor !is CallableDescriptor || descriptor.getExtensionReceiverParameter() == null
+
+        override val fullyExcludedDescriptorKinds: Int
+            get() = DescriptorKindFilter.ALL_KINDS_MASK and (DescriptorKindFilter.FUNCTIONS_MASK or DescriptorKindFilter.VARIABLES_MASK).inv()
     }
 
     public object EnumEntry : DescriptorKindExclude {
         override fun matches(descriptor: DeclarationDescriptor)
                 = descriptor is ClassDescriptor && descriptor.getKind() == ClassKind.ENUM_ENTRY
+
+        override val fullyExcludedDescriptorKinds: Int get() = 0
     }
 }
diff --git a/core/descriptors/src/org/jetbrains/kotlin/resolve/scopes/JetScopeImpl.kt b/core/descriptors/src/org/jetbrains/kotlin/resolve/scopes/JetScopeImpl.kt
index 7a16104950e..bb5905a005d 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/resolve/scopes/JetScopeImpl.kt
+++ b/core/descriptors/src/org/jetbrains/kotlin/resolve/scopes/JetScopeImpl.kt
@@ -18,6 +18,7 @@ package org.jetbrains.kotlin.resolve.scopes
 
 import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.name.Name
+import org.jetbrains.kotlin.types.JetType
 import org.jetbrains.kotlin.utils.Printer
 
 public abstract class JetScopeImpl : JetScope {
@@ -31,6 +32,10 @@ public abstract class JetScopeImpl : JetScope {
 
     override fun getFunctions(name: Name): Collection<FunctionDescriptor> = setOf()
 
+    override fun getSyntheticExtensionProperties(receiverTypes: Collection<JetType>, name: Name): Collection<PropertyDescriptor> = listOf()
+
+    override fun getSyntheticExtensionProperties(receiverTypes: Collection<JetType>): Collection<PropertyDescriptor> = listOf()
+
     override fun getDeclarationsByLabel(labelName: Name): Collection<DeclarationDescriptor> = listOf()
 
     override fun getDescriptors(kindFilter: DescriptorKindFilter,
diff --git a/core/descriptors/src/org/jetbrains/kotlin/resolve/scopes/StaticScopeForKotlinClass.kt b/core/descriptors/src/org/jetbrains/kotlin/resolve/scopes/StaticScopeForKotlinClass.kt
index e088eed4f45..cfe0ea28415 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/resolve/scopes/StaticScopeForKotlinClass.kt
+++ b/core/descriptors/src/org/jetbrains/kotlin/resolve/scopes/StaticScopeForKotlinClass.kt
@@ -16,16 +16,18 @@
 
 package org.jetbrains.kotlin.resolve.scopes
 
-import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.descriptors.*
+import org.jetbrains.kotlin.name.Name
+import org.jetbrains.kotlin.resolve.DescriptorFactory.createEnumValueOfMethod
+import org.jetbrains.kotlin.resolve.DescriptorFactory.createEnumValuesMethod
+import org.jetbrains.kotlin.types.JetType
 import org.jetbrains.kotlin.utils.Printer
 import java.util.ArrayList
 import kotlin.properties.Delegates
-import org.jetbrains.kotlin.resolve.DescriptorFactory.*
 
 public class StaticScopeForKotlinClass(
         private val containingClass: ClassDescriptor
-) : JetScope {
+) : JetScopeImpl() {
     override fun getClassifier(name: Name) = null // TODO
 
     private val functions: List<FunctionDescriptor> by Delegates.lazy {
@@ -44,12 +46,7 @@ public class StaticScopeForKotlinClass(
 
     override fun getFunctions(name: Name) = functions.filterTo(ArrayList<FunctionDescriptor>(2)) { it.getName() == name }
 
-    override fun getPackage(name: Name) = null
-    override fun getProperties(name: Name) = listOf<VariableDescriptor>()
-    override fun getLocalVariable(name: Name) = null
     override fun getContainingDeclaration() = containingClass
-    override fun getDeclarationsByLabel(labelName: Name) = listOf<DeclarationDescriptor>()
-    override fun getImplicitReceiversHierarchy() = listOf<ReceiverParameterDescriptor>()
 
     override fun printScopeStructure(p: Printer) {
         p.println("Static scope for $containingClass")
diff --git a/core/descriptors/src/org/jetbrains/kotlin/resolve/scopes/SubstitutingScope.kt b/core/descriptors/src/org/jetbrains/kotlin/resolve/scopes/SubstitutingScope.kt
index fe5f9b4836c..25d9e79d4bb 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/resolve/scopes/SubstitutingScope.kt
+++ b/core/descriptors/src/org/jetbrains/kotlin/resolve/scopes/SubstitutingScope.kt
@@ -16,11 +16,15 @@
 
 package org.jetbrains.kotlin.resolve.scopes
 
-import org.jetbrains.kotlin.descriptors.*
+import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
+import org.jetbrains.kotlin.descriptors.PropertyDescriptor
+import org.jetbrains.kotlin.descriptors.ReceiverParameterDescriptor
 import org.jetbrains.kotlin.name.Name
+import org.jetbrains.kotlin.types.JetType
 import org.jetbrains.kotlin.types.TypeSubstitutor
-import org.jetbrains.kotlin.utils.*
-import java.util.*
+import org.jetbrains.kotlin.utils.Printer
+import org.jetbrains.kotlin.utils.newHashSetWithExpectedSize
+import java.util.HashMap
 import kotlin.properties.Delegates
 
 public class SubstitutingScope(private val workerScope: JetScope, private val substitutor: TypeSubstitutor) : JetScope {
@@ -34,7 +38,7 @@ public class SubstitutingScope(private val workerScope: JetScope, private val su
         if (substitutor.isEmpty()) return descriptor
 
         if (substitutedDescriptors == null) {
-            substitutedDescriptors = HashMap<DeclarationDescriptor, DeclarationDescriptor>()
+            substitutedDescriptors = HashMap<DeclarationDescriptor, DeclarationDescriptor?>()
         }
 
         val substituted = substitutedDescriptors!!.getOrPut(descriptor, { descriptor.substitute(substitutor) })
@@ -66,6 +70,10 @@ public class SubstitutingScope(private val workerScope: JetScope, private val su
 
     override fun getFunctions(name: Name) = substitute(workerScope.getFunctions(name))
 
+    override fun getSyntheticExtensionProperties(receiverTypes: Collection<JetType>, name: Name): Collection<PropertyDescriptor> = substitute(workerScope.getSyntheticExtensionProperties(receiverTypes, name))
+
+    override fun getSyntheticExtensionProperties(receiverTypes: Collection<JetType>): Collection<PropertyDescriptor> = substitute(workerScope.getSyntheticExtensionProperties(receiverTypes))
+
     override fun getPackage(name: Name) = workerScope.getPackage(name)
 
     override fun getImplicitReceiversHierarchy(): List<ReceiverParameterDescriptor> {
diff --git a/core/descriptors/src/org/jetbrains/kotlin/types/DescriptorSubstitutor.java b/core/descriptors/src/org/jetbrains/kotlin/types/DescriptorSubstitutor.java
index 8e2f40e0d58..d8f90e6c230 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/types/DescriptorSubstitutor.java
+++ b/core/descriptors/src/org/jetbrains/kotlin/types/DescriptorSubstitutor.java
@@ -18,6 +18,7 @@ package org.jetbrains.kotlin.types;
 
 import org.jetbrains.annotations.Mutable;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.ReadOnly;
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor;
 import org.jetbrains.kotlin.descriptors.SourceElement;
 import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor;
@@ -33,7 +34,7 @@ public class DescriptorSubstitutor {
 
     @NotNull
     public static TypeSubstitutor substituteTypeParameters(
-            @NotNull List<TypeParameterDescriptor> typeParameters,
+            @ReadOnly @NotNull List<TypeParameterDescriptor> typeParameters,
             @NotNull final TypeSubstitutor originalSubstitutor,
             @NotNull DeclarationDescriptor newContainingDeclaration,
             @NotNull @Mutable List<TypeParameterDescriptor> result
diff --git a/core/descriptors/src/org/jetbrains/kotlin/types/ErrorUtils.java b/core/descriptors/src/org/jetbrains/kotlin/types/ErrorUtils.java
index b579ac9e289..86fc5e0d1f2 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/types/ErrorUtils.java
+++ b/core/descriptors/src/org/jetbrains/kotlin/types/ErrorUtils.java
@@ -88,6 +88,20 @@ public class ErrorUtils {
         @NotNull
         @Override
         public Set<VariableDescriptor> getProperties(@NotNull Name name) {
+            return ERROR_VARIABLE_GROUP;
+        }
+
+        @NotNull
+        @Override
+        public Collection<PropertyDescriptor> getSyntheticExtensionProperties(
+                @NotNull Collection<? extends JetType> receiverTypes, @NotNull Name name
+        ) {
+            return ERROR_PROPERTY_GROUP;
+        }
+
+        @NotNull
+        @Override
+        public Collection<PropertyDescriptor> getSyntheticExtensionProperties(@NotNull Collection<? extends JetType> receiverTypes) {
             return ERROR_PROPERTY_GROUP;
         }
 
@@ -193,6 +207,20 @@ public class ErrorUtils {
             throw new IllegalStateException();
         }
 
+        @NotNull
+        @Override
+        public Collection<PropertyDescriptor> getSyntheticExtensionProperties(
+                @NotNull Collection<? extends JetType> receiverTypes, @NotNull Name name
+        ) {
+            throw new IllegalStateException();
+        }
+
+        @NotNull
+        @Override
+        public Collection<PropertyDescriptor> getSyntheticExtensionProperties(@NotNull Collection<? extends JetType> receiverTypes) {
+            throw new IllegalStateException();
+        }
+
         @NotNull
         @Override
         public DeclarationDescriptor getContainingDeclaration() {
@@ -305,9 +333,10 @@ public class ErrorUtils {
     }
 
     private static final JetType ERROR_PROPERTY_TYPE = createErrorType("<ERROR PROPERTY TYPE>");
-    private static final VariableDescriptor ERROR_PROPERTY = createErrorProperty();
+    private static final PropertyDescriptor ERROR_PROPERTY = createErrorProperty();
 
-    private static final Set<VariableDescriptor> ERROR_PROPERTY_GROUP = Collections.singleton(ERROR_PROPERTY);
+    private static final Set<VariableDescriptor> ERROR_VARIABLE_GROUP = Collections.<VariableDescriptor>singleton(ERROR_PROPERTY);
+    private static final Set<PropertyDescriptor> ERROR_PROPERTY_GROUP = Collections.singleton(ERROR_PROPERTY);
 
     @NotNull
     private static PropertyDescriptorImpl createErrorProperty() {
diff --git a/core/descriptors/src/org/jetbrains/kotlin/types/TypeSubstitutor.java b/core/descriptors/src/org/jetbrains/kotlin/types/TypeSubstitutor.java
index dad4ac43afb..55bcc9e499a 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/types/TypeSubstitutor.java
+++ b/core/descriptors/src/org/jetbrains/kotlin/types/TypeSubstitutor.java
@@ -20,6 +20,7 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
 import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor;
+import org.jetbrains.kotlin.descriptors.annotations.CompositeAnnotations;
 import org.jetbrains.kotlin.resolve.calls.inference.InferencePackage;
 import org.jetbrains.kotlin.resolve.scopes.SubstitutingScope;
 import org.jetbrains.kotlin.types.typeUtil.TypeUtilPackage;
@@ -221,6 +222,14 @@ public class TypeSubstitutor {
                 substitutedType = TypeUtils.makeNullableIfNeeded(replacement.getType(), type.isMarkedNullable());
             }
 
+            // substitutionType.annotations = replacement.annotations ++ type.annotations
+            if (!type.getAnnotations().isEmpty()) {
+                substitutedType = TypeUtilPackage.replaceAnnotations(
+                        substitutedType,
+                        new CompositeAnnotations(substitutedType.getAnnotations(), type.getAnnotations())
+                );
+            }
+
             Variance resultingProjectionKind = varianceConflict == VarianceConflictType.NO_CONFLICT
                                                ? combine(originalProjectionKind, replacement.getProjectionKind())
                                                : originalProjectionKind;
diff --git a/core/descriptors/src/org/jetbrains/kotlin/types/TypeUtils.java b/core/descriptors/src/org/jetbrains/kotlin/types/TypeUtils.java
index 32cd7348529..9c03dd4c489 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/types/TypeUtils.java
+++ b/core/descriptors/src/org/jetbrains/kotlin/types/TypeUtils.java
@@ -37,6 +37,7 @@ import org.jetbrains.kotlin.utils.UtilsPackage;
 
 import java.util.*;
 
+import static org.jetbrains.kotlin.resolve.calls.inference.InferencePackage.registerTypeVariables;
 import static org.jetbrains.kotlin.resolve.calls.inference.constraintPosition.ConstraintPositionKind.SPECIAL;
 
 public class TypeUtils {
@@ -301,7 +302,7 @@ public class TypeUtils {
             processAllTypeParameters(withParameters, Variance.INVARIANT, processor);
             processAllTypeParameters(expected, Variance.INVARIANT, processor);
             ConstraintSystemImpl constraintSystem = new ConstraintSystemImpl();
-            constraintSystem.registerTypeVariables(parameters);
+            registerTypeVariables(constraintSystem, parameters);
             constraintSystem.addSubtypeConstraint(withParameters, expected, SPECIAL.position());
 
             return constraintSystem.getStatus().isSuccessful();
diff --git a/core/descriptors/src/org/jetbrains/kotlin/types/TypeUtils.kt b/core/descriptors/src/org/jetbrains/kotlin/types/TypeUtils.kt
index 558ed9d3912..64f76e5d310 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/types/TypeUtils.kt
+++ b/core/descriptors/src/org/jetbrains/kotlin/types/TypeUtils.kt
@@ -16,23 +16,41 @@
 
 package org.jetbrains.kotlin.types.typeUtil
 
-import java.util.LinkedHashSet
+import org.jetbrains.kotlin.builtins.KotlinBuiltIns
 import org.jetbrains.kotlin.descriptors.CallableDescriptor
 import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor
-import org.jetbrains.kotlin.types.JetType
-import org.jetbrains.kotlin.types.Flexibility
-import org.jetbrains.kotlin.types.TypeConstructor
-import org.jetbrains.kotlin.utils.toReadOnlyList
-import org.jetbrains.kotlin.types.checker.JetTypeChecker
-import org.jetbrains.kotlin.builtins.KotlinBuiltIns
-import org.jetbrains.kotlin.types.isDynamic
-import org.jetbrains.kotlin.types.TypeProjection
-import org.jetbrains.kotlin.types.TypeProjectionImpl
 import org.jetbrains.kotlin.descriptors.annotations.Annotations
 import org.jetbrains.kotlin.resolve.DescriptorUtils
-import org.jetbrains.kotlin.types.DelegatingType
+import org.jetbrains.kotlin.types.*
+import org.jetbrains.kotlin.types.checker.JetTypeChecker
+import org.jetbrains.kotlin.utils.toReadOnlyList
+import java.util.*
+
+public enum class TypeNullability {
+    NOT_NULL,
+    NULLABLE,
+    FLEXIBLE
+}
+
+public fun JetType.nullability(): TypeNullability {
+    return when {
+        isNullabilityFlexible() -> TypeNullability.FLEXIBLE
+        TypeUtils.isNullableType(this) -> TypeNullability.NULLABLE
+        else -> TypeNullability.NOT_NULL
+    }
+}
+
+fun JetType.makeNullable() = TypeUtils.makeNullable(this)
+fun JetType.makeNotNullable() = TypeUtils.makeNotNullable(this)
+
+fun JetType.supertypes(): Set<JetType> = TypeUtils.getAllSupertypes(this)
+
+fun JetType.isNothing(): Boolean = KotlinBuiltIns.isNothing(this)
+fun JetType.isUnit(): Boolean = KotlinBuiltIns.isUnit(this)
+fun JetType.isAnyOrNullableAny(): Boolean = KotlinBuiltIns.isAnyOrNullableAny(this)
+fun JetType.isBoolean(): Boolean = KotlinBuiltIns.isBoolean(this)
 
 private fun JetType.getContainedTypeParameters(): Collection<TypeParameterDescriptor> {
     val declarationDescriptor = getConstructor().getDeclarationDescriptor()
@@ -63,7 +81,8 @@ fun DeclarationDescriptor.getCapturedTypeParameters(): Collection<TypeParameterD
 
 public fun JetType.getContainedAndCapturedTypeParameterConstructors(): Collection<TypeConstructor> {
     // todo type arguments (instead of type parameters) of the type of outer class must be considered; KT-6325
-    val typeParameters = getContainedTypeParameters() + getConstructor().getDeclarationDescriptor().getCapturedTypeParameters()
+    val capturedTypeParameters = getConstructor().getDeclarationDescriptor()?.getCapturedTypeParameters() ?: emptyList()
+    val typeParameters = getContainedTypeParameters() + capturedTypeParameters
     return typeParameters.map { it.getTypeConstructor() }.toReadOnlyList()
 }
 
@@ -90,4 +109,21 @@ public fun JetTypeChecker.equalTypesOrNulls(type1: JetType?, type2: JetType?): B
     if (type1 identityEquals type2) return true
     if (type1 == null || type2 == null) return false
     return equalTypes(type1, type2)
+}
+
+fun JetType.getNestedArguments(): List<TypeProjection> {
+    val result = ArrayList<TypeProjection>()
+
+    val stack = ArrayDeque<TypeProjection>()
+    stack.push(TypeProjectionImpl(this))
+
+    while (!stack.isEmpty()) {
+        val typeProjection = stack.pop()
+        if (typeProjection.isStarProjection()) continue
+
+        result.add(typeProjection)
+
+        typeProjection.getType().getArguments().forEach { stack.add(it) }
+    }
+    return result
 }
\ No newline at end of file
diff --git a/core/descriptors/src/org/jetbrains/kotlin/types/checker/TypeCheckingProcedure.java b/core/descriptors/src/org/jetbrains/kotlin/types/checker/TypeCheckingProcedure.java
index f017d890f14..0844dc4548d 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/types/checker/TypeCheckingProcedure.java
+++ b/core/descriptors/src/org/jetbrains/kotlin/types/checker/TypeCheckingProcedure.java
@@ -40,17 +40,7 @@ public class TypeCheckingProcedure {
     // as the second parameter, applying the substitution of type arguments to it
     @Nullable
     public static JetType findCorrespondingSupertype(@NotNull JetType subtype, @NotNull JetType supertype, @NotNull TypeCheckingProcedureCallbacks typeCheckingProcedureCallbacks) {
-        TypeConstructor constructor = subtype.getConstructor();
-        if (typeCheckingProcedureCallbacks.assertEqualTypeConstructors(constructor, supertype.getConstructor())) {
-            return subtype;
-        }
-        for (JetType immediateSupertype : constructor.getSupertypes()) {
-            JetType correspondingSupertype = findCorrespondingSupertype(immediateSupertype, supertype, typeCheckingProcedureCallbacks);
-            if (correspondingSupertype != null) {
-                return TypeSubstitutor.create(subtype).safeSubstitute(correspondingSupertype, Variance.INVARIANT);
-            }
-        }
-        return null;
+        return CheckerPackage.findCorrespondingSupertype(subtype, supertype, typeCheckingProcedureCallbacks);
     }
 
     public static JetType getOutType(TypeParameterDescriptor parameter, TypeProjection argument) {
diff --git a/core/descriptors/src/org/jetbrains/kotlin/types/checker/utils.kt b/core/descriptors/src/org/jetbrains/kotlin/types/checker/utils.kt
new file mode 100644
index 00000000000..bcd0681b245
--- /dev/null
+++ b/core/descriptors/src/org/jetbrains/kotlin/types/checker/utils.kt
@@ -0,0 +1,59 @@
+/*
+ * Copyright 2010-2015 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.kotlin.types.checker
+
+import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.TypeSubstitutor
+import org.jetbrains.kotlin.types.Variance
+import org.jetbrains.kotlin.types.checker.TypeCheckingProcedureCallbacks
+import java.util.*
+
+private class SubtypePathNode(val type: JetType, val previous: SubtypePathNode?)
+
+public fun findCorrespondingSupertype(
+        subtype: JetType, supertype: JetType,
+        typeCheckingProcedureCallbacks: TypeCheckingProcedureCallbacks
+): JetType? {
+    val queue = ArrayDeque<SubtypePathNode>()
+    queue.add(SubtypePathNode(subtype, null))
+
+    val supertypeConstructor = supertype.getConstructor()
+
+    while (!queue.isEmpty()) {
+        val lastPathNode = queue.poll()
+        val currentSubtype = lastPathNode.type
+        val constructor = currentSubtype.getConstructor()
+
+        if (typeCheckingProcedureCallbacks.assertEqualTypeConstructors(constructor, supertypeConstructor)) {
+            var substituted = currentSubtype
+            var currentPathNode = lastPathNode.previous
+
+            while (currentPathNode != null) {
+                substituted = TypeSubstitutor.create(currentPathNode.type).safeSubstitute(substituted, Variance.INVARIANT)
+                currentPathNode = currentPathNode.previous
+            }
+
+            return substituted
+        }
+
+        for (immediateSupertype in constructor.getSupertypes()) {
+            queue.add(SubtypePathNode(immediateSupertype, lastPathNode))
+        }
+    }
+
+    return null
+}
diff --git a/core/descriptors/src/org/jetbrains/kotlin/types/flexibleTypes.kt b/core/descriptors/src/org/jetbrains/kotlin/types/flexibleTypes.kt
index 779346885a8..28834dd1aa8 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/types/flexibleTypes.kt
+++ b/core/descriptors/src/org/jetbrains/kotlin/types/flexibleTypes.kt
@@ -105,38 +105,6 @@ public trait NullAwareness : TypeCapability {
     public fun computeIsNullable(): Boolean
 }
 
-public trait Approximation : TypeCapability {
-    public class Info(val from: JetType, val to: JetType, val message: String)
-    public trait DataFlowExtras {
-        object EMPTY : DataFlowExtras {
-            override val canBeNull: Boolean get() = true
-            override val possibleTypes: Set<JetType> get() = setOf()
-            override val presentableText: String = "<unknown>"
-        }
-
-        class OnlyMessage(message: String) : DataFlowExtras {
-            override val canBeNull: Boolean get() = true
-            override val possibleTypes: Set<JetType> get() = setOf()
-            override val presentableText: String = message
-        }
-
-        val canBeNull: Boolean
-        val possibleTypes: Set<JetType>
-        val presentableText: String
-    }
-
-    public fun approximateToExpectedType(expectedType: JetType, dataFlowExtras: DataFlowExtras): Info?
-}
-
-fun Approximation.Info.assertNotNull(): Boolean {
-    return from.upperIfFlexible().isMarkedNullable() && !TypeUtils.isNullableType(to)
-}
-
-public fun JetType.getApproximationTo(
-        expectedType: JetType,
-        extras: Approximation.DataFlowExtras = Approximation.DataFlowExtras.EMPTY
-): Approximation.Info? = this.getCapability(javaClass<Approximation>())?.approximateToExpectedType(expectedType, extras)
-
 trait FlexibleTypeDelegation : TypeCapability {
     public val delegateType: JetType
 }
@@ -145,14 +113,13 @@ public open class DelegatingFlexibleType protected constructor(
         override val lowerBound: JetType,
         override val upperBound: JetType,
         override val extraCapabilities: FlexibleTypeCapabilities
-) : DelegatingType(), NullAwareness, Flexibility, FlexibleTypeDelegation, Approximation {
+) : DelegatingType(), NullAwareness, Flexibility, FlexibleTypeDelegation {
     companion object {
         internal val capabilityClasses = hashSetOf(
                 javaClass<NullAwareness>(),
                 javaClass<Flexibility>(),
                 javaClass<SubtypingRepresentatives>(),
-                javaClass<FlexibleTypeDelegation>(),
-                javaClass<Approximation>()
+                javaClass<FlexibleTypeDelegation>()
         )
 
         platformStatic fun create(lowerBound: JetType, upperBound: JetType, extraCapabilities: FlexibleTypeCapabilities): JetType {
@@ -193,20 +160,6 @@ public open class DelegatingFlexibleType protected constructor(
 
     override fun isMarkedNullable(): Boolean = getCapability(javaClass<NullAwareness>())!!.computeIsNullable()
 
-    override fun approximateToExpectedType(expectedType: JetType, dataFlowExtras: Approximation.DataFlowExtras): Approximation.Info? {
-        // val foo: Any? = foo() : Foo!
-        if (JetTypeChecker.DEFAULT.isSubtypeOf(upperBound, expectedType)) return null
-
-        // if (foo : Foo! != null) {
-        //     val bar: Any = foo
-        // }
-        if (!dataFlowExtras.canBeNull && JetTypeChecker.DEFAULT.isSubtypeOf(TypeUtils.makeNotNullable(upperBound), expectedType)) return null
-
-        // TODO: maybe check possibleTypes to avoid extra approximations
-
-        return Approximation.Info(this, expectedType, dataFlowExtras.presentableText)
-    }
-
     override val delegateType: JetType = lowerBound
 
     override fun getDelegate() = getCapability(javaClass<FlexibleTypeDelegation>())!!.delegateType
diff --git a/core/deserialization/src/descriptors.proto b/core/deserialization/src/descriptors.proto
index 65056d72d46..531b62e9a18 100644
--- a/core/deserialization/src/descriptors.proto
+++ b/core/deserialization/src/descriptors.proto
@@ -189,11 +189,11 @@ message Class {
 
   // we store only names, because the actual information must reside in the corresponding .class files,
   // to be obtainable through reflection at runtime
-  repeated int32 nested_class_name = 7;
+  repeated int32 nested_class_name = 7 [packed = true];
 
   repeated Callable member = 11;
 
-  repeated int32 enum_entry = 12;
+  repeated int32 enum_entry = 12 [packed = true];
 
   message PrimaryConstructor {
     // If this field is present, it contains serialized data for the primary constructor.
diff --git a/core/deserialization/src/org/jetbrains/kotlin/serialization/ProtoBuf.java b/core/deserialization/src/org/jetbrains/kotlin/serialization/ProtoBuf.java
index 8caaf42eb3d..d5cae9f51fd 100644
--- a/core/deserialization/src/org/jetbrains/kotlin/serialization/ProtoBuf.java
+++ b/core/deserialization/src/org/jetbrains/kotlin/serialization/ProtoBuf.java
@@ -7417,9 +7417,9 @@ public final class ProtoBuf {
      */
     int getSupertypeCount();
 
-    // repeated int32 nested_class_name = 7;
+    // repeated int32 nested_class_name = 7 [packed = true];
     /**
-     * <code>repeated int32 nested_class_name = 7;</code>
+     * <code>repeated int32 nested_class_name = 7 [packed = true];</code>
      *
      * <pre>
      * we store only names, because the actual information must reside in the corresponding .class files,
@@ -7428,7 +7428,7 @@ public final class ProtoBuf {
      */
     java.util.List<java.lang.Integer> getNestedClassNameList();
     /**
-     * <code>repeated int32 nested_class_name = 7;</code>
+     * <code>repeated int32 nested_class_name = 7 [packed = true];</code>
      *
      * <pre>
      * we store only names, because the actual information must reside in the corresponding .class files,
@@ -7437,7 +7437,7 @@ public final class ProtoBuf {
      */
     int getNestedClassNameCount();
     /**
-     * <code>repeated int32 nested_class_name = 7;</code>
+     * <code>repeated int32 nested_class_name = 7 [packed = true];</code>
      *
      * <pre>
      * we store only names, because the actual information must reside in the corresponding .class files,
@@ -7461,17 +7461,17 @@ public final class ProtoBuf {
      */
     int getMemberCount();
 
-    // repeated int32 enum_entry = 12;
+    // repeated int32 enum_entry = 12 [packed = true];
     /**
-     * <code>repeated int32 enum_entry = 12;</code>
+     * <code>repeated int32 enum_entry = 12 [packed = true];</code>
      */
     java.util.List<java.lang.Integer> getEnumEntryList();
     /**
-     * <code>repeated int32 enum_entry = 12;</code>
+     * <code>repeated int32 enum_entry = 12 [packed = true];</code>
      */
     int getEnumEntryCount();
     /**
-     * <code>repeated int32 enum_entry = 12;</code>
+     * <code>repeated int32 enum_entry = 12 [packed = true];</code>
      */
     int getEnumEntry(int index);
 
@@ -8394,11 +8394,11 @@ public final class ProtoBuf {
       return supertype_.get(index);
     }
 
-    // repeated int32 nested_class_name = 7;
+    // repeated int32 nested_class_name = 7 [packed = true];
     public static final int NESTED_CLASS_NAME_FIELD_NUMBER = 7;
     private java.util.List<java.lang.Integer> nestedClassName_;
     /**
-     * <code>repeated int32 nested_class_name = 7;</code>
+     * <code>repeated int32 nested_class_name = 7 [packed = true];</code>
      *
      * <pre>
      * we store only names, because the actual information must reside in the corresponding .class files,
@@ -8410,7 +8410,7 @@ public final class ProtoBuf {
       return nestedClassName_;
     }
     /**
-     * <code>repeated int32 nested_class_name = 7;</code>
+     * <code>repeated int32 nested_class_name = 7 [packed = true];</code>
      *
      * <pre>
      * we store only names, because the actual information must reside in the corresponding .class files,
@@ -8421,7 +8421,7 @@ public final class ProtoBuf {
       return nestedClassName_.size();
     }
     /**
-     * <code>repeated int32 nested_class_name = 7;</code>
+     * <code>repeated int32 nested_class_name = 7 [packed = true];</code>
      *
      * <pre>
      * we store only names, because the actual information must reside in the corresponding .class files,
@@ -8431,6 +8431,7 @@ public final class ProtoBuf {
     public int getNestedClassName(int index) {
       return nestedClassName_.get(index);
     }
+    private int nestedClassNameMemoizedSerializedSize = -1;
 
     // repeated .org.jetbrains.kotlin.serialization.Callable member = 11;
     public static final int MEMBER_FIELD_NUMBER = 11;
@@ -8468,28 +8469,29 @@ public final class ProtoBuf {
       return member_.get(index);
     }
 
-    // repeated int32 enum_entry = 12;
+    // repeated int32 enum_entry = 12 [packed = true];
     public static final int ENUM_ENTRY_FIELD_NUMBER = 12;
     private java.util.List<java.lang.Integer> enumEntry_;
     /**
-     * <code>repeated int32 enum_entry = 12;</code>
+     * <code>repeated int32 enum_entry = 12 [packed = true];</code>
      */
     public java.util.List<java.lang.Integer>
         getEnumEntryList() {
       return enumEntry_;
     }
     /**
-     * <code>repeated int32 enum_entry = 12;</code>
+     * <code>repeated int32 enum_entry = 12 [packed = true];</code>
      */
     public int getEnumEntryCount() {
       return enumEntry_.size();
     }
     /**
-     * <code>repeated int32 enum_entry = 12;</code>
+     * <code>repeated int32 enum_entry = 12 [packed = true];</code>
      */
     public int getEnumEntry(int index) {
       return enumEntry_.get(index);
     }
+    private int enumEntryMemoizedSerializedSize = -1;
 
     // optional .org.jetbrains.kotlin.serialization.Class.PrimaryConstructor primary_constructor = 13;
     public static final int PRIMARY_CONSTRUCTOR_FIELD_NUMBER = 13;
@@ -8631,14 +8633,22 @@ public final class ProtoBuf {
       for (int i = 0; i < supertype_.size(); i++) {
         output.writeMessage(6, supertype_.get(i));
       }
+      if (getNestedClassNameList().size() > 0) {
+        output.writeRawVarint32(58);
+        output.writeRawVarint32(nestedClassNameMemoizedSerializedSize);
+      }
       for (int i = 0; i < nestedClassName_.size(); i++) {
-        output.writeInt32(7, nestedClassName_.get(i));
+        output.writeInt32NoTag(nestedClassName_.get(i));
       }
       for (int i = 0; i < member_.size(); i++) {
         output.writeMessage(11, member_.get(i));
       }
+      if (getEnumEntryList().size() > 0) {
+        output.writeRawVarint32(98);
+        output.writeRawVarint32(enumEntryMemoizedSerializedSize);
+      }
       for (int i = 0; i < enumEntry_.size(); i++) {
-        output.writeInt32(12, enumEntry_.get(i));
+        output.writeInt32NoTag(enumEntry_.get(i));
       }
       if (((bitField0_ & 0x00000008) == 0x00000008)) {
         output.writeMessage(13, primaryConstructor_);
@@ -8682,7 +8692,12 @@ public final class ProtoBuf {
             .computeInt32SizeNoTag(nestedClassName_.get(i));
         }
         size += dataSize;
-        size += 1 * getNestedClassNameList().size();
+        if (!getNestedClassNameList().isEmpty()) {
+          size += 1;
+          size += com.google.protobuf.CodedOutputStream
+              .computeInt32SizeNoTag(dataSize);
+        }
+        nestedClassNameMemoizedSerializedSize = dataSize;
       }
       for (int i = 0; i < member_.size(); i++) {
         size += com.google.protobuf.CodedOutputStream
@@ -8695,7 +8710,12 @@ public final class ProtoBuf {
             .computeInt32SizeNoTag(enumEntry_.get(i));
         }
         size += dataSize;
-        size += 1 * getEnumEntryList().size();
+        if (!getEnumEntryList().isEmpty()) {
+          size += 1;
+          size += com.google.protobuf.CodedOutputStream
+              .computeInt32SizeNoTag(dataSize);
+        }
+        enumEntryMemoizedSerializedSize = dataSize;
       }
       if (((bitField0_ & 0x00000008) == 0x00000008)) {
         size += com.google.protobuf.CodedOutputStream
@@ -9429,7 +9449,7 @@ public final class ProtoBuf {
         return this;
       }
 
-      // repeated int32 nested_class_name = 7;
+      // repeated int32 nested_class_name = 7 [packed = true];
       private java.util.List<java.lang.Integer> nestedClassName_ = java.util.Collections.emptyList();
       private void ensureNestedClassNameIsMutable() {
         if (!((bitField0_ & 0x00000020) == 0x00000020)) {
@@ -9438,7 +9458,7 @@ public final class ProtoBuf {
          }
       }
       /**
-       * <code>repeated int32 nested_class_name = 7;</code>
+       * <code>repeated int32 nested_class_name = 7 [packed = true];</code>
        *
        * <pre>
        * we store only names, because the actual information must reside in the corresponding .class files,
@@ -9450,7 +9470,7 @@ public final class ProtoBuf {
         return java.util.Collections.unmodifiableList(nestedClassName_);
       }
       /**
-       * <code>repeated int32 nested_class_name = 7;</code>
+       * <code>repeated int32 nested_class_name = 7 [packed = true];</code>
        *
        * <pre>
        * we store only names, because the actual information must reside in the corresponding .class files,
@@ -9461,7 +9481,7 @@ public final class ProtoBuf {
         return nestedClassName_.size();
       }
       /**
-       * <code>repeated int32 nested_class_name = 7;</code>
+       * <code>repeated int32 nested_class_name = 7 [packed = true];</code>
        *
        * <pre>
        * we store only names, because the actual information must reside in the corresponding .class files,
@@ -9472,7 +9492,7 @@ public final class ProtoBuf {
         return nestedClassName_.get(index);
       }
       /**
-       * <code>repeated int32 nested_class_name = 7;</code>
+       * <code>repeated int32 nested_class_name = 7 [packed = true];</code>
        *
        * <pre>
        * we store only names, because the actual information must reside in the corresponding .class files,
@@ -9487,7 +9507,7 @@ public final class ProtoBuf {
         return this;
       }
       /**
-       * <code>repeated int32 nested_class_name = 7;</code>
+       * <code>repeated int32 nested_class_name = 7 [packed = true];</code>
        *
        * <pre>
        * we store only names, because the actual information must reside in the corresponding .class files,
@@ -9501,7 +9521,7 @@ public final class ProtoBuf {
         return this;
       }
       /**
-       * <code>repeated int32 nested_class_name = 7;</code>
+       * <code>repeated int32 nested_class_name = 7 [packed = true];</code>
        *
        * <pre>
        * we store only names, because the actual information must reside in the corresponding .class files,
@@ -9516,7 +9536,7 @@ public final class ProtoBuf {
         return this;
       }
       /**
-       * <code>repeated int32 nested_class_name = 7;</code>
+       * <code>repeated int32 nested_class_name = 7 [packed = true];</code>
        *
        * <pre>
        * we store only names, because the actual information must reside in the corresponding .class files,
@@ -9655,7 +9675,7 @@ public final class ProtoBuf {
         return this;
       }
 
-      // repeated int32 enum_entry = 12;
+      // repeated int32 enum_entry = 12 [packed = true];
       private java.util.List<java.lang.Integer> enumEntry_ = java.util.Collections.emptyList();
       private void ensureEnumEntryIsMutable() {
         if (!((bitField0_ & 0x00000080) == 0x00000080)) {
@@ -9664,26 +9684,26 @@ public final class ProtoBuf {
          }
       }
       /**
-       * <code>repeated int32 enum_entry = 12;</code>
+       * <code>repeated int32 enum_entry = 12 [packed = true];</code>
        */
       public java.util.List<java.lang.Integer>
           getEnumEntryList() {
         return java.util.Collections.unmodifiableList(enumEntry_);
       }
       /**
-       * <code>repeated int32 enum_entry = 12;</code>
+       * <code>repeated int32 enum_entry = 12 [packed = true];</code>
        */
       public int getEnumEntryCount() {
         return enumEntry_.size();
       }
       /**
-       * <code>repeated int32 enum_entry = 12;</code>
+       * <code>repeated int32 enum_entry = 12 [packed = true];</code>
        */
       public int getEnumEntry(int index) {
         return enumEntry_.get(index);
       }
       /**
-       * <code>repeated int32 enum_entry = 12;</code>
+       * <code>repeated int32 enum_entry = 12 [packed = true];</code>
        */
       public Builder setEnumEntry(
           int index, int value) {
@@ -9693,7 +9713,7 @@ public final class ProtoBuf {
         return this;
       }
       /**
-       * <code>repeated int32 enum_entry = 12;</code>
+       * <code>repeated int32 enum_entry = 12 [packed = true];</code>
        */
       public Builder addEnumEntry(int value) {
         ensureEnumEntryIsMutable();
@@ -9702,7 +9722,7 @@ public final class ProtoBuf {
         return this;
       }
       /**
-       * <code>repeated int32 enum_entry = 12;</code>
+       * <code>repeated int32 enum_entry = 12 [packed = true];</code>
        */
       public Builder addAllEnumEntry(
           java.lang.Iterable<? extends java.lang.Integer> values) {
@@ -9712,7 +9732,7 @@ public final class ProtoBuf {
         return this;
       }
       /**
-       * <code>repeated int32 enum_entry = 12;</code>
+       * <code>repeated int32 enum_entry = 12 [packed = true];</code>
        */
       public Builder clearEnumEntry() {
         enumEntry_ = java.util.Collections.emptyList();
diff --git a/core/deserialization/src/org/jetbrains/kotlin/serialization/SerializedResourcePaths.kt b/core/deserialization/src/org/jetbrains/kotlin/serialization/SerializedResourcePaths.kt
index af3851d61ba..63c4f0d3c4c 100644
--- a/core/deserialization/src/org/jetbrains/kotlin/serialization/SerializedResourcePaths.kt
+++ b/core/deserialization/src/org/jetbrains/kotlin/serialization/SerializedResourcePaths.kt
@@ -21,7 +21,7 @@ import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.FqName
 
 public abstract class SerializedResourcePaths {
-    public abstract val EXTENSION_REGISTRY: ExtensionRegistryLite
+    public abstract val extensionRegistry: ExtensionRegistryLite
 
     public abstract fun getClassMetadataPath(classId: ClassId): String
 
@@ -39,5 +39,4 @@ public abstract class SerializedResourcePaths {
     }
 
     public val fallbackPaths: FallbackPaths = FallbackPaths
-
-}
\ No newline at end of file
+}
diff --git a/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/AnnotationDeserializer.kt b/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/AnnotationDeserializer.kt
index d4930a87147..475a9e34f8b 100644
--- a/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/AnnotationDeserializer.kt
+++ b/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/AnnotationDeserializer.kt
@@ -16,22 +16,24 @@
 
 package org.jetbrains.kotlin.serialization.deserialization
 
-import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptor
+import org.jetbrains.kotlin.builtins.KotlinBuiltIns
+import org.jetbrains.kotlin.descriptors.ClassDescriptor
+import org.jetbrains.kotlin.descriptors.ClassKind
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor
-import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptorImpl
 import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor
+import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptor
+import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptorImpl
+import org.jetbrains.kotlin.name.ClassId
+import org.jetbrains.kotlin.name.Name
+import org.jetbrains.kotlin.resolve.constants.AnnotationValue
+import org.jetbrains.kotlin.resolve.constants.ConstantValue
+import org.jetbrains.kotlin.resolve.constants.ConstantValueFactory
 import org.jetbrains.kotlin.serialization.ProtoBuf.Annotation
 import org.jetbrains.kotlin.serialization.ProtoBuf.Annotation.Argument
 import org.jetbrains.kotlin.serialization.ProtoBuf.Annotation.Argument.Value
 import org.jetbrains.kotlin.serialization.ProtoBuf.Annotation.Argument.Value.Type
-import org.jetbrains.kotlin.builtins.KotlinBuiltIns
-import org.jetbrains.kotlin.name.Name
-import org.jetbrains.kotlin.resolve.constants.*
-import org.jetbrains.kotlin.types.JetType
-import org.jetbrains.kotlin.descriptors.ClassDescriptor
-import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.types.ErrorUtils
-import org.jetbrains.kotlin.descriptors.ClassKind
+import org.jetbrains.kotlin.types.JetType
 import org.jetbrains.kotlin.types.Variance
 import org.jetbrains.kotlin.types.typeUtil.isSubtypeOf
 
@@ -39,6 +41,8 @@ public class AnnotationDeserializer(private val module: ModuleDescriptor) {
     private val builtIns: KotlinBuiltIns
         get() = module.builtIns
 
+    private val factory = ConstantValueFactory(builtIns)
+
     public fun deserializeAnnotation(proto: Annotation, nameResolver: NameResolver): AnnotationDescriptor {
         val annotationClass = resolveClass(nameResolver.getClassId(proto.getId()))
 
@@ -58,7 +62,7 @@ public class AnnotationDeserializer(private val module: ModuleDescriptor) {
             proto: Argument,
             parameterByName: Map<Name, ValueParameterDescriptor>,
             nameResolver: NameResolver
-    ): Pair<ValueParameterDescriptor, CompileTimeConstant<*>>? {
+    ): Pair<ValueParameterDescriptor, ConstantValue<*>>? {
         val parameter = parameterByName[nameResolver.getName(proto.getNameId())] ?: return null
         return Pair(parameter, resolveValue(parameter.getType(), proto.getValue(), nameResolver))
     }
@@ -67,18 +71,18 @@ public class AnnotationDeserializer(private val module: ModuleDescriptor) {
             expectedType: JetType,
             value: Value,
             nameResolver: NameResolver
-    ): CompileTimeConstant<*> {
-        val result = when (value.getType()) {
-            Type.BYTE -> ByteValue(value.getIntValue().toByte(), true, true, true)
-            Type.CHAR -> CharValue(value.getIntValue().toChar(), true, true, true)
-            Type.SHORT -> ShortValue(value.getIntValue().toShort(), true, true, true)
-            Type.INT -> IntValue(value.getIntValue().toInt(), true, true, true)
-            Type.LONG -> LongValue(value.getIntValue(), true, true, true)
-            Type.FLOAT -> FloatValue(value.getFloatValue(), true, true)
-            Type.DOUBLE -> DoubleValue(value.getDoubleValue(), true, true)
-            Type.BOOLEAN -> BooleanValue(value.getIntValue() != 0L, true, true)
+    ): ConstantValue<*> {
+        val result: ConstantValue<*> = when (value.getType()) {
+            Type.BYTE -> factory.createByteValue(value.getIntValue().toByte())
+            Type.CHAR -> factory.createCharValue(value.getIntValue().toChar())
+            Type.SHORT -> factory.createShortValue(value.getIntValue().toShort())
+            Type.INT -> factory.createIntValue(value.getIntValue().toInt())
+            Type.LONG -> factory.createLongValue(value.getIntValue())
+            Type.FLOAT -> factory.createFloatValue(value.getFloatValue())
+            Type.DOUBLE -> factory.createDoubleValue(value.getDoubleValue())
+            Type.BOOLEAN -> factory.createBooleanValue(value.getIntValue() != 0L)
             Type.STRING -> {
-                StringValue(nameResolver.getString(value.getStringValue()), true, true)
+                factory.createStringValue(nameResolver.getString(value.getStringValue()))
             }
             Type.CLASS -> {
                 // TODO: support class literals
@@ -109,34 +113,35 @@ public class AnnotationDeserializer(private val module: ModuleDescriptor) {
 
                 val expectedElementType = builtIns.getArrayElementType(if (expectedIsArray) expectedType else actualArrayType)
 
-                ArrayValue(
-                        arrayElements.map { resolveValue(expectedElementType, it, nameResolver) },
-                        actualArrayType,
-                        true, true
+                factory.createArrayValue(
+                        arrayElements.map {
+                            resolveValue(expectedElementType, it, nameResolver)
+                        },
+                        actualArrayType
                 )
             }
             else -> error("Unsupported annotation argument type: ${value.getType()} (expected $expectedType)")
         }
 
-        if (result.getType(builtIns) isSubtypeOf expectedType) {
+        if (result.type isSubtypeOf expectedType) {
             return result
         }
         else {
             // This means that an annotation class has been changed incompatibly without recompiling clients
-            return ErrorValue.create("Unexpected argument value")
+            return factory.createErrorValue("Unexpected argument value")
         }
     }
 
     // NOTE: see analogous code in BinaryClassAnnotationAndConstantLoaderImpl
-    private fun resolveEnumValue(enumClassId: ClassId, enumEntryName: Name): CompileTimeConstant<*> {
+    private fun resolveEnumValue(enumClassId: ClassId, enumEntryName: Name): ConstantValue<*> {
         val enumClass = resolveClass(enumClassId)
         if (enumClass.getKind() == ClassKind.ENUM_CLASS) {
             val enumEntry = enumClass.getUnsubstitutedInnerClassesScope().getClassifier(enumEntryName)
             if (enumEntry is ClassDescriptor) {
-                return EnumValue(enumEntry, true)
+                return factory.createEnumValue(enumEntry)
             }
         }
-        return ErrorValue.create("Unresolved enum entry: $enumClassId.$enumEntryName")
+        return factory.createErrorValue("Unresolved enum entry: $enumClassId.$enumEntryName")
     }
 
     private fun resolveArrayElementType(value: Value, nameResolver: NameResolver): JetType =
diff --git a/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/ClassDeserializer.kt b/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/ClassDeserializer.kt
index f26af6d8b5b..22e680678a8 100644
--- a/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/ClassDeserializer.kt
+++ b/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/ClassDeserializer.kt
@@ -35,12 +35,24 @@ public class ClassDeserializer(private val components: DeserializationComponents
 
         val classData = key.classData ?: components.classDataFinder.findClassData(classId) ?: return null
         val outerContext = if (classId.isNestedClass()) {
-            (deserializeClass(classId.getOuterClassId()) as? DeserializedClassDescriptor)?.c ?: return null
+            val outerClass = deserializeClass(classId.getOuterClassId()) as? DeserializedClassDescriptor ?: return null
+
+            // Find the outer class first and check if he knows anything about the nested class we're looking for
+            if (!outerClass.hasNestedClass(classId.getShortClassName())) return null
+
+            outerClass.c
         }
         else {
             val fragments = components.packageFragmentProvider.getPackageFragments(classId.getPackageFqName())
             assert(fragments.size() == 1) { "There should be exactly one package: $fragments, class id is $classId" }
-            components.createContext(fragments.single(), classData.getNameResolver())
+
+            val fragment = fragments.single()
+            if (fragment is DeserializedPackageFragment) {
+                // Similarly, verify that the containing package has information about this class
+                if (!fragment.hasTopLevelClass(classId.getShortClassName())) return null
+            }
+
+            components.createContext(fragment, classData.getNameResolver())
         }
 
         return DeserializedClassDescriptor(outerContext, classData.getClassProto(), classData.getNameResolver())
diff --git a/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/DeserializedPackageFragment.kt b/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/DeserializedPackageFragment.kt
index 2dc100d084d..52f955cfcf6 100644
--- a/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/DeserializedPackageFragment.kt
+++ b/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/DeserializedPackageFragment.kt
@@ -20,12 +20,11 @@ import org.jetbrains.kotlin.descriptors.ModuleDescriptor
 import org.jetbrains.kotlin.descriptors.impl.PackageFragmentDescriptorImpl
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
-import org.jetbrains.kotlin.resolve.scopes.JetScope
 import org.jetbrains.kotlin.serialization.ProtoBuf
 import org.jetbrains.kotlin.serialization.SerializedResourcePaths
 import org.jetbrains.kotlin.serialization.deserialization.descriptors.DeserializedPackageMemberScope
-import org.jetbrains.kotlin.storage.NotNullLazyValue
 import org.jetbrains.kotlin.storage.StorageManager
+import org.jetbrains.kotlin.storage.get
 import java.io.InputStream
 import javax.inject.Inject
 import kotlin.properties.Delegates
@@ -45,21 +44,26 @@ public abstract class DeserializedPackageFragment(
 
     protected var components: DeserializationComponents by Delegates.notNull()
 
+    // component dependency cycle
     Inject
     public fun setDeserializationComponents(components: DeserializationComponents) {
         this.components = components
     }
 
-    private val memberScopeLazyValue: NotNullLazyValue<JetScope> = storageManager.createLazyValue {
+    internal val deserializedMemberScope by storageManager.createLazyValue {
         val packageStream = loadResourceSure(serializedResourcePaths.getPackageFilePath(fqName))
-        val packageProto = ProtoBuf.Package.parseFrom(packageStream, serializedResourcePaths.EXTENSION_REGISTRY)
-        DeserializedPackageMemberScope(this, packageProto, nameResolver, components, classNames = { loadClassNames(fqName, packageProto) })
+        val packageProto = ProtoBuf.Package.parseFrom(packageStream, serializedResourcePaths.extensionRegistry)
+        DeserializedPackageMemberScope(this, packageProto, nameResolver, components, classNames = { loadClassNames(packageProto) })
     }
 
-    override fun getMemberScope() = memberScopeLazyValue()
+    override fun getMemberScope() = deserializedMemberScope
 
-    protected abstract fun loadClassNames(fqName: FqName, packageProto: ProtoBuf.Package): Collection<Name>
+    internal fun hasTopLevelClass(name: Name): Boolean {
+        return name in getMemberScope().classNames
+    }
+
+    protected abstract fun loadClassNames(packageProto: ProtoBuf.Package): Collection<Name>
 
     protected fun loadResourceSure(path: String): InputStream =
             loadResource(path) ?: throw IllegalStateException("Resource not found in classpath: $path")
-}
\ No newline at end of file
+}
diff --git a/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/LocalClassResolverImpl.kt b/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/LocalClassResolverImpl.kt
index bb6d55f5200..33b8f54d1ef 100644
--- a/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/LocalClassResolverImpl.kt
+++ b/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/LocalClassResolverImpl.kt
@@ -24,6 +24,7 @@ import kotlin.properties.Delegates
 public class LocalClassResolverImpl : LocalClassResolver {
     public var components: DeserializationComponents by Delegates.notNull()
 
+    // component dependency cycle
     Inject
     public fun setDeserializationComponents(components: DeserializationComponents) {
         this.components = components
diff --git a/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/MemberDeserializer.kt b/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/MemberDeserializer.kt
index 7a92b70da47..694f079c0b2 100644
--- a/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/MemberDeserializer.kt
+++ b/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/MemberDeserializer.kt
@@ -16,14 +16,22 @@
 
 package org.jetbrains.kotlin.serialization.deserialization
 
-import org.jetbrains.kotlin.serialization.*
-import org.jetbrains.kotlin.serialization.deserialization.descriptors.*
 import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.descriptors.annotations.Annotations
-import org.jetbrains.kotlin.descriptors.impl.*
+import org.jetbrains.kotlin.descriptors.impl.ConstructorDescriptorImpl
+import org.jetbrains.kotlin.descriptors.impl.PropertyGetterDescriptorImpl
+import org.jetbrains.kotlin.descriptors.impl.PropertySetterDescriptorImpl
+import org.jetbrains.kotlin.descriptors.impl.ValueParameterDescriptorImpl
 import org.jetbrains.kotlin.resolve.DescriptorFactory
+import org.jetbrains.kotlin.serialization.Flags
 import org.jetbrains.kotlin.serialization.ProtoBuf.Callable
-import org.jetbrains.kotlin.serialization.ProtoBuf.Callable.CallableKind.*
+import org.jetbrains.kotlin.serialization.ProtoBuf.Callable.CallableKind.FUN
+import org.jetbrains.kotlin.serialization.ProtoBuf.Callable.CallableKind.VAL
+import org.jetbrains.kotlin.serialization.ProtoBuf.Callable.CallableKind.VAR
+import org.jetbrains.kotlin.serialization.deserialization.descriptors.DeserializedAnnotations
+import org.jetbrains.kotlin.serialization.deserialization.descriptors.DeserializedClassDescriptor
+import org.jetbrains.kotlin.serialization.deserialization.descriptors.DeserializedPropertyDescriptor
+import org.jetbrains.kotlin.serialization.deserialization.descriptors.DeserializedSimpleFunctionDescriptor
 
 public class MemberDeserializer(private val c: DeserializationContext) {
     public fun loadCallable(proto: Callable): CallableMemberDescriptor {
@@ -170,11 +178,12 @@ public class MemberDeserializer(private val c: DeserializationContext) {
     }
 
     private fun valueParameters(callable: Callable, kind: AnnotatedCallableKind): List<ValueParameterDescriptor> {
-        val containerOfCallable = c.containingDeclaration.getContainingDeclaration().asProtoContainer()
+        val callableDescriptor = c.containingDeclaration as CallableDescriptor
+        val containerOfCallable = callableDescriptor.getContainingDeclaration().asProtoContainer()
 
         return callable.getValueParameterList().mapIndexed { i, proto ->
             ValueParameterDescriptorImpl(
-                    c.containingDeclaration, null, i,
+                    callableDescriptor, null, i,
                     getParameterAnnotations(containerOfCallable, callable, kind, proto),
                     c.nameResolver.getName(proto.getName()),
                     c.typeDeserializer.type(proto.getType()),
diff --git a/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/ResourceLoadingClassDataFinder.kt b/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/ResourceLoadingClassDataFinder.kt
index d689f211a2c..a7ba2d90484 100644
--- a/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/ResourceLoadingClassDataFinder.kt
+++ b/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/ResourceLoadingClassDataFinder.kt
@@ -16,7 +16,6 @@
 
 package org.jetbrains.kotlin.serialization.deserialization
 
-import org.jetbrains.kotlin.serialization.deserialization.DeserializedPackageFragment
 import org.jetbrains.kotlin.descriptors.PackageFragmentProvider
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.serialization.ClassData
@@ -30,22 +29,14 @@ public open class ResourceLoadingClassDataFinder(
         private val loadResource: (path: String) -> InputStream?
 ) : ClassDataFinder {
     override fun findClassData(classId: ClassId): ClassData? {
-        val packageFragment = packageFragmentProvider.getPackageFragments(classId.getPackageFqName()).singleOrNull() ?: return null
+        val packageFragment = packageFragmentProvider.getPackageFragments(classId.getPackageFqName()).singleOrNull()
+                                      as? DeserializedPackageFragment ?: return null
 
         val stream = loadResource(serializedResourcePaths.getClassMetadataPath(classId)) ?: return null
 
-        val classProto = ProtoBuf.Class.parseFrom(stream, serializedResourcePaths.EXTENSION_REGISTRY)
-        val nameResolver =
-                (packageFragment as? DeserializedPackageFragment ?: error("Not a deserialized package fragment: $packageFragment")).nameResolver
-
-        val expectedShortName = classId.getShortClassName()
-        val actualShortName = nameResolver.getClassId(classProto.getFqName()).getShortClassName()
-        if (!actualShortName.isSpecial() && actualShortName != expectedShortName) {
-            // Workaround for case-insensitive file systems,
-            // otherwise we'd find "Collection" for "collection" etc
-            return null
-        }
-
-        return ClassData(nameResolver, classProto)
+        return ClassData(
+                packageFragment.nameResolver,
+                ProtoBuf.Class.parseFrom(stream, serializedResourcePaths.extensionRegistry)
+        )
     }
-}
\ No newline at end of file
+}
diff --git a/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/context.kt b/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/context.kt
index 002cf06197e..bdd5fdf394d 100644
--- a/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/context.kt
+++ b/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/context.kt
@@ -19,7 +19,7 @@ package org.jetbrains.kotlin.serialization.deserialization
 import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptor
 import org.jetbrains.kotlin.name.ClassId
-import org.jetbrains.kotlin.resolve.constants.CompileTimeConstant
+import org.jetbrains.kotlin.resolve.constants.ConstantValue
 import org.jetbrains.kotlin.serialization.ProtoBuf
 import org.jetbrains.kotlin.storage.StorageManager
 
@@ -27,7 +27,7 @@ public class DeserializationComponents(
         public val storageManager: StorageManager,
         public val moduleDescriptor: ModuleDescriptor,
         public val classDataFinder: ClassDataFinder,
-        public val annotationAndConstantLoader: AnnotationAndConstantLoader<AnnotationDescriptor, CompileTimeConstant<*>>,
+        public val annotationAndConstantLoader: AnnotationAndConstantLoader<AnnotationDescriptor, ConstantValue<*>>,
         public val packageFragmentProvider: PackageFragmentProvider,
         public val localClassResolver: LocalClassResolver,
         public val flexibleTypeCapabilitiesDeserializer: FlexibleTypeCapabilitiesDeserializer,
diff --git a/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/descriptors/DeserializedClassDescriptor.kt b/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/descriptors/DeserializedClassDescriptor.kt
index ae5ee0bfc77..bbbf6233675 100644
--- a/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/descriptors/DeserializedClassDescriptor.kt
+++ b/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/descriptors/DeserializedClassDescriptor.kt
@@ -91,7 +91,7 @@ public class DeserializedClassDescriptor(
 
     override fun getAnnotations() = annotations
 
-    override fun getScopeForMemberLookup() = memberScope
+    override fun getUnsubstitutedMemberScope() = memberScope
 
     override fun getStaticScope() = staticScope
 
@@ -139,6 +139,10 @@ public class DeserializedClassDescriptor(
         return supertypes
     }
 
+    internal fun hasNestedClass(name: Name): Boolean {
+        return name in nestedClasses.nestedClassNames
+    }
+
     override fun toString() = "deserialized class ${getName().toString()}" // not using descriptor render to preserve laziness
 
     override fun getSource() = SourceElement.NO_SOURCE
@@ -199,7 +203,7 @@ public class DeserializedClassDescriptor(
         private fun <D : CallableMemberDescriptor> generateFakeOverrides(name: Name, fromSupertypes: Collection<D>, result: MutableCollection<D>) {
             val fromCurrent = ArrayList<CallableMemberDescriptor>(result)
             OverridingUtil.generateOverridesInFunctionGroup(name, fromSupertypes, fromCurrent, classDescriptor, object : OverridingUtil.DescriptorSink {
-                override fun addToScope(fakeOverride: CallableMemberDescriptor) {
+                override fun addFakeOverride(fakeOverride: CallableMemberDescriptor) {
                     // TODO: report "cannot infer visibility"
                     OverridingUtil.resolveUnknownVisibilityForMember(fakeOverride, null)
                     @suppress("UNCHECKED_CAST")
@@ -241,9 +245,9 @@ public class DeserializedClassDescriptor(
     }
 
     private inner class NestedClassDescriptors {
-        private val nestedClassNames = nestedClassNames()
+        internal val nestedClassNames = nestedClassNames()
 
-        val findNestedClass = c.storageManager.createMemoizedFunctionWithNullableValues<Name, ClassDescriptor> {
+        internal val findNestedClass = c.storageManager.createMemoizedFunctionWithNullableValues<Name, ClassDescriptor> {
             name ->
             if (name in nestedClassNames) {
                 c.components.deserializeClass(classId.createNestedClassId(name))
diff --git a/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/descriptors/DeserializedMemberScope.kt b/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/descriptors/DeserializedMemberScope.kt
index 688aee37174..f2cc98fdb0c 100644
--- a/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/descriptors/DeserializedMemberScope.kt
+++ b/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/descriptors/DeserializedMemberScope.kt
@@ -16,22 +16,25 @@
 
 package org.jetbrains.kotlin.serialization.deserialization.descriptors
 
-import org.jetbrains.kotlin.serialization.Flags
-import org.jetbrains.kotlin.serialization.ProtoBuf
 import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.name.Name
-import org.jetbrains.kotlin.resolve.scopes.JetScope
-import org.jetbrains.kotlin.utils.Printer
-import org.jetbrains.kotlin.utils.toReadOnlyList
 import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter
+import org.jetbrains.kotlin.resolve.scopes.JetScopeImpl
+import org.jetbrains.kotlin.serialization.Flags
+import org.jetbrains.kotlin.serialization.ProtoBuf
 import org.jetbrains.kotlin.serialization.ProtoBuf.Callable.CallableKind
 import org.jetbrains.kotlin.serialization.deserialization.DeserializationContext
-import java.util.*
+import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.utils.Printer
+import org.jetbrains.kotlin.utils.toReadOnlyList
+import java.util.ArrayList
+import java.util.LinkedHashMap
+import java.util.LinkedHashSet
 
 public abstract class DeserializedMemberScope protected constructor(
         protected val c: DeserializationContext,
         membersList: Collection<ProtoBuf.Callable>
-) : JetScope {
+) : JetScopeImpl() {
 
     private data class ProtoKey(val name: Name, val kind: Kind, val isExtension: Boolean)
     private enum class Kind { FUNCTION, PROPERTY }
@@ -109,14 +112,8 @@ public abstract class DeserializedMemberScope protected constructor(
 
     protected abstract fun addClassDescriptors(result: MutableCollection<DeclarationDescriptor>, nameFilter: (Name) -> Boolean)
 
-    override fun getPackage(name: Name): PackageViewDescriptor? = null
-
-    override fun getLocalVariable(name: Name): VariableDescriptor? = null
-
     override fun getContainingDeclaration() = c.containingDeclaration
 
-    override fun getDeclarationsByLabel(labelName: Name): Collection<DeclarationDescriptor> = listOf()
-
     protected fun computeDescriptors(kindFilter: DescriptorKindFilter,
                                      nameFilter: (Name) -> Boolean): Collection<DeclarationDescriptor> {
         //NOTE: descriptors should be in the same order they were serialized in
diff --git a/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/descriptors/DeserializedPackageMemberScope.kt b/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/descriptors/DeserializedPackageMemberScope.kt
index 9a98d7e8cd8..55c647defef 100644
--- a/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/descriptors/DeserializedPackageMemberScope.kt
+++ b/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/descriptors/DeserializedPackageMemberScope.kt
@@ -16,16 +16,17 @@
 
 package org.jetbrains.kotlin.serialization.deserialization.descriptors
 
-import org.jetbrains.kotlin.serialization.ProtoBuf
-import org.jetbrains.kotlin.serialization.deserialization.DeserializationComponents
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 import org.jetbrains.kotlin.descriptors.PackageFragmentDescriptor
 import org.jetbrains.kotlin.descriptors.ReceiverParameterDescriptor
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.Name
-import org.jetbrains.kotlin.utils.addIfNotNull
 import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter
+import org.jetbrains.kotlin.serialization.ProtoBuf
+import org.jetbrains.kotlin.serialization.deserialization.DeserializationComponents
 import org.jetbrains.kotlin.serialization.deserialization.NameResolver
+import org.jetbrains.kotlin.storage.get
+import org.jetbrains.kotlin.utils.addIfNotNull
 
 public open class DeserializedPackageMemberScope(
         packageDescriptor: PackageFragmentDescriptor,
@@ -36,7 +37,8 @@ public open class DeserializedPackageMemberScope(
 ) : DeserializedMemberScope(components.createContext(packageDescriptor, nameResolver), proto.getMemberList()) {
 
     private val packageFqName = packageDescriptor.fqName
-    private val classNames = c.storageManager.createLazyValue(classNames)
+
+    internal val classNames by c.storageManager.createLazyValue { classNames().toSet() }
 
     override fun getDescriptors(kindFilter: DescriptorKindFilter, nameFilter: (Name) -> Boolean)
             = computeDescriptors(kindFilter, nameFilter)
@@ -44,7 +46,7 @@ public open class DeserializedPackageMemberScope(
     override fun getClassDescriptor(name: Name) = c.components.deserializeClass(ClassId(packageFqName, name))
 
     override fun addClassDescriptors(result: MutableCollection<DeclarationDescriptor>, nameFilter: (Name) -> Boolean) {
-        for (className in classNames()) {
+        for (className in classNames) {
             if (nameFilter(className)) {
                 result.addIfNotNull(getClassDescriptor(className))
             }
diff --git a/core/reflection.jvm/reflection.jvm.iml b/core/reflection.jvm/reflection.jvm.iml
index c27ceec3095..401fe141a0d 100644
--- a/core/reflection.jvm/reflection.jvm.iml
+++ b/core/reflection.jvm/reflection.jvm.iml
@@ -8,6 +8,7 @@
     <orderEntry type="inheritedJdk" />
     <orderEntry type="sourceFolder" forTests="false" />
     <orderEntry type="module" module-name="builtins" />
+    <orderEntry type="module" module-name="runtime.jvm" />
     <orderEntry type="module" module-name="descriptors.runtime" />
     <orderEntry type="library" name="kotlin-runtime" level="project" />
   </component>
diff --git a/core/reflection.jvm/src/kotlin/reflect/KClassExtensions.kt b/core/reflection.jvm/src/kotlin/reflect/KClassExtensions.kt
index 30d73543926..ddddc04a511 100644
--- a/core/reflection.jvm/src/kotlin/reflect/KClassExtensions.kt
+++ b/core/reflection.jvm/src/kotlin/reflect/KClassExtensions.kt
@@ -21,11 +21,11 @@ import kotlin.reflect.jvm.internal.KClassImpl
 /**
  * Returns non-extension properties declared in this class.
  */
-public val <T> KClass<T>.declaredProperties: Collection<KMemberProperty<T, *>>
+public val <T> KClass<T>.declaredProperties: Collection<KProperty1<T, *>>
     get() = (this as KClassImpl<T>).getProperties(declared = true)
 
 /**
  * Returns extension properties declared in this class.
  */
-public val <T> KClass<T>.declaredExtensionProperties: Collection<KMemberExtensionProperty<T, *, *>>
+public val <T> KClass<T>.declaredExtensionProperties: Collection<KProperty2<T, *, *>>
     get() = (this as KClassImpl<T>).getExtensionProperties(declared = true)
diff --git a/core/builtins/src/kotlin/reflect/KTopLevelExtensionFunction.kt b/core/reflection.jvm/src/kotlin/reflect/jvm/classes.kt
similarity index 65%
rename from core/builtins/src/kotlin/reflect/KTopLevelExtensionFunction.kt
rename to core/reflection.jvm/src/kotlin/reflect/jvm/classes.kt
index 133b1bb61d8..f059b078f0f 100644
--- a/core/builtins/src/kotlin/reflect/KTopLevelExtensionFunction.kt
+++ b/core/reflection.jvm/src/kotlin/reflect/jvm/classes.kt
@@ -14,12 +14,17 @@
  * limitations under the License.
  */
 
-package kotlin.reflect
+package kotlin.reflect.jvm
+
+import kotlin.reflect.KClass
+import kotlin.reflect.jvm.internal.KClassImpl
 
 /**
- * Represents an extension function declared in a package.
+ * Returns the JVM name of the class represented by this [KClass] instance.
  *
- * @param E the type of the extension receiver.
- * @param R the return type of the function.
+ * @see [java.lang.Class.getName]
  */
-public interface KTopLevelExtensionFunction<in E, out R> : KExtensionFunction<E, R>
+public val KClass<*>.jvmName: String
+    get() {
+        return (this as KClassImpl).jClass.getName()
+    }
diff --git a/core/reflection.jvm/src/kotlin/reflect/jvm/internal/DescriptorBasedProperty.kt b/core/reflection.jvm/src/kotlin/reflect/jvm/internal/DescriptorBasedProperty.kt
index c281e039e43..87ebafd26a1 100644
--- a/core/reflection.jvm/src/kotlin/reflect/jvm/internal/DescriptorBasedProperty.kt
+++ b/core/reflection.jvm/src/kotlin/reflect/jvm/internal/DescriptorBasedProperty.kt
@@ -30,17 +30,17 @@ import java.lang.reflect.Method
 abstract class DescriptorBasedProperty protected constructor(
         container: KCallableContainerImpl,
         name: String,
-        receiverParameterDesc: String?,
+        signature: String,
         descriptorInitialValue: PropertyDescriptor?
 ) {
-    constructor(container: KCallableContainerImpl, name: String, receiverParameterClass: Class<*>?) : this(
-            container, name, receiverParameterClass?.desc, null
+    constructor(container: KCallableContainerImpl, name: String, signature: String) : this(
+            container, name, signature, null
     )
 
     constructor(container: KCallableContainerImpl, descriptor: PropertyDescriptor) : this(
             container,
             descriptor.getName().asString(),
-            descriptor.getExtensionReceiverParameter()?.getType()?.let { type -> RuntimeTypeMapper.mapTypeToJvmDesc(type) },
+            RuntimeTypeMapper.mapPropertySignature(descriptor),
             descriptor
     )
 
@@ -51,7 +51,7 @@ abstract class DescriptorBasedProperty protected constructor(
     )
 
     protected val descriptor: PropertyDescriptor by ReflectProperties.lazySoft<PropertyDescriptor>(descriptorInitialValue) {
-        container.findPropertyDescriptor(name, receiverParameterDesc)
+        container.findPropertyDescriptor(name, signature)
     }
 
     // null if this is a property declared in a foreign (Java) class
@@ -66,21 +66,21 @@ abstract class DescriptorBasedProperty protected constructor(
         null
     }
 
-    open val field: Field? by ReflectProperties.lazySoft {
+    open val javaField: Field? by ReflectProperties.lazySoft {
         val proto = protoData
         if (proto == null) container.jClass.getField(name)
         else if (!proto.signature.hasField()) null
         else container.findFieldBySignature(proto.proto, proto.signature.getField(), proto.nameResolver)
     }
 
-    open val getter: Method? by ReflectProperties.lazySoft {
+    open val javaGetter: Method? by ReflectProperties.lazySoft {
         val proto = protoData
         if (proto == null || !proto.signature.hasGetter()) null
         else container.findMethodBySignature(proto.signature.getGetter(), proto.nameResolver,
                                              descriptor.getGetter()?.getVisibility()?.let { Visibilities.isPrivate(it) } ?: false)
     }
 
-    open val setter: Method? by ReflectProperties.lazySoft {
+    open val javaSetter: Method? by ReflectProperties.lazySoft {
         val proto = protoData
         if (proto == null || !proto.signature.hasSetter()) null
         else container.findMethodBySignature(proto.signature.getSetter(), proto.nameResolver,
diff --git a/core/reflection.jvm/src/kotlin/reflect/jvm/internal/KCallableContainerImpl.kt b/core/reflection.jvm/src/kotlin/reflect/jvm/internal/KCallableContainerImpl.kt
index 3c0ebd4b6e8..08141bae80b 100644
--- a/core/reflection.jvm/src/kotlin/reflect/jvm/internal/KCallableContainerImpl.kt
+++ b/core/reflection.jvm/src/kotlin/reflect/jvm/internal/KCallableContainerImpl.kt
@@ -16,6 +16,7 @@
 
 package kotlin.reflect.jvm.internal
 
+import org.jetbrains.kotlin.descriptors.FunctionDescriptor
 import org.jetbrains.kotlin.descriptors.PropertyDescriptor
 import org.jetbrains.kotlin.load.java.structure.reflect.classId
 import org.jetbrains.kotlin.load.java.structure.reflect.classLoader
@@ -29,9 +30,10 @@ import org.jetbrains.kotlin.serialization.jvm.JvmProtoBuf
 import org.jetbrains.kotlin.serialization.jvm.JvmProtoBuf.JvmType.PrimitiveType.*
 import java.lang.reflect.Field
 import java.lang.reflect.Method
+import kotlin.reflect.KDeclarationContainer
 import kotlin.reflect.KotlinReflectionInternalError
 
-abstract class KCallableContainerImpl {
+abstract class KCallableContainerImpl : KDeclarationContainer {
     // Note: this is stored here on a soft reference to prevent GC from destroying the weak reference to it in the moduleByClassLoader cache
     val moduleData by ReflectProperties.lazySoft {
         jClass.getOrCreateModule()
@@ -41,29 +43,43 @@ abstract class KCallableContainerImpl {
 
     abstract val scope: JetScope
 
-    fun findPropertyDescriptor(name: String, receiverDesc: String? = null): PropertyDescriptor {
+    fun findPropertyDescriptor(name: String, signature: String): PropertyDescriptor {
         val properties = scope
-                .getProperties(Name.identifier(name))
+                .getProperties(Name.guess(name))
                 .filter { descriptor ->
                     descriptor is PropertyDescriptor &&
-                    descriptor.getName().asString() == name &&
-                    with(descriptor.getExtensionReceiverParameter()) {
-                        (this == null && receiverDesc == null) ||
-                        (this != null && RuntimeTypeMapper.mapTypeToJvmDesc(getType()) == receiverDesc)
-                    }
+                    RuntimeTypeMapper.mapPropertySignature(descriptor) == signature
                 }
 
         if (properties.size() != 1) {
-            val debugText = if (receiverDesc == null) name else "$receiverDesc.$name"
+            val debugText = "'$name' (JVM signature: $signature)"
             throw KotlinReflectionInternalError(
-                    if (properties.isEmpty()) "Property '$debugText' not resolved in $this"
-                    else "${properties.size()} properties '$debugText' resolved in $this"
+                    if (properties.isEmpty()) "Property $debugText not resolved in $this"
+                    else "${properties.size()} properties $debugText resolved in $this: $properties"
             )
         }
 
         return properties.single() as PropertyDescriptor
     }
 
+    fun findFunctionDescriptor(name: String, signature: String): FunctionDescriptor {
+        val functions = scope
+                .getFunctions(Name.guess(name))
+                .filter { descriptor ->
+                    RuntimeTypeMapper.mapSignature(descriptor) == signature
+                }
+
+        if (functions.size() != 1) {
+            val debugText = "'$name' (JVM signature: $signature)"
+            throw KotlinReflectionInternalError(
+                    if (functions.isEmpty()) "Function $debugText not resolved in $this"
+                    else "${functions.size()} functions $debugText resolved in $this: $functions"
+            )
+        }
+
+        return functions.single()
+    }
+
     // TODO: check resulting method's return type
     fun findMethodBySignature(signature: JvmProtoBuf.JvmMethodSignature, nameResolver: NameResolver, declared: Boolean): Method? {
         val name = nameResolver.getString(signature.getName())
diff --git a/core/reflection.jvm/src/kotlin/reflect/jvm/internal/KCallableImpl.kt b/core/reflection.jvm/src/kotlin/reflect/jvm/internal/KCallableImpl.kt
index eb4460b5f53..d98e816c3d7 100644
--- a/core/reflection.jvm/src/kotlin/reflect/jvm/internal/KCallableImpl.kt
+++ b/core/reflection.jvm/src/kotlin/reflect/jvm/internal/KCallableImpl.kt
@@ -18,4 +18,4 @@ package kotlin.reflect.jvm.internal
 
 import kotlin.reflect.KCallable
 
-trait KCallableImpl<out R> : KCallable<R>
+interface KCallableImpl<out R> : KCallable<R>
diff --git a/core/reflection.jvm/src/kotlin/reflect/jvm/internal/KClassImpl.kt b/core/reflection.jvm/src/kotlin/reflect/jvm/internal/KClassImpl.kt
index f00a88bd7ed..903648d59cf 100644
--- a/core/reflection.jvm/src/kotlin/reflect/jvm/internal/KClassImpl.kt
+++ b/core/reflection.jvm/src/kotlin/reflect/jvm/internal/KClassImpl.kt
@@ -19,6 +19,7 @@ package kotlin.reflect.jvm.internal
 import org.jetbrains.kotlin.descriptors.PropertyDescriptor
 import org.jetbrains.kotlin.descriptors.Visibilities
 import org.jetbrains.kotlin.name.ClassId
+import org.jetbrains.kotlin.resolve.scopes.ChainedScope
 import org.jetbrains.kotlin.resolve.scopes.JetScope
 import org.jetbrains.kotlin.serialization.deserialization.findClassAcrossModuleDependencies
 import kotlin.reflect.*
@@ -39,12 +40,15 @@ class KClassImpl<T>(override val jClass: Class<T>) : KCallableContainerImpl(), K
 
     private val classId: ClassId get() = RuntimeTypeMapper.mapJvmClassToKotlinClassId(jClass)
 
-    override val scope: JetScope get() = descriptor.getDefaultType().getMemberScope()
+    override val scope: JetScope get() = ChainedScope(
+            descriptor, "KClassImpl scope", descriptor.getDefaultType().getMemberScope(), descriptor.getStaticScope()
+    )
 
     override val simpleName: String? get() {
+        if (jClass.isAnonymousClass()) return null
+
         val classId = classId
         return when {
-            jClass.isAnonymousClass() -> null
             classId.isLocal() -> calculateLocalClassName(jClass)
             else -> classId.getShortClassName().asString()
         }
@@ -61,22 +65,32 @@ class KClassImpl<T>(override val jClass: Class<T>) : KCallableContainerImpl(), K
         return name.substringAfter('$')
     }
 
-    override val properties: Collection<KMemberProperty<T, *>>
+    override val qualifiedName: String? get() {
+        if (jClass.isAnonymousClass()) return null
+
+        val classId = classId
+        return when {
+            classId.isLocal() -> null
+            else -> classId.asSingleFqName().asString()
+        }
+    }
+
+    override val properties: Collection<KProperty1<T, *>>
             get() = getProperties(declared = false)
 
-    override val extensionProperties: Collection<KMemberExtensionProperty<T, *, *>>
+    override val extensionProperties: Collection<KProperty2<T, *, *>>
             get() = getExtensionProperties(declared = false)
 
-    fun getProperties(declared: Boolean): Collection<KMemberProperty<T, *>> =
+    fun getProperties(declared: Boolean): Collection<KProperty1<T, *>> =
             getProperties(extension = false, declared = declared) { descriptor ->
-                if (descriptor.isVar()) KMutableMemberPropertyImpl<T, Any?>(this, descriptor)
-                else KMemberPropertyImpl<T, Any?>(this, descriptor)
+                if (descriptor.isVar()) KMutableProperty1Impl<T, Any?>(this, descriptor)
+                else KProperty1Impl<T, Any?>(this, descriptor)
             }
 
-    fun getExtensionProperties(declared: Boolean): Collection<KMemberExtensionProperty<T, *, *>> =
+    fun getExtensionProperties(declared: Boolean): Collection<KProperty2<T, *, *>> =
             getProperties(extension = true, declared = declared) { descriptor ->
-                if (descriptor.isVar()) KMutableMemberExtensionPropertyImpl<T, Any?, Any?>(this, descriptor)
-                else KMemberExtensionPropertyImpl<T, Any?, Any?>(this, descriptor)
+                if (descriptor.isVar()) KMutableProperty2Impl<T, Any?, Any?>(this, descriptor)
+                else KProperty2Impl<T, Any?, Any?>(this, descriptor)
             }
 
     private fun <P : KProperty<*>> getProperties(extension: Boolean, declared: Boolean, create: (PropertyDescriptor) -> P): Collection<P> =
@@ -90,12 +104,6 @@ class KClassImpl<T>(override val jClass: Class<T>) : KCallableContainerImpl(), K
                     .map(create)
                     .toList()
 
-    fun memberProperty(name: String): KMemberProperty<T, *> =
-            KMemberPropertyImpl<T, Any>(this, name)
-
-    fun mutableMemberProperty(name: String): KMutableMemberProperty<T, *> =
-            KMutableMemberPropertyImpl<T, Any>(this, name)
-
     override fun equals(other: Any?): Boolean =
             other is KClassImpl<*> && jClass == other.jClass
 
diff --git a/core/reflection.jvm/src/kotlin/reflect/jvm/internal/KFunctionFromReferenceImpl.kt b/core/reflection.jvm/src/kotlin/reflect/jvm/internal/KFunctionFromReferenceImpl.kt
new file mode 100644
index 00000000000..ede7ae70e58
--- /dev/null
+++ b/core/reflection.jvm/src/kotlin/reflect/jvm/internal/KFunctionFromReferenceImpl.kt
@@ -0,0 +1,69 @@
+/*
+ * Copyright 2010-2015 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.reflect.jvm.internal
+
+import org.jetbrains.kotlin.resolve.scopes.JetScope
+import kotlin.jvm.internal.FunctionReference
+import kotlin.reflect.KotlinReflectionInternalError
+
+class KFunctionFromReferenceImpl(
+        val reference: FunctionReference
+): KFunctionImpl(
+        reference.getOwner() as? KCallableContainerImpl ?: EmptyContainerForLocal,
+        reference.getName(),
+        reference.getSignature()
+) {
+    override fun getArity() = reference.getArity()
+
+    override val name = reference.getName()
+
+    // The rest of the class is auto-generated. Use the following script:
+    // (0..22).forEach { n -> println("override fun invoke(" + (1..n).joinToString { "p$it: Any?" } + "): Any? = reference(" + (1..n).joinToString { "p$it" } + ")") }
+    override fun invoke(): Any? = reference()
+    override fun invoke(p1: Any?): Any? = reference(p1)
+    override fun invoke(p1: Any?, p2: Any?): Any? = reference(p1, p2)
+    override fun invoke(p1: Any?, p2: Any?, p3: Any?): Any? = reference(p1, p2, p3)
+    override fun invoke(p1: Any?, p2: Any?, p3: Any?, p4: Any?): Any? = reference(p1, p2, p3, p4)
+    override fun invoke(p1: Any?, p2: Any?, p3: Any?, p4: Any?, p5: Any?): Any? = reference(p1, p2, p3, p4, p5)
+    override fun invoke(p1: Any?, p2: Any?, p3: Any?, p4: Any?, p5: Any?, p6: Any?): Any? = reference(p1, p2, p3, p4, p5, p6)
+    override fun invoke(p1: Any?, p2: Any?, p3: Any?, p4: Any?, p5: Any?, p6: Any?, p7: Any?): Any? = reference(p1, p2, p3, p4, p5, p6, p7)
+    override fun invoke(p1: Any?, p2: Any?, p3: Any?, p4: Any?, p5: Any?, p6: Any?, p7: Any?, p8: Any?): Any? = reference(p1, p2, p3, p4, p5, p6, p7, p8)
+    override fun invoke(p1: Any?, p2: Any?, p3: Any?, p4: Any?, p5: Any?, p6: Any?, p7: Any?, p8: Any?, p9: Any?): Any? = reference(p1, p2, p3, p4, p5, p6, p7, p8, p9)
+    override fun invoke(p1: Any?, p2: Any?, p3: Any?, p4: Any?, p5: Any?, p6: Any?, p7: Any?, p8: Any?, p9: Any?, p10: Any?): Any? = reference(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10)
+    override fun invoke(p1: Any?, p2: Any?, p3: Any?, p4: Any?, p5: Any?, p6: Any?, p7: Any?, p8: Any?, p9: Any?, p10: Any?, p11: Any?): Any? = reference(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11)
+    override fun invoke(p1: Any?, p2: Any?, p3: Any?, p4: Any?, p5: Any?, p6: Any?, p7: Any?, p8: Any?, p9: Any?, p10: Any?, p11: Any?, p12: Any?): Any? = reference(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12)
+    override fun invoke(p1: Any?, p2: Any?, p3: Any?, p4: Any?, p5: Any?, p6: Any?, p7: Any?, p8: Any?, p9: Any?, p10: Any?, p11: Any?, p12: Any?, p13: Any?): Any? = reference(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13)
+    override fun invoke(p1: Any?, p2: Any?, p3: Any?, p4: Any?, p5: Any?, p6: Any?, p7: Any?, p8: Any?, p9: Any?, p10: Any?, p11: Any?, p12: Any?, p13: Any?, p14: Any?): Any? = reference(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14)
+    override fun invoke(p1: Any?, p2: Any?, p3: Any?, p4: Any?, p5: Any?, p6: Any?, p7: Any?, p8: Any?, p9: Any?, p10: Any?, p11: Any?, p12: Any?, p13: Any?, p14: Any?, p15: Any?): Any? = reference(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15)
+    override fun invoke(p1: Any?, p2: Any?, p3: Any?, p4: Any?, p5: Any?, p6: Any?, p7: Any?, p8: Any?, p9: Any?, p10: Any?, p11: Any?, p12: Any?, p13: Any?, p14: Any?, p15: Any?, p16: Any?): Any? = reference(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16)
+    override fun invoke(p1: Any?, p2: Any?, p3: Any?, p4: Any?, p5: Any?, p6: Any?, p7: Any?, p8: Any?, p9: Any?, p10: Any?, p11: Any?, p12: Any?, p13: Any?, p14: Any?, p15: Any?, p16: Any?, p17: Any?): Any? = reference(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17)
+    override fun invoke(p1: Any?, p2: Any?, p3: Any?, p4: Any?, p5: Any?, p6: Any?, p7: Any?, p8: Any?, p9: Any?, p10: Any?, p11: Any?, p12: Any?, p13: Any?, p14: Any?, p15: Any?, p16: Any?, p17: Any?, p18: Any?): Any? = reference(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18)
+    override fun invoke(p1: Any?, p2: Any?, p3: Any?, p4: Any?, p5: Any?, p6: Any?, p7: Any?, p8: Any?, p9: Any?, p10: Any?, p11: Any?, p12: Any?, p13: Any?, p14: Any?, p15: Any?, p16: Any?, p17: Any?, p18: Any?, p19: Any?): Any? = reference(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19)
+    override fun invoke(p1: Any?, p2: Any?, p3: Any?, p4: Any?, p5: Any?, p6: Any?, p7: Any?, p8: Any?, p9: Any?, p10: Any?, p11: Any?, p12: Any?, p13: Any?, p14: Any?, p15: Any?, p16: Any?, p17: Any?, p18: Any?, p19: Any?, p20: Any?): Any? = reference(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20)
+    override fun invoke(p1: Any?, p2: Any?, p3: Any?, p4: Any?, p5: Any?, p6: Any?, p7: Any?, p8: Any?, p9: Any?, p10: Any?, p11: Any?, p12: Any?, p13: Any?, p14: Any?, p15: Any?, p16: Any?, p17: Any?, p18: Any?, p19: Any?, p20: Any?, p21: Any?): Any? = reference(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21)
+    override fun invoke(p1: Any?, p2: Any?, p3: Any?, p4: Any?, p5: Any?, p6: Any?, p7: Any?, p8: Any?, p9: Any?, p10: Any?, p11: Any?, p12: Any?, p13: Any?, p14: Any?, p15: Any?, p16: Any?, p17: Any?, p18: Any?, p19: Any?, p20: Any?, p21: Any?, p22: Any?): Any? = reference(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22)
+}
+
+object EmptyContainerForLocal : KCallableContainerImpl() {
+    override val jClass: Class<*>
+        get() = fail()
+
+    override val scope: JetScope
+        get() = fail()
+
+    private fun fail() = throw KotlinReflectionInternalError("Introspecting local functions is not yet supported in Kotlin reflection")
+}
diff --git a/core/reflection.jvm/src/kotlin/reflect/jvm/internal/KFunctionImpl.kt b/core/reflection.jvm/src/kotlin/reflect/jvm/internal/KFunctionImpl.kt
index 33ea57638c5..875804fcd52 100644
--- a/core/reflection.jvm/src/kotlin/reflect/jvm/internal/KFunctionImpl.kt
+++ b/core/reflection.jvm/src/kotlin/reflect/jvm/internal/KFunctionImpl.kt
@@ -16,9 +16,42 @@
 
 package kotlin.reflect.jvm.internal
 
+import org.jetbrains.kotlin.descriptors.FunctionDescriptor
 import kotlin.jvm.internal.FunctionImpl
+import kotlin.reflect.*
 
-/**
- * @suppress
- */
-public abstract class KFunctionImpl<out R> : FunctionImpl()
+open class KFunctionImpl protected constructor(
+        container: KCallableContainerImpl,
+        name: String,
+        signature: String,
+        descriptorInitialValue: FunctionDescriptor?
+) : KFunction<Any?>, FunctionImpl(),
+        KLocalFunction<Any?>, KMemberFunction<Any, Any?>, KTopLevelExtensionFunction<Any?, Any?>, KTopLevelFunction<Any?> {
+    constructor(container: KCallableContainerImpl, name: String, signature: String) : this(container, name, signature, null)
+
+    constructor(container: KCallableContainerImpl, descriptor: FunctionDescriptor) : this(
+            container, descriptor.getName().asString(), RuntimeTypeMapper.mapSignature(descriptor), descriptor
+    )
+
+    protected val descriptor: FunctionDescriptor by ReflectProperties.lazySoft<FunctionDescriptor>(descriptorInitialValue) {
+        container.findFunctionDescriptor(name, signature)
+    }
+
+    override val name: String get() = descriptor.getName().asString()
+
+    override fun getArity(): Int {
+        // TODO: test?
+        return descriptor.getValueParameters().size() +
+               (if (descriptor.getDispatchReceiverParameter() != null) 1 else 0) +
+               (if (descriptor.getExtensionReceiverParameter() != null) 1 else 0)
+    }
+
+    override fun equals(other: Any?): Boolean =
+            other is KFunctionImpl && descriptor == other.descriptor
+
+    override fun hashCode(): Int =
+            descriptor.hashCode()
+
+    override fun toString(): String =
+            ReflectionObjectRenderer.renderFunction(descriptor)
+}
diff --git a/core/reflection.jvm/src/kotlin/reflect/jvm/internal/KMemberExtensionPropertyImpl.kt b/core/reflection.jvm/src/kotlin/reflect/jvm/internal/KMemberExtensionPropertyImpl.kt
deleted file mode 100644
index 5777671ca62..00000000000
--- a/core/reflection.jvm/src/kotlin/reflect/jvm/internal/KMemberExtensionPropertyImpl.kt
+++ /dev/null
@@ -1,67 +0,0 @@
-/*
- * Copyright 2010-2015 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.reflect.jvm.internal
-
-import org.jetbrains.kotlin.descriptors.PropertyDescriptor
-import java.lang.reflect.Field
-import java.lang.reflect.Method
-import kotlin.reflect.IllegalPropertyAccessException
-import kotlin.reflect.KMemberExtensionProperty
-import kotlin.reflect.KMutableMemberExtensionProperty
-
-open class KMemberExtensionPropertyImpl<D : Any, E, out R> : DescriptorBasedProperty, KMemberExtensionProperty<D, E, R>, KPropertyImpl<R> {
-    constructor(container: KClassImpl<D>, name: String, receiverParameterClass: Class<E>) : super(container, name, receiverParameterClass)
-
-    constructor(container: KClassImpl<D>, descriptor: PropertyDescriptor) : super(container, descriptor)
-
-    override val name: String get() = descriptor.getName().asString()
-
-    override val getter: Method get() = super<DescriptorBasedProperty>.getter!!
-
-    override val field: Field? get() = null
-
-    override fun get(instance: D, extensionReceiver: E): R {
-        try {
-            @suppress("UNCHECKED_CAST")
-            return getter.invoke(instance, extensionReceiver) as R
-        }
-        catch (e: IllegalAccessException) {
-            throw IllegalPropertyAccessException(e)
-        }
-    }
-}
-
-
-class KMutableMemberExtensionPropertyImpl<D : Any, E, R> :
-        KMemberExtensionPropertyImpl<D, E, R>,
-        KMutableMemberExtensionProperty<D, E, R>,
-        KMutablePropertyImpl<R> {
-    constructor(container: KClassImpl<D>, name: String, receiverParameterClass: Class<E>) : super(container, name, receiverParameterClass)
-
-    constructor(container: KClassImpl<D>, descriptor: PropertyDescriptor) : super(container, descriptor)
-
-    override val setter: Method get() = super<KMemberExtensionPropertyImpl>.setter!!
-
-    override fun set(instance: D, extensionReceiver: E, value: R) {
-        try {
-            setter.invoke(instance, extensionReceiver, value)
-        }
-        catch (e: IllegalAccessException) {
-            throw IllegalPropertyAccessException(e)
-        }
-    }
-}
diff --git a/core/reflection.jvm/src/kotlin/reflect/jvm/internal/KMemberPropertyImpl.kt b/core/reflection.jvm/src/kotlin/reflect/jvm/internal/KMemberPropertyImpl.kt
deleted file mode 100644
index 5a2522d63f5..00000000000
--- a/core/reflection.jvm/src/kotlin/reflect/jvm/internal/KMemberPropertyImpl.kt
+++ /dev/null
@@ -1,58 +0,0 @@
-/*
- * Copyright 2010-2015 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.reflect.jvm.internal
-
-import org.jetbrains.kotlin.descriptors.PropertyDescriptor
-import kotlin.reflect.IllegalPropertyAccessException
-import kotlin.reflect.KMemberProperty
-import kotlin.reflect.KMutableMemberProperty
-
-open class KMemberPropertyImpl<T : Any, out R> : DescriptorBasedProperty, KMemberProperty<T, R>, KPropertyImpl<R> {
-    constructor(container: KClassImpl<T>, name: String) : super(container, name, null)
-
-    constructor(container: KClassImpl<T>, descriptor: PropertyDescriptor) : super(container, descriptor)
-
-    override val name: String get() = descriptor.getName().asString()
-
-    override fun get(instance: T): R {
-        try {
-            val getter = getter
-            @suppress("UNCHECKED_CAST")
-            return if (getter != null) getter(instance) as R else field!!.get(instance) as R
-        }
-        catch (e: IllegalAccessException) {
-            throw IllegalPropertyAccessException(e)
-        }
-    }
-}
-
-
-class KMutableMemberPropertyImpl<T : Any, R> : KMemberPropertyImpl<T, R>, KMutableMemberProperty<T, R>, KMutablePropertyImpl<R> {
-    constructor(container: KClassImpl<T>, name: String) : super(container, name)
-
-    constructor(container: KClassImpl<T>, descriptor: PropertyDescriptor) : super(container, descriptor)
-
-    override fun set(instance: T, value: R) {
-        try {
-            val setter = setter
-            if (setter != null) setter(instance, value) else field!!.set(instance, value)
-        }
-        catch (e: IllegalAccessException) {
-            throw IllegalPropertyAccessException(e)
-        }
-    }
-}
diff --git a/core/reflection.jvm/src/kotlin/reflect/jvm/internal/KPackageImpl.kt b/core/reflection.jvm/src/kotlin/reflect/jvm/internal/KPackageImpl.kt
index 28a9a48a9ca..22d236f0b45 100644
--- a/core/reflection.jvm/src/kotlin/reflect/jvm/internal/KPackageImpl.kt
+++ b/core/reflection.jvm/src/kotlin/reflect/jvm/internal/KPackageImpl.kt
@@ -31,18 +31,6 @@ class KPackageImpl(override val jClass: Class<*>) : KCallableContainerImpl(), KP
 
     override val scope: JetScope get() = descriptor.memberScope
 
-    fun topLevelVariable(name: String): KTopLevelVariable<*> =
-            KTopLevelVariableImpl<Any?>(this, name)
-
-    fun mutableTopLevelVariable(name: String): KMutableTopLevelVariable<*> =
-            KMutableTopLevelVariableImpl<Any?>(this, name)
-
-    fun <T> topLevelExtensionProperty(name: String, receiver: Class<T>): KTopLevelExtensionProperty<T, *> =
-            KTopLevelExtensionPropertyImpl<T, Any?>(this, name, receiver)
-
-    fun <T> mutableTopLevelExtensionProperty(name: String, receiver: Class<T>): KMutableTopLevelExtensionProperty<T, *> =
-            KMutableTopLevelExtensionPropertyImpl<T, Any?>(this, name, receiver)
-
     override fun equals(other: Any?): Boolean =
             other is KPackageImpl && jClass == other.jClass
 
diff --git a/core/reflection.jvm/src/kotlin/reflect/jvm/internal/KProperty0Impl.kt b/core/reflection.jvm/src/kotlin/reflect/jvm/internal/KProperty0Impl.kt
new file mode 100644
index 00000000000..2877a9111ed
--- /dev/null
+++ b/core/reflection.jvm/src/kotlin/reflect/jvm/internal/KProperty0Impl.kt
@@ -0,0 +1,99 @@
+/*
+ * Copyright 2010-2015 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.reflect.jvm.internal
+
+import java.lang.reflect.Method
+import kotlin.jvm.internal.MutablePropertyReference0
+import kotlin.jvm.internal.PropertyReference0
+import kotlin.reflect.IllegalPropertyAccessException
+import kotlin.reflect.KMutableProperty0
+import kotlin.reflect.KProperty0
+
+open class KProperty0Impl<out R> : DescriptorBasedProperty, KProperty0<R>, KPropertyImpl<R> {
+    constructor(container: KCallableContainerImpl, name: String, signature: String) : super(container, name, signature)
+
+    override val name: String get() = descriptor.getName().asString()
+
+    override val getter by ReflectProperties.lazy { Getter(this) }
+
+    override val javaGetter: Method get() = super.javaGetter!!
+
+    override fun get(): R {
+        try {
+            @suppress("UNCHECKED_CAST")
+            return javaGetter.invoke(null) as R
+        }
+        catch (e: IllegalAccessException) {
+            throw IllegalPropertyAccessException(e)
+        }
+    }
+
+    class Getter<out R>(override val property: KProperty0Impl<R>) : KPropertyImpl.Getter<R>, KProperty0.Getter<R> {
+        override fun invoke(): R = property.get()
+    }
+}
+
+open class KMutableProperty0Impl<R> : KProperty0Impl<R>, KMutableProperty0<R>, KMutablePropertyImpl<R> {
+    constructor(container: KCallableContainerImpl, name: String, signature: String) : super(container, name, signature)
+
+    override val setter by ReflectProperties.lazy { Setter(this) }
+
+    override val javaSetter: Method get() = super.javaSetter!!
+
+    override fun set(value: R) {
+        try {
+            javaSetter.invoke(null, value)
+        }
+        catch (e: IllegalAccessException) {
+            throw IllegalPropertyAccessException(e)
+        }
+    }
+
+    class Setter<R>(override val property: KMutableProperty0Impl<R>) : KMutablePropertyImpl.Setter<R>, KMutableProperty0.Setter<R> {
+        override fun invoke(value: R): Unit = property.set(value)
+    }
+}
+
+
+class KProperty0FromReferenceImpl(
+        val reference: PropertyReference0
+) : KProperty0Impl<Any?>(
+        reference.getOwner() as KCallableContainerImpl,
+        reference.getName(),
+        reference.getSignature()
+) {
+    override val name: String get() = reference.getName()
+
+    override fun get(): Any? = reference.get()
+}
+
+
+class KMutableProperty0FromReferenceImpl(
+        val reference: MutablePropertyReference0
+) : KMutableProperty0Impl<Any?>(
+        reference.getOwner() as KCallableContainerImpl,
+        reference.getName(),
+        reference.getSignature()
+) {
+    override val name: String get() = reference.getName()
+
+    override fun get(): Any? = reference.get()
+
+    override fun set(value: Any?) {
+        reference.set(value)
+    }
+}
diff --git a/core/reflection.jvm/src/kotlin/reflect/jvm/internal/KProperty1Impl.kt b/core/reflection.jvm/src/kotlin/reflect/jvm/internal/KProperty1Impl.kt
new file mode 100644
index 00000000000..a4bde8fcfd9
--- /dev/null
+++ b/core/reflection.jvm/src/kotlin/reflect/jvm/internal/KProperty1Impl.kt
@@ -0,0 +1,128 @@
+/*
+ * Copyright 2010-2015 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.reflect.jvm.internal
+
+import org.jetbrains.kotlin.descriptors.PropertyDescriptor
+import java.lang.reflect.Modifier
+import kotlin.jvm.internal.MutablePropertyReference1
+import kotlin.jvm.internal.PropertyReference1
+import kotlin.reflect.IllegalPropertyAccessException
+import kotlin.reflect.KMutableProperty1
+import kotlin.reflect.KProperty1
+
+open class KProperty1Impl<T, out R> : DescriptorBasedProperty, KProperty1<T, R>, KPropertyImpl<R> {
+    constructor(container: KCallableContainerImpl, name: String, signature: String) : super(container, name, signature)
+
+    constructor(container: KCallableContainerImpl, descriptor: PropertyDescriptor) : super(container, descriptor)
+
+    override val name: String get() = descriptor.getName().asString()
+
+    override val getter by ReflectProperties.lazy { Getter(this) }
+
+    // TODO: consider optimizing this, not to do complex checks on every access
+    @suppress("UNCHECKED_CAST")
+    override fun get(receiver: T): R {
+        try {
+            val getter = javaGetter ?:
+                         return javaField!!.get(receiver) as R
+
+            if (Modifier.isStatic(getter.getModifiers())) {
+                // Workaround the case of platformStatic property in object, getter of which doesn't take a receiver
+                if (getter.getParameterTypes().isEmpty()) {
+                    return getter.invoke(null) as R
+                }
+
+                return getter.invoke(null, receiver) as R
+            }
+
+            return getter.invoke(receiver) as R
+        }
+        catch (e: IllegalAccessException) {
+            throw IllegalPropertyAccessException(e)
+        }
+    }
+
+    class Getter<T, out R>(override val property: KProperty1Impl<T, R>) : KPropertyImpl.Getter<R>, KProperty1.Getter<T, R> {
+        override fun invoke(receiver: T): R = property.get(receiver)
+    }
+}
+
+
+open class KMutableProperty1Impl<T, R> : KProperty1Impl<T, R>, KMutableProperty1<T, R>, KMutablePropertyImpl<R> {
+    constructor(container: KCallableContainerImpl, name: String, signature: String) : super(container, name, signature)
+
+    constructor(container: KCallableContainerImpl, descriptor: PropertyDescriptor) : super(container, descriptor)
+
+    override val setter by ReflectProperties.lazy { Setter(this) }
+
+    override fun set(receiver: T, value: R) {
+        try {
+            val setter = javaSetter ?:
+                         return javaField!!.set(receiver, value)
+
+            if (Modifier.isStatic(setter.getModifiers())) {
+                // Workaround the case of platformStatic property in object, setter of which doesn't take a receiver
+                if (setter.getParameterTypes().size() == 1) {
+                    setter.invoke(null, value)
+                }
+                else {
+                    setter.invoke(null, receiver, value)
+                }
+            }
+            else {
+                setter.invoke(receiver, value)
+            }
+        }
+        catch (e: IllegalAccessException) {
+            throw IllegalPropertyAccessException(e)
+        }
+    }
+
+    class Setter<T, R>(override val property: KMutableProperty1Impl<T, R>) : KMutablePropertyImpl.Setter<R>, KMutableProperty1.Setter<T, R> {
+        override fun invoke(receiver: T, value: R): Unit = property.set(receiver, value)
+    }
+}
+
+
+class KProperty1FromReferenceImpl(
+        val reference: PropertyReference1
+) : KProperty1Impl<Any?, Any?>(
+        reference.getOwner() as KCallableContainerImpl,
+        reference.getName(),
+        reference.getSignature()
+) {
+    override val name: String get() = reference.getName()
+
+    override fun get(receiver: Any?): Any? = reference.get(receiver)
+}
+
+
+class KMutableProperty1FromReferenceImpl(
+        val reference: MutablePropertyReference1
+) : KMutableProperty1Impl<Any?, Any?>(
+        reference.getOwner() as KCallableContainerImpl,
+        reference.getName(),
+        reference.getSignature()
+) {
+    override val name: String get() = reference.getName()
+
+    override fun get(receiver: Any?): Any? = reference.get(receiver)
+
+    override fun set(receiver: Any?, value: Any?) {
+        reference.set(receiver, value)
+    }
+}
diff --git a/core/reflection.jvm/src/kotlin/reflect/jvm/internal/KProperty2Impl.kt b/core/reflection.jvm/src/kotlin/reflect/jvm/internal/KProperty2Impl.kt
new file mode 100644
index 00000000000..02de0088c96
--- /dev/null
+++ b/core/reflection.jvm/src/kotlin/reflect/jvm/internal/KProperty2Impl.kt
@@ -0,0 +1,76 @@
+/*
+ * Copyright 2010-2015 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.reflect.jvm.internal
+
+import org.jetbrains.kotlin.descriptors.PropertyDescriptor
+import java.lang.reflect.Field
+import java.lang.reflect.Method
+import kotlin.reflect.IllegalPropertyAccessException
+import kotlin.reflect.KMutableProperty2
+import kotlin.reflect.KProperty2
+
+open class KProperty2Impl<D, E, out R> : DescriptorBasedProperty, KProperty2<D, E, R>, KPropertyImpl<R> {
+    constructor(container: KClassImpl<D>, name: String, signature: String) : super(container, name, signature)
+
+    constructor(container: KClassImpl<D>, descriptor: PropertyDescriptor) : super(container, descriptor)
+
+    override val name: String get() = descriptor.getName().asString()
+
+    override val getter by ReflectProperties.lazy { Getter(this) }
+
+    override val javaGetter: Method get() = super.javaGetter!!
+
+    override val javaField: Field? get() = null
+
+    override fun get(receiver1: D, receiver2: E): R {
+        try {
+            @suppress("UNCHECKED_CAST")
+            return javaGetter.invoke(receiver1, receiver2) as R
+        }
+        catch (e: IllegalAccessException) {
+            throw IllegalPropertyAccessException(e)
+        }
+    }
+
+    class Getter<D, E, out R>(override val property: KProperty2Impl<D, E, R>) : KPropertyImpl.Getter<R>, KProperty2.Getter<D, E, R> {
+        override fun invoke(receiver1: D, receiver2: E): R = property.get(receiver1, receiver2)
+    }
+}
+
+
+class KMutableProperty2Impl<D, E, R> : KProperty2Impl<D, E, R>, KMutableProperty2<D, E, R>, KMutablePropertyImpl<R> {
+    constructor(container: KClassImpl<D>, name: String, signature: String) : super(container, name, signature)
+
+    constructor(container: KClassImpl<D>, descriptor: PropertyDescriptor) : super(container, descriptor)
+
+    override val setter by ReflectProperties.lazy { Setter(this) }
+
+    override val javaSetter: Method get() = super.javaSetter!!
+
+    override fun set(receiver1: D, receiver2: E, value: R) {
+        try {
+            javaSetter.invoke(receiver1, receiver2, value)
+        }
+        catch (e: IllegalAccessException) {
+            throw IllegalPropertyAccessException(e)
+        }
+    }
+
+    class Setter<D, E, R>(override val property: KMutableProperty2Impl<D, E, R>) : KMutablePropertyImpl.Setter<R>, KMutableProperty2.Setter<D, E, R> {
+        override fun invoke(receiver1: D, receiver2: E, value: R): Unit = property.set(receiver1, receiver2, value)
+    }
+}
diff --git a/core/reflection.jvm/src/kotlin/reflect/jvm/internal/KPropertyImpl.kt b/core/reflection.jvm/src/kotlin/reflect/jvm/internal/KPropertyImpl.kt
index 42843629643..cca0803d778 100644
--- a/core/reflection.jvm/src/kotlin/reflect/jvm/internal/KPropertyImpl.kt
+++ b/core/reflection.jvm/src/kotlin/reflect/jvm/internal/KPropertyImpl.kt
@@ -19,13 +19,29 @@ package kotlin.reflect.jvm.internal
 import java.lang.reflect.*
 import kotlin.reflect.*
 
-trait KPropertyImpl<out R> : KProperty<R>, KCallableImpl<R> {
-    val field: Field?
+interface KPropertyImpl<out R> : KProperty<R>, KCallableImpl<R> {
+    val javaField: Field?
 
-    val getter: Method?
+    val javaGetter: Method?
+
+    override val getter: Getter<R>
+
+    interface Accessor<out R> : KProperty.Accessor<R> {
+        override val property: KPropertyImpl<R>
+    }
+
+    interface Getter<out R> : KProperty.Getter<R>, KCallableImpl<R> {
+        override val name: String get() = "<get-${property.name}>"
+    }
 }
 
 
-trait KMutablePropertyImpl<R> : KMutableProperty<R>, KPropertyImpl<R> {
-    val setter: Method?
+interface KMutablePropertyImpl<R> : KMutableProperty<R>, KPropertyImpl<R> {
+    val javaSetter: Method?
+
+    override val setter: Setter<R>
+
+    interface Setter<R> : KMutableProperty.Setter<R>, KPropertyImpl.Accessor<R>, KCallableImpl<Unit> {
+        override val name: String get() = "<set-${property.name}>"
+    }
 }
diff --git a/core/reflection.jvm/src/kotlin/reflect/jvm/internal/KTopLevelExtensionPropertyImpl.kt b/core/reflection.jvm/src/kotlin/reflect/jvm/internal/KTopLevelExtensionPropertyImpl.kt
deleted file mode 100644
index bae24330fce..00000000000
--- a/core/reflection.jvm/src/kotlin/reflect/jvm/internal/KTopLevelExtensionPropertyImpl.kt
+++ /dev/null
@@ -1,58 +0,0 @@
-/*
- * Copyright 2010-2015 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.reflect.jvm.internal
-
-import java.lang.reflect.Method
-import kotlin.reflect.IllegalPropertyAccessException
-import kotlin.reflect.KMutableTopLevelExtensionProperty
-import kotlin.reflect.KTopLevelExtensionProperty
-
-open class KTopLevelExtensionPropertyImpl<T, out R> : DescriptorBasedProperty, KTopLevelExtensionProperty<T, R>, KPropertyImpl<R> {
-    constructor(container: KPackageImpl, name: String, receiverParameterClass: Class<T>) : super(container, name, receiverParameterClass)
-
-    override val name: String get() = descriptor.getName().asString()
-
-    override val getter: Method get() = super<DescriptorBasedProperty>.getter!!
-
-    override fun get(receiver: T): R {
-        try {
-            @suppress("UNCHECKED_CAST")
-            return getter.invoke(null, receiver) as R
-        }
-        catch (e: IllegalAccessException) {
-            throw IllegalPropertyAccessException(e)
-        }
-    }
-}
-
-class KMutableTopLevelExtensionPropertyImpl<T, R> :
-        KTopLevelExtensionPropertyImpl<T, R>,
-        KMutableTopLevelExtensionProperty<T, R>,
-        KMutablePropertyImpl<R> {
-    constructor(container: KPackageImpl, name: String, receiverParameterClass: Class<T>) : super(container, name, receiverParameterClass)
-
-    override val setter: Method get() = super<KTopLevelExtensionPropertyImpl>.setter!!
-
-    override fun set(receiver: T, value: R) {
-        try {
-            setter.invoke(null, receiver, value)
-        }
-        catch (e: IllegalAccessException) {
-            throw IllegalPropertyAccessException(e)
-        }
-    }
-}
diff --git a/core/reflection.jvm/src/kotlin/reflect/jvm/internal/KTopLevelVariableImpl.kt b/core/reflection.jvm/src/kotlin/reflect/jvm/internal/KTopLevelVariableImpl.kt
deleted file mode 100644
index b1758677721..00000000000
--- a/core/reflection.jvm/src/kotlin/reflect/jvm/internal/KTopLevelVariableImpl.kt
+++ /dev/null
@@ -1,55 +0,0 @@
-/*
- * Copyright 2010-2015 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.reflect.jvm.internal
-
-import java.lang.reflect.Method
-import kotlin.reflect.IllegalPropertyAccessException
-import kotlin.reflect.KMutableTopLevelVariable
-import kotlin.reflect.KTopLevelVariable
-
-open class KTopLevelVariableImpl<out R> : DescriptorBasedProperty, KTopLevelVariable<R>, KVariableImpl<R> {
-    constructor(container: KPackageImpl, name: String) : super(container, name, null)
-
-    override val name: String get() = descriptor.getName().asString()
-
-    override val getter: Method get() = super<DescriptorBasedProperty>.getter!!
-
-    override fun get(): R {
-        try {
-            @suppress("UNCHECKED_CAST")
-            return getter.invoke(null) as R
-        }
-        catch (e: IllegalAccessException) {
-            throw IllegalPropertyAccessException(e)
-        }
-    }
-}
-
-class KMutableTopLevelVariableImpl<R> : KTopLevelVariableImpl<R>, KMutableTopLevelVariable<R>, KMutableVariableImpl<R> {
-    constructor(container: KPackageImpl, name: String) : super(container, name)
-
-    override val setter: Method get() = super<KTopLevelVariableImpl>.setter!!
-
-    override fun set(value: R) {
-        try {
-            setter.invoke(null, value)
-        }
-        catch (e: IllegalAccessException) {
-            throw IllegalPropertyAccessException(e)
-        }
-    }
-}
diff --git a/core/reflection.jvm/src/kotlin/reflect/jvm/internal/ReflectionFactoryImpl.java b/core/reflection.jvm/src/kotlin/reflect/jvm/internal/ReflectionFactoryImpl.java
index 59fbdc4b56b..27f730367ef 100644
--- a/core/reflection.jvm/src/kotlin/reflect/jvm/internal/ReflectionFactoryImpl.java
+++ b/core/reflection.jvm/src/kotlin/reflect/jvm/internal/ReflectionFactoryImpl.java
@@ -16,8 +16,8 @@
 
 package kotlin.reflect.jvm.internal;
 
-import kotlin.jvm.internal.FunctionReference;
-import kotlin.jvm.internal.ReflectionFactory;
+import kotlin.jvm.KotlinReflectionNotSupportedError;
+import kotlin.jvm.internal.*;
 import kotlin.reflect.*;
 
 /**
@@ -44,38 +44,52 @@ public class ReflectionFactoryImpl extends ReflectionFactory {
 
     @Override
     public KFunction function(FunctionReference f) {
-        return f;
+        try {
+            return new KFunctionFromReferenceImpl(f);
+        }
+        catch (KotlinReflectionNotSupportedError e) {
+            // If this function reference is compiled with an older compiler, it doesn't have the newer methods
+            // (getName(), getOwner(), getSignature()), so the default implementation from FunctionReference will be invoked
+            // and KotlinReflectionNotSupportedError will be thrown.
+            // Instead it's much better to use the reference as a KFunction. Yes, it will throw "no kotlin-reflect.jar was found"
+            // exceptions even if it exists in the classpath. However, at least it can be used as a function (invoke() will work).
+            // Moreover, old function references were not supposed to be introspected anyway because there was no reflection API back then.
+            // TODO: drop after M13
+            return f;
+        }
     }
 
     // Properties
 
     @Override
-    public KMemberProperty memberProperty(String name, KClass owner) {
-        return ((KClassImpl) owner).memberProperty(name);
+    public KProperty0 property0(PropertyReference0 p) {
+        return new KProperty0FromReferenceImpl(p);
     }
 
     @Override
-    public KMutableMemberProperty mutableMemberProperty(String name, KClass owner) {
-        return ((KClassImpl) owner).mutableMemberProperty(name);
+    public KMutableProperty0 mutableProperty0(MutablePropertyReference0 p) {
+        return new KMutableProperty0FromReferenceImpl(p);
     }
 
     @Override
-    public KTopLevelVariable topLevelVariable(String name, KPackage owner) {
-        return ((KPackageImpl) owner).topLevelVariable(name);
+    public KProperty1 property1(PropertyReference1 p) {
+        return new KProperty1FromReferenceImpl(p);
     }
 
     @Override
-    public KMutableTopLevelVariable mutableTopLevelVariable(String name, KPackage owner) {
-        return ((KPackageImpl) owner).mutableTopLevelVariable(name);
+    public KMutableProperty1 mutableProperty1(MutablePropertyReference1 p) {
+        return new KMutableProperty1FromReferenceImpl(p);
     }
 
     @Override
-    public KTopLevelExtensionProperty topLevelExtensionProperty(String name, KPackage owner, Class receiver) {
-        return ((KPackageImpl) owner).topLevelExtensionProperty(name, receiver);
+    public KProperty2 property2(PropertyReference2 p) {
+        // TODO: support member extension property references
+        return p;
     }
 
     @Override
-    public KMutableTopLevelExtensionProperty mutableTopLevelExtensionProperty(String name, KPackage owner, Class receiver) {
-        return ((KPackageImpl) owner).mutableTopLevelExtensionProperty(name, receiver);
+    public KMutableProperty2 mutableProperty2(MutablePropertyReference2 p) {
+        // TODO: support member extension property references
+        return p;
     }
 }
diff --git a/core/reflection.jvm/src/kotlin/reflect/jvm/internal/ReflectionObjectRenderer.kt b/core/reflection.jvm/src/kotlin/reflect/jvm/internal/ReflectionObjectRenderer.kt
index f4eda03bdba..ea104dfeb8d 100644
--- a/core/reflection.jvm/src/kotlin/reflect/jvm/internal/ReflectionObjectRenderer.kt
+++ b/core/reflection.jvm/src/kotlin/reflect/jvm/internal/ReflectionObjectRenderer.kt
@@ -16,6 +16,8 @@
 
 package kotlin.reflect.jvm.internal
 
+import org.jetbrains.kotlin.descriptors.CallableDescriptor
+import org.jetbrains.kotlin.descriptors.FunctionDescriptor
 import org.jetbrains.kotlin.descriptors.PropertyDescriptor
 import org.jetbrains.kotlin.descriptors.ReceiverParameterDescriptor
 import org.jetbrains.kotlin.renderer.DescriptorRenderer
@@ -23,29 +25,46 @@ import org.jetbrains.kotlin.renderer.DescriptorRenderer
 object ReflectionObjectRenderer {
     private val renderer = DescriptorRenderer.FQ_NAMES_IN_TYPES
 
+    private fun StringBuilder.appendReceiverType(receiver: ReceiverParameterDescriptor?) {
+        if (receiver != null) {
+            append(renderer.renderType(receiver.getType()))
+            append(".")
+        }
+    }
+
+    private fun StringBuilder.appendReceiversAndName(callable: CallableDescriptor) {
+        val dispatchReceiver = callable.getDispatchReceiverParameter()
+        val extensionReceiver = callable.getExtensionReceiverParameter()
+
+        appendReceiverType(dispatchReceiver)
+
+        val addParentheses = dispatchReceiver != null && extensionReceiver != null
+        if (addParentheses) append("(")
+        appendReceiverType(extensionReceiver)
+        if (addParentheses) append(")")
+
+        append(renderer.renderName(callable.getName()))
+    }
+
     // TODO: include visibility, return type
     fun renderProperty(descriptor: PropertyDescriptor): String {
-        fun StringBuilder.appendReceiverType(receiver: ReceiverParameterDescriptor?) {
-            if (receiver != null) {
-                append(renderer.renderType(receiver.getType()))
-                append(".")
-            }
-        }
-
         return StringBuilder {
             append(if (descriptor.isVar()) "var " else "val ")
+            appendReceiversAndName(descriptor)
+        }.toString()
+    }
 
-            val dispatchReceiver = descriptor.getDispatchReceiverParameter()
-            val extensionReceiver = descriptor.getExtensionReceiverParameter()
+    fun renderFunction(descriptor: FunctionDescriptor): String {
+        return StringBuilder {
+            append("fun ")
+            appendReceiversAndName(descriptor)
 
-            appendReceiverType(dispatchReceiver)
+            descriptor.getValueParameters().joinTo(this, separator = ", ", prefix = "(", postfix = ")") {
+                renderer.renderType(it.getType()) // TODO: vararg
+            }
 
-            val addParentheses = dispatchReceiver != null && extensionReceiver != null
-            if (addParentheses) append("(")
-            appendReceiverType(extensionReceiver)
-            if (addParentheses) append(")")
-
-            append(renderer.renderName(descriptor.getName()))
+            append(": ")
+            append(renderer.renderType(descriptor.getReturnType()!!))
         }.toString()
     }
 }
diff --git a/core/reflection.jvm/src/kotlin/reflect/jvm/internal/RuntimeTypeMapper.kt b/core/reflection.jvm/src/kotlin/reflect/jvm/internal/RuntimeTypeMapper.kt
index 5070f927b96..4a960067e1e 100644
--- a/core/reflection.jvm/src/kotlin/reflect/jvm/internal/RuntimeTypeMapper.kt
+++ b/core/reflection.jvm/src/kotlin/reflect/jvm/internal/RuntimeTypeMapper.kt
@@ -18,48 +18,114 @@ package kotlin.reflect.jvm.internal
 
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns
 import org.jetbrains.kotlin.builtins.PrimitiveType
-import org.jetbrains.kotlin.descriptors.ClassDescriptor
-import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor
-import org.jetbrains.kotlin.load.java.structure.reflect.classId
+import org.jetbrains.kotlin.descriptors.FunctionDescriptor
+import org.jetbrains.kotlin.descriptors.PropertyDescriptor
+import org.jetbrains.kotlin.load.java.JvmAbi
+import org.jetbrains.kotlin.load.java.descriptors.JavaMethodDescriptor
+import org.jetbrains.kotlin.load.java.descriptors.JavaPropertyDescriptor
+import org.jetbrains.kotlin.load.java.sources.JavaSourceElement
+import org.jetbrains.kotlin.load.java.structure.*
+import org.jetbrains.kotlin.load.java.structure.reflect.*
+import org.jetbrains.kotlin.load.kotlin.SignatureDeserializer
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.platform.JavaToKotlinClassMap
-import org.jetbrains.kotlin.resolve.DescriptorUtils
 import org.jetbrains.kotlin.resolve.descriptorUtil.classId
-import org.jetbrains.kotlin.resolve.jvm.JvmClassName
 import org.jetbrains.kotlin.resolve.jvm.JvmPrimitiveType
-import org.jetbrains.kotlin.types.JetType
-import org.jetbrains.kotlin.types.TypeUtils
+import org.jetbrains.kotlin.serialization.deserialization.descriptors.DeserializedPropertyDescriptor
+import org.jetbrains.kotlin.serialization.deserialization.descriptors.DeserializedSimpleFunctionDescriptor
+import org.jetbrains.kotlin.serialization.jvm.JvmProtoBuf
+import kotlin.reflect.KotlinReflectionInternalError
 
 object RuntimeTypeMapper {
-    // TODO: this logic must be shared with JetTypeMapper
-    fun mapTypeToJvmDesc(type: JetType): String {
-        val classifier = type.getConstructor().getDeclarationDescriptor()
-        if (classifier is TypeParameterDescriptor) {
-            return mapTypeToJvmDesc(classifier.getUpperBounds().first())
+    fun mapSignature(function: FunctionDescriptor): String {
+        if (function is DeserializedSimpleFunctionDescriptor) {
+            val proto = function.getProto()
+            if (!proto.hasExtension(JvmProtoBuf.methodSignature)) {
+                throw KotlinReflectionInternalError("No metadata found for $function")
+            }
+            val signature = proto.getExtension(JvmProtoBuf.methodSignature)
+            return SignatureDeserializer(function.getNameResolver()).methodSignatureString(signature)
         }
+        else if (function is JavaMethodDescriptor) {
+            val method = (function.getSource() as? JavaSourceElement)?.javaElement as? JavaMethod ?:
+                         throw KotlinReflectionInternalError("Incorrect resolution sequence for Java method $function")
 
-        if (KotlinBuiltIns.isArray(type)) {
-            val elementType = KotlinBuiltIns.getInstance().getArrayElementType(type)
-            // makeNullable is called here to map primitive types to the corresponding wrappers,
-            // because the given type is Array<Something>, not SomethingArray
-            return "[" + mapTypeToJvmDesc(TypeUtils.makeNullable(elementType))
+            return StringBuilder {
+                append(method.getName().asString())
+
+                append("(")
+                for (parameter in method.getValueParameters()) {
+                    appendJavaType(parameter.getType())
+                }
+                append(")")
+
+                appendJavaType(method.getReturnType())
+            }.toString()
         }
+        else throw KotlinReflectionInternalError("Unknown origin of $function (${function.javaClass})")
+    }
 
-        val classDescriptor = classifier as ClassDescriptor
-        val fqName = DescriptorUtils.getFqName(classDescriptor)
-
-        KotlinBuiltIns.getPrimitiveTypeByFqName(fqName)?.let { primitiveType ->
-            val jvmType = JvmPrimitiveType.get(primitiveType)
-            return if (TypeUtils.isNullableType(type)) ClassId.topLevel(jvmType.getWrapperFqName()).desc else jvmType.getDesc()
+    // TODO: verify edge cases when it's possible to reference generic functions
+    private tailRecursive fun StringBuilder.appendJavaType(type: JavaType) {
+        when (type) {
+            is JavaPrimitiveType -> {
+                append(type.getType()?.let { JvmPrimitiveType.get(it).getDesc() } ?: "V")
+            }
+            is JavaArrayType -> {
+                append("[")
+                appendJavaType(type.getComponentType())
+            }
+            is JavaWildcardType -> {
+                val bound = type.getBound()
+                if (bound != null && type.isExtends()) appendJavaType(bound)
+                else append("Ljava/lang/Object;")
+            }
+            is JavaClassifierType -> {
+                val classifier = type.getClassifier()
+                when (classifier) {
+                    is ReflectJavaClass ->
+                        append(classifier.element.desc)
+                    is ReflectJavaTypeParameter ->
+                        appendJavaType(ReflectJavaType.create(classifier.typeVariable.getBounds().first()))
+                }
+            }
         }
+    }
 
-        KotlinBuiltIns.getPrimitiveTypeByArrayClassFqName(fqName)?.let { primitiveType ->
-            return "[" + JvmPrimitiveType.get(primitiveType).getDesc()
+    fun mapPropertySignature(property: PropertyDescriptor): String {
+        if (property is DeserializedPropertyDescriptor) {
+            val proto = property.proto
+            val nameResolver = property.nameResolver
+            if (!proto.hasExtension(JvmProtoBuf.propertySignature)) {
+                throw KotlinReflectionInternalError("No metadata found for $property")
+            }
+            val signature = proto.getExtension(JvmProtoBuf.propertySignature)
+            val deserializer = SignatureDeserializer(nameResolver)
+
+            if (signature.hasGetter()) {
+                return deserializer.methodSignatureString(signature.getGetter())
+            }
+
+            // In case the property doesn't have a getter, construct the signature of its imaginary default getter.
+            // See PropertyReference#getSignature
+            val field = signature.getField()
+
+            // TODO: some kind of test on the Java Bean convention?
+            return JvmAbi.getterName(nameResolver.getString(field.getName())) +
+                   "()" +
+                   deserializer.typeDescriptor(field.getType())
         }
+        else if (property is JavaPropertyDescriptor) {
+            val method = (property.getSource() as? JavaSourceElement)?.javaElement as? JavaField ?:
+                         throw KotlinReflectionInternalError("Incorrect resolution sequence for Java field $property")
 
-        JavaToKotlinClassMap.INSTANCE.mapKotlinToJava(fqName)?.let { return it.desc }
-
-        return classDescriptor.classId.desc
+            return StringBuilder {
+                append(JvmAbi.getterName(method.getName().asString()))
+                append("()")
+                appendJavaType(method.getType())
+            }.toString()
+        }
+        else throw KotlinReflectionInternalError("Unknown origin of $property (${property.javaClass})")
     }
 
     fun mapJvmClassToKotlinClassId(klass: Class<*>): ClassId {
@@ -84,7 +150,4 @@ object RuntimeTypeMapper {
 
     private val Class<*>.primitiveType: PrimitiveType?
         get() = if (isPrimitive()) JvmPrimitiveType.get(getSimpleName()).getPrimitiveType() else null
-
-    private val ClassId.desc: String
-        get() = "L${JvmClassName.byClassId(this).getInternalName()};"
 }
diff --git a/core/reflection.jvm/src/kotlin/reflect/jvm/mapping.kt b/core/reflection.jvm/src/kotlin/reflect/jvm/mapping.kt
index e29e44245e5..9ba00c2bb24 100644
--- a/core/reflection.jvm/src/kotlin/reflect/jvm/mapping.kt
+++ b/core/reflection.jvm/src/kotlin/reflect/jvm/mapping.kt
@@ -41,60 +41,28 @@ public val KPackage.javaFacade: Class<*>
     get() = (this as KPackageImpl).jClass
 
 
+/**
+ * Returns a Java [Field] instance corresponding to the backing field of the given property,
+ * or `null` if the property has no backing field.
+ */
+public val KProperty<*>.javaField: Field?
+    get() = (this as KPropertyImpl<*>).javaField
+
 /**
  * Returns a Java [Method] instance corresponding to the getter of the given property,
  * or `null` if the property has no getter, for example in case of a simple private `val` in a class.
  */
 public val KProperty<*>.javaGetter: Method?
-    get() = (this as? KPropertyImpl<*>)?.getter
+    get() = (this as? KPropertyImpl<*>)?.javaGetter
 
 /**
  * Returns a Java [Method] instance corresponding to the setter of the given mutable property,
  * or `null` if the property has no setter, for example in case of a simple private `var` in a class.
  */
 public val KMutableProperty<*>.javaSetter: Method?
-    get() = (this as? KMutablePropertyImpl<*>)?.setter
+    get() = (this as? KMutablePropertyImpl<*>)?.javaSetter
 
 
-/**
- * Returns a Java [Field] instance corresponding to the backing field of the given top level property,
- * or `null` if the property has no backing field.
- */
-public val KTopLevelVariable<*>.javaField: Field?
-    get() = (this as KPropertyImpl<*>).field
-
-/**
- * Returns a Java [Method] instance corresponding to the getter of the given top level property.
- */
-public val KTopLevelVariable<*>.javaGetter: Method
-    get() = (this as KTopLevelVariableImpl<*>).getter
-
-/**
- * Returns a Java [Method] instance corresponding to the setter of the given top level property.
- */
-public val KMutableTopLevelVariable<*>.javaSetter: Method
-    get() = (this as KMutableTopLevelVariableImpl<*>).setter
-
-
-/**
- * Returns a Java [Method] instance corresponding to the getter of the given top level extension property.
- */
-public val KTopLevelExtensionProperty<*, *>.javaGetter: Method
-    get() = (this as KTopLevelExtensionPropertyImpl<*, *>).getter
-
-/**
- * Returns a Java [Method] instance corresponding to the setter of the given top level extension property.
- */
-public val KMutableTopLevelExtensionProperty<*, *>.javaSetter: Method
-    get() = (this as KMutableTopLevelExtensionPropertyImpl<*, *>).setter
-
-
-/**
- * Returns a Java [Field] instance corresponding to the backing field of the given member property,
- * or `null` if the property has no backing field.
- */
-public val KMemberProperty<*, *>.javaField: Field?
-    get() = (this as KPropertyImpl<*>).field
 
 
 // Java reflection -> Kotlin reflection
@@ -127,17 +95,10 @@ public val Field.kotlin: KProperty<*>?
     get() {
         if (isSynthetic()) return null
 
-        val clazz = getDeclaringClass()
-        val name = getName()
-        val modifiers = getModifiers()
-        val static = Modifier.isStatic(modifiers)
-        val final = Modifier.isFinal(modifiers)
-        if (static) {
-            val kPackage = clazz.kotlinPackage
-            return if (final) Reflection.topLevelVariable(name, kPackage) else Reflection.mutableTopLevelVariable(name, kPackage)
-        }
-        else {
-            val kClass = clazz.kotlin
-            return if (final) Reflection.memberProperty(name, kClass) else Reflection.mutableMemberProperty(name, kClass)
+        val clazz = getDeclaringClass().kotlin as KClassImpl
+
+        // TODO: optimize (search by name)
+        return clazz.properties.firstOrNull { p: KProperty<*> ->
+            (p as KPropertyImpl<*>).javaField == this
         }
     }
diff --git a/core/reflection.jvm/src/kotlin/reflect/jvm/properties.kt b/core/reflection.jvm/src/kotlin/reflect/jvm/properties.kt
index 093aa963fa4..d3b40bc1b31 100644
--- a/core/reflection.jvm/src/kotlin/reflect/jvm/properties.kt
+++ b/core/reflection.jvm/src/kotlin/reflect/jvm/properties.kt
@@ -17,8 +17,8 @@
 package kotlin.reflect.jvm
 
 import kotlin.reflect.KProperty
-import kotlin.reflect.jvm.internal.KMemberPropertyImpl
-import kotlin.reflect.jvm.internal.KMutableMemberPropertyImpl
+import kotlin.reflect.jvm.internal.KMutablePropertyImpl
+import kotlin.reflect.jvm.internal.KPropertyImpl
 
 /**
  * Provides a way to suppress JVM access checks for a property.
@@ -34,29 +34,27 @@ import kotlin.reflect.jvm.internal.KMutableMemberPropertyImpl
 public var <R> KProperty<R>.accessible: Boolean
         get() {
             return when (this) {
-                is KMutableMemberPropertyImpl<*, R> ->
-                        field?.isAccessible() ?: true &&
-                        getter?.isAccessible() ?: true &&
-                        setter?.isAccessible() ?: true
-                is KMemberPropertyImpl<*, R> ->
-                        field?.isAccessible() ?: true &&
-                        getter?.isAccessible() ?: true
-                else -> {
-                    // Non-member properties always have public visibility on JVM, thus accessible has no effect on them
-                    true
-                }
+                is KMutablePropertyImpl<R> ->
+                        javaField?.isAccessible() ?: true &&
+                        javaGetter?.isAccessible() ?: true &&
+                        javaSetter?.isAccessible() ?: true
+                is KPropertyImpl<R> ->
+                        javaField?.isAccessible() ?: true &&
+                        javaGetter?.isAccessible() ?: true
+                else -> throw UnsupportedOperationException("Unknown property: $this ($javaClass)")
             }
         }
         set(value) {
             when (this) {
-                is KMutableMemberPropertyImpl<*, R> -> {
-                    field?.setAccessible(value)
-                    getter?.setAccessible(value)
-                    setter?.setAccessible(value)
+                is KMutablePropertyImpl<R> -> {
+                    javaField?.setAccessible(value)
+                    javaGetter?.setAccessible(value)
+                    javaSetter?.setAccessible(value)
                 }
-                is KMemberPropertyImpl<*, R> -> {
-                    field?.setAccessible(value)
-                    getter?.setAccessible(value)
+                is KPropertyImpl<R> -> {
+                    javaField?.setAccessible(value)
+                    javaGetter?.setAccessible(value)
                 }
+                else -> throw UnsupportedOperationException("Unknown property: $this ($javaClass)")
             }
         }
diff --git a/core/runtime.jvm/runtime.jvm.iml b/core/runtime.jvm/runtime.jvm.iml
index b5df517c6fb..7ce21791fb6 100644
--- a/core/runtime.jvm/runtime.jvm.iml
+++ b/core/runtime.jvm/runtime.jvm.iml
@@ -2,7 +2,9 @@
 <module type="JAVA_MODULE" version="4">
   <component name="NewModuleRootManager" inherit-compiler-output="true">
     <exclude-output />
-    <content url="file://$MODULE_DIR$" />
+    <content url="file://$MODULE_DIR$">
+      <sourceFolder url="file://$MODULE_DIR$/src" isTestSource="false" />
+    </content>
     <orderEntry type="inheritedJdk" />
     <orderEntry type="sourceFolder" forTests="false" />
     <orderEntry type="module" module-name="builtins" />
diff --git a/core/runtime.jvm/src/kotlin/jvm/PurelyImplements.kt b/core/runtime.jvm/src/kotlin/jvm/PurelyImplements.kt
new file mode 100644
index 00000000000..3f0d061d69f
--- /dev/null
+++ b/core/runtime.jvm/src/kotlin/jvm/PurelyImplements.kt
@@ -0,0 +1,37 @@
+/*
+ * Copyright 2010-2015 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
+
+/**
+ * Instructs the Kotlin compiler to treat annotated Java class as pure implementation of given Kotlin interface.
+ * "Pure" means here that each type parameter of class becomes non-platform type argument of that interface.
+ *
+ * Example:
+ *
+ * class MyList<T> extends AbstractList<T> { ... }
+ *
+ * Methods defined in MyList<T> use T as platform, i.e. it's possible to perform unsafe operation in Kotlin:
+ *  MyList<Int>().add(null) // compiles
+ *
+ * @PurelyImplements("kotlin.MutableList")
+ * class MyPureList<T> extends AbstractList<T> { ... }
+ *
+ * Methods defined in MyPureList<T> overriding methods in MutableList use T as non-platform types:
+ *  MyList<Int>().add(null) // Error
+ *  MyList<Int?>().add(null) // Ok
+ */
+public annotation class PurelyImplements(public val value: String)
diff --git a/core/runtime.jvm/src/kotlin/jvm/internal/CallableReference.java b/core/runtime.jvm/src/kotlin/jvm/internal/CallableReference.java
new file mode 100644
index 00000000000..d0bb16a299b
--- /dev/null
+++ b/core/runtime.jvm/src/kotlin/jvm/internal/CallableReference.java
@@ -0,0 +1,68 @@
+/*
+ * Copyright 2010-2015 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.internal;
+
+import kotlin.jvm.KotlinReflectionNotSupportedError;
+import kotlin.reflect.KCallable;
+import kotlin.reflect.KDeclarationContainer;
+
+/**
+ * A superclass for all classes generated by Kotlin compiler for callable references.
+ *
+ * All methods from reflection API should be implemented here to throw informative exceptions (see KotlinReflectionNotSupportedError)
+ */
+public abstract class CallableReference implements KCallable {
+
+    // The following methods provide the information identifying this callable, which is used by the reflection implementation.
+    // They are supposed to be overridden in each subclass (each anonymous class generated for a callable reference).
+
+    /**
+     * @return the class or package where the callable should be located, usually specified on the LHS of the '::' operator
+     */
+    public KDeclarationContainer getOwner() {
+        throw error();
+    }
+
+    /**
+     * @return Kotlin name of the callable, the one which was declared in the source code (@platformName doesn't change it)
+     */
+    @Override
+    public String getName() {
+        throw error();
+    }
+
+    /**
+     * @return JVM signature of the callable, e.g. "println(Ljava/lang/Object;)V". If this is a property reference,
+     * returns the JVM signature of its getter, e.g. "getFoo(Ljava/lang/String;)I". If the property has no getter in the bytecode
+     * (e.g. private property in a class), it's still the signature of the imaginary default getter that would be generated otherwise.
+     *
+     * Note that technically the signature itself is not even used as a signature per se in reflection implementation,
+     * but only as a unique and unambiguous way to map a function/property descriptor to a string.
+     */
+    public String getSignature() {
+        throw error();
+    }
+
+    // The following methods are the stub implementations of reflection functions.
+    // They are called when you're using reflection on a property reference without the reflection implementation in the classpath.
+
+    // (nothing here yet)
+
+    protected static Error error() {
+        throw new KotlinReflectionNotSupportedError();
+    }
+}
diff --git a/core/runtime.jvm/src/kotlin/jvm/internal/FunctionReference.java b/core/runtime.jvm/src/kotlin/jvm/internal/FunctionReference.java
index 32d6e321a45..bdf895a0a43 100644
--- a/core/runtime.jvm/src/kotlin/jvm/internal/FunctionReference.java
+++ b/core/runtime.jvm/src/kotlin/jvm/internal/FunctionReference.java
@@ -16,11 +16,14 @@
 
 package kotlin.jvm.internal;
 
+import kotlin.jvm.KotlinReflectionNotSupportedError;
 import kotlin.reflect.*;
 
-public abstract class FunctionReference
+@SuppressWarnings("deprecation")
+public class FunctionReference
         extends FunctionImpl
-        implements KTopLevelFunction,
+        implements KFunction,
+                   KTopLevelFunction,
                    KMemberFunction,
                    KTopLevelExtensionFunction,
                    KLocalFunction {
@@ -39,4 +42,23 @@ public abstract class FunctionReference
     public int getArity() {
         return arity;
     }
+
+    // Most of the following methods are copies from CallableReference, since this class cannot inherit from it
+
+    public KDeclarationContainer getOwner() {
+        throw error();
+    }
+
+    @Override
+    public String getName() {
+        throw error();
+    }
+
+    public String getSignature() {
+        throw error();
+    }
+
+    protected static Error error() {
+        throw new KotlinReflectionNotSupportedError();
+    }
 }
diff --git a/core/runtime.jvm/src/kotlin/jvm/internal/KotlinClass.java b/core/runtime.jvm/src/kotlin/jvm/internal/KotlinClass.java
index 8efd073d8f3..cf67e5352cc 100644
--- a/core/runtime.jvm/src/kotlin/jvm/internal/KotlinClass.java
+++ b/core/runtime.jvm/src/kotlin/jvm/internal/KotlinClass.java
@@ -23,7 +23,7 @@ import java.lang.annotation.RetentionPolicy;
 public @interface KotlinClass {
     int abiVersion();
 
-    Kind kind();
+    Kind kind() default Kind.CLASS;
 
     String[] data();
 
@@ -31,7 +31,7 @@ public @interface KotlinClass {
         CLASS,
 
         /**
-         * A class has this kind if and only if its first non-class container is not a package.
+         * A class has kind LOCAL_CLASS if and only if it's not an anonymous object and its first non-class container is not a package.
          */
         LOCAL_CLASS,
 
diff --git a/core/runtime.jvm/src/kotlin/jvm/internal/Lambda.kt b/core/runtime.jvm/src/kotlin/jvm/internal/Lambda.kt
index 59e857a5b10..a8b68232083 100644
--- a/core/runtime.jvm/src/kotlin/jvm/internal/Lambda.kt
+++ b/core/runtime.jvm/src/kotlin/jvm/internal/Lambda.kt
@@ -19,5 +19,6 @@ package kotlin.jvm.internal
 public abstract class Lambda(private val arity: Int) : FunctionImpl() {
     override fun getArity() = arity
 
+    @suppress("PLATFORM_CLASS_MAPPED_TO_KOTLIN")
     override fun toString() = "${(this as Object).getClass().getGenericInterfaces()[0]}"
 }
diff --git a/idea/src/org/jetbrains/kotlin/idea/util/Maybe.kt b/core/runtime.jvm/src/kotlin/jvm/internal/MutablePropertyReference.java
similarity index 74%
rename from idea/src/org/jetbrains/kotlin/idea/util/Maybe.kt
rename to core/runtime.jvm/src/kotlin/jvm/internal/MutablePropertyReference.java
index 96fcfa6fc67..b5c4b6b7771 100644
--- a/idea/src/org/jetbrains/kotlin/idea/util/Maybe.kt
+++ b/core/runtime.jvm/src/kotlin/jvm/internal/MutablePropertyReference.java
@@ -14,9 +14,9 @@
  * limitations under the License.
  */
 
-package org.jetbrains.kotlin.idea.util
+package kotlin.jvm.internal;
 
-abstract class Maybe<out V, out E>
-public class MaybeValue<V, E>(public val value: V) : Maybe<V, E>()
-public class MaybeError<V, E>(public val error: E) : Maybe<V, E>()
+import kotlin.reflect.KMutableProperty;
 
+public abstract class MutablePropertyReference extends PropertyReference implements KMutableProperty {
+}
diff --git a/core/runtime.jvm/src/kotlin/jvm/internal/MutablePropertyReference0.java b/core/runtime.jvm/src/kotlin/jvm/internal/MutablePropertyReference0.java
new file mode 100644
index 00000000000..0e8840ee65f
--- /dev/null
+++ b/core/runtime.jvm/src/kotlin/jvm/internal/MutablePropertyReference0.java
@@ -0,0 +1,42 @@
+/*
+ * Copyright 2010-2015 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.internal;
+
+import kotlin.reflect.KMutableProperty0;
+import kotlin.reflect.KProperty0;
+
+public class MutablePropertyReference0 extends MutablePropertyReference implements KMutableProperty0 {
+    @Override
+    public Object get() {
+        throw error();
+    }
+
+    @Override
+    public void set(Object value) {
+        throw error();
+    }
+
+    @Override
+    public KProperty0.Getter getGetter() {
+        throw error();
+    }
+
+    @Override
+    public KMutableProperty0.Setter getSetter() {
+        throw error();
+    }
+}
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/JetVisibilityChecker.java b/core/runtime.jvm/src/kotlin/jvm/internal/MutablePropertyReference1.java
similarity index 51%
rename from compiler/frontend/src/org/jetbrains/kotlin/resolve/JetVisibilityChecker.java
rename to core/runtime.jvm/src/kotlin/jvm/internal/MutablePropertyReference1.java
index aa3d597f9a7..ec5dcb604fc 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/JetVisibilityChecker.java
+++ b/core/runtime.jvm/src/kotlin/jvm/internal/MutablePropertyReference1.java
@@ -14,19 +14,29 @@
  * limitations under the License.
  */
 
-package org.jetbrains.kotlin.resolve;
+package kotlin.jvm.internal;
 
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.kotlin.descriptors.DeclarationDescriptor;
+import kotlin.reflect.KMutableProperty1;
+import kotlin.reflect.KProperty1;
 
-public class JetVisibilityChecker {
-    /**
-     * @param locationOwner owner of the call site
-     * @param subject the descriptor whose visibility is being checked
-     * @return <code>true</code> iff subject is visible locationOwner
-     */
-    public static boolean isVisible(@NotNull DeclarationDescriptor locationOwner, @NotNull DeclarationDescriptor subject) {
-        // TODO : stub implementation
-        return true;
+public class MutablePropertyReference1 extends MutablePropertyReference implements KMutableProperty1 {
+    @Override
+    public Object get(Object receiver) {
+        throw error();
+    }
+
+    @Override
+    public void set(Object receiver, Object value) {
+        throw error();
+    }
+
+    @Override
+    public KProperty1.Getter getGetter() {
+        throw error();
+    }
+
+    @Override
+    public KMutableProperty1.Setter getSetter() {
+        throw error();
     }
 }
diff --git a/core/runtime.jvm/src/kotlin/jvm/internal/MutablePropertyReference2.java b/core/runtime.jvm/src/kotlin/jvm/internal/MutablePropertyReference2.java
new file mode 100644
index 00000000000..b4c53be92a1
--- /dev/null
+++ b/core/runtime.jvm/src/kotlin/jvm/internal/MutablePropertyReference2.java
@@ -0,0 +1,42 @@
+/*
+ * Copyright 2010-2015 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.internal;
+
+import kotlin.reflect.KMutableProperty2;
+import kotlin.reflect.KProperty2;
+
+public class MutablePropertyReference2 extends MutablePropertyReference implements KMutableProperty2 {
+    @Override
+    public Object get(Object receiver1, Object receiver2) {
+        throw error();
+    }
+
+    @Override
+    public void set(Object receiver1, Object receiver2, Object value) {
+        throw error();
+    }
+
+    @Override
+    public KProperty2.Getter getGetter() {
+        throw error();
+    }
+
+    @Override
+    public KMutableProperty2.Setter getSetter() {
+        throw error();
+    }
+}
diff --git a/core/runtime.jvm/src/kotlin/jvm/internal/PrimitiveSpreadBuilders.kt b/core/runtime.jvm/src/kotlin/jvm/internal/PrimitiveSpreadBuilders.kt
index bca205a0877..0646197b3ac 100644
--- a/core/runtime.jvm/src/kotlin/jvm/internal/PrimitiveSpreadBuilders.kt
+++ b/core/runtime.jvm/src/kotlin/jvm/internal/PrimitiveSpreadBuilders.kt
@@ -20,6 +20,8 @@ private abstract class PrimitiveSpreadBuilder<T : Any>(private val size: Int) {
     abstract protected fun T.getSize(): Int
 
     protected var position: Int = 0
+
+    @suppress("CAST_NEVER_SUCCEEDS")
     private val spreads: Array<T?> = arrayOfNulls<Any>(size) as Array<T?>
 
     public fun addSpread(spreadArgument: T) {
@@ -41,17 +43,17 @@ private abstract class PrimitiveSpreadBuilder<T : Any>(private val size: Int) {
             val spreadArgument = spreads[i]
             if (spreadArgument != null) {
                 if (copyValuesFrom < i) {
-                    System.arraycopy(values, copyValuesFrom, result, dstIndex, i-copyValuesFrom)
+                    System.arraycopy(values, copyValuesFrom, result, dstIndex, i - copyValuesFrom)
                     dstIndex += i - copyValuesFrom
                 }
                 val spreadSize = spreadArgument.getSize()
                 System.arraycopy(spreadArgument, 0, result, dstIndex, spreadSize)
                 dstIndex += spreadSize
-                copyValuesFrom = i+1
+                copyValuesFrom = i + 1
             }
         }
         if (copyValuesFrom < size) {
-            System.arraycopy(values, copyValuesFrom, result, dstIndex, size-copyValuesFrom)
+            System.arraycopy(values, copyValuesFrom, result, dstIndex, size - copyValuesFrom)
         }
 
         return result
diff --git a/core/reflection.jvm/src/kotlin/reflect/jvm/internal/KVariableImpl.kt b/core/runtime.jvm/src/kotlin/jvm/internal/PropertyReference.java
similarity index 73%
rename from core/reflection.jvm/src/kotlin/reflect/jvm/internal/KVariableImpl.kt
rename to core/runtime.jvm/src/kotlin/jvm/internal/PropertyReference.java
index 45c7c09d564..822d9fc9af2 100644
--- a/core/reflection.jvm/src/kotlin/reflect/jvm/internal/KVariableImpl.kt
+++ b/core/runtime.jvm/src/kotlin/jvm/internal/PropertyReference.java
@@ -14,10 +14,9 @@
  * limitations under the License.
  */
 
-package kotlin.reflect.jvm.internal
+package kotlin.jvm.internal;
 
-import kotlin.reflect.*
+import kotlin.reflect.KProperty;
 
-trait KVariableImpl<out R> : KVariable<R>, KPropertyImpl<R>
-
-trait KMutableVariableImpl<R> : KMutableVariable<R>, KVariableImpl<R>, KMutablePropertyImpl<R>
+public abstract class PropertyReference extends CallableReference implements KProperty {
+}
diff --git a/core/builtins/src/kotlin/reflect/KTopLevelProperty.kt b/core/runtime.jvm/src/kotlin/jvm/internal/PropertyReference0.java
similarity index 66%
rename from core/builtins/src/kotlin/reflect/KTopLevelProperty.kt
rename to core/runtime.jvm/src/kotlin/jvm/internal/PropertyReference0.java
index 597e831325f..027d3fb2dec 100644
--- a/core/builtins/src/kotlin/reflect/KTopLevelProperty.kt
+++ b/core/runtime.jvm/src/kotlin/jvm/internal/PropertyReference0.java
@@ -14,14 +14,18 @@
  * limitations under the License.
  */
 
-package kotlin.reflect
+package kotlin.jvm.internal;
 
-/**
- * Represents a property declared in a package.
- */
-public interface KTopLevelProperty<out R> : KProperty<R>
+import kotlin.reflect.KProperty0;
 
-/**
- * Represents a package property declared as a `var`.
- */
-public interface KMutableTopLevelProperty<R> : KTopLevelProperty<R>, KMutableProperty<R>
+public class PropertyReference0 extends PropertyReference implements KProperty0 {
+    @Override
+    public Object get() {
+        throw error();
+    }
+
+    @Override
+    public KProperty0.Getter getGetter() {
+        throw error();
+    }
+}
diff --git a/core/runtime.jvm/src/kotlin/jvm/internal/PropertyReference1.java b/core/runtime.jvm/src/kotlin/jvm/internal/PropertyReference1.java
new file mode 100644
index 00000000000..ab45224ef95
--- /dev/null
+++ b/core/runtime.jvm/src/kotlin/jvm/internal/PropertyReference1.java
@@ -0,0 +1,31 @@
+/*
+ * Copyright 2010-2015 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.internal;
+
+import kotlin.reflect.KProperty1;
+
+public class PropertyReference1 extends PropertyReference implements KProperty1 {
+    @Override
+    public Object get(Object receiver) {
+        throw error();
+    }
+
+    @Override
+    public KProperty1.Getter getGetter() {
+        throw error();
+    }
+}
diff --git a/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/IntegerValueConstant.java b/core/runtime.jvm/src/kotlin/jvm/internal/PropertyReference2.java
similarity index 65%
rename from core/descriptors/src/org/jetbrains/kotlin/resolve/constants/IntegerValueConstant.java
rename to core/runtime.jvm/src/kotlin/jvm/internal/PropertyReference2.java
index 7c3b9de2e65..f6404e32c2c 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/IntegerValueConstant.java
+++ b/core/runtime.jvm/src/kotlin/jvm/internal/PropertyReference2.java
@@ -14,11 +14,18 @@
  * limitations under the License.
  */
 
-package org.jetbrains.kotlin.resolve.constants;
+package kotlin.jvm.internal;
 
-public abstract class IntegerValueConstant<T> extends CompileTimeConstant<T> {
+import kotlin.reflect.KProperty2;
 
-    protected IntegerValueConstant(T value, boolean canBeUsedInAnnotations, boolean pure, boolean usesVariableAsConstant) {
-        super(value, canBeUsedInAnnotations, pure, usesVariableAsConstant);
+public class PropertyReference2 extends PropertyReference implements KProperty2 {
+    @Override
+    public Object get(Object receiver1, Object receiver2) {
+        throw error();
+    }
+
+    @Override
+    public KProperty2.Getter getGetter() {
+        throw error();
     }
 }
diff --git a/core/runtime.jvm/src/kotlin/jvm/internal/Reflection.java b/core/runtime.jvm/src/kotlin/jvm/internal/Reflection.java
index 6c48b3d55da..26bfe9fa704 100644
--- a/core/runtime.jvm/src/kotlin/jvm/internal/Reflection.java
+++ b/core/runtime.jvm/src/kotlin/jvm/internal/Reflection.java
@@ -67,27 +67,27 @@ public class Reflection {
 
     // Properties
 
-    public static KMemberProperty memberProperty(String name, KClass owner) {
-        return factory.memberProperty(name, owner);
+    public static KProperty0 property0(PropertyReference0 p) {
+        return factory.property0(p);
     }
 
-    public static KMutableMemberProperty mutableMemberProperty(String name, KClass owner) {
-        return factory.mutableMemberProperty(name, owner);
+    public static KMutableProperty0 mutableProperty0(MutablePropertyReference0 p) {
+        return factory.mutableProperty0(p);
     }
 
-    public static KTopLevelVariable topLevelVariable(String name, KPackage owner) {
-        return factory.topLevelVariable(name, owner);
+    public static KProperty1 property1(PropertyReference1 p) {
+        return factory.property1(p);
     }
 
-    public static KMutableTopLevelVariable mutableTopLevelVariable(String name, KPackage owner) {
-        return factory.mutableTopLevelVariable(name, owner);
+    public static KMutableProperty1 mutableProperty1(MutablePropertyReference1 p) {
+        return factory.mutableProperty1(p);
     }
 
-    public static KTopLevelExtensionProperty topLevelExtensionProperty(String name, KPackage owner, Class receiver) {
-        return factory.topLevelExtensionProperty(name, owner, receiver);
+    public static KProperty2 property2(PropertyReference2 p) {
+        return factory.property2(p);
     }
 
-    public static KMutableTopLevelExtensionProperty mutableTopLevelExtensionProperty(String name, KPackage owner, Class receiver) {
-        return factory.mutableTopLevelExtensionProperty(name, owner, receiver);
+    public static KMutableProperty2 mutableProperty2(MutablePropertyReference2 p) {
+        return factory.mutableProperty2(p);
     }
 }
diff --git a/core/runtime.jvm/src/kotlin/jvm/internal/ReflectionFactory.java b/core/runtime.jvm/src/kotlin/jvm/internal/ReflectionFactory.java
index 431863234fa..05adf0b59b7 100644
--- a/core/runtime.jvm/src/kotlin/jvm/internal/ReflectionFactory.java
+++ b/core/runtime.jvm/src/kotlin/jvm/internal/ReflectionFactory.java
@@ -40,28 +40,28 @@ public class ReflectionFactory {
 
     // Properties
 
-    public KMemberProperty memberProperty(String name, KClass owner) {
-        throw error();
+    public KProperty0 property0(PropertyReference0 p) {
+        return p;
     }
 
-    public KMutableMemberProperty mutableMemberProperty(String name, KClass owner) {
-        throw error();
+    public KMutableProperty0 mutableProperty0(MutablePropertyReference0 p) {
+        return p;
     }
 
-    public KTopLevelVariable topLevelVariable(String name, KPackage owner) {
-        throw error();
+    public KProperty1 property1(PropertyReference1 p) {
+        return p;
     }
 
-    public KMutableTopLevelVariable mutableTopLevelVariable(String name, KPackage owner) {
-        throw error();
+    public KMutableProperty1 mutableProperty1(MutablePropertyReference1 p) {
+        return p;
     }
 
-    public KTopLevelExtensionProperty topLevelExtensionProperty(String name, KPackage owner, Class receiver) {
-        throw error();
+    public KProperty2 property2(PropertyReference2 p) {
+        return p;
     }
 
-    public KMutableTopLevelExtensionProperty mutableTopLevelExtensionProperty(String name, KPackage owner, Class receiver) {
-        throw error();
+    public KMutableProperty2 mutableProperty2(MutablePropertyReference2 p) {
+        return p;
     }
 
     private Error error() {
diff --git a/core/util.runtime/src/org/jetbrains/kotlin/utils/functions.kt b/core/util.runtime/src/org/jetbrains/kotlin/utils/functions.kt
index 1b538942cd6..5414a37327f 100644
--- a/core/util.runtime/src/org/jetbrains/kotlin/utils/functions.kt
+++ b/core/util.runtime/src/org/jetbrains/kotlin/utils/functions.kt
@@ -16,12 +16,17 @@
 
 package org.jetbrains.kotlin.utils
 
-private val IDENTITY: Function1<Any?, Any?> = { it }
+private val IDENTITY: (Any?) -> Any? = { it }
 
 suppress("UNCHECKED_CAST")
-public fun <T> identity(): Function1<T, T> = IDENTITY as Function1<T, T>
+public fun <T> identity(): (T) -> T = IDENTITY as (T) -> T
 
 
-private val ALWAYS_TRUE: Function1<Any?, Boolean> = { true }
+private val ALWAYS_TRUE: (Any?) -> Boolean = { true }
 
-public fun <T> alwaysTrue(): Function1<T, Boolean> = ALWAYS_TRUE
+public fun <T> alwaysTrue(): (T) -> Boolean = ALWAYS_TRUE
+
+
+public val DO_NOTHING: (Any?) -> Unit = { }
+
+public fun <T> doNothing(): (T) -> Unit = DO_NOTHING
diff --git a/generators/src/org/jetbrains/kotlin/generators/builtins/common.kt b/generators/src/org/jetbrains/kotlin/generators/builtins/common.kt
index 736282866aa..75d6acd97ba 100644
--- a/generators/src/org/jetbrains/kotlin/generators/builtins/common.kt
+++ b/generators/src/org/jetbrains/kotlin/generators/builtins/common.kt
@@ -31,8 +31,8 @@ enum class PrimitiveType {
 
     val capitalized: String get() = name().toLowerCase().capitalize()
     companion object {
-        val exceptBoolean: List<PrimitiveType> by Delegates.lazy { PrimitiveType.values().filterNot { it == BOOLEAN } }
-        val onlyNumeric: List<PrimitiveType> by Delegates.lazy { PrimitiveType.values().filterNot { it == BOOLEAN || it == CHAR }}
+        val exceptBoolean: List<PrimitiveType> by lazy { PrimitiveType.values().filterNot { it == BOOLEAN } }
+        val onlyNumeric: List<PrimitiveType> by lazy { PrimitiveType.values().filterNot { it == BOOLEAN || it == CHAR }}
     }
 }
 
diff --git a/generators/src/org/jetbrains/kotlin/generators/builtins/primitives.kt b/generators/src/org/jetbrains/kotlin/generators/builtins/primitives.kt
index a54d632126c..0b2b85af5ef 100644
--- a/generators/src/org/jetbrains/kotlin/generators/builtins/primitives.kt
+++ b/generators/src/org/jetbrains/kotlin/generators/builtins/primitives.kt
@@ -90,18 +90,12 @@ class GeneratePrimitives(out: PrintWriter) : BuiltInsSourceGenerator(out) {
     }
 
     private fun generateCompareTo(thisKind: PrimitiveType) {
-        for (otherKind in PrimitiveType.exceptBoolean) {
+        for (otherKind in PrimitiveType.onlyNumeric) {
             out.println("/**")
-            if (otherKind == PrimitiveType.CHAR) {
-                out.println(" * Compares this value with the character code of the specified character for order.")
-            } else {
-                out.println(" * Compares this value with the specified value for order.")
-            }
+            out.println(" * Compares this value with the specified value for order.")
             out.println(" * Returns zero if this value is equal to the specified other value, a negative number if its less than other, ")
             out.println(" * or a positive number if its greater than other.")
             out.println(" */")
-            if (otherKind == PrimitiveType.CHAR)
-                out.println("""    deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")""")
             out.print("    public ")
             if (otherKind == thisKind) out.print("override ")
             out.println("fun compareTo(other: ${otherKind.capitalized}): Int")
@@ -116,22 +110,18 @@ class GeneratePrimitives(out: PrintWriter) : BuiltInsSourceGenerator(out) {
     }
 
     private fun generateOperator(name: String, doc: String, thisKind: PrimitiveType) {
-        for (otherKind in PrimitiveType.exceptBoolean) {
+        for (otherKind in PrimitiveType.onlyNumeric) {
             val returnType = getOperatorReturnType(thisKind, otherKind)
             out.println("    /** $doc */")
-            if (otherKind == PrimitiveType.CHAR)
-                out.println("""    deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")""")
             out.println("    public fun $name(other: ${otherKind.capitalized}): $returnType")
         }
         out.println()
     }
 
     private fun generateRangeTo(thisKind: PrimitiveType) {
-        for (otherKind in PrimitiveType.exceptBoolean) {
+        for (otherKind in PrimitiveType.onlyNumeric) {
             val returnType = if (otherKind.ordinal() > thisKind.ordinal()) otherKind else thisKind
             out.println("     /** Creates a range from this value to the specified [other] value. */")
-            if (otherKind == PrimitiveType.CHAR)
-                out.println("""    deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")""")
             out.println("    public fun rangeTo(other: ${otherKind.capitalized}): ${returnType.capitalized}Range")
         }
         out.println()
diff --git a/generators/src/org/jetbrains/kotlin/generators/builtins/progressions.kt b/generators/src/org/jetbrains/kotlin/generators/builtins/progressions.kt
index 490bc979152..2674cfe06dd 100644
--- a/generators/src/org/jetbrains/kotlin/generators/builtins/progressions.kt
+++ b/generators/src/org/jetbrains/kotlin/generators/builtins/progressions.kt
@@ -46,7 +46,7 @@ class GenerateProgressions(out: PrintWriter) : BuiltInsSourceGenerator(out) {
 
             val hashCode = when (kind) {
                 BYTE, CHAR, SHORT -> "=\n" +
-                "        if (isEmpty()) -1 else (31 * (31 * start.toInt() + end) + increment)"
+                "        if (isEmpty()) -1 else (31 * (31 * start.toInt() + end.toInt()) + increment)"
                 INT -> "=\n" +
                 "        if (isEmpty()) -1 else (31 * (31 * start + end) + increment)"
                 LONG -> "=\n" +
diff --git a/generators/src/org/jetbrains/kotlin/generators/builtins/ranges.kt b/generators/src/org/jetbrains/kotlin/generators/builtins/ranges.kt
index 377db8d7130..d049c24850c 100644
--- a/generators/src/org/jetbrains/kotlin/generators/builtins/ranges.kt
+++ b/generators/src/org/jetbrains/kotlin/generators/builtins/ranges.kt
@@ -46,7 +46,7 @@ class GenerateRanges(out: PrintWriter) : BuiltInsSourceGenerator(out) {
 
             val hashCode = when (kind) {
                 BYTE, CHAR, SHORT -> "=\n" +
-                "        if (isEmpty()) -1 else (31 * start.toInt() + end)"
+                "        if (isEmpty()) -1 else (31 * start.toInt() + end.toInt())"
                 INT -> "=\n" +
                 "        if (isEmpty()) -1 else (31 * start + end)"
                 LONG -> "=\n" +
diff --git a/generators/src/org/jetbrains/kotlin/generators/mockJDK/GenerateMockJdk.java b/generators/src/org/jetbrains/kotlin/generators/mockJDK/GenerateMockJdk.java
index e8136ef26ef..5c0d49e04a4 100644
--- a/generators/src/org/jetbrains/kotlin/generators/mockJDK/GenerateMockJdk.java
+++ b/generators/src/org/jetbrains/kotlin/generators/mockJDK/GenerateMockJdk.java
@@ -227,6 +227,7 @@ public class GenerateMockJdk {
             "java/util/concurrent/atomic/AtomicReferenceFieldUpdater.class",
             "java/util/concurrent/atomic/AtomicStampedReference.class",
             "java/util/concurrent/Callable.class",
+            "java/util/concurrent/ConcurrentHashMap.class",
             "java/util/concurrent/locks/AbstractQueuedSynchronizer.class",
             "java/util/concurrent/locks/Condition.class",
             "java/util/concurrent/locks/Lock.class",
@@ -244,6 +245,7 @@ public class GenerateMockJdk {
             "java/util/HashSet.class",
             "java/util/IdentityHashMap.class",
             "java/util/Iterator.class",
+            "java/util/LinkedHashSet.class",
             "java/util/List.class",
             "java/util/ListIterator.class",
             "java/util/Locale.class",
@@ -258,6 +260,7 @@ public class GenerateMockJdk {
             "java/util/SortedSet.class",
             "java/util/TimeZone.class",
             "java/util/TreeMap.class",
+            "java/util/TreeSet.class",
             "javax/swing/AbstractButton.class",
             "javax/swing/Icon.class",
             "javax/swing/JButton.class",
diff --git a/generators/src/org/jetbrains/kotlin/generators/tests/GenerateTests.kt b/generators/src/org/jetbrains/kotlin/generators/tests/GenerateTests.kt
index 792e0fcd107..a8002afcd25 100644
--- a/generators/src/org/jetbrains/kotlin/generators/tests/GenerateTests.kt
+++ b/generators/src/org/jetbrains/kotlin/generators/tests/GenerateTests.kt
@@ -66,10 +66,7 @@ import org.jetbrains.kotlin.idea.decompiler.textBuilder.AbstractDecompiledTextTe
 import org.jetbrains.kotlin.idea.editor.quickDoc.AbstractJetQuickDocProviderTest
 import org.jetbrains.kotlin.idea.folding.AbstractKotlinFoldingTest
 import org.jetbrains.kotlin.idea.hierarchy.AbstractHierarchyTest
-import org.jetbrains.kotlin.idea.highlighter.AbstractDiagnosticMessageJsTest
-import org.jetbrains.kotlin.idea.highlighter.AbstractDiagnosticMessageTest
-import org.jetbrains.kotlin.idea.highlighter.AbstractHighlightExitPointsTest
-import org.jetbrains.kotlin.idea.highlighter.AbstractHighlightingTest
+import org.jetbrains.kotlin.idea.highlighter.*
 import org.jetbrains.kotlin.idea.imports.AbstractOptimizeImportsTest
 import org.jetbrains.kotlin.idea.intentions.AbstractIntentionTest
 import org.jetbrains.kotlin.idea.intentions.AbstractMultiFileIntentionTest
@@ -161,7 +158,7 @@ fun main(args: Array<String>) {
         }
 
         testClass(javaClass<AbstractConstraintSystemTest>()) {
-            model("constraintSystem", extension = "bounds")
+            model("constraintSystem", extension = "constraints")
         }
 
         testClass(javaClass<AbstractJetParsingTest>()) {
@@ -395,6 +392,10 @@ fun main(args: Array<String>) {
             model("highlighter")
         }
 
+        testClass(javaClass<AbstractUsageHighlightingTest>()) {
+            model("usageHighlighter")
+        }
+
         testClass(javaClass<AbstractKotlinFoldingTest>()) {
             model("folding/noCollapse")
             model("folding/checkCollapse", testMethod = "doSettingsFoldingTest")
diff --git a/idea/ide-common/src/org/jetbrains/kotlin/idea/codeInsight/ReferenceVariantsHelper.kt b/idea/ide-common/src/org/jetbrains/kotlin/idea/codeInsight/ReferenceVariantsHelper.kt
index 83fbe3443b2..9cc005276f6 100644
--- a/idea/ide-common/src/org/jetbrains/kotlin/idea/codeInsight/ReferenceVariantsHelper.kt
+++ b/idea/ide-common/src/org/jetbrains/kotlin/idea/codeInsight/ReferenceVariantsHelper.kt
@@ -18,11 +18,11 @@
 package org.jetbrains.kotlin.idea.codeInsight
 
 import com.intellij.openapi.project.Project
-import org.jetbrains.kotlin.descriptors.CallableDescriptor
-import org.jetbrains.kotlin.descriptors.ClassDescriptor
-import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
-import org.jetbrains.kotlin.descriptors.ModuleDescriptor
-import org.jetbrains.kotlin.idea.util.*
+import org.jetbrains.kotlin.descriptors.*
+import org.jetbrains.kotlin.idea.util.CallType
+import org.jetbrains.kotlin.idea.util.ShadowedDeclarationsFilter
+import org.jetbrains.kotlin.idea.util.getImplicitReceiversWithInstance
+import org.jetbrains.kotlin.idea.util.substituteExtensionIfCallable
 import org.jetbrains.kotlin.lexer.JetTokens
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.psi.*
@@ -37,9 +37,11 @@ import org.jetbrains.kotlin.resolve.scopes.JetScope
 import org.jetbrains.kotlin.resolve.scopes.getDescriptorsFiltered
 import org.jetbrains.kotlin.resolve.scopes.receivers.ExpressionReceiver
 import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue
+import org.jetbrains.kotlin.synthetic.SyntheticJavaPropertyDescriptor
 import org.jetbrains.kotlin.types.JetType
 import org.jetbrains.kotlin.types.TypeUtils
 import org.jetbrains.kotlin.types.checker.JetTypeChecker
+import org.jetbrains.kotlin.utils.addIfNotNull
 import java.util.*
 
 public class ReferenceVariantsHelper(
@@ -60,12 +62,30 @@ public class ReferenceVariantsHelper(
     public fun getReferenceVariants(
             expression: JetSimpleNameExpression,
             kindFilter: DescriptorKindFilter,
-            useRuntimeReceiverType: Boolean,
-            nameFilter: (Name) -> Boolean
+            nameFilter: (Name) -> Boolean,
+            filterOutJavaGettersAndSetters: Boolean = false,
+            useRuntimeReceiverType: Boolean = false
     ): Collection<DeclarationDescriptor> {
-        val variants = getReferenceVariantsNoVisibilityFilter(expression, kindFilter, useRuntimeReceiverType, nameFilter)
+        var variants: Collection<DeclarationDescriptor>
+                = getReferenceVariantsNoVisibilityFilter(expression, kindFilter, useRuntimeReceiverType, nameFilter)
                 .filter(visibilityFilter)
-        return ShadowedDeclarationsFilter(context, moduleDescriptor, project).filter(variants, expression)
+
+        variants = ShadowedDeclarationsFilter(context, moduleDescriptor, project).filter(variants, expression)
+
+        if (filterOutJavaGettersAndSetters) {
+            val accessorMethodsToRemove = HashSet<FunctionDescriptor>()
+            for (variant in variants) {
+                val original = variant.original
+                if (original is SyntheticJavaPropertyDescriptor) {
+                    accessorMethodsToRemove.add(original.getMethod)
+                    accessorMethodsToRemove.addIfNotNull(original.setMethod)
+                }
+            }
+
+            variants = variants.filter { it.original !in accessorMethodsToRemove }
+        }
+
+        return variants
     }
 
     private fun getReferenceVariantsNoVisibilityFilter(
@@ -88,6 +108,8 @@ public class ReferenceVariantsHelper(
 
         val descriptors = LinkedHashSet<DeclarationDescriptor>()
 
+        val dataFlowInfo = context.getDataFlowInfo(expression)
+
         val pair = getExplicitReceiverData(expression)
         if (pair != null) {
             val (receiverExpression, callType) = pair
@@ -104,25 +126,17 @@ public class ReferenceVariantsHelper(
                                         context.getType(receiverExpression)
             if (expressionType != null && !expressionType.isError()) {
                 val receiverValue = ExpressionReceiver(receiverExpression, expressionType)
-                val dataFlowInfo = context.getDataFlowInfo(expression)
-
-                for (variant in SmartCastUtils.getSmartCastVariantsWithLessSpecificExcluded(receiverValue, context, containingDeclaration, dataFlowInfo)) {
-                    descriptors.addMembersFromReceiver(variant, callType, kindFilter, nameFilter)
-                }
+                descriptors.addMembersFromReceiverAndSyntheticExtensions(receiverValue, callType, kindFilter, nameFilter, resolutionScope, dataFlowInfo)
 
                 descriptors.addCallableExtensions(resolutionScope, receiverValue, dataFlowInfo, callType, kindFilter, nameFilter)
             }
         }
         else {
-            val dataFlowInfo = context.getDataFlowInfo(expression)
-
             // process instance members that can be called via implicit receiver's instances
             val receivers = resolutionScope.getImplicitReceiversWithInstance()
             val receiverValues = receivers.map { it.getValue() }
             for (receiverValue in receiverValues) {
-                for (variant in SmartCastUtils.getSmartCastVariantsWithLessSpecificExcluded(receiverValue, context, containingDeclaration, dataFlowInfo)) {
-                    descriptors.addMembersFromReceiver(variant, CallType.NORMAL, kindFilter, nameFilter)
-                }
+                descriptors.addMembersFromReceiverAndSyntheticExtensions(receiverValue, CallType.NORMAL, kindFilter, nameFilter, resolutionScope, dataFlowInfo)
             }
 
             // process extensions and non-instance members
@@ -143,22 +157,38 @@ public class ReferenceVariantsHelper(
         return descriptors
     }
 
-    private fun MutableCollection<DeclarationDescriptor>.addMembersFromReceiver(
-            receiverType: JetType,
+    private fun MutableSet<DeclarationDescriptor>.addMembersFromReceiverAndSyntheticExtensions(
+            receiverValue: ReceiverValue,
             callType: CallType,
             kindFilter: DescriptorKindFilter,
-            nameFilter: (Name) -> Boolean
+            nameFilter: (Name) -> Boolean,
+            resolutionScope: JetScope,
+            dataFlowInfo: DataFlowInfo
     ) {
-        var memberFilter = kindFilter exclude DescriptorKindExclude.Extensions
-        val members = receiverType.getMemberScope().getDescriptorsFiltered(DescriptorKindFilter.ALL, nameFilter) // filter by kind later because of constructors
-        for (member in members) {
-            if (member is ClassDescriptor) {
-                if (member.isInner()) {
-                    member.getConstructors().filterTo(this) { callType.canCall(it) && memberFilter.accepts(it) }
+        val memberFilter = kindFilter exclude DescriptorKindExclude.Extensions
+        val containingDeclaration = resolutionScope.getContainingDeclaration()
+
+        val receiverTypes = SmartCastUtils.getSmartCastVariantsWithLessSpecificExcluded(receiverValue, context, containingDeclaration, dataFlowInfo)
+
+        for (receiverType in receiverTypes) {
+            val members = receiverType.getMemberScope().getDescriptorsFiltered(DescriptorKindFilter.ALL, nameFilter) // filter by kind later because of constructors
+            for (member in members) {
+                if (member is ClassDescriptor) {
+                    if (member.isInner()) {
+                        member.getConstructors().filterTo(this) { callType.canCall(it) && memberFilter.accepts(it) }
+                    }
+                }
+                else if (callType.canCall(member) && memberFilter.accepts(member)) {
+                    this.add(member)
                 }
             }
-            else if (callType.canCall(member) && memberFilter.accepts(member)) {
-                this.add(member)
+        }
+
+        if (!kindFilter.excludes.contains(DescriptorKindExclude.Extensions)) {
+            for (extension in resolutionScope.getSyntheticExtensionProperties(receiverTypes)) {
+                if (nameFilter(extension.getName()) && kindFilter.accepts(extension)) {
+                    addAll(extension.substituteExtensionIfCallable(receiverValue, callType, context, dataFlowInfo, containingDeclaration))
+                }
             }
         }
     }
diff --git a/idea/ide-common/src/org/jetbrains/kotlin/idea/util/FuzzyType.kt b/idea/ide-common/src/org/jetbrains/kotlin/idea/util/FuzzyType.kt
index 48f8687fbed..62d3065ebcd 100644
--- a/idea/ide-common/src/org/jetbrains/kotlin/idea/util/FuzzyType.kt
+++ b/idea/ide-common/src/org/jetbrains/kotlin/idea/util/FuzzyType.kt
@@ -16,18 +16,20 @@
 
 package org.jetbrains.kotlin.idea.util
 
-import org.jetbrains.kotlin.types.JetType
-import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor
 import org.jetbrains.kotlin.descriptors.CallableDescriptor
-import org.jetbrains.kotlin.utils.addIfNotNull
-import java.util.HashSet
+import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor
 import org.jetbrains.kotlin.resolve.calls.inference.ConstraintSystemImpl
-import java.util.LinkedHashMap
-import org.jetbrains.kotlin.types.Variance
-import org.jetbrains.kotlin.resolve.calls.inference.ConstraintsUtil
+import org.jetbrains.kotlin.resolve.calls.inference.constraintPosition.ConstraintPositionKind
+import org.jetbrains.kotlin.resolve.calls.inference.registerTypeVariables
+import org.jetbrains.kotlin.types.JetType
 import org.jetbrains.kotlin.types.TypeSubstitutor
+import org.jetbrains.kotlin.types.Variance
 import org.jetbrains.kotlin.types.typeUtil.isSubtypeOf
 import org.jetbrains.kotlin.resolve.calls.inference.constraintPosition.ConstraintPositionKind
+import org.jetbrains.kotlin.types.typeUtil.makeNotNullable
+import org.jetbrains.kotlin.types.typeUtil.makeNullable
+import org.jetbrains.kotlin.types.typeUtil.nullability
+import java.util.HashSet
 
 fun CallableDescriptor.fuzzyReturnType(): FuzzyType? {
     val returnType = getReturnType() ?: return null
@@ -103,18 +105,14 @@ class FuzzyType(
         }
 
         val constraintSystem = ConstraintSystemImpl()
-        val typeVariables = LinkedHashMap<TypeParameterDescriptor, Variance>()
-        for (typeParameter in freeParameters) {
-            typeVariables[typeParameter] = Variance.INVARIANT
-        }
-        constraintSystem.registerTypeVariables(typeVariables)
+        constraintSystem.registerTypeVariables(freeParameters, { Variance.INVARIANT })
 
         when (matchKind) {
-            MatchKind.IS_SUBTYPE -> constraintSystem.addSubtypeConstraint(type, otherType, ConstraintPositionKind.SPECIAL.position())
-            MatchKind.IS_SUPERTYPE -> constraintSystem.addSubtypeConstraint(otherType, type, ConstraintPositionKind.SPECIAL.position())
+            MatchKind.IS_SUBTYPE -> constraintSystem.addSubtypeConstraint(type, otherType, ConstraintPositionKind.RECEIVER_POSITION.position())
+            MatchKind.IS_SUPERTYPE -> constraintSystem.addSubtypeConstraint(otherType, type, ConstraintPositionKind.RECEIVER_POSITION.position())
         }
 
-        constraintSystem.processDeclaredBoundConstraints()
+        constraintSystem.fixVariables()
 
         if (!constraintSystem.getStatus().hasContradiction()) {
             // currently ConstraintSystem return successful status in case there are problems with nullability
diff --git a/idea/ide-common/src/org/jetbrains/kotlin/idea/util/ShadowedDeclarationsFilter.kt b/idea/ide-common/src/org/jetbrains/kotlin/idea/util/ShadowedDeclarationsFilter.kt
index fc6551a2fc9..577e5bc0566 100644
--- a/idea/ide-common/src/org/jetbrains/kotlin/idea/util/ShadowedDeclarationsFilter.kt
+++ b/idea/ide-common/src/org/jetbrains/kotlin/idea/util/ShadowedDeclarationsFilter.kt
@@ -35,6 +35,7 @@ import org.jetbrains.kotlin.resolve.scopes.ChainedScope
 import org.jetbrains.kotlin.resolve.scopes.ExplicitImportsScope
 import org.jetbrains.kotlin.resolve.validation.SymbolUsageValidator
 import org.jetbrains.kotlin.types.TypeUtils
+import org.jetbrains.kotlin.util.descriptorsEqualWithSubstitution
 import java.util.ArrayList
 import java.util.HashSet
 
@@ -168,8 +169,12 @@ public class ShadowedDeclarationsFilter(
                                                         CompositeChecker(listOf()), SymbolUsageValidator.Empty, AdditionalTypeChecker.Composite(listOf()), false)
         val callResolver = createContainerForMacros(project, moduleDescriptor).callResolver
         val results = if (isFunction) callResolver.resolveFunctionCall(context) else callResolver.resolveSimpleProperty(context)
-        val resultingDescriptors = results.getResultingCalls().map { it.getResultingDescriptor() }.toSet()
-        val filtered = descriptors.filter { it in resultingDescriptors }
+        val resultingDescriptors = results.getResultingCalls().map { it.getResultingDescriptor() }
+        val resultingOriginals = resultingDescriptors.mapTo(HashSet<DeclarationDescriptor>()) { it.getOriginal() }
+        val filtered = descriptors.filter { candidateDescriptor ->
+            candidateDescriptor.getOriginal() in resultingOriginals /* optimization */
+                && resultingDescriptors.any { descriptorsEqualWithSubstitution(it, candidateDescriptor) }
+        }
         return if (filtered.isNotEmpty()) filtered else descriptors /* something went wrong, none of our declarations among resolve candidates, let's not filter anything */
     }
 
diff --git a/idea/ide-common/src/org/jetbrains/kotlin/idea/util/TypeUtils.kt b/idea/ide-common/src/org/jetbrains/kotlin/idea/util/TypeUtils.kt
index f69c29cee03..9864f331b0c 100644
--- a/idea/ide-common/src/org/jetbrains/kotlin/idea/util/TypeUtils.kt
+++ b/idea/ide-common/src/org/jetbrains/kotlin/idea/util/TypeUtils.kt
@@ -27,23 +27,16 @@ import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.platform.JavaToKotlinClassMap
 import org.jetbrains.kotlin.resolve.scopes.JetScope
 import org.jetbrains.kotlin.types.*
+import org.jetbrains.kotlin.types.typeUtil.makeNotNullable
 import org.jetbrains.kotlin.types.typeUtil.substitute
-
-fun JetType.makeNullable() = TypeUtils.makeNullable(this)
-fun JetType.makeNotNullable() = TypeUtils.makeNotNullable(this)
-
-fun JetType.supertypes(): Set<JetType> = TypeUtils.getAllSupertypes(this)
-
-fun JetType.isNothing(): Boolean = KotlinBuiltIns.isNothing(this)
-fun JetType.isUnit(): Boolean = KotlinBuiltIns.isUnit(this)
-fun JetType.isAny(): Boolean = KotlinBuiltIns.isAnyOrNullableAny(this)
+import org.jetbrains.kotlin.types.typeUtil.supertypes
 
 public fun approximateFlexibleTypes(jetType: JetType, outermost: Boolean = true): JetType {
     if (jetType.isDynamic()) return jetType
     if (jetType.isFlexible()) {
         val flexible = jetType.flexibility()
         val lowerClass = flexible.lowerBound.getConstructor().getDeclarationDescriptor() as? ClassDescriptor?
-        val isCollection = lowerClass != null && JavaToKotlinClassMap.INSTANCE.isMutableCollection(lowerClass)
+        val isCollection = lowerClass != null && JavaToKotlinClassMap.INSTANCE.isMutable(lowerClass)
         // (Mutable)Collection<T>! -> MutableCollection<T>?
         // Foo<(Mutable)Collection<T>!>! -> Foo<Collection<T>>?
         // Foo! -> Foo?
@@ -81,20 +74,6 @@ private fun JetType.hasAnnotationMaybeExternal(fqName: FqName) = with (getAnnota
     findAnnotation(fqName) ?: findExternalAnnotation(fqName)
 } != null
 
-public enum class TypeNullability {
-    NOT_NULL,
-    NULLABLE,
-    FLEXIBLE
-}
-
-public fun JetType.nullability(): TypeNullability {
-    return when {
-        isNullabilityFlexible() -> TypeNullability.FLEXIBLE
-        TypeUtils.isNullableType(this) -> TypeNullability.NULLABLE
-        else -> TypeNullability.NOT_NULL
-    }
-}
-
 fun JetType.isResolvableInScope(scope: JetScope?, checkTypeParameters: Boolean): Boolean {
     if (canBeReferencedViaImport()) return true
 
diff --git a/idea/ide-common/src/org/jetbrains/kotlin/idea/util/extensionsUtils.kt b/idea/ide-common/src/org/jetbrains/kotlin/idea/util/extensionsUtils.kt
index d514f844681..bdabaa0ee08 100644
--- a/idea/ide-common/src/org/jetbrains/kotlin/idea/util/extensionsUtils.kt
+++ b/idea/ide-common/src/org/jetbrains/kotlin/idea/util/extensionsUtils.kt
@@ -28,6 +28,9 @@ import org.jetbrains.kotlin.resolve.scopes.JetScope
 import org.jetbrains.kotlin.resolve.scopes.receivers.ExpressionReceiver
 import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue
 import org.jetbrains.kotlin.resolve.scopes.receivers.ThisReceiver
+import org.jetbrains.kotlin.types.typeUtil.TypeNullability
+import org.jetbrains.kotlin.types.typeUtil.makeNotNullable
+import org.jetbrains.kotlin.types.typeUtil.nullability
 
 public enum class CallType {
     NORMAL,
@@ -102,7 +105,7 @@ public fun CallableDescriptor.substituteExtensionIfCallable(
         return if (substitutors.any()) listOf(this) else listOf()
     }
     else {
-        return substitutors.map { substitute(it) }.toList()
+        return substitutors.map { substitute(it)!! }.toList()
     }
 }
 
diff --git a/idea/ide-common/src/org/jetbrains/kotlin/resolve/lazy/ElementResolver.kt b/idea/ide-common/src/org/jetbrains/kotlin/resolve/lazy/ElementResolver.kt
index eb253798cf4..5e973a05733 100644
--- a/idea/ide-common/src/org/jetbrains/kotlin/resolve/lazy/ElementResolver.kt
+++ b/idea/ide-common/src/org/jetbrains/kotlin/resolve/lazy/ElementResolver.kt
@@ -26,6 +26,7 @@ import org.jetbrains.kotlin.context.withProject
 import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.descriptors.annotations.Annotations
 import org.jetbrains.kotlin.frontend.di.createContainerForBodyResolve
+import org.jetbrains.kotlin.resolve.util.getScopeAndDataFlowForAnalyzeFragment
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.psi.*
@@ -45,41 +46,27 @@ import org.jetbrains.kotlin.utils.addToStdlib.firstIsInstanceOrNull
 public abstract class ElementResolver protected constructor(
         public val resolveSession: ResolveSession
 ) {
-
-    public open fun getElementAdditionalResolve(jetElement: JetElement): BindingContext {
-        return performElementAdditionalResolve(jetElement, jetElement, BodyResolveMode.FULL)
+    protected open fun getElementAdditionalResolve(resolveElement: JetElement, contextElement: JetElement, bodyResolveMode: BodyResolveMode): BindingContext {
+        return performElementAdditionalResolve(resolveElement, resolveElement, bodyResolveMode).first
     }
 
-    public open fun hasElementAdditionalResolveCached(jetElement: JetElement): Boolean = false
-
     protected open fun probablyNothingCallableNames(): ProbablyNothingCallableNames
             = throw UnsupportedOperationException("Cannot use partial body resolve with no Nothing-functions index");
 
-    public fun resolveToElement(jetElement: JetElement, bodyResolveMode: BodyResolveMode = BodyResolveMode.FULL): BindingContext {
-        @suppress("NAME_SHADOWING")
-        var jetElement = jetElement
+    public fun resolveToElement(element: JetElement, bodyResolveMode: BodyResolveMode = BodyResolveMode.FULL): BindingContext {
+        var contextElement = element
 
-        val elementOfAdditionalResolve = findElementOfAdditionalResolve(jetElement)
-
-        if (elementOfAdditionalResolve != null) {
-            if (elementOfAdditionalResolve !is JetParameter) {
-                if (bodyResolveMode != BodyResolveMode.FULL && !hasElementAdditionalResolveCached(elementOfAdditionalResolve)) {
-                    return performElementAdditionalResolve(elementOfAdditionalResolve, jetElement, bodyResolveMode)
-                }
-
-                return getElementAdditionalResolve(elementOfAdditionalResolve)
-            }
-
-            val klass = elementOfAdditionalResolve.getParentOfType<JetClass>(true)
-            if (klass != null && elementOfAdditionalResolve.getParent() == klass.getPrimaryConstructorParameterList()) {
-                return getElementAdditionalResolve(klass)
-            }
+        val elementOfAdditionalResolve = findElementOfAdditionalResolve(contextElement)
 
+        if (elementOfAdditionalResolve is JetParameter) {
             // Parameters for function literal could be met inside other parameters. We can't make resolveToDescriptors for internal elements.
-            jetElement = elementOfAdditionalResolve
+            contextElement = elementOfAdditionalResolve
+        }
+        else if (elementOfAdditionalResolve != null) {
+            return getElementAdditionalResolve(elementOfAdditionalResolve, contextElement, bodyResolveMode)
         }
 
-        val declaration = jetElement.getParentOfType<JetDeclaration>(false)
+        val declaration = contextElement.getParentOfType<JetDeclaration>(false)
         if (declaration != null && declaration !is JetClassInitializer) {
             // Activate descriptor resolution
             resolveSession.resolveToDescriptor(declaration)
@@ -89,7 +76,7 @@ public abstract class ElementResolver protected constructor(
     }
 
     private fun findElementOfAdditionalResolve(element: JetElement): JetElement? {
-        var elementOfAdditionalResolve = JetPsiUtil.getTopmostParentOfTypes(
+        val elementOfAdditionalResolve = JetPsiUtil.getTopmostParentOfTypes(
                 element,
                 javaClass<JetNamedFunction>(),
                 javaClass<JetClassInitializer>(),
@@ -98,42 +85,60 @@ public abstract class ElementResolver protected constructor(
                 javaClass<JetParameter>(),
                 javaClass<JetDelegationSpecifierList>(),
                 javaClass<JetInitializerList>(),
-                javaClass<JetImportDirective>(),
+                javaClass<JetImportList>(),
                 javaClass<JetAnnotationEntry>(),
                 javaClass<JetTypeParameter>(),
                 javaClass<JetTypeConstraint>(),
                 javaClass<JetPackageDirective>(),
-                javaClass<JetCodeFragment>()) as JetElement?
+                javaClass<JetCodeFragment>()) as JetElement? ?: return null
 
-        if (elementOfAdditionalResolve is JetPackageDirective) {
-            return element
+        when (elementOfAdditionalResolve) {
+            is JetPackageDirective -> return element
+
+            is JetParameter -> {
+                val klass = elementOfAdditionalResolve.getParentOfType<JetClass>(strict = true)
+                if (klass != null && elementOfAdditionalResolve.getParent() == klass.getPrimaryConstructorParameterList()) {
+                    return klass
+                }
+
+                return elementOfAdditionalResolve
+            }
+
+            else -> return elementOfAdditionalResolve
         }
-
-        return elementOfAdditionalResolve
     }
 
-    protected fun performElementAdditionalResolve(resolveElement: JetElement, contextElement: JetElement, bodyResolveMode: BodyResolveMode): BindingContext {
+    protected fun performElementAdditionalResolve(resolveElement: JetElement, contextElement: JetElement, bodyResolveMode: BodyResolveMode): Pair<BindingContext, StatementFilter> {
         val file = resolveElement.getContainingJetFile()
 
-        val statementFilter = if (bodyResolveMode != BodyResolveMode.FULL && resolveElement is JetDeclaration)
-            PartialBodyResolveFilter(contextElement, resolveElement, probablyNothingCallableNames(), bodyResolveMode == BodyResolveMode.PARTIAL_FOR_COMPLETION)
-        else
-            StatementFilter.NONE
+        var statementFilterUsed = StatementFilter.NONE
+
+        fun createStatementFilter(): StatementFilter {
+            assert(resolveElement is JetDeclaration)
+            if (bodyResolveMode != BodyResolveMode.FULL) {
+                statementFilterUsed = PartialBodyResolveFilter(
+                        contextElement,
+                        resolveElement as JetDeclaration,
+                        probablyNothingCallableNames(),
+                        bodyResolveMode == BodyResolveMode.PARTIAL_FOR_COMPLETION)
+            }
+            return statementFilterUsed
+        }
 
         val trace : BindingTrace = when (resolveElement) {
-            is JetNamedFunction -> functionAdditionalResolve(resolveSession, resolveElement, file, statementFilter)
+            is JetNamedFunction -> functionAdditionalResolve(resolveSession, resolveElement, file, createStatementFilter())
 
-            is JetClassInitializer -> initializerAdditionalResolve(resolveSession, resolveElement, file, statementFilter)
+            is JetClassInitializer -> initializerAdditionalResolve(resolveSession, resolveElement, file, createStatementFilter())
 
-            is JetSecondaryConstructor -> secondaryConstructorAdditionalResolve(resolveSession, resolveElement, file, statementFilter)
+            is JetSecondaryConstructor -> secondaryConstructorAdditionalResolve(resolveSession, resolveElement, file, createStatementFilter())
 
-            is JetProperty -> propertyAdditionalResolve(resolveSession, resolveElement, file, statementFilter)
+            is JetProperty -> propertyAdditionalResolve(resolveSession, resolveElement, file, createStatementFilter())
 
             is JetDelegationSpecifierList -> delegationSpecifierAdditionalResolve(resolveSession, resolveElement, resolveElement.getParent() as JetClassOrObject, file)
 
             is JetInitializerList -> delegationSpecifierAdditionalResolve(resolveSession, resolveElement, resolveElement.getParent() as JetEnumEntry, file)
 
-            is JetImportDirective -> {
+            is JetImportList -> {
                 val scope = resolveSession.getFileScopeProvider().getFileScope(resolveElement.getContainingJetFile())
                 scope.forceResolveAllImports()
                 resolveSession.getTrace()
@@ -141,7 +146,7 @@ public abstract class ElementResolver protected constructor(
 
             is JetAnnotationEntry -> annotationAdditionalResolve(resolveSession, resolveElement)
 
-            is JetClass -> constructorAdditionalResolve(resolveSession, resolveElement, file, statementFilter)
+            is JetClass -> constructorAdditionalResolve(resolveSession, resolveElement, file)
 
             is JetTypeParameter -> typeParameterAdditionalResolve(resolveSession, resolveElement)
 
@@ -163,7 +168,7 @@ public abstract class ElementResolver protected constructor(
         JetFlowInformationProvider(resolveElement, controlFlowTrace).checkDeclaration()
         controlFlowTrace.addOwnDataTo(trace, null, false)
 
-        return trace.getBindingContext()
+        return Pair(trace.getBindingContext(), statementFilterUsed)
     }
 
     private fun packageRefAdditionalResolve(resolveSession: ResolveSession, jetElement: JetElement): BindingTrace {
@@ -206,53 +211,22 @@ public abstract class ElementResolver protected constructor(
         val trace = createDelegatingTrace(codeFragment)
 
         val codeFragmentExpression = codeFragment.getContentElement() as? JetExpression ?: return trace
-        val contextElement = codeFragment.correctedContext
 
-        val scopeForContextElement: JetScope?
-        val dataFlowInfoForContextElement: DataFlowInfo
-        when (contextElement) {
-            is JetClassOrObject -> {
-                val descriptor = resolveSession.resolveToDescriptor(contextElement) as LazyClassDescriptor
-                scopeForContextElement = descriptor.getScopeForMemberDeclarationResolution()
-                dataFlowInfoForContextElement = DataFlowInfo.EMPTY
-            }
+        val (scopeForContextElement, dataFlowInfoForContextElement) = codeFragment.getScopeAndDataFlowForAnalyzeFragment(resolveSession) {
+            val contextResolveMode = if (bodyResolveMode == BodyResolveMode.PARTIAL)
+                BodyResolveMode.PARTIAL_FOR_COMPLETION
+            else
+                bodyResolveMode
 
-            is JetExpression -> {
-                // do not use PARTIAL body resolve mode because because it does not know about names used in our fragment
-                val contextResolveMode = if (bodyResolveMode == BodyResolveMode.PARTIAL)
-                    BodyResolveMode.PARTIAL_FOR_COMPLETION
-                else
-                    bodyResolveMode
-                val contextForElement = resolveToElement(contextElement, contextResolveMode)
-                scopeForContextElement = contextForElement[BindingContext.RESOLUTION_SCOPE, contextElement]
-                dataFlowInfoForContextElement = contextForElement.getDataFlowInfo(contextElement)
-            }
+            resolveToElement(it, contextResolveMode)
+        } ?: return trace
 
-            else -> return trace
-        }
-
-        if (scopeForContextElement == null) return trace
-
-        val codeFragmentScope = resolveSession.getFileScopeProvider().getFileScope(codeFragment)
-        val chainedScope = ChainedScope(scopeForContextElement.getContainingDeclaration(),
-                                        "Scope for resolve code fragment", scopeForContextElement, codeFragmentScope)
-
-        codeFragmentExpression.computeTypeInContext(chainedScope, trace, dataFlowInfoForContextElement,
+        codeFragmentExpression.computeTypeInContext(scopeForContextElement, trace, dataFlowInfoForContextElement,
                                                     TypeUtils.NO_EXPECTED_TYPE, resolveSession.getModuleDescriptor())
 
         return trace
     }
 
-    //TODO: this code should be moved into debugger which should set correct context for its code fragment
-    private val JetCodeFragment.correctedContext: PsiElement?
-        get() {
-            val context = getContext()
-            if (context is JetBlockExpression) {
-                return context.getStatements().lastOrNull() ?: context
-            }
-            return context
-        }
-
     private fun annotationAdditionalResolve(resolveSession: ResolveSession, jetAnnotationEntry: JetAnnotationEntry): BindingTrace {
         val modifierList = jetAnnotationEntry.getParentOfType<JetModifierList>(true)
         val declaration = modifierList?.getParentOfType<JetDeclaration>(true)
@@ -375,7 +349,7 @@ public abstract class ElementResolver protected constructor(
         return trace
     }
 
-    private fun constructorAdditionalResolve(resolveSession: ResolveSession, klass: JetClass, file: JetFile, statementFilter: StatementFilter): BindingTrace {
+    private fun constructorAdditionalResolve(resolveSession: ResolveSession, klass: JetClass, file: JetFile): BindingTrace {
         val trace = createDelegatingTrace(klass)
         val scope = resolveSession.getDeclarationScopeProvider().getResolutionScopeForDeclaration(klass)
 
@@ -383,7 +357,7 @@ public abstract class ElementResolver protected constructor(
         val constructorDescriptor = classDescriptor.getUnsubstitutedPrimaryConstructor()
                                     ?: error("Can't get primary constructor for descriptor '$classDescriptor' in from class '${klass.getElementTextWithContext()}'")
 
-        val bodyResolver = createBodyResolver(resolveSession, trace, file, statementFilter)
+        val bodyResolver = createBodyResolver(resolveSession, trace, file, StatementFilter.NONE)
         bodyResolver.resolveConstructorParameterDefaultValuesAndAnnotations(DataFlowInfo.EMPTY, trace, klass, constructorDescriptor, scope)
 
         return trace
@@ -397,15 +371,21 @@ public abstract class ElementResolver protected constructor(
 
         val bodyResolver = createBodyResolver(resolveSession, trace, file, statementFilter)
         bodyResolver.resolveAnonymousInitializer(DataFlowInfo.EMPTY, classInitializer, classOrObjectDescriptor)
-    
+
         return trace
     }
 
-    private fun createBodyResolver(resolveSession: ResolveSession, trace: BindingTrace, file: JetFile, statementFilter: StatementFilter): BodyResolver {
+    private fun createBodyResolver(
+            resolveSession: ResolveSession,
+            trace: BindingTrace,
+            file: JetFile,
+            statementFilter: StatementFilter
+    ): BodyResolver {
         val globalContext = SimpleGlobalContext(resolveSession.getStorageManager(), resolveSession.getExceptionTracker())
+        val module = resolveSession.getModuleDescriptor()
         return createContainerForBodyResolve(
-                globalContext.withProject(file.getProject()).withModule(resolveSession.getModuleDescriptor()),
-                trace, getAdditionalCheckerProvider(file), statementFilter, getDynamicTypesSettings(file)
+                globalContext.withProject(file.getProject()).withModule(module),
+                trace, createAdditionalCheckerProvider(file, module), statementFilter, getDynamicTypesSettings(file)
         ).get<BodyResolver>()
     }
 
@@ -477,8 +457,9 @@ public abstract class ElementResolver protected constructor(
         return null
     }
 
-    protected abstract fun getAdditionalCheckerProvider(jetFile: JetFile): AdditionalCheckerProvider
-    protected abstract fun getDynamicTypesSettings(jetFile: JetFile): DynamicTypesSettings
+    protected abstract fun createAdditionalCheckerProvider(file: JetFile, module: ModuleDescriptor): AdditionalCheckerProvider
+
+    protected abstract fun getDynamicTypesSettings(file: JetFile): DynamicTypesSettings
 
     private class BodyResolveContextForLazy(
             private val topDownAnalysisMode: TopDownAnalysisMode,
@@ -486,19 +467,19 @@ public abstract class ElementResolver protected constructor(
     ) : BodiesResolveContext {
         override fun getFiles(): Collection<JetFile> = setOf()
 
-        override fun getDeclaredClasses(): Map<JetClassOrObject, ClassDescriptorWithResolutionScopes> = mapOf()
+        override fun getDeclaredClasses(): MutableMap<JetClassOrObject, ClassDescriptorWithResolutionScopes> = hashMapOf()
 
-        override fun getAnonymousInitializers(): Map<JetClassInitializer, ClassDescriptorWithResolutionScopes> = mapOf()
+        override fun getAnonymousInitializers(): MutableMap<JetClassInitializer, ClassDescriptorWithResolutionScopes> = hashMapOf()
 
-        override fun getSecondaryConstructors(): Map<JetSecondaryConstructor, ConstructorDescriptor> = mapOf()
+        override fun getSecondaryConstructors(): MutableMap<JetSecondaryConstructor, ConstructorDescriptor> = hashMapOf()
 
-        override fun getProperties(): Map<JetProperty, PropertyDescriptor> = mapOf()
+        override fun getProperties(): MutableMap<JetProperty, PropertyDescriptor> = hashMapOf()
 
-        override fun getFunctions(): Map<JetNamedFunction, SimpleFunctionDescriptor> = mapOf()
+        override fun getFunctions(): MutableMap<JetNamedFunction, SimpleFunctionDescriptor> = hashMapOf()
 
         override fun getDeclaringScope(declaration: JetDeclaration): JetScope? = declaringScopes(declaration)
 
-        override fun getScripts(): Map<JetScript, ScriptDescriptor> = mapOf()
+        override fun getScripts(): MutableMap<JetScript, ScriptDescriptor> = hashMapOf()
 
         override fun getOuterDataFlowInfo(): DataFlowInfo = DataFlowInfo.EMPTY
 
diff --git a/idea/ide-common/src/org/jetbrains/kotlin/resolve/lazy/PartialBodyResolveFilter.kt b/idea/ide-common/src/org/jetbrains/kotlin/resolve/lazy/PartialBodyResolveFilter.kt
index 5a1407fe076..c6bce01f18f 100644
--- a/idea/ide-common/src/org/jetbrains/kotlin/resolve/lazy/PartialBodyResolveFilter.kt
+++ b/idea/ide-common/src/org/jetbrains/kotlin/resolve/lazy/PartialBodyResolveFilter.kt
@@ -16,20 +16,19 @@
 
 package org.jetbrains.kotlin.resolve.lazy
 
-import java.util.HashSet
-import org.jetbrains.kotlin.psi.*
-import org.jetbrains.kotlin.psi.psiUtil.siblings
+import com.intellij.psi.PsiElement
+import com.intellij.util.SmartList
+import org.jetbrains.kotlin.JetNodeTypes
 import org.jetbrains.kotlin.lexer.JetTokens
-import org.jetbrains.kotlin.utils.addIfNotNull
+import org.jetbrains.kotlin.psi.*
+import org.jetbrains.kotlin.psi.psiUtil.*
+import org.jetbrains.kotlin.resolve.StatementFilter
+import org.jetbrains.kotlin.util.isProbablyNothing
+import org.jetbrains.kotlin.utils.addToStdlib.firstIsInstanceOrNull
+import org.jetbrains.kotlin.utils.addToStdlib.swap
 import java.util.ArrayList
 import java.util.HashMap
-import com.intellij.psi.PsiElement
-import org.jetbrains.kotlin.JetNodeTypes
-import org.jetbrains.kotlin.utils.addToStdlib.firstIsInstanceOrNull
-import org.jetbrains.kotlin.psi.psiUtil.isAncestor
-import org.jetbrains.kotlin.resolve.StatementFilter
-import org.jetbrains.kotlin.utils.addToStdlib.swap
-import org.jetbrains.kotlin.util.isProbablyNothing
+import java.util.HashSet
 
 //TODO: do resolve anonymous object's body
 
@@ -45,39 +44,32 @@ class PartialBodyResolveFilter(
     private val nothingFunctionNames = HashSet(probablyNothingCallableNames.functionNames())
     private val nothingVariableNames = HashSet(probablyNothingCallableNames.propertyNames())
 
-    override val filter: ((JetExpression) -> Boolean)? = { statementMarks.statementMark(it) != MarkLevel.SKIP }
+    override val filter: ((JetExpression) -> Boolean)? = { statementMarks.statementMark(it) != MarkLevel.NONE }
+
+    val allStatementsToResolve: Collection<JetExpression>
+        get() = statementMarks.allMarkedStatements()
 
     init {
         assert(declaration.isAncestor(elementToResolve))
         assert(!JetPsiUtil.isLocal(declaration),
                "Should never be invoked on local declaration otherwise we may miss some local declarations with type Nothing")
 
-        declaration.accept(object : JetVisitorVoid() {
-            override fun visitDeclaration(declaration: JetDeclaration) {
-                super.visitDeclaration(declaration)
-
-                if (declaration is JetCallableDeclaration) {
-                    if (declaration.getTypeReference().containsProbablyNothing()) {
-                        val name = declaration.getName()
-                        if (name != null) {
-                            if (declaration is JetNamedFunction) {
-                                nothingFunctionNames.add(name)
-                            }
-                            else {
-                                nothingVariableNames.add(name)
-                            }
-                        }
+        declaration.forEachDescendantOfType<JetCallableDeclaration> { declaration ->
+            if (declaration.getTypeReference().containsProbablyNothing()) {
+                val name = declaration.getName()
+                if (name != null) {
+                    if (declaration is JetNamedFunction) {
+                        nothingFunctionNames.add(name)
+                    }
+                    else {
+                        nothingVariableNames.add(name)
                     }
                 }
             }
-
-            override fun visitElement(element: PsiElement) {
-                element.acceptChildren(this)
-            }
-        })
+        }
 
         statementMarks.mark(elementToResolve, if (forCompletion) MarkLevel.NEED_COMPLETION else MarkLevel.NEED_REFERENCE_RESOLVE)
-        declaration.blocks().forEach { processBlock(it) }
+        declaration.forTopLevelBlocksInside { processBlock(it) }
     }
 
     //TODO: do..while is special case
@@ -131,7 +123,7 @@ class PartialBodyResolveFilter(
 
             val level = statementMarks.statementMark(statement)
             if (level > MarkLevel.TAKE) { // otherwise there are no statements inside that need processBlock which only works when reference resolve needed
-                for (nestedBlock in statement.blocks()) {
+                statement.forTopLevelBlocksInside { nestedBlock ->
                     val childFilter = processBlock(nestedBlock)
                     nameFilter.addNamesFromFilter(childFilter)
                 }
@@ -496,22 +488,11 @@ class PartialBodyResolveFilter(
         val isEmpty: Boolean
             get() = names?.isEmpty() ?: false
 
-        private val addUsedNamesVisitor = object : JetVisitorVoid(){
-            override fun visitSimpleNameExpression(expression: JetSimpleNameExpression) {
-                names!!.add(expression.getReferencedName())
-            }
-
-            override fun visitJetElement(element: JetElement) {
-                element.acceptChildren(this)
-            }
-
-            override fun visitBlockExpression(expression: JetBlockExpression) {
-            }
-        }
-
         fun addUsedNames(statement: JetExpression) {
             if (names != null) {
-                statement.accept(addUsedNamesVisitor)
+                statement.forEachDescendantOfType<JetSimpleNameExpression>(canGoInside = { it !is JetBlockExpression }) {
+                    names!!.add(it.getReferencedName())
+                }
             }
         }
 
@@ -531,25 +512,19 @@ class PartialBodyResolveFilter(
     }
 
     private enum class MarkLevel {
-        SKIP,
+        NONE,
         TAKE,
         NEED_REFERENCE_RESOLVE,
         NEED_COMPLETION
     }
 
     companion object {
-        private fun JetElement.blocks(): Collection<JetBlockExpression> {
-            val result = ArrayList<JetBlockExpression>(1)
-            this.accept(object : JetVisitorVoid() {
-                override fun visitBlockExpression(expression: JetBlockExpression) {
-                    result.add(expression)
-                }
+        public fun findStatementToResolve(element: JetElement, declaration: JetDeclaration): JetExpression? {
+            return element.parentsWithSelf.takeWhile { it != declaration }.firstOrNull { it.isStatement() } as JetExpression?
+        }
 
-                override fun visitElement(element: PsiElement) {
-                    element.acceptChildren(this)
-                }
-            })
-            return result
+        private fun JetElement.forTopLevelBlocksInside(action: (JetBlockExpression) -> Unit) {
+            forEachDescendantOfType(canGoInside = { it !is JetBlockExpression }, action = action)
         }
 
         private fun JetExpression?.isNullLiteral() = this?.getNode()?.getElementType() == JetNodeTypes.NULL
@@ -577,6 +552,8 @@ class PartialBodyResolveFilter(
                         true
                 }
 
+                is JetClassInitializer -> false
+
                 else -> true
             }
         }
@@ -586,21 +563,8 @@ class PartialBodyResolveFilter(
 
         private fun PsiElement.isStatement() = this is JetExpression && getParent() is JetBlockExpression
 
-        private fun JetTypeReference?.containsProbablyNothing(): Boolean {
-            var result = false
-            this?.getTypeElement()?.accept(object : JetVisitorVoid() {
-                override fun visitJetElement(element: JetElement) {
-                    element.acceptChildren(this)
-                }
-
-                override fun visitUserType(type: JetUserType) {
-                    if (type.isProbablyNothing()) {
-                        result = true
-                    }
-                }
-            })
-            return result
-        }
+        private fun JetTypeReference?.containsProbablyNothing()
+                = this?.getTypeElement()?.anyDescendantOfType<JetUserType> { it.isProbablyNothing() } ?: false
     }
 
     private inner class StatementMarks {
@@ -623,7 +587,7 @@ class PartialBodyResolveFilter(
                 statementMarks[statement] = level
 
                 val block = statement.getParent() as JetBlockExpression
-                val currentBlockLevel = blockLevels[block] ?: MarkLevel.SKIP
+                val currentBlockLevel = blockLevels[block] ?: MarkLevel.NONE
                 if (currentBlockLevel < level) {
                     blockLevels[block] = level
                 }
@@ -631,10 +595,13 @@ class PartialBodyResolveFilter(
         }
 
         fun statementMark(statement: JetExpression): MarkLevel
-                = statementMarks[statement] ?: MarkLevel.SKIP
+                = statementMarks[statement] ?: MarkLevel.NONE
+
+        fun allMarkedStatements(): Collection<JetExpression>
+                = statementMarks.keySet()
 
         fun lastMarkedStatement(block: JetBlockExpression, minLevel: MarkLevel): JetExpression? {
-            val level = blockLevels[block] ?: MarkLevel.SKIP
+            val level = blockLevels[block] ?: MarkLevel.NONE
             if (level < minLevel) return null // optimization
             return block.getLastChild().siblings(forward = false)
                     .filterIsInstance<JetExpression>()
diff --git a/idea/ide-common/src/org/jetbrains/kotlin/resolve/util/codeFragmentResolveUtils.kt b/idea/ide-common/src/org/jetbrains/kotlin/resolve/util/codeFragmentResolveUtils.kt
new file mode 100644
index 00000000000..b9d79298474
--- /dev/null
+++ b/idea/ide-common/src/org/jetbrains/kotlin/resolve/util/codeFragmentResolveUtils.kt
@@ -0,0 +1,97 @@
+/*
+ * Copyright 2010-2015 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.kotlin.resolve.util
+
+import org.jetbrains.kotlin.descriptors.ClassDescriptorWithResolutionScopes
+import org.jetbrains.kotlin.psi.*
+import org.jetbrains.kotlin.psi.psiUtil.parents
+import org.jetbrains.kotlin.psi.psiUtil.siblings
+import org.jetbrains.kotlin.resolve.BindingContext
+import org.jetbrains.kotlin.resolve.bindingContextUtil.getDataFlowInfo
+import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo
+import org.jetbrains.kotlin.resolve.lazy.KotlinCodeAnalyzer
+import org.jetbrains.kotlin.resolve.scopes.ChainedScope
+import org.jetbrains.kotlin.resolve.scopes.JetScope
+import org.jetbrains.kotlin.utils.addToStdlib.firstIsInstanceOrNull
+
+//TODO: this code should be moved into debugger which should set correct context for its code fragment
+private fun JetExpression.correctContextForExpression(): JetExpression {
+    when (this) {
+        is JetBlockExpression -> {
+            return this.getStatements().lastOrNull() ?: this
+        }
+        is JetFunctionLiteral -> {
+            return this.getBodyExpression()?.getStatements()?.lastOrNull() ?: this
+        }
+        else -> {
+            val previousExpression = this.siblings(forward = false, withItself = false).firstIsInstanceOrNull<JetExpression>()
+            if (previousExpression is JetExpression) {
+                return previousExpression
+            }
+            else {
+                val parentExpression = this.parents.firstIsInstanceOrNull<JetExpression>()
+                if (parentExpression is JetExpression) {
+                    return parentExpression
+                }
+            }
+        }
+    }
+    return this
+}
+
+public fun JetCodeFragment.getScopeAndDataFlowForAnalyzeFragment(
+        resolveSession: KotlinCodeAnalyzer,
+        resolveToElement: (JetElement) -> BindingContext
+): Pair<JetScope, DataFlowInfo>? {
+    val context = getContext()
+    if (context !is JetExpression) return null
+
+    val scopeForContextElement: JetScope?
+    val dataFlowInfo: DataFlowInfo
+
+    when (context) {
+        is JetClassOrObject -> {
+            val descriptor = resolveSession.getClassDescriptor(context) as ClassDescriptorWithResolutionScopes
+
+            scopeForContextElement = descriptor.getScopeForMemberDeclarationResolution()
+            dataFlowInfo = DataFlowInfo.EMPTY
+        }
+        is JetExpression -> {
+            val correctedContext = context.correctContextForExpression()
+
+            val contextForElement = resolveToElement(correctedContext)
+
+            scopeForContextElement = contextForElement[BindingContext.RESOLUTION_SCOPE, correctedContext]
+            dataFlowInfo = contextForElement.getDataFlowInfo(correctedContext)
+        }
+        is JetFile -> {
+            scopeForContextElement = resolveSession.getFileScopeProvider().getFileScope(context)
+            dataFlowInfo = DataFlowInfo.EMPTY
+        }
+        else -> return null
+    }
+
+    if (scopeForContextElement == null) return null
+
+    val codeFragmentScope = resolveSession.getFileScopeProvider().getFileScope(this)
+    val chainedScope = ChainedScope(
+            scopeForContextElement.getContainingDeclaration(),
+            "Scope for resolve code fragment",
+            scopeForContextElement, codeFragmentScope)
+
+    return chainedScope to dataFlowInfo
+}
diff --git a/idea/ide-common/src/org/jetbrains/kotlin/util/descriptorUtils.kt b/idea/ide-common/src/org/jetbrains/kotlin/util/descriptorUtils.kt
new file mode 100644
index 00000000000..61598d00aad
--- /dev/null
+++ b/idea/ide-common/src/org/jetbrains/kotlin/util/descriptorUtils.kt
@@ -0,0 +1,58 @@
+/*
+ * Copyright 2010-2015 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.kotlin.util
+
+import org.jetbrains.kotlin.descriptors.CallableDescriptor
+import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
+import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor
+import org.jetbrains.kotlin.types.TypeConstructor
+import org.jetbrains.kotlin.types.checker.JetTypeChecker
+import org.jetbrains.kotlin.types.typeUtil.equalTypesOrNulls
+
+public fun descriptorsEqualWithSubstitution(descriptor1: DeclarationDescriptor?, descriptor2: DeclarationDescriptor?): Boolean {
+    if (descriptor1 == descriptor2) return true
+    if (descriptor1 == null || descriptor2 == null) return false
+    if (descriptor1.getOriginal() != descriptor2.getOriginal()) return false
+    if (descriptor1 !is CallableDescriptor) return true
+    descriptor2 as CallableDescriptor
+
+    val typeChecker = JetTypeChecker.withAxioms(object: JetTypeChecker.TypeConstructorEquality {
+        override fun equals(a: TypeConstructor, b: TypeConstructor): Boolean {
+            val typeParam1 = a.getDeclarationDescriptor() as? TypeParameterDescriptor
+            val typeParam2 = b.getDeclarationDescriptor() as? TypeParameterDescriptor
+            if (typeParam1 != null
+                && typeParam2 != null
+                && typeParam1.getContainingDeclaration() == descriptor1
+                && typeParam2.getContainingDeclaration() == descriptor2) {
+                return typeParam1.getIndex() == typeParam2.getIndex()
+            }
+
+            return a == b
+        }
+    })
+
+    if (!typeChecker.equalTypesOrNulls(descriptor1.getReturnType(), descriptor2.getReturnType())) return false
+
+    val parameters1 = descriptor1.getValueParameters()
+    val parameters2 = descriptor2.getValueParameters()
+    if (parameters1.size() != parameters2.size()) return false
+    for ((param1, param2) in parameters1.zip(parameters2)) {
+        if (!typeChecker.equalTypes(param1.getType(), param2.getType())) return false
+    }
+    return true
+}
+
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/JetBundle.properties b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/JetBundle.properties
index c57187ff1aa..e80b9aaff18 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/JetBundle.properties
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/JetBundle.properties
@@ -47,7 +47,7 @@ introduce.non.null.assertion=Add non-null asserted (!!) call
 remove.unnecessary.non.null.assertion=Remove unnecessary non-null assertion (!!)
 change.to.backing.field=Change reference to backing field
 implement.members=Implement members
-new.kotlin.file.action=Kotlin File
+new.kotlin.file.action=Kotlin File/Class
 import.fix=Import
 imports.chooser.title=Imports
 rename.parameter.to.match.overridden.method=Rename parameter to match overridden method
@@ -270,7 +270,7 @@ usageType.packageMemberAccess = Package member access
 
 x.in.y={0} in {1}
 x.implements.y={0} in {1} implements {2} in {3}.
-x.overrides.y.in.class.list={0} in {1} overrides functions in the following classes/interfaces: {2} Do you want to {3} the base functions?
+x.overrides.y.in.class.list={0} in {1} overrides declarations in the following classes/interfaces: {2} Do you want to {3} the base declarations?
 
 unused.overriding.methods.title=Unused Overriding Members
 there.are.unused.methods.that.override.methods.you.delete=There are unused members that override methods you delete.
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/JetIcons.java b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/JetIcons.java
index 92b1e51c537..49d0151a479 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/JetIcons.java
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/JetIcons.java
@@ -31,7 +31,7 @@ public interface JetIcons {
     Icon ENUM = IconLoader.getIcon("/org/jetbrains/kotlin/idea/icons/enumKotlin.png");
     Icon FILE = IconLoader.getIcon("/org/jetbrains/kotlin/idea/icons/kotlin_file.png");
     Icon OBJECT = IconLoader.getIcon("/org/jetbrains/kotlin/idea/icons/objectKotlin.png");
-    Icon TRAIT = IconLoader.getIcon("/org/jetbrains/kotlin/idea/icons/traitKotlin.png");
+    Icon TRAIT = IconLoader.getIcon("/org/jetbrains/kotlin/idea/icons/interfaceKotlin.png");
     Icon FUNCTION = IconLoader.getIcon("/org/jetbrains/kotlin/idea/icons/function.png");
     Icon EXTENSION_FUNCTION = PlatformIcons.FUNCTION_ICON;
     Icon LAMBDA = IconLoader.getIcon("/org/jetbrains/kotlin/idea/icons/lambda.png");
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/IDELightClassGenerationSupport.java b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/IDELightClassGenerationSupport.java
index cb1b09ccf46..41347685827 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/IDELightClassGenerationSupport.java
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/IDELightClassGenerationSupport.java
@@ -59,6 +59,7 @@ import org.jetbrains.kotlin.resolve.BindingContext;
 import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode;
 import org.jetbrains.kotlin.resolve.lazy.ForceResolveUtil;
 import org.jetbrains.kotlin.resolve.lazy.KotlinCodeAnalyzer;
+import org.jetbrains.kotlin.resolve.scopes.JetScope;
 
 import java.io.IOException;
 import java.util.*;
@@ -204,7 +205,7 @@ public class IDELightClassGenerationSupport extends LightClassGenerationSupport
     @NotNull
     @Override
     public Collection<FqName> getSubPackages(@NotNull FqName fqn, @NotNull GlobalSearchScope scope) {
-        return PackageIndexUtil.getSubPackageFqNames(fqn, kotlinSourceAndClassFiles(scope, project), project);
+        return PackageIndexUtil.getSubPackageFqNames(fqn, kotlinSourceAndClassFiles(scope, project), project, JetScope.ALL_NAME_FILTER);
     }
 
     @Nullable
@@ -237,8 +238,8 @@ public class IDELightClassGenerationSupport extends LightClassGenerationSupport
             @NotNull JetClassOrObject decompiledClassOrObject,
             @NotNull PsiClass rootLightClassForDecompiledFile
     ) {
-        List<Name> relativeClassNameSegments = getClassRelativeName(decompiledClassOrObject).pathSegments();
-        Iterator<Name> iterator = relativeClassNameSegments.iterator();
+        FqName relativeFqName = getClassRelativeName(decompiledClassOrObject);
+        Iterator<Name> iterator = relativeFqName.pathSegments().iterator();
         Name base = iterator.next();
         assert rootLightClassForDecompiledFile.getName().equals(base.asString())
                 : "Light class for file:\n" + decompiledClassOrObject.getContainingJetFile().getVirtualFile().getCanonicalPath()
@@ -247,7 +248,8 @@ public class IDELightClassGenerationSupport extends LightClassGenerationSupport
         while (iterator.hasNext()) {
             Name name = iterator.next();
             PsiClass innerClass = current.findInnerClassByName(name.asString(), false);
-            assert innerClass != null : "Inner class should be found";
+            assert innerClass != null : "Could not find corresponding inner/nested class " + relativeFqName + "in class " + decompiledClassOrObject.getName() + "\n" +
+                                        "File: " + decompiledClassOrObject.getContainingJetFile().getVirtualFile().getName();
             current = innerClass;
         }
         return current;
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/JavaResolveExtension.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/JavaResolveExtension.kt
index 95cfd9a5edf..6bfc09d511e 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/JavaResolveExtension.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/JavaResolveExtension.kt
@@ -45,32 +45,21 @@ public object JavaResolveExtension : CacheExtension<(PsiElement) -> Pair<JavaDes
             KotlinCacheService.getInstance(project)[this](element).second
 }
 
-fun PsiMethod.getJavaMethodDescriptor(): FunctionDescriptor {
-    val method = getOriginalElement() as PsiMethod
+fun PsiMethod.getJavaMethodDescriptor(): FunctionDescriptor? {
+    val method = getOriginalElement() as? PsiMethod ?: return null
     val resolver = JavaResolveExtension.getResolver(method.getProject(), method)
-    val methodDescriptor = when {
+    return when {
         method.isConstructor() -> resolver.resolveConstructor(JavaConstructorImpl(method))
         else -> resolver.resolveMethod(JavaMethodImpl(method))
     }
-    assert(methodDescriptor != null) { "No descriptor found for " + method.getText() }
-
-    return methodDescriptor!!
 }
 
-fun PsiClass.getJavaClassDescriptor(): ClassDescriptor {
-    val resolver = JavaResolveExtension.getResolver(getProject(), this)
-    val classDescriptor = resolver.resolveClass(JavaClassImpl(this))
-    assert(classDescriptor != null) { "No descriptor found for " + getText() }
-
-    return classDescriptor!!
+fun PsiClass.getJavaClassDescriptor(): ClassDescriptor? {
+    return JavaResolveExtension.getResolver(getProject(), this).resolveClass(JavaClassImpl(this))
 }
 
-fun PsiField.getJavaFieldDescriptor(): PropertyDescriptor {
-    val resolver = JavaResolveExtension.getResolver(getProject(), this)
-    val fieldDescriptor = resolver.resolveField(JavaFieldImpl(this))
-    assert(fieldDescriptor != null) { "No descriptor found for " + getText() }
-
-    return fieldDescriptor!!
+fun PsiField.getJavaFieldDescriptor(): PropertyDescriptor? {
+    return JavaResolveExtension.getResolver(getProject(), this).resolveField(JavaFieldImpl(this))
 }
 
 fun PsiMember.getJavaMemberDescriptor(): DeclarationDescriptor? {
@@ -104,7 +93,7 @@ private fun JavaDescriptorResolver.getContainingScope(member: JavaMember): JetSc
 
 private fun <T : DeclarationDescriptorWithSource> Collection<T>.findByJavaElement(javaElement: JavaElement): T? {
     return firstOrNull { member ->
-        val memberJavaElement = (member.getSource() as? JavaSourceElement)?.javaElement
+        val memberJavaElement = (member.getOriginal().getSource() as? JavaSourceElement)?.javaElement
         when {
             memberJavaElement == javaElement ->
                 true
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/KotlinCacheService.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/KotlinCacheService.kt
index d3c016855c9..9d2a61818ba 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/KotlinCacheService.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/KotlinCacheService.kt
@@ -21,6 +21,7 @@ import com.intellij.openapi.diagnostic.Logger
 import com.intellij.openapi.project.Project
 import com.intellij.openapi.roots.ProjectRootModificationTracker
 import com.intellij.psi.util.CachedValueProvider
+import com.intellij.psi.util.CachedValuesManager
 import com.intellij.psi.util.PsiModificationTracker
 import com.intellij.util.containers.SLRUCache
 import org.jetbrains.kotlin.analyzer.AnalysisResult
@@ -102,67 +103,77 @@ public class KotlinCacheService(val project: Project) {
     private fun getGlobalCache(platform: TargetPlatform) = globalCachesPerPlatform[platform]!!.modulesCache
     private fun getGlobalLibrariesCache(platform: TargetPlatform) = globalCachesPerPlatform[platform]!!.librariesCache
 
-    private val syntheticFileCaches = object : SLRUCache<Set<JetFile>, KotlinResolveCache>(2, 3) {
-        override fun createValue(files: Set<JetFile>): KotlinResolveCache {
-            // we assume that all files come from the same module
-            val targetPlatform = files.map { TargetPlatformDetector.getPlatform(it) }.toSet().single()
-            val syntheticFileModule = files.map { it.getModuleInfo() }.toSet().single()
-            val dependenciesForSyntheticFileCache = listOf(
-                    PsiModificationTracker.OUT_OF_CODE_BLOCK_MODIFICATION_COUNT,
-                    KotlinOutOfBlockCompletionModificationTracker.getInstance(project)
-            )
-            return when {
-                syntheticFileModule is ModuleSourceInfo -> {
-                    val dependentModules = syntheticFileModule.getDependentModules()
-                    KotlinResolveCache(
-                            project,
-                            globalResolveSessionProvider(
-                                    targetPlatform,
-                                    syntheticFiles = files,
-                                    reuseDataFromCache = getGlobalCache(targetPlatform),
-                                    moduleFilter = { it in dependentModules },
-                                    dependencies = dependenciesForSyntheticFileCache
-                            )
-                    )
-                }
-
-                syntheticFileModule is LibrarySourceInfo || syntheticFileModule is NotUnderContentRootModuleInfo -> {
-                    KotlinResolveCache(
-                            project,
-                            globalResolveSessionProvider(
-                                    targetPlatform,
-                                    syntheticFiles = files,
-                                    reuseDataFromCache = getGlobalLibrariesCache(targetPlatform),
-                                    moduleFilter = { it == syntheticFileModule },
-                                    dependencies = dependenciesForSyntheticFileCache
-                            )
-                    )
-                }
-
-                syntheticFileModule.isLibraryClasses() -> {
-                    //NOTE: this code should not be called for sdk or library classes
-                    // currently the only known scenario is when we cannot determine that file is a library source
-                    // (file under both classes and sources root)
-                    LOG.warn("Creating cache with synthetic files ($files) in classes of library $syntheticFileModule")
-                    KotlinResolveCache(
-                            project,
-                            globalResolveSessionProvider(
-                                    targetPlatform,
-                                    syntheticFiles = files,
-                                    moduleFilter = { true },
-                                    dependencies = dependenciesForSyntheticFileCache
-                            )
-                    )
-                }
-
-                else -> throw IllegalStateException("Unknown IdeaModuleInfo ${syntheticFileModule.javaClass}")
+    private fun createCacheForSyntheticFiles(files: Set<JetFile>): KotlinResolveCache {
+        // we assume that all files come from the same module
+        val targetPlatform = files.map { TargetPlatformDetector.getPlatform(it) }.toSet().single()
+        val syntheticFileModule = files.map { it.getModuleInfo() }.toSet().single()
+        val dependenciesForSyntheticFileCache = listOf(
+                PsiModificationTracker.OUT_OF_CODE_BLOCK_MODIFICATION_COUNT,
+                KotlinOutOfBlockCompletionModificationTracker.getInstance(project)
+        )
+        return when {
+            syntheticFileModule is ModuleSourceInfo -> {
+                val dependentModules = syntheticFileModule.getDependentModules()
+                KotlinResolveCache(
+                        project,
+                        globalResolveSessionProvider(
+                                targetPlatform,
+                                syntheticFiles = files,
+                                reuseDataFromCache = getGlobalCache(targetPlatform),
+                                moduleFilter = { it in dependentModules },
+                                dependencies = dependenciesForSyntheticFileCache
+                        )
+                )
             }
+
+            syntheticFileModule is LibrarySourceInfo || syntheticFileModule is NotUnderContentRootModuleInfo -> {
+                KotlinResolveCache(
+                        project,
+                        globalResolveSessionProvider(
+                                targetPlatform,
+                                syntheticFiles = files,
+                                reuseDataFromCache = getGlobalLibrariesCache(targetPlatform),
+                                moduleFilter = { it == syntheticFileModule },
+                                dependencies = dependenciesForSyntheticFileCache
+                        )
+                )
+            }
+
+            syntheticFileModule.isLibraryClasses() -> {
+                //NOTE: this code should not be called for sdk or library classes
+                // currently the only known scenario is when we cannot determine that file is a library source
+                // (file under both classes and sources root)
+                LOG.warn("Creating cache with synthetic files ($files) in classes of library $syntheticFileModule")
+                KotlinResolveCache(
+                        project,
+                        globalResolveSessionProvider(
+                                targetPlatform,
+                                syntheticFiles = files,
+                                moduleFilter = { true },
+                                dependencies = dependenciesForSyntheticFileCache
+                        )
+                )
+            }
+
+            else -> throw IllegalStateException("Unknown IdeaModuleInfo ${syntheticFileModule.javaClass}")
         }
     }
 
+    private val syntheticFileCachesLock = Any()
+
+    private val slruCacheProvider = CachedValueProvider {
+        CachedValueProvider.Result(object : SLRUCache<Set<JetFile>, KotlinResolveCache>(2, 3) {
+            override fun createValue(files: Set<JetFile>): KotlinResolveCache {
+                return createCacheForSyntheticFiles(files)
+            }
+        }, LibraryModificationTracker.getInstance(project), ProjectRootModificationTracker.getInstance(project))
+    }
+
     private fun getCacheForSyntheticFiles(files: Set<JetFile>): KotlinResolveCache {
-        return synchronized(syntheticFileCaches) {
-            syntheticFileCaches[files]
+        return synchronized(syntheticFileCachesLock) {
+            //NOTE: computations inside createCacheForSyntheticFiles depend on project root structure
+            // so we additionally drop the whole slru cache on change
+            CachedValuesManager.getManager(project).getCachedValue(project, slruCacheProvider).get(files)
         }
     }
 
@@ -188,12 +199,12 @@ public class KotlinCacheService(val project: Project) {
 
     private fun findSyntheticFiles(files: Collection<JetFile>) = files.map {
         if (it is JetCodeFragment) it.getContextFile() else it
-    }.filter {
+    }.filterNotNull().filter {
         !ProjectRootsUtil.isInProjectSource(it)
     }.toSet()
 
-    private fun JetCodeFragment.getContextFile(): JetFile {
-        val contextElement = getContext() ?: throw AssertionError("Analyzing code fragment of type $javaClass with no context")
+    private fun JetCodeFragment.getContextFile(): JetFile? {
+        val contextElement = getContext() ?: return null
         val contextFile = (contextElement as? JetElement)?.getContainingJetFile()
                           ?: throw AssertionError("Analyzing kotlin code fragment of type $javaClass with java context of type ${contextElement.javaClass}")
         return if (contextFile is JetCodeFragment) contextFile.getContextFile() else contextFile
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/KotlinResolveCache.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/KotlinResolveCache.kt
index b4d824fadd7..bea4defa543 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/KotlinResolveCache.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/KotlinResolveCache.kt
@@ -21,6 +21,7 @@ import com.intellij.openapi.project.DumbService
 import com.intellij.openapi.project.IndexNotReadyException
 import com.intellij.openapi.project.Project
 import com.intellij.psi.PsiElement
+import com.intellij.psi.PsiFile
 import com.intellij.psi.util.CachedValueProvider
 import com.intellij.psi.util.CachedValuesManager
 import com.intellij.psi.util.PsiModificationTracker
@@ -47,6 +48,7 @@ import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode
 import org.jetbrains.kotlin.resolve.lazy.descriptors.LazyClassDescriptor
 import org.jetbrains.kotlin.resolve.scopes.ChainedScope
 import org.jetbrains.kotlin.resolve.scopes.JetScope
+import org.jetbrains.kotlin.resolve.util.getScopeAndDataFlowForAnalyzeFragment
 import org.jetbrains.kotlin.types.TypeUtils
 import java.util.HashMap
 
@@ -195,6 +197,8 @@ private object KotlinResolveDataProvider {
     )
 
     fun findAnalyzableParent(element: JetElement): JetElement {
+        if (element is JetFile) return element
+
         val topmostElement = JetPsiUtil.getTopmostParentOfTypes(element, *topmostElementTypes) as JetElement?
         // parameters and supertype lists are not analyzable by themselves, but if we don't count them as topmost, we'll stop inside, say,
         // object expressions inside arguments of super constructors of classes (note that classes themselves are not topmost elements)
@@ -215,11 +219,9 @@ private object KotlinResolveDataProvider {
 
     fun analyze(project: Project, resolveSession: ResolveSessionForBodies, analyzableElement: JetElement): AnalysisResult {
         try {
+            val module = resolveSession.getModuleDescriptor()
             if (analyzableElement is JetCodeFragment) {
-                return AnalysisResult.success(
-                        analyzeExpressionCodeFragment(resolveSession, analyzableElement),
-                        resolveSession.getModuleDescriptor()
-                )
+                return AnalysisResult.success(analyzeExpressionCodeFragment(resolveSession, analyzableElement), module)
             }
 
             val file = analyzableElement.getContainingJetFile()
@@ -232,12 +234,12 @@ private object KotlinResolveDataProvider {
 
             val targetPlatform = TargetPlatformDetector.getPlatform(analyzableElement.getContainingJetFile())
             val globalContext = SimpleGlobalContext(resolveSession.getStorageManager(), resolveSession.getExceptionTracker())
-            val moduleContext = globalContext.withProject(project).withModule(resolveSession.getModuleDescriptor())
+            val moduleContext = globalContext.withProject(project).withModule(module)
             val lazyTopDownAnalyzer = createContainerForLazyBodyResolve(
                     moduleContext,
                     resolveSession,
                     trace,
-                    targetPlatform.getAdditionalCheckerProvider(),
+                    targetPlatform.createAdditionalCheckerProvider(module),
                     targetPlatform.getDynamicTypesSettings(),
                     resolveSession.getBodyResolveCache()
             ).get<LazyTopDownAnalyzerForTopLevel>()
@@ -248,7 +250,7 @@ private object KotlinResolveDataProvider {
             )
             return AnalysisResult.success(
                     trace.getBindingContext(),
-                    resolveSession.getModuleDescriptor()
+                    module
             )
         }
         catch (e: ProcessCanceledException) {
@@ -269,44 +271,13 @@ private object KotlinResolveDataProvider {
         val codeFragmentExpression = codeFragment.getContentElement()
         if (codeFragmentExpression !is JetExpression) return BindingContext.EMPTY
 
-        val contextElement = codeFragment.getContext()
+        val (scopeForContextElement, dataFlowInfo) = codeFragment.getScopeAndDataFlowForAnalyzeFragment(resolveSession) {
+            resolveSession.resolveToElement(it, BodyResolveMode.PARTIAL_FOR_COMPLETION) //TODO: discuss it
+        } ?: return BindingContext.EMPTY
 
-        val scopeForContextElement: JetScope?
-        val dataFlowInfo: DataFlowInfo
-        if (contextElement is JetClassOrObject) {
-            val descriptor = resolveSession.resolveToDescriptor(contextElement) as LazyClassDescriptor
-
-            scopeForContextElement = descriptor.getScopeForMemberDeclarationResolution()
-            dataFlowInfo = DataFlowInfo.EMPTY
-        }
-        else if (contextElement is JetBlockExpression) {
-            val newContextElement = contextElement.getStatements().lastOrNull()
-            if (newContextElement !is JetExpression) return BindingContext.EMPTY
-
-            val contextForElement = newContextElement.getResolutionFacade().analyze(newContextElement, BodyResolveMode.FULL)
-
-            scopeForContextElement = contextForElement[BindingContext.RESOLUTION_SCOPE, newContextElement]
-            dataFlowInfo = contextForElement.getDataFlowInfo(newContextElement)
-        }
-        else {
-            if (contextElement !is JetExpression) return BindingContext.EMPTY
-
-            val contextForElement = contextElement.getResolutionFacade().analyze(contextElement, BodyResolveMode.PARTIAL_FOR_COMPLETION) //TODO: discuss it
-
-            scopeForContextElement = contextForElement[BindingContext.RESOLUTION_SCOPE, contextElement]
-            dataFlowInfo = contextForElement.getDataFlowInfo(contextElement)
-        }
-
-        if (scopeForContextElement == null) return BindingContext.EMPTY
-
-        val codeFragmentScope = resolveSession.getFileScopeProvider().getFileScope(codeFragment)
-        val chainedScope = ChainedScope(
-                                scopeForContextElement.getContainingDeclaration(),
-                                "Scope for resolve code fragment",
-                                scopeForContextElement, codeFragmentScope)
 
         return codeFragmentExpression.analyzeInContext(
-                chainedScope,
+                scopeForContextElement,
                 BindingTraceContext(),
                 dataFlowInfo,
                 TypeUtils.NO_EXPECTED_TYPE,
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/stubBuilder/ClassClsStubBuilder.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/stubBuilder/ClassClsStubBuilder.kt
index a4b20654904..a68424c06a1 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/stubBuilder/ClassClsStubBuilder.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/stubBuilder/ClassClsStubBuilder.kt
@@ -94,7 +94,6 @@ private class ClassClsStubBuilder(
         }
         val additionalModifiers = when (classKind) {
             ProtoBuf.Class.Kind.ENUM_CLASS -> listOf(JetTokens.ENUM_KEYWORD)
-            ProtoBuf.Class.Kind.ANNOTATION_CLASS -> listOf(JetTokens.ANNOTATION_KEYWORD)
             ProtoBuf.Class.Kind.CLASS_OBJECT -> listOf(JetTokens.COMPANION_KEYWORD)
             else -> listOf<JetModifierKeywordToken>()
         }
@@ -108,7 +107,7 @@ private class ClassClsStubBuilder(
         val superTypeRefs = supertypeIds.filterNot {
             //TODO: filtering function types should go away
             KotlinBuiltIns.isNumberedFunctionClassFqName(it.asSingleFqName().toUnsafe())
-        }.map { it.getShortClassName().ref() }.toTypedArray()
+        }.map { it.getShortClassName().ref()!! }.toTypedArray()
         return when (classKind) {
             ProtoBuf.Class.Kind.OBJECT, ProtoBuf.Class.Kind.CLASS_OBJECT -> {
                 KotlinObjectStubImpl(
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/stubBuilder/KotlinClsStubBuilder.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/stubBuilder/KotlinClsStubBuilder.kt
index 963559d741a..a4118eb2b62 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/stubBuilder/KotlinClsStubBuilder.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/stubBuilder/KotlinClsStubBuilder.kt
@@ -49,7 +49,7 @@ public open class KotlinClsStubBuilder : ClsStubBuilder() {
     }
 
     fun doBuildFileStub(file: VirtualFile): PsiFileStub<JetFile>? {
-        val kotlinBinaryClass = KotlinBinaryClassCache.getKotlinBinaryClass(file)
+        val kotlinBinaryClass = KotlinBinaryClassCache.getKotlinBinaryClass(file)!!
         val header = kotlinBinaryClass.getClassHeader()
         val classId = kotlinBinaryClass.getClassId()
         val packageFqName = classId.getPackageFqName()
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/stubBuilder/TypeClsStubBuilder.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/stubBuilder/TypeClsStubBuilder.kt
index 66ae2034b30..61cc3156c56 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/stubBuilder/TypeClsStubBuilder.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/stubBuilder/TypeClsStubBuilder.kt
@@ -216,7 +216,7 @@ class TypeClsStubBuilder(private val c: ClsStubBuilderContext) {
         val typeConstraintListStub = KotlinPlaceHolderStubImpl<JetTypeConstraintList>(parent, JetStubElementTypes.TYPE_CONSTRAINT_LIST)
         for ((name, type) in protosForTypeConstraintList) {
             val typeConstraintStub = KotlinPlaceHolderStubImpl<JetTypeConstraint>(typeConstraintListStub, JetStubElementTypes.TYPE_CONSTRAINT)
-            KotlinNameReferenceExpressionStubImpl(typeConstraintStub, name.ref())
+            KotlinNameReferenceExpressionStubImpl(typeConstraintStub, name.ref()!!)
             createTypeReferenceStub(typeConstraintStub, type)
         }
     }
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/stubBuilder/clsStubBuilding.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/stubBuilder/clsStubBuilding.kt
index f35d64d8230..b66cc21dac1 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/stubBuilder/clsStubBuilding.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/stubBuilder/clsStubBuilding.kt
@@ -116,7 +116,8 @@ enum class FlagsToModifiers {
                 ProtoBuf.Modality.ABSTRACT -> JetTokens.ABSTRACT_KEYWORD
                 ProtoBuf.Modality.FINAL -> JetTokens.FINAL_KEYWORD
                 ProtoBuf.Modality.OPEN -> JetTokens.OPEN_KEYWORD
-                else -> throw IllegalStateException("Unexpected modality: $modality")
+                ProtoBuf.Modality.SEALED -> JetTokens.SEALED_KEYWORD
+                null -> throw IllegalStateException("Unexpected modality: null")
             }
         }
     },
@@ -203,6 +204,6 @@ val ProtoBuf.Callable.annotatedCallableKind: AnnotatedCallableKind
         }
     }
 
-fun Name.ref() = StringRef.fromString(this.asString())
+fun Name.ref() = StringRef.fromString(this.asString())!!
 
-fun FqName.ref() = StringRef.fromString(this.asString())
+fun FqName.ref() = StringRef.fromString(this.asString())!!
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/textBuilder/DecompiledTextFactory.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/textBuilder/DecompiledTextFactory.kt
index 191cd9b47c6..bd241a27d5d 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/textBuilder/DecompiledTextFactory.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/textBuilder/DecompiledTextFactory.kt
@@ -147,7 +147,7 @@ public fun buildDecompiledText(
 
         if (descriptor is CallableDescriptor) {
             //NOTE: assuming that only return types can be flexible
-            if (descriptor.getReturnType().isFlexible()) {
+            if (descriptor.getReturnType()!!.isFlexible()) {
                 builder.append(" ").append(FLEXIBLE_TYPE_COMMENT)
             }
         }
@@ -191,7 +191,7 @@ public fun buildDecompiledText(
                         companionNeeded = false
                         newlineExceptFirst()
                         builder.append(subindent)
-                        appendDescriptor(companionObject, subindent)
+                        appendDescriptor(companionObject!!, subindent)
                     }
                     if (member is CallableMemberDescriptor
                         && member.getKind() != CallableMemberDescriptor.Kind.DECLARATION
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/textBuilder/DeserializerForDecompilerBase.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/textBuilder/DeserializerForDecompilerBase.kt
index e5165daf03b..badad22cf71 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/textBuilder/DeserializerForDecompilerBase.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/textBuilder/DeserializerForDecompilerBase.kt
@@ -27,7 +27,7 @@ import org.jetbrains.kotlin.descriptors.impl.MutablePackageFragmentDescriptor
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
-import org.jetbrains.kotlin.resolve.constants.CompileTimeConstant
+import org.jetbrains.kotlin.resolve.constants.ConstantValue
 import org.jetbrains.kotlin.serialization.deserialization.AnnotationAndConstantLoader
 import org.jetbrains.kotlin.serialization.deserialization.ClassDataFinder
 import org.jetbrains.kotlin.serialization.deserialization.DeserializationComponents
@@ -43,7 +43,7 @@ public abstract class DeserializerForDecompilerBase(
 
     protected abstract val classDataFinder: ClassDataFinder
 
-    protected abstract val annotationAndConstantLoader: AnnotationAndConstantLoader<AnnotationDescriptor, CompileTimeConstant<*>>
+    protected abstract val annotationAndConstantLoader: AnnotationAndConstantLoader<AnnotationDescriptor, ConstantValue<*>>
 
     protected val storageManager: StorageManager = LockBasedStorageManager.NO_LOCKS
 
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/textBuilder/missingDependencies.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/textBuilder/missingDependencies.kt
index cef52d9312f..dbfd26ea74f 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/textBuilder/missingDependencies.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/textBuilder/missingDependencies.kt
@@ -77,7 +77,7 @@ private class MissingDependencyErrorClassDescriptor(
 
     override fun substitute(substitutor: TypeSubstitutor) = this
 
-    override fun getScopeForMemberLookup() = scope
+    override fun getUnsubstitutedMemberScope() = scope
 
     override fun getMemberScope(typeArguments: List<TypeProjection?>) = scope
 }
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/findUsages/UsageTypeUtils.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/findUsages/UsageTypeUtils.kt
index 2ea675ccd76..124068962d1 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/findUsages/UsageTypeUtils.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/findUsages/UsageTypeUtils.kt
@@ -36,6 +36,7 @@ import org.jetbrains.kotlin.idea.caches.resolve.analyze
 import org.jetbrains.kotlin.psi.psiUtil.getParentOfTypeAndBranch
 import org.jetbrains.kotlin.idea.references.JetArrayAccessReference
 import org.jetbrains.kotlin.idea.references.JetInvokeFunctionReference
+import org.jetbrains.kotlin.idea.references.mainReference
 import org.jetbrains.kotlin.idea.references.unwrappedTargets
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.resolve.DescriptorUtils
@@ -161,8 +162,7 @@ public object UsageTypeUtils {
         }
 
         fun getFunctionUsageType(descriptor: FunctionDescriptor): UsageTypeEnum? {
-            val ref = refExpr.getReference()
-            when (ref) {
+            when (refExpr.mainReference) {
                 is JetArrayAccessReference -> {
                     return when {
                         context[BindingContext.INDEXED_LVALUE_GET, refExpr] != null -> IMPLICIT_GET
@@ -216,7 +216,7 @@ public object UsageTypeUtils {
                 else -> getClassUsageType()
             }
             is PackageViewDescriptor -> {
-                if (refExpr.getReference()?.resolve() is PsiPackage) getPackageUsageType() else getClassUsageType()
+                if (refExpr.mainReference.resolve() is PsiPackage) getPackageUsageType() else getClassUsageType()
             }
             is VariableDescriptor -> getVariableUsageType()
             is FunctionDescriptor -> getFunctionUsageType(descriptor)
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/highlighter/IdeErrorMessages.java b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/highlighter/IdeErrorMessages.java
index f0ac21fd13e..21fc23f1c03 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/highlighter/IdeErrorMessages.java
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/highlighter/IdeErrorMessages.java
@@ -71,7 +71,7 @@ public class IdeErrorMessages {
 
         MAP.put(TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS, "<html>Type inference failed: {0}</html>", HTML_TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS_RENDERER);
         MAP.put(TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER, "<html>Type inference failed: {0}</html>", HTML_TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER_RENDERER);
-        MAP.put(TYPE_INFERENCE_TYPE_CONSTRUCTOR_MISMATCH, "<html>Type inference failed: {0}</html>", HTML_TYPE_INFERENCE_TYPE_CONSTRUCTOR_MISMATCH_RENDERER);
+        MAP.put(TYPE_INFERENCE_PARAMETER_CONSTRAINT_ERROR, "<html>Type inference failed: {0}</html>", HTML_TYPE_INFERENCE_PARAMETER_CONSTRAINT_ERROR_RENDERER);
         MAP.put(TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH, tableForTypes("Type inference failed. Expected type mismatch: ",
                                                                      "required: ", TextElementType.STRONG,
                                                                      "found: ", TextElementType.ERROR), HTML_RENDER_TYPE, HTML_RENDER_TYPE);
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/highlighter/IdeRenderers.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/highlighter/IdeRenderers.kt
index 55647ab662b..21bdc38ae5d 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/highlighter/IdeRenderers.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/highlighter/IdeRenderers.kt
@@ -53,8 +53,8 @@ public object IdeRenderers {
         Renderers.renderConflictingSubstitutionsInferenceError(it, HtmlTabledDescriptorRenderer.create()).toString()
     }
 
-    public val HTML_TYPE_INFERENCE_TYPE_CONSTRUCTOR_MISMATCH_RENDERER: Renderer<InferenceErrorData> = Renderer {
-        Renderers.renderTypeConstructorMismatchError(it, HtmlTabledDescriptorRenderer.create()).toString()
+    public val HTML_TYPE_INFERENCE_PARAMETER_CONSTRAINT_ERROR_RENDERER: Renderer<InferenceErrorData> = Renderer {
+        Renderers.renderParameterConstraintError(it, HtmlTabledDescriptorRenderer.create()).toString()
     }
 
     public val HTML_TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER_RENDERER: Renderer<InferenceErrorData> = Renderer {
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/highlighter/JetPsiChecker.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/highlighter/JetPsiChecker.kt
index 4f1b91e0d70..e6d441994be 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/highlighter/JetPsiChecker.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/highlighter/JetPsiChecker.kt
@@ -41,6 +41,7 @@ import org.jetbrains.kotlin.idea.actions.internal.KotlinInternalMode
 import org.jetbrains.kotlin.idea.caches.resolve.analyzeFullyAndGetResult
 import org.jetbrains.kotlin.idea.kdoc.KDocHighlightingVisitor
 import org.jetbrains.kotlin.idea.quickfix.QuickFixes
+import org.jetbrains.kotlin.idea.references.mainReference
 import org.jetbrains.kotlin.idea.util.ProjectRootsUtil
 import org.jetbrains.kotlin.psi.JetCodeFragment
 import org.jetbrains.kotlin.psi.JetFile
@@ -104,7 +105,7 @@ public open class JetPsiChecker : Annotator, HighlightRangeExtension {
                     when (factory) {
                         in Errors.UNRESOLVED_REFERENCE_DIAGNOSTICS -> {
                             val referenceExpression = diagnostic.getPsiElement() as JetReferenceExpression
-                            val reference = referenceExpression.getReference()
+                            val reference = referenceExpression.mainReference
                             if (reference is MultiRangeReference) {
                                 for (range in reference.getRanges()) {
                                     val annotation = holder.createErrorAnnotation(range.shiftRight(referenceExpression.getTextOffset()), getDefaultMessage(diagnostic))
@@ -254,11 +255,11 @@ public open class JetPsiChecker : Annotator, HighlightRangeExtension {
 
         public fun createQuickfixes(diagnostic: Diagnostic): Collection<IntentionAction> {
             val result = arrayListOf<IntentionAction>()
-            val intentionActionsFactories = QuickFixes.getActionsFactories(diagnostic.getFactory())
+            val intentionActionsFactories = QuickFixes.getInstance().getActionFactories(diagnostic.getFactory())
             for (intentionActionsFactory in intentionActionsFactories.filterNotNull()) {
                 result.addAll(intentionActionsFactory.createActions(diagnostic))
             }
-            result.addAll(QuickFixes.getActions(diagnostic.getFactory()))
+            result.addAll(QuickFixes.getInstance().getActions(diagnostic.getFactory()))
             return result
         }
     }
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/highlighter/KotlinSuppressableWarningProblemGroup.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/highlighter/KotlinSuppressableWarningProblemGroup.kt
index 15961a47845..041030aff2c 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/highlighter/KotlinSuppressableWarningProblemGroup.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/highlighter/KotlinSuppressableWarningProblemGroup.kt
@@ -90,7 +90,7 @@ private object DeclarationKindDetector : JetVisitor<AnnotationHostKind?, Unit?>(
     override fun visitProperty(d: JetProperty, _: Unit?) = detect(d, d.getValOrVarKeyword().getText()!!)
 
     override fun visitMultiDeclaration(d: JetMultiDeclaration, _: Unit?) = detect(d, d.getValOrVarKeyword()?.getText() ?: "val",
-                                                                                  name = d.getEntries().map { it.getName() }.join(", ", "(", ")"))
+                                                                                  name = d.getEntries().map { it.getName()!! }.join(", ", "(", ")"))
 
     override fun visitTypeParameter(d: JetTypeParameter, _: Unit?) = detect(d, "type parameter", newLineNeeded = false)
 
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/highlighter/TypeKindHighlightingVisitor.java b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/highlighter/TypeKindHighlightingVisitor.java
index a4267bd75fa..31b8a1db3d4 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/highlighter/TypeKindHighlightingVisitor.java
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/highlighter/TypeKindHighlightingVisitor.java
@@ -20,10 +20,12 @@ import com.intellij.lang.annotation.AnnotationHolder;
 import com.intellij.openapi.editor.colors.TextAttributesKey;
 import com.intellij.openapi.util.TextRange;
 import com.intellij.psi.PsiElement;
-import com.intellij.psi.PsiReference;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.descriptors.*;
-import org.jetbrains.kotlin.psi.*;
+import org.jetbrains.kotlin.psi.JetClassOrObject;
+import org.jetbrains.kotlin.psi.JetDynamicType;
+import org.jetbrains.kotlin.psi.JetSimpleNameExpression;
+import org.jetbrains.kotlin.psi.JetTypeParameter;
 import org.jetbrains.kotlin.psi.psiUtil.PsiUtilPackage;
 import org.jetbrains.kotlin.resolve.BindingContext;
 
@@ -34,8 +36,6 @@ class TypeKindHighlightingVisitor extends AfterAnalysisHighlightingVisitor {
 
     @Override
     public void visitSimpleNameExpression(@NotNull JetSimpleNameExpression expression) {
-        PsiReference ref = expression.getReference();
-        if (ref == null) return;
         if (JetPsiChecker.Companion.getNamesHighlightingEnabled()) {
             DeclarationDescriptor referenceTarget = bindingContext.get(BindingContext.REFERENCE_TARGET, expression);
             if (referenceTarget instanceof ConstructorDescriptor) {
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/intentions/OperatorToFunctionIntention.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/intentions/OperatorToFunctionIntention.kt
index 5b9f0734b0e..7e932fa33af 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/intentions/OperatorToFunctionIntention.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/intentions/OperatorToFunctionIntention.kt
@@ -22,8 +22,9 @@ import org.jetbrains.kotlin.descriptors.FunctionDescriptor
 import org.jetbrains.kotlin.idea.caches.resolve.analyze
 import org.jetbrains.kotlin.lexer.JetTokens
 import org.jetbrains.kotlin.psi.*
-import org.jetbrains.kotlin.resolve.BindingContext
+import org.jetbrains.kotlin.psi.psiUtil.getQualifiedElementSelector
 import org.jetbrains.kotlin.resolve.calls.callUtil.getResolvedCall
+import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode
 import org.jetbrains.kotlin.types.expressions.OperatorConventions
 
 public class OperatorToFunctionIntention : JetSelfTargetingIntention<JetExpression>(javaClass(), "Replace overloaded operator with function call") {
@@ -126,7 +127,7 @@ public class OperatorToFunctionIntention : JetSelfTargetingIntention<JetExpressi
                 return element
             }
 
-            val context = element.analyze()
+            val context = element.analyze(BodyResolveMode.PARTIAL)
             val functionCandidate = element.getResolvedCall(context)
             val functionName = functionCandidate?.getCandidateDescriptor()?.getName().toString()
             val elemType = context.getType(left)
@@ -195,14 +196,31 @@ public class OperatorToFunctionIntention : JetSelfTargetingIntention<JetExpressi
             return callee.getParent()!!.replace(transformed) as JetExpression
         }
 
-        public fun convert(element: JetExpression): JetExpression {
-            return when (element) {
+        public fun convert(element: JetExpression): Pair<JetExpression, JetSimpleNameExpression> {
+            val result = when (element) {
                 is JetPrefixExpression -> convertPrefix(element)
                 is JetPostfixExpression -> convertPostFix(element)
                 is JetBinaryExpression -> convertBinary(element)
                 is JetArrayAccessExpression -> convertArrayAccess(element)
                 is JetCallExpression -> convertCall(element)
-                else -> element
+                else -> throw IllegalArgumentException(element.toString())
+            }
+
+            return result to findCallName(result)
+        }
+
+        private fun findCallName(result: JetExpression): JetSimpleNameExpression {
+            return when (result) {
+                is JetBinaryExpression -> {
+                    if (JetPsiUtil.isAssignment(result))
+                        findCallName(result.getRight()!!)
+                    else
+                        findCallName(result.getLeft()!!)
+                }
+
+                is JetUnaryExpression -> findCallName(result.getBaseExpression()!!)
+
+                else -> result.getQualifiedElementSelector() as JetSimpleNameExpression
             }
         }
     }
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/kdoc/KDocReference.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/kdoc/KDocReference.kt
index 69a14e754c9..d57575e72b9 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/kdoc/KDocReference.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/kdoc/KDocReference.kt
@@ -58,7 +58,7 @@ public class KDocReference(element: KDocName): JetMultiReference<KDocName>(eleme
 
     override fun handleElementRename(newElementName: String?): PsiElement? {
         val textRange = getElement().getNameTextRange()
-        val newText = textRange.replace(getElement().getText(), newElementName)
+        val newText = textRange.replace(getElement().getText(), newElementName!!)
         val newLink = KDocElementFactory(getElement().getProject()).createNameFromText(newText)
         return getElement().replace(newLink)
     }
@@ -181,5 +181,5 @@ private fun getOuterScope(descriptor: DeclarationDescriptorWithSource, resolutio
             return resolutionFacade.getFileTopLevelScope(containingFile)
         }
     }
-    return getResolutionScope(resolutionFacade, parent)
+    return getResolutionScope(resolutionFacade, parent!!)
 }
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/kdoc/KDocUnresolvedReferenceInspection.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/kdoc/KDocUnresolvedReferenceInspection.kt
index cede495a1a0..a82f28d4bdf 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/kdoc/KDocUnresolvedReferenceInspection.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/kdoc/KDocUnresolvedReferenceInspection.kt
@@ -20,6 +20,7 @@ import org.jetbrains.kotlin.idea.inspections.AbstractKotlinInspection
 import com.intellij.codeInspection.ProblemsHolder
 import com.intellij.psi.PsiElementVisitor
 import com.intellij.psi.PsiElement
+import org.jetbrains.kotlin.idea.references.mainReference
 import org.jetbrains.kotlin.kdoc.psi.impl.KDocName
 
 public class KDocUnresolvedReferenceInspection(): AbstractKotlinInspection() {
@@ -29,8 +30,8 @@ public class KDocUnresolvedReferenceInspection(): AbstractKotlinInspection() {
     private class KDocUnresolvedReferenceVisitor(private val holder: ProblemsHolder): PsiElementVisitor() {
         override fun visitElement(element: PsiElement) {
             if (element is KDocName) {
-                val ref = element.getReference()
-                if (ref != null && ref.resolve() == null) {
+                val ref = element.mainReference
+                if (ref.resolve() == null) {
                     holder.registerProblem(ref)
                 }
             }
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/project/ResolveElementCache.java b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/project/ResolveElementCache.java
deleted file mode 100644
index da676ed39b9..00000000000
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/project/ResolveElementCache.java
+++ /dev/null
@@ -1,125 +0,0 @@
-/*
- * Copyright 2010-2015 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.kotlin.idea.project;
-
-import com.intellij.openapi.project.Project;
-import com.intellij.psi.util.CachedValue;
-import com.intellij.psi.util.CachedValueProvider;
-import com.intellij.psi.util.CachedValuesManager;
-import com.intellij.psi.util.PsiModificationTracker;
-import kotlin.jvm.functions.Function1;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.idea.stubindex.JetProbablyNothingFunctionShortNameIndex;
-import org.jetbrains.kotlin.idea.stubindex.JetProbablyNothingPropertyShortNameIndex;
-import org.jetbrains.kotlin.psi.JetElement;
-import org.jetbrains.kotlin.psi.JetFile;
-import org.jetbrains.kotlin.psi.JetNamedFunction;
-import org.jetbrains.kotlin.resolve.AdditionalCheckerProvider;
-import org.jetbrains.kotlin.resolve.BindingContext;
-import org.jetbrains.kotlin.resolve.BodyResolveCache;
-import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode;
-import org.jetbrains.kotlin.resolve.lazy.ElementResolver;
-import org.jetbrains.kotlin.resolve.lazy.ProbablyNothingCallableNames;
-import org.jetbrains.kotlin.resolve.lazy.ResolveSession;
-import org.jetbrains.kotlin.storage.LazyResolveStorageManager;
-import org.jetbrains.kotlin.storage.MemoizedFunctionToNotNull;
-import org.jetbrains.kotlin.types.DynamicTypesSettings;
-
-import java.util.Collection;
-
-public class ResolveElementCache extends ElementResolver implements BodyResolveCache {
-    private final Project project;
-    private final CachedValue<MemoizedFunctionToNotNull<JetElement, BindingContext>> additionalResolveCache;
-
-    public ResolveElementCache(ResolveSession resolveSession, Project project) {
-        super(resolveSession);
-        this.project = project;
-
-        // Recreate internal cache after change of modification count
-        this.additionalResolveCache =
-                CachedValuesManager.getManager(project).createCachedValue(new CachedValueProvider<MemoizedFunctionToNotNull<JetElement, BindingContext>>() {
-                            @Nullable
-                            @Override
-                            public Result<MemoizedFunctionToNotNull<JetElement, BindingContext>> compute() {
-                                ResolveSession resolveSession = ResolveElementCache.this.getResolveSession();
-                                LazyResolveStorageManager manager = resolveSession.getStorageManager();
-                                MemoizedFunctionToNotNull<JetElement, BindingContext> elementsCacheFunction =
-                                        manager.createSoftlyRetainedMemoizedFunction(new Function1<JetElement, BindingContext>() {
-                                            @Override
-                                            public BindingContext invoke(JetElement jetElement) {
-                                                return performElementAdditionalResolve(jetElement, jetElement, BodyResolveMode.FULL);
-                                            }
-                                        });
-
-                                return Result.create(elementsCacheFunction,
-                                                     PsiModificationTracker.MODIFICATION_COUNT,
-                                                     resolveSession.getExceptionTracker());
-                            }
-                        },
-                        false);
-    }
-
-    @NotNull
-    @Override
-    public BindingContext getElementAdditionalResolve(@NotNull JetElement jetElement) {
-        return additionalResolveCache.getValue().invoke(jetElement);
-    }
-
-    @Override
-    public boolean hasElementAdditionalResolveCached(@NotNull JetElement jetElement) {
-        if (!additionalResolveCache.hasUpToDateValue()) return false;
-        return additionalResolveCache.getValue().isComputed(jetElement);
-    }
-
-    @NotNull
-    @Override
-    public AdditionalCheckerProvider getAdditionalCheckerProvider(@NotNull JetFile jetFile) {
-        return TargetPlatformDetector.getPlatform(jetFile).getAdditionalCheckerProvider();
-    }
-
-    @NotNull
-    @Override
-    public DynamicTypesSettings getDynamicTypesSettings(@NotNull JetFile jetFile) {
-        return TargetPlatformDetector.getPlatform(jetFile).getDynamicTypesSettings();
-    }
-
-    @NotNull
-    @Override
-    protected ProbablyNothingCallableNames probablyNothingCallableNames() {
-        return new ProbablyNothingCallableNames() {
-            @NotNull
-            @Override
-            public Collection<String> functionNames() {
-                // we have to add hardcoded-names until we have Kotlin compiled classes in caches
-                return JetProbablyNothingFunctionShortNameIndex.getInstance().getAllKeys(project);
-            }
-
-            @NotNull
-            @Override
-            public Collection<String> propertyNames() {
-                return JetProbablyNothingPropertyShortNameIndex.getInstance().getAllKeys(project);
-            }
-        };
-    }
-
-    @NotNull
-    @Override
-    public BindingContext resolveFunctionBody(@NotNull JetNamedFunction function) {
-        return getElementAdditionalResolve(function);
-    }
-}
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/project/ResolveElementCache.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/project/ResolveElementCache.kt
new file mode 100644
index 00000000000..b7ee86f7969
--- /dev/null
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/project/ResolveElementCache.kt
@@ -0,0 +1,120 @@
+/*
+ * Copyright 2010-2015 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.kotlin.idea.project
+
+import com.intellij.openapi.project.Project
+import com.intellij.psi.util.CachedValue
+import com.intellij.psi.util.CachedValueProvider
+import com.intellij.psi.util.CachedValuesManager
+import com.intellij.psi.util.PsiModificationTracker
+import com.intellij.util.containers.ContainerUtil
+import org.jetbrains.kotlin.descriptors.ModuleDescriptor
+import org.jetbrains.kotlin.idea.stubindex.JetProbablyNothingFunctionShortNameIndex
+import org.jetbrains.kotlin.idea.stubindex.JetProbablyNothingPropertyShortNameIndex
+import org.jetbrains.kotlin.psi.*
+import org.jetbrains.kotlin.resolve.BindingContext
+import org.jetbrains.kotlin.resolve.BodyResolveCache
+import org.jetbrains.kotlin.resolve.StatementFilter
+import org.jetbrains.kotlin.resolve.lazy.*
+import org.jetbrains.kotlin.storage.MemoizedFunctionToNotNull
+
+public class ResolveElementCache(resolveSession: ResolveSession, private val project: Project) : ElementResolver(resolveSession), BodyResolveCache {
+    // Recreate internal cache after change of modification count
+    private val fullResolveCache: CachedValue<MutableMap<JetElement, BindingContext>> = CachedValuesManager.getManager(project).createCachedValue(
+            object : CachedValueProvider<MutableMap<JetElement, BindingContext>> {
+                override fun compute(): CachedValueProvider.Result<MutableMap<JetElement, BindingContext>> {
+                    return CachedValueProvider.Result.create(ContainerUtil.createConcurrentSoftValueMap<JetElement, BindingContext>(),
+                                                             PsiModificationTracker.MODIFICATION_COUNT,
+                                                             resolveSession.getExceptionTracker())
+                }
+            },
+            false)
+
+    private val partialBodyResolveCache: CachedValue<MutableMap<JetExpression, BindingContext>> = CachedValuesManager.getManager(project).createCachedValue(
+            object : CachedValueProvider<MutableMap<JetExpression, BindingContext>> {
+                override fun compute(): CachedValueProvider.Result<MutableMap<JetExpression, BindingContext>> {
+                    return CachedValueProvider.Result.create(ContainerUtil.createConcurrentSoftValueMap<JetExpression, BindingContext>(),
+                                                             PsiModificationTracker.MODIFICATION_COUNT,
+                                                             resolveSession.getExceptionTracker())
+                }
+            },
+            false)
+
+    override fun getElementAdditionalResolve(resolveElement: JetElement, contextElement: JetElement, bodyResolveMode: BodyResolveMode): BindingContext {
+        val fullResolveMap = fullResolveCache.getValue()
+        fullResolveMap[resolveElement]?.let { return it } // check if full additional resolve already performed
+
+        when (bodyResolveMode) {
+            BodyResolveMode.FULL -> {
+                val bindingContext = performElementAdditionalResolve(resolveElement, resolveElement, BodyResolveMode.FULL).first
+                fullResolveMap[resolveElement] = bindingContext
+                return bindingContext
+            }
+
+            BodyResolveMode.PARTIAL -> {
+                if (resolveElement !is JetDeclaration) {
+                    return getElementAdditionalResolve(resolveElement, contextElement, BodyResolveMode.FULL)
+                }
+
+                val statementToResolve = PartialBodyResolveFilter.findStatementToResolve(contextElement, resolveElement)
+                val partialResolveMap = partialBodyResolveCache.getValue()
+                partialResolveMap[statementToResolve ?: resolveElement]?.let { return it } // partial resolve is already cached for this statement
+
+                val (bindingContext, statementFilter) = performElementAdditionalResolve(resolveElement, contextElement, BodyResolveMode.PARTIAL)
+
+                if (statementFilter == StatementFilter.NONE) { // partial resolve is not supported for the given declaration - full resolve performed instead
+                    fullResolveMap[resolveElement] = bindingContext
+                    return bindingContext
+                }
+
+                for (statement in (statementFilter as PartialBodyResolveFilter).allStatementsToResolve) {
+                    if (!partialResolveMap.containsKey(statement) && bindingContext[BindingContext.PROCESSED, statement] == true) {
+                        partialResolveMap[statement] = bindingContext
+                    }
+                }
+                partialResolveMap[resolveElement] = bindingContext // we use the whole declaration key in the map to obtain resolve not inside any block (e.g. default parameter values)
+
+                return bindingContext
+            }
+
+            BodyResolveMode.PARTIAL_FOR_COMPLETION -> {
+                if (resolveElement !is JetDeclaration) {
+                    return getElementAdditionalResolve(resolveElement, contextElement, BodyResolveMode.FULL)
+                }
+
+                // not cached
+                return performElementAdditionalResolve(resolveElement, contextElement, bodyResolveMode).first
+            }
+        }
+    }
+
+    override fun createAdditionalCheckerProvider(file: JetFile, module: ModuleDescriptor)
+            = TargetPlatformDetector.getPlatform(file).createAdditionalCheckerProvider(module)
+
+    override fun getDynamicTypesSettings(file: JetFile)
+            = TargetPlatformDetector.getPlatform(file).getDynamicTypesSettings()
+
+    override fun probablyNothingCallableNames(): ProbablyNothingCallableNames {
+        return object : ProbablyNothingCallableNames {
+            override fun functionNames() = JetProbablyNothingFunctionShortNameIndex.getInstance().getAllKeys(project)
+            override fun propertyNames() = JetProbablyNothingPropertyShortNameIndex.getInstance().getAllKeys(project)
+        }
+    }
+
+    override fun resolveFunctionBody(function: JetNamedFunction)
+            = getElementAdditionalResolve(function, function, BodyResolveMode.FULL)
+}
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/project/TargetPlatform.java b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/project/TargetPlatform.java
index 03b7117e50a..b9e363fabf3 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/project/TargetPlatform.java
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/project/TargetPlatform.java
@@ -17,6 +17,7 @@
 package org.jetbrains.kotlin.idea.project;
 
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.kotlin.descriptors.ModuleDescriptor;
 import org.jetbrains.kotlin.js.resolve.KotlinJsCheckerProvider;
 import org.jetbrains.kotlin.load.kotlin.KotlinJvmCheckerProvider;
 import org.jetbrains.kotlin.resolve.AdditionalCheckerProvider;
@@ -25,11 +26,24 @@ import org.jetbrains.kotlin.types.DynamicTypesSettings;
 
 public interface TargetPlatform {
     @NotNull
-    AdditionalCheckerProvider getAdditionalCheckerProvider();
+    AdditionalCheckerProvider createAdditionalCheckerProvider(@NotNull ModuleDescriptor module);
 
     @NotNull
     DynamicTypesSettings getDynamicTypesSettings();
 
-    TargetPlatform JVM = new TargetPlatformImpl("JVM", KotlinJvmCheckerProvider.INSTANCE$, new DynamicTypesSettings());
-    TargetPlatform JS = new TargetPlatformImpl("JS", KotlinJsCheckerProvider.INSTANCE$, new DynamicTypesAllowed());
+    TargetPlatform JVM = new TargetPlatformImpl("JVM", new DynamicTypesSettings()) {
+        @NotNull
+        @Override
+        public AdditionalCheckerProvider createAdditionalCheckerProvider(@NotNull ModuleDescriptor module) {
+            return new KotlinJvmCheckerProvider(module);
+        }
+    };
+
+    TargetPlatform JS = new TargetPlatformImpl("JS", new DynamicTypesAllowed()) {
+        @NotNull
+        @Override
+        public AdditionalCheckerProvider createAdditionalCheckerProvider(@NotNull ModuleDescriptor module) {
+            return KotlinJsCheckerProvider.INSTANCE$;
+        }
+    };
 }
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/project/TargetPlatformImpl.java b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/project/TargetPlatformImpl.java
index e653fc1c691..a577f7bd45f 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/project/TargetPlatformImpl.java
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/project/TargetPlatformImpl.java
@@ -17,30 +17,17 @@
 package org.jetbrains.kotlin.idea.project;
 
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.kotlin.resolve.AdditionalCheckerProvider;
 import org.jetbrains.kotlin.types.DynamicTypesSettings;
 
-public class TargetPlatformImpl implements TargetPlatform {
-    @NotNull private final String platformName;
-    @NotNull private final AdditionalCheckerProvider additionalCheckerProvider;
-    @NotNull private final DynamicTypesSettings dynamicTypesSettings;
+public abstract class TargetPlatformImpl implements TargetPlatform {
+    private final String platformName;
+    private final DynamicTypesSettings dynamicTypesSettings;
 
-    public TargetPlatformImpl(
-            @NotNull String platformName,
-            @NotNull AdditionalCheckerProvider additionalCheckerProvider,
-            @NotNull DynamicTypesSettings dynamicTypesSettings
-    ) {
+    public TargetPlatformImpl(@NotNull String platformName, @NotNull DynamicTypesSettings dynamicTypesSettings) {
         this.platformName = platformName;
-        this.additionalCheckerProvider = additionalCheckerProvider;
         this.dynamicTypesSettings = dynamicTypesSettings;
     }
 
-    @NotNull
-    @Override
-    public AdditionalCheckerProvider getAdditionalCheckerProvider() {
-        return additionalCheckerProvider;
-    }
-
     @NotNull
     @Override
     public DynamicTypesSettings getDynamicTypesSettings() {
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/quickfix/QuickFixes.java b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/quickfix/QuickFixes.java
deleted file mode 100644
index 7b582615a44..00000000000
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/quickfix/QuickFixes.java
+++ /dev/null
@@ -1,40 +0,0 @@
-/*
- * Copyright 2010-2015 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.kotlin.idea.quickfix;
-
-import com.google.common.collect.HashMultimap;
-import com.google.common.collect.Multimap;
-import com.intellij.codeInsight.intention.IntentionAction;
-import org.jetbrains.kotlin.diagnostics.DiagnosticFactory;
-
-import java.util.Collection;
-
-public class QuickFixes {
-
-    static final Multimap<DiagnosticFactory<?>, JetIntentionActionsFactory> factories = HashMultimap.create();
-    static final Multimap<DiagnosticFactory<?>, IntentionAction> actions = HashMultimap.create();
-
-    public static Collection<JetIntentionActionsFactory> getActionsFactories(DiagnosticFactory<?> diagnosticFactory) {
-        return factories.get(diagnosticFactory);
-    }
-
-    public static Collection<IntentionAction> getActions(DiagnosticFactory<?> diagnosticFactory) {
-        return actions.get(diagnosticFactory);
-    }
-
-    private QuickFixes() {}
-}
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/quickfix/QuickFixes.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/quickfix/QuickFixes.kt
new file mode 100644
index 00000000000..ec90b9f1762
--- /dev/null
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/quickfix/QuickFixes.kt
@@ -0,0 +1,62 @@
+/*
+ * Copyright 2010-2015 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.kotlin.idea.quickfix
+
+import com.google.common.collect.HashMultimap
+import com.google.common.collect.Multimap
+import com.intellij.codeInsight.intention.IntentionAction
+import com.intellij.openapi.components.ServiceManager
+import com.intellij.openapi.extensions.ExtensionPointName
+import com.intellij.openapi.extensions.Extensions
+import org.jetbrains.kotlin.diagnostics.DiagnosticFactory
+
+public class QuickFixes {
+    private val factories: Multimap<DiagnosticFactory<*>, JetIntentionActionsFactory> = HashMultimap.create<DiagnosticFactory<*>, JetIntentionActionsFactory>()
+    private val actions: Multimap<DiagnosticFactory<*>, IntentionAction> = HashMultimap.create<DiagnosticFactory<*>, IntentionAction>()
+
+    init {
+        Extensions.getExtensions(QuickFixContributor.EP_NAME).forEach { it.registerQuickFixes(this) }
+    }
+
+    public fun register(diagnosticFactory: DiagnosticFactory<*>, vararg factory: JetIntentionActionsFactory) {
+        factories.putAll(diagnosticFactory, factory.toList())
+    }
+
+    public fun register(diagnosticFactory: DiagnosticFactory<*>, vararg action: IntentionAction) {
+        actions.putAll(diagnosticFactory, action.toList())
+    }
+
+    public fun getActionFactories(diagnosticFactory: DiagnosticFactory<*>): Collection<JetIntentionActionsFactory> {
+        return factories.get(diagnosticFactory)
+    }
+
+    public fun getActions(diagnosticFactory: DiagnosticFactory<*>): Collection<IntentionAction> {
+        return actions.get(diagnosticFactory)
+    }
+
+    companion object {
+        public fun getInstance(): QuickFixes = ServiceManager.getService(javaClass<QuickFixes>())
+    }
+}
+
+public interface QuickFixContributor {
+    companion object {
+        val EP_NAME: ExtensionPointName<QuickFixContributor> = ExtensionPointName.create("org.jetbrains.kotlin.quickFixContributor")
+    }
+
+    fun registerQuickFixes(quickFixes: QuickFixes)
+}
\ No newline at end of file
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/references/JetReference.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/references/JetReference.kt
index f56408f4947..983f9885c27 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/references/JetReference.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/references/JetReference.kt
@@ -30,8 +30,10 @@ import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode
 import org.jetbrains.kotlin.utils.addToStdlib.singletonOrEmptyList
 import java.util.Collections
 
-public trait JetReference : PsiPolyVariantReference {
-    public fun resolveToDescriptors(bindingContext: BindingContext): Collection<DeclarationDescriptor>
+public interface JetReference : PsiPolyVariantReference {
+    fun resolveToDescriptors(bindingContext: BindingContext): Collection<DeclarationDescriptor>
+
+    override fun getElement(): JetElement
 }
 
 public abstract class AbstractJetReference<T : JetElement>(element: T)
@@ -114,6 +116,8 @@ public abstract class AbstractJetReference<T : JetElement>(element: T)
         }
         return context[BindingContext.AMBIGUOUS_LABEL_TARGET, reference]
     }
+
+    override fun toString() = javaClass.getSimpleName() + ": " + expression.getText()
 }
 
 public abstract class JetSimpleReference<T : JetReferenceExpression>(expression: T) : AbstractJetReference<T>(expression) {
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/references/JetReferenceContributor.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/references/JetReferenceContributor.kt
index ba9e1b958c8..7dfa4ec0d87 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/references/JetReferenceContributor.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/references/JetReferenceContributor.kt
@@ -16,12 +16,16 @@
 
 package org.jetbrains.kotlin.idea.references
 
-import com.intellij.psi.*
-import org.jetbrains.kotlin.psi.*
-import com.intellij.util.ProcessingContext
 import com.intellij.patterns.PlatformPatterns
+import com.intellij.psi.*
+import com.intellij.util.ProcessingContext
 import org.jetbrains.kotlin.idea.kdoc.KDocReference
 import org.jetbrains.kotlin.kdoc.psi.impl.KDocName
+import org.jetbrains.kotlin.lexer.JetTokens
+import org.jetbrains.kotlin.psi.*
+import org.jetbrains.kotlin.psi.psiUtil.getAssignmentByLHS
+import org.jetbrains.kotlin.psi.psiUtil.getQualifiedExpressionForSelectorOrThis
+import org.jetbrains.kotlin.utils.addToStdlib.constant
 
 public class JetReferenceContributor() : PsiReferenceContributor() {
     public override fun registerReferenceProviders(registrar: PsiReferenceRegistrar) {
@@ -29,38 +33,78 @@ public class JetReferenceContributor() : PsiReferenceContributor() {
             registerProvider(javaClass<JetSimpleNameExpression>()) {
                 JetSimpleNameReference(it)
             }
+
+            registerMultiProvider(javaClass<JetNameReferenceExpression>()) {
+                if (it.getReferencedNameElementType() != JetTokens.IDENTIFIER) return@registerMultiProvider emptyArray()
+
+                when (it.access()) {
+                    Access.READ -> arrayOf(SyntheticPropertyAccessorReference.Getter(it))
+                    Access.WRITE -> arrayOf(SyntheticPropertyAccessorReference.Setter(it))
+                    Access.READ_WRITE -> arrayOf(SyntheticPropertyAccessorReference.Getter(it), SyntheticPropertyAccessorReference.Setter(it))
+                }
+            }
+
             registerProvider(javaClass<JetConstructorDelegationReferenceExpression>()) {
                 JetConstructorDelegationReference(it)
             }
+
             registerProvider(javaClass<JetCallExpression>()) {
                 JetInvokeFunctionReference(it)
             }
+
             registerProvider(javaClass<JetArrayAccessExpression>()) {
                 JetArrayAccessReference(it)
             }
+
             registerProvider(javaClass<JetForExpression>()) {
                 JetForLoopInReference(it)
             }
+
             registerProvider(javaClass<JetPropertyDelegate>()) {
                 JetPropertyDelegationMethodsReference(it)
             }
+
             registerProvider(javaClass<JetMultiDeclaration>()) {
                 JetMultiDeclarationReference(it)
             }
+
             registerProvider(javaClass<KDocName>()) {
                 KDocReference(it)
             }
         }
     }
 
-    private fun <E : JetElement, R : AbstractJetReference<E>> PsiReferenceRegistrar.registerProvider(
-            elementClass: Class<E>,
-            factory: (E) -> R
-        ) {
+    //TODO: there should be some common util for that
+    private enum class Access {
+        READ, WRITE, READ_WRITE
+    }
+
+    private fun JetSimpleNameExpression.access(): Access {
+        var expression = getQualifiedExpressionForSelectorOrThis()
+        while (expression.getParent() is JetParenthesizedExpression) {
+            expression = expression.getParent() as JetParenthesizedExpression
+        }
+
+        val assignment = expression.getAssignmentByLHS()
+        if (assignment != null) {
+            return if (assignment.getOperationToken() == JetTokens.EQ) Access.WRITE else Access.READ_WRITE
+        }
+
+        return if ((expression.getParent() as? JetUnaryExpression)?.getOperationToken() in constant { setOf(JetTokens.PLUSPLUS, JetTokens.MINUSMINUS) })
+            Access.READ_WRITE
+        else
+            Access.READ
+    }
+
+    private fun <E : JetElement> PsiReferenceRegistrar.registerProvider(elementClass: Class<E>, factory: (E) -> JetReference) {
+        registerMultiProvider(elementClass, { arrayOf(factory(it)) })
+    }
+
+    private fun <E : JetElement> PsiReferenceRegistrar.registerMultiProvider(elementClass: Class<E>, factory: (E) -> Array<PsiReference>) {
         registerReferenceProvider(PlatformPatterns.psiElement(elementClass), object: PsiReferenceProvider() {
             override fun getReferencesByElement(element: PsiElement, context: ProcessingContext): Array<PsiReference> {
                 @suppress("UNCHECKED_CAST")
-                return arrayOf(factory(element as E))
+                return factory(element as E)
             }
         })
     }
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/references/JetSimpleNameReference.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/references/JetSimpleNameReference.kt
index fa01d90bd26..eaaeb37fba7 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/references/JetSimpleNameReference.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/references/JetSimpleNameReference.kt
@@ -16,40 +16,35 @@
 
 package org.jetbrains.kotlin.idea.references
 
+import com.intellij.openapi.extensions.Extensions
 import com.intellij.openapi.util.TextRange
 import com.intellij.psi.PsiElement
 import com.intellij.psi.util.PsiTreeUtil
-import org.jetbrains.kotlin.psi.*
-import org.jetbrains.kotlin.name.FqName
-import org.jetbrains.kotlin.lexer.JetTokens
-import org.jetbrains.kotlin.idea.util.ShortenReferences
-import org.jetbrains.kotlin.idea.refactoring.fqName.changeQualifiedName
-import org.jetbrains.kotlin.idea.codeInsight.shorten.addToShorteningWaitSet
-import org.jetbrains.kotlin.idea.refactoring.fqName.getKotlinFqName
-import org.jetbrains.kotlin.types.expressions.OperatorConventions
-import org.jetbrains.kotlin.lexer.JetToken
-import org.jetbrains.kotlin.idea.intentions.OperatorToFunctionIntention
-import org.jetbrains.kotlin.resolve.BindingContext
 import com.intellij.util.IncorrectOperationException
-import org.jetbrains.kotlin.name.Name
-import org.jetbrains.kotlin.resolve.dataClassUtils.isComponentLike
 import org.jetbrains.kotlin.idea.caches.resolve.analyze
-import org.jetbrains.kotlin.psi.psiUtil.*
-import com.intellij.psi.impl.light.LightElement
-import com.intellij.openapi.extensions.Extensions
-import org.jetbrains.kotlin.idea.util.ProjectRootsUtil
+import org.jetbrains.kotlin.idea.codeInsight.shorten.addToShorteningWaitSet
+import org.jetbrains.kotlin.idea.intentions.OperatorToFunctionIntention
+import org.jetbrains.kotlin.idea.refactoring.fqName.changeQualifiedName
+import org.jetbrains.kotlin.idea.refactoring.fqName.getKotlinFqName
+import org.jetbrains.kotlin.idea.util.ShortenReferences
+import org.jetbrains.kotlin.lexer.JetToken
+import org.jetbrains.kotlin.lexer.JetTokens
+import org.jetbrains.kotlin.name.FqName
+import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.plugin.references.SimpleNameReferenceExtension
+import org.jetbrains.kotlin.psi.*
+import org.jetbrains.kotlin.psi.psiUtil.*
+import org.jetbrains.kotlin.resolve.BindingContext
+import org.jetbrains.kotlin.resolve.dataClassUtils.isComponentLike
+import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode
+import org.jetbrains.kotlin.types.expressions.OperatorConventions
 
-public class JetSimpleNameReference(
-        jetSimpleNameExpression: JetSimpleNameExpression
-) : JetSimpleReference<JetSimpleNameExpression>(jetSimpleNameExpression) {
-
+class JetSimpleNameReference(expression: JetSimpleNameExpression) : JetSimpleReference<JetSimpleNameExpression>(expression) {
     override fun isReferenceTo(element: PsiElement?): Boolean {
         if (element != null) {
             if (!canBeReferenceTo(element)) return false
 
-            val extensions = Extensions.getArea(element.getProject()).getExtensionPoint(
-                    SimpleNameReferenceExtension.EP_NAME).getExtensions()
+            val extensions = Extensions.getArea(element.getProject()).getExtensionPoint(SimpleNameReferenceExtension.EP_NAME).getExtensions()
             for (extension in extensions) {
                 val value = extension.isReferenceTo(this, element)
                 if (value != null) {
@@ -76,7 +71,7 @@ public class JetSimpleNameReference(
         return true
     }
 
-    public override fun handleElementRename(newElementName: String?): PsiElement? {
+    override fun handleElementRename(newElementName: String?): PsiElement {
         if (!canRename()) throw IncorrectOperationException()
         if (newElementName == null) return expression;
 
@@ -91,42 +86,25 @@ public class JetSimpleNameReference(
         val psiFactory = JetPsiFactory(expression)
         val element = when (expression.getReferencedNameElementType()) {
             JetTokens.FIELD_IDENTIFIER -> psiFactory.createFieldIdentifier(newElementName)
-            else -> {
-                val extensions = Extensions.getArea(expression.getProject()).getExtensionPoint(
-                        SimpleNameReferenceExtension.EP_NAME).getExtensions()
 
-                var handled: PsiElement? = null
-                for (extension in extensions) {
-                    handled = extension.handleElementRename(this, psiFactory, newElementName)
-                    if (handled != null) {
-                        break
-                    }
-                }
-                handled ?: psiFactory.createNameIdentifier(newElementName)
+            else -> {
+                Extensions.getArea(expression.getProject()).getExtensionPoint(SimpleNameReferenceExtension.EP_NAME).getExtensions()
+                        .asSequence()
+                        .map { it.handleElementRename(this, psiFactory, newElementName) }
+                        .firstOrNull { it != null } ?: psiFactory.createNameIdentifier(newElementName)
             }
         }
 
-        var nameElement = expression.getReferencedNameElement()
+        val nameElement = expression.getReferencedNameElement()
 
-        val elementType = nameElement.getNode()?.getElementType()
-        val opExpression =
-                PsiTreeUtil.getParentOfType<JetExpression>(expression, javaClass<JetUnaryExpression>(), javaClass<JetBinaryExpression>())
-        if (elementType is JetToken && OperatorConventions.getNameForOperationSymbol(elementType) != null && opExpression != null) {
-            val oldDescriptor = expression.analyze()[BindingContext.REFERENCE_TARGET, expression]
-            val newExpression = OperatorToFunctionIntention.convert(opExpression)
-            newExpression.accept(
-                    object: JetTreeVisitorVoid() {
-                        override fun visitCallExpression(expression: JetCallExpression) {
-                            val callee = expression.getCalleeExpression() as? JetSimpleNameExpression
-                            if (callee != null && callee.analyze()[BindingContext.REFERENCE_TARGET, callee] == oldDescriptor) {
-                                nameElement = callee.getReferencedNameElement()
-                            }
-                            else {
-                                super.visitCallExpression(expression)
-                            }
-                        }
-                    }
-            )
+        val elementType = nameElement.getNode().getElementType()
+        if (elementType is JetToken && OperatorConventions.getNameForOperationSymbol(elementType) != null) {
+            val opExpression = expression.getParent() as? JetOperationExpression
+            if (opExpression != null) {
+                val (newExpression, newNameElement) = OperatorToFunctionIntention.convert(opExpression)
+                newNameElement.replace(element)
+                return newExpression
+            }
         }
 
         nameElement.replace(element)
@@ -146,7 +124,7 @@ public class JetSimpleNameReference(
     fun bindToElement(element: PsiElement, shorteningMode: ShorteningMode): PsiElement =
             element.getKotlinFqName()?.let { fqName -> bindToFqName(fqName, shorteningMode) } ?: expression
 
-    public fun bindToFqName(fqName: FqName, shorteningMode: ShorteningMode = ShorteningMode.DELAYED_SHORTENING): PsiElement {
+    fun bindToFqName(fqName: FqName, shorteningMode: ShorteningMode = ShorteningMode.DELAYED_SHORTENING): PsiElement {
         if (fqName.isRoot()) return expression
 
         val newExpression = expression.changeQualifiedName(fqName).getQualifiedElementSelector() as JetSimpleNameExpression
@@ -168,9 +146,5 @@ public class JetSimpleNameReference(
         return newExpression
     }
 
-    override fun toString(): String {
-        return javaClass<JetSimpleNameReference>().getSimpleName() + ": " + expression.getText()
-    }
-
     override fun getCanonicalText(): String = expression.getText()
 }
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/references/SyntheticPropertyAccessorReference.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/references/SyntheticPropertyAccessorReference.kt
new file mode 100644
index 00000000000..da13e967668
--- /dev/null
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/references/SyntheticPropertyAccessorReference.kt
@@ -0,0 +1,78 @@
+/*
+ * Copyright 2010-2015 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.kotlin.idea.references
+
+import com.intellij.openapi.util.TextRange
+import com.intellij.psi.PsiElement
+import com.intellij.util.SmartList
+import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
+import org.jetbrains.kotlin.descriptors.FunctionDescriptor
+import org.jetbrains.kotlin.idea.caches.resolve.analyze
+import org.jetbrains.kotlin.name.Name
+import org.jetbrains.kotlin.psi.JetNameReferenceExpression
+import org.jetbrains.kotlin.psi.JetPsiFactory
+import org.jetbrains.kotlin.resolve.BindingContext
+import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode
+import org.jetbrains.kotlin.synthetic.SyntheticJavaPropertyDescriptor
+import org.jetbrains.kotlin.utils.addIfNotNull
+
+sealed class SyntheticPropertyAccessorReference(expression: JetNameReferenceExpression, private val getter: Boolean) : JetSimpleReference<JetNameReferenceExpression>(expression) {
+    override fun getTargetDescriptors(context: BindingContext): Collection<DeclarationDescriptor> {
+        val descriptors = super.getTargetDescriptors(context)
+        if (descriptors.none { it.original is SyntheticJavaPropertyDescriptor }) return emptyList()
+
+        val result = SmartList<FunctionDescriptor>()
+        for (descriptor in descriptors) {
+            val original = descriptor.original
+            if (original is SyntheticJavaPropertyDescriptor) {
+                if (getter) {
+                    result.add(original.getMethod)
+                }
+                else {
+                    result.addIfNotNull(original.setMethod)
+                }
+            }
+        }
+        return result
+    }
+
+    override fun getRangeInElement() = TextRange(0, expression.getTextLength())
+
+    override fun canRename() = true
+
+    override fun handleElementRename(newElementName: String?): PsiElement? {
+        if (!Name.isValidIdentifier(newElementName!!)) return expression
+
+        val newNameAsName = Name.identifier(newElementName)
+        val newName = if (getter) {
+            SyntheticJavaPropertyDescriptor.propertyNameByGetMethodName(newNameAsName)
+        }
+        else {
+            //TODO: it's not correct
+            //TODO: setIsY -> setIsIsY bug
+            SyntheticJavaPropertyDescriptor.propertyNameBySetMethodName(newNameAsName, withIsPrefix = expression.getReferencedNameAsName().asString().startsWith("is"))
+        }
+        if (newName == null) return expression //TODO: handle the case when get/set becomes ordinary method
+
+        val nameIdentifier = JetPsiFactory(expression).createNameIdentifier(newName.getIdentifier())
+        expression.getReferencedNameElement().replace(nameIdentifier)
+        return expression
+    }
+
+    public class Getter(expression: JetNameReferenceExpression) : SyntheticPropertyAccessorReference(expression, true)
+    public class Setter(expression: JetNameReferenceExpression) : SyntheticPropertyAccessorReference(expression, false)
+}
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/references/referenceUtil.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/references/referenceUtil.kt
index aab2fdae0d3..6b076a2a7c1 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/references/referenceUtil.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/references/referenceUtil.kt
@@ -19,12 +19,15 @@ package org.jetbrains.kotlin.idea.references
 import com.intellij.psi.*
 import org.jetbrains.kotlin.asJava.unwrapped
 import org.jetbrains.kotlin.idea.intentions.OperatorToFunctionIntention
-import org.jetbrains.kotlin.idea.search.usagesSearch.dataClassComponentFunctionName
+import org.jetbrains.kotlin.idea.kdoc.KDocReference
 import org.jetbrains.kotlin.idea.util.ProjectRootsUtil
+import org.jetbrains.kotlin.kdoc.psi.impl.KDocName
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.getNonStrictParentOfType
+import org.jetbrains.kotlin.psi.psiUtil.getQualifiedElementSelector
 import org.jetbrains.kotlin.psi.psiUtil.getStrictParentOfType
-import org.jetbrains.kotlin.resolve.dataClassUtils.isComponentLike
+import org.jetbrains.kotlin.utils.addToStdlib.firstIsInstance
+import org.jetbrains.kotlin.utils.addToStdlib.firstIsInstanceOrNull
 import org.jetbrains.kotlin.utils.emptyOrSingletonList
 import java.util.HashSet
 
@@ -110,7 +113,25 @@ private fun PsiElement.isConstructorOf(unwrappedCandidate: PsiElement) =
 fun AbstractJetReference<out JetExpression>.renameImplicitConventionalCall(newName: String?): JetExpression {
     if (newName == null) return expression
 
-    val expr = OperatorToFunctionIntention.convert(expression) as JetQualifiedExpression
-    val newCallee = (expr.getSelectorExpression() as JetCallExpression).getCalleeExpression()!!.getReference()!!.handleElementRename(newName)
-    return newCallee.getStrictParentOfType<JetQualifiedExpression>() as JetExpression
+    val (newExpression, newNameElement) = OperatorToFunctionIntention.convert(expression)
+    newNameElement.mainReference.handleElementRename(newName)
+    return newExpression
 }
+
+val JetSimpleNameExpression.mainReference: JetSimpleNameReference
+    get() = getReferences().firstIsInstance()
+
+val JetReferenceExpression.mainReference: JetReference
+    get() = if (this is JetSimpleNameExpression) mainReference else getReferences().firstIsInstance<JetReference>()
+
+val KDocName.mainReference: KDocReference
+    get() = getReferences().firstIsInstance()
+
+val JetElement.mainReference: JetReference?
+    get() {
+        return when {
+            this is JetReferenceExpression -> mainReference
+            this is KDocName -> mainReference
+            else -> getReferences().firstIsInstanceOrNull<JetReference>()
+        }
+    }
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/search/ideaExtensions/KotlinReferencesSearcher.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/search/ideaExtensions/KotlinReferencesSearcher.kt
index 27d9aaa6e23..c5c6743cbcd 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/search/ideaExtensions/KotlinReferencesSearcher.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/search/ideaExtensions/KotlinReferencesSearcher.kt
@@ -16,20 +16,21 @@
 
 package org.jetbrains.kotlin.idea.search.ideaExtensions
 
-import com.intellij.openapi.application.ApplicationManager
 import com.intellij.openapi.application.QueryExecutorBase
 import com.intellij.openapi.progress.ProgressManager
-import com.intellij.openapi.util.Computable
 import com.intellij.psi.*
+import com.intellij.psi.search.LocalSearchScope
 import com.intellij.psi.search.RequestResultProcessor
+import com.intellij.psi.search.SearchScope
 import com.intellij.psi.search.searches.ReferencesSearch
 import com.intellij.psi.util.PsiTreeUtil
 import com.intellij.util.Processor
 import org.jetbrains.kotlin.asJava.KotlinLightMethod
 import org.jetbrains.kotlin.asJava.LightClassUtil
 import org.jetbrains.kotlin.asJava.namedUnwrappedElement
-import org.jetbrains.kotlin.idea.references.matchesTarget
-import org.jetbrains.kotlin.idea.search.usagesSearch.*
+import org.jetbrains.kotlin.idea.JetFileType
+import org.jetbrains.kotlin.idea.search.usagesSearch.UsagesSearchLocation
+import org.jetbrains.kotlin.idea.search.usagesSearch.getSpecialNamesToSearch
 import org.jetbrains.kotlin.idea.util.ProjectRootsUtil
 import org.jetbrains.kotlin.idea.util.application.runReadAction
 import org.jetbrains.kotlin.psi.*
@@ -66,7 +67,9 @@ public class KotlinReferencesSearcher : QueryExecutorBase<PsiReference, Referenc
                                                       resultProcessor)
         }
 
-        searchLightElements(queryParameters, element)
+        if (!(unwrappedElement is JetElement && isOnlyKotlinSearch(queryParameters.getEffectiveSearchScope()))) {
+            searchLightElements(queryParameters, element)
+        }
     }
 
     companion object {
@@ -100,9 +103,9 @@ public class KotlinReferencesSearcher : QueryExecutorBase<PsiReference, Referenc
                 }
                 is JetProperty -> {
                     val propertyMethods = runReadAction { LightClassUtil.getLightClassPropertyMethods(element) }
-                    searchNamedElement(queryParameters, propertyMethods.getGetter())
-                    searchNamedElement(queryParameters, propertyMethods.getSetter())
-                }
+                            searchNamedElement(queryParameters, propertyMethods.getGetter())
+                            searchNamedElement(queryParameters, propertyMethods.getSetter())
+                        }
                 is KotlinLightMethod -> {
                     val declaration = element.getOrigin()
                     if (declaration is JetProperty || (declaration is JetParameter && declaration.hasValOrVar())) {
@@ -115,6 +118,9 @@ public class KotlinReferencesSearcher : QueryExecutorBase<PsiReference, Referenc
             }
         }
 
+        private fun isOnlyKotlinSearch(searchScope: SearchScope) =
+                searchScope is LocalSearchScope && searchScope.getScope().all { it.getContainingFile().getFileType() == JetFileType.INSTANCE }
+
         private fun searchNamedElement(queryParameters: ReferencesSearch.SearchParameters, element: PsiNamedElement?,
                                        name: String? = element?.getName()) {
             if (name != null && element != null) {
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/search/usagesSearch/searchHelpers.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/search/usagesSearch/searchHelpers.kt
index 909c2a5ea63..dc4439c4ec4 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/search/usagesSearch/searchHelpers.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/search/usagesSearch/searchHelpers.kt
@@ -173,7 +173,7 @@ class ClassUsagesSearchHelper(
                         val resolvedCall = bindingContext[BindingContext.RESOLVED_CALL, call] ?: return
                         if ((resolvedCall.getDispatchReceiver() as? ClassReceiver)?.getDeclarationDescriptor() == companionObjectDescriptor
                             || (resolvedCall.getExtensionReceiver() as? ClassReceiver)?.getDeclarationDescriptor() == companionObjectDescriptor) {
-                            element.getReference()?.let { processor.process(it) }
+                            element.getReferences().forEach { processor.process(it) }
                         }
                     }
                 })
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/search/usagesSearch/usagesSearch.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/search/usagesSearch/usagesSearch.kt
index 292919bf1ad..e7431fc9b94 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/search/usagesSearch/usagesSearch.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/search/usagesSearch/usagesSearch.kt
@@ -153,9 +153,10 @@ public class KotlinPsiSearchHelper(private val project: Project): PsiSearchHelpe
     }
 
     public fun processFilesWithText(item: UsagesSearchRequestItem, consumer: Processor<PsiReference>): Boolean {
+        val scope = runReadAction { item.target.effectiveScope }
         return item.words.all { word ->
             val textProcessor = ResultTextProcessorImpl(item, consumer)
-            processElementsWithWord(textProcessor, item.target.effectiveScope, word, item.target.location.searchContext, true)
+            processElementsWithWord(textProcessor, scope, word, item.target.location.searchContext, true)
         }
     }
 }
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/search/usagesSearch/utils.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/search/usagesSearch/utils.kt
index 348c47b96f8..29d488b3c77 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/search/usagesSearch/utils.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/search/usagesSearch/utils.kt
@@ -19,27 +19,27 @@ package org.jetbrains.kotlin.idea.search.usagesSearch
 import com.intellij.psi.PsiConstructorCall
 import com.intellij.psi.PsiElement
 import com.intellij.psi.PsiMethod
-import org.jetbrains.kotlin.descriptors.*
-import org.jetbrains.kotlin.psi.*
-import org.jetbrains.kotlin.psi.psiUtil.*
-import org.jetbrains.kotlin.resolve.BindingContext
 import com.intellij.psi.PsiReference
 import com.intellij.psi.search.SearchScope
 import org.jetbrains.kotlin.asJava.KotlinLightElement
-import org.jetbrains.kotlin.resolve.DescriptorUtils
-import org.jetbrains.kotlin.codegen.PropertyCodegen
 import org.jetbrains.kotlin.asJava.KotlinLightMethod
 import org.jetbrains.kotlin.asJava.KotlinNoOriginLightMethod
 import org.jetbrains.kotlin.asJava.unwrapped
-import org.jetbrains.kotlin.resolve.OverrideResolver
-import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils
-import org.jetbrains.kotlin.idea.references.*
-import org.jetbrains.kotlin.idea.findUsages.UsageTypeUtils
-import org.jetbrains.kotlin.idea.findUsages.UsageTypeEnum
+import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.idea.caches.resolve.analyze
 import org.jetbrains.kotlin.idea.caches.resolve.getJavaMethodDescriptor
+import org.jetbrains.kotlin.idea.findUsages.UsageTypeEnum
+import org.jetbrains.kotlin.idea.findUsages.UsageTypeUtils
+import org.jetbrains.kotlin.idea.references.unwrappedTargets
 import org.jetbrains.kotlin.idea.search.declarationsSearch.HierarchySearchRequest
 import org.jetbrains.kotlin.idea.search.declarationsSearch.searchInheritors
+import org.jetbrains.kotlin.load.java.JvmAbi
+import org.jetbrains.kotlin.psi.*
+import org.jetbrains.kotlin.psi.psiUtil.getNonStrictParentOfType
+import org.jetbrains.kotlin.resolve.BindingContext
+import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils
+import org.jetbrains.kotlin.resolve.DescriptorUtils
+import org.jetbrains.kotlin.resolve.OverrideResolver
 
 val JetDeclaration.descriptor: DeclarationDescriptor?
     get() = this.analyze().get(BindingContext.DECLARATION_TO_DESCRIPTOR, this)
@@ -221,7 +221,7 @@ fun PsiReference.isPropertyReadOnlyUsage(): Boolean {
             is JetProperty, is JetParameter -> origin as JetNamedDeclaration
             else -> null
         }
-        return declaration != null && refTarget.getName() == PropertyCodegen.getterName(declaration.getNameAsName())
+        return declaration != null && refTarget.getName() == JvmAbi.getterName(declaration.getName()!!)
     }
 
     return false
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/stubindex/PackageIndexUtil.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/stubindex/PackageIndexUtil.kt
index 77c83de0381..556258abbbb 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/stubindex/PackageIndexUtil.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/stubindex/PackageIndexUtil.kt
@@ -27,14 +27,16 @@ import org.jetbrains.kotlin.load.kotlin.PackageClassUtils
 import com.intellij.psi.util.CachedValuesManager
 import com.intellij.psi.util.CachedValueProvider.Result
 import com.intellij.psi.util.PsiModificationTracker
+import org.jetbrains.kotlin.name.Name
 
 public object PackageIndexUtil {
     platformStatic public fun getSubPackageFqNames(
             packageFqName: FqName,
             scope: GlobalSearchScope,
-            project: Project
+            project: Project,
+            nameFilter: (Name) -> Boolean
     ): Collection<FqName> {
-        return SubpackagesIndexService.getInstance(project).getSubpackages(packageFqName, scope)
+        return SubpackagesIndexService.getInstance(project).getSubpackages(packageFqName, scope, nameFilter)
     }
 
     platformStatic public fun findFilesWithExactPackage(
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/stubindex/SubpackagesIndexService.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/stubindex/SubpackagesIndexService.kt
index 5da45903c66..4669e5f2b5c 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/stubindex/SubpackagesIndexService.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/stubindex/SubpackagesIndexService.kt
@@ -59,15 +59,14 @@ public class SubpackagesIndexService(private val project: Project) {
             }
         }
 
-        public fun getSubpackages(fqName: FqName, scope: GlobalSearchScope): Collection<FqName> {
+        public fun getSubpackages(fqName: FqName, scope: GlobalSearchScope, nameFilter: (Name) -> Boolean): Collection<FqName> {
             val possibleFilesFqNames = fqNameByPrefix[fqName]
             val existingSubPackagesShortNames = HashSet<Name>()
             val len = fqName.pathSegments().size()
             for (filesFqName in possibleFilesFqNames) {
                 val candidateSubPackageShortName = filesFqName.pathSegments()[len]
-                if (candidateSubPackageShortName in existingSubPackagesShortNames) {
-                    continue
-                }
+                if (candidateSubPackageShortName in existingSubPackagesShortNames || !nameFilter(candidateSubPackageShortName)) continue
+
                 val existsInThisScope = PackageIndexUtil.containsFilesWithExactPackage(filesFqName, scope, project)
                 if (existsInThisScope) {
                     existingSubPackagesShortNames.add(candidateSubPackageShortName)
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/stubindex/resolve/StubBasedPackageMemberDeclarationProvider.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/stubindex/resolve/StubBasedPackageMemberDeclarationProvider.kt
index 1c8af0c3552..c9372752aa6 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/stubindex/resolve/StubBasedPackageMemberDeclarationProvider.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/stubindex/resolve/StubBasedPackageMemberDeclarationProvider.kt
@@ -77,8 +77,8 @@ public class StubBasedPackageMemberDeclarationProvider(
         return JetTopLevelPropertyFqnNameIndex.getInstance().get(childName(name), project, searchScope)
     }
 
-    override fun getAllDeclaredSubPackages(): Collection<FqName> {
-        return PackageIndexUtil.getSubPackageFqNames(fqName, searchScope, project)
+    override fun getAllDeclaredSubPackages(nameFilter: (Name) -> Boolean): Collection<FqName> {
+        return PackageIndexUtil.getSubPackageFqNames(fqName, searchScope, project, nameFilter)
     }
 
     override fun getPackageFiles(): Collection<JetFile> {
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/versions/KotlinRuntimeLibraryCoreUtil.java b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/versions/KotlinRuntimeLibraryCoreUtil.java
index e3389f3c152..f4e7472e19e 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/versions/KotlinRuntimeLibraryCoreUtil.java
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/versions/KotlinRuntimeLibraryCoreUtil.java
@@ -28,7 +28,7 @@ import org.jetbrains.annotations.Nullable;
 
 public class KotlinRuntimeLibraryCoreUtil {
     private static final ImmutableList<String> CANDIDATE_CLASSES = ImmutableList.of(
-            "kotlin.jvm.internal.Intrinsics",
+            "kotlin.Unit",
 
             // For older versions
             "jet.runtime.Intrinsics"
diff --git a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/AllClassesCompletion.kt b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/AllClassesCompletion.kt
index e85703308ea..63016f0329f 100644
--- a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/AllClassesCompletion.kt
+++ b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/AllClassesCompletion.kt
@@ -40,10 +40,13 @@ class AllClassesCompletion(private val parameters: CompletionParameters,
     fun collect(classDescriptorCollector: (ClassDescriptor) -> Unit, javaClassCollector: (PsiClass) -> Unit) {
         //TODO: this is a temporary hack until we have built-ins in indices
         val builtIns = JavaToKotlinClassMap.INSTANCE.allKotlinClasses()
-        val filteredBuiltIns = builtIns.filter { kindFilter(it.getKind()) && prefixMatcher.prefixMatches(it.getName().asString()) }
+        val filteredBuiltIns = builtIns
+                .filter { kindFilter(it.getKind()) && prefixMatcher.prefixMatches(it.getName().asString()) }
         filteredBuiltIns.forEach { classDescriptorCollector(it) }
 
-        kotlinIndicesHelper.getClassDescriptors({ prefixMatcher.prefixMatches(it) }, kindFilter).forEach { classDescriptorCollector(it) }
+        kotlinIndicesHelper
+                .getKotlinClasses({ prefixMatcher.prefixMatches(it) }, kindFilter)
+                .forEach { classDescriptorCollector(it) }
 
         if (!ProjectStructureUtil.isJsKotlinModule(parameters.getOriginalFile() as JetFile)) {
             addAdaptedJavaCompletion(javaClassCollector)
@@ -69,7 +72,7 @@ class AllClassesCompletion(private val parameters: CompletionParameters,
     }
 
     private fun PsiClass.isSyntheticKotlinClass(): Boolean {
-        if (!getName().contains('$')) return false // optimization to not analyze annotations of all classes
+        if (!getName()!!.contains('$')) return false // optimization to not analyze annotations of all classes
         return getModifierList()?.findAnnotation(javaClass<kotlin.jvm.internal.KotlinSyntheticClass>().getName()) != null
     }
 }
diff --git a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/BasicCompletionSession.kt b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/BasicCompletionSession.kt
index ce541503e30..b2b77ba55a1 100644
--- a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/BasicCompletionSession.kt
+++ b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/BasicCompletionSession.kt
@@ -19,12 +19,17 @@ package org.jetbrains.kotlin.idea.completion
 import com.intellij.codeInsight.completion.*
 import com.intellij.patterns.PatternCondition
 import com.intellij.patterns.StandardPatterns
+import com.intellij.psi.JavaPsiFacade
 import com.intellij.psi.util.PsiTreeUtil
 import com.intellij.util.ProcessingContext
 import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.descriptors.ClassKind
 import org.jetbrains.kotlin.descriptors.ClassifierDescriptor
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
+import org.jetbrains.kotlin.idea.project.ProjectStructureUtil
+import org.jetbrains.kotlin.idea.stubindex.PackageIndexUtil
+import org.jetbrains.kotlin.name.FqName
+import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.getNonStrictParentOfType
 import org.jetbrains.kotlin.psi.psiUtil.getStrictParentOfType
@@ -70,7 +75,10 @@ class BasicCompletionSession(configuration: CompletionSessionConfiguration,
 
     private val completionKind = calcCompletionKind()
 
-    override val descriptorKindFilter = completionKind.descriptorKindFilter
+    override val descriptorKindFilter = if (isNoQualifierContext())
+        completionKind.descriptorKindFilter?.withoutKinds(DescriptorKindFilter.PACKAGES_MASK)
+    else
+        completionKind.descriptorKindFilter
 
     private val parameterNameAndTypeCompletion = if (shouldCompleteParameterNameAndType())
         ParameterNameAndTypeCompletion(collector, lookupElementFactory, prefixMatcher, resolutionFacade)
@@ -82,7 +90,7 @@ class BasicCompletionSession(configuration: CompletionSessionConfiguration,
             return CompletionKind.NAMED_ARGUMENTS_ONLY
         }
 
-        if (reference == null) {
+        if (nameExpression == null) {
             val parameter = position.getParent() as? JetParameter
             return if (parameter != null && position == parameter.getNameIdentifier())
                 CompletionKind.PARAMETER_NAME
@@ -107,7 +115,7 @@ class BasicCompletionSession(configuration: CompletionSessionConfiguration,
         val typeReference = position.getStrictParentOfType<JetTypeReference>()
         if (typeReference != null) {
             val firstPartReference = PsiTreeUtil.findChildOfType(typeReference, javaClass<JetSimpleNameExpression>())
-            if (firstPartReference == reference.expression) {
+            if (firstPartReference == nameExpression) {
                 return CompletionKind.TYPES
             }
         }
@@ -193,6 +201,24 @@ class BasicCompletionSession(configuration: CompletionSessionConfiguration,
                 }
             }
 
+            // getting root packages from scope is very slow so we do this in alternative way
+            if (isNoQualifierContext() && (completionKind.descriptorKindFilter?.kindMask ?: 0).and(DescriptorKindFilter.PACKAGES_MASK) != 0) {
+                //TODO: move this code somewhere else
+                val packageNames = PackageIndexUtil.getSubPackageFqNames(FqName.ROOT, originalSearchScope, project, prefixMatcher.asNameFilter())
+                        .toMutableSet()
+
+                if (!ProjectStructureUtil.isJsKotlinModule(parameters.getOriginalFile() as JetFile)) {
+                    JavaPsiFacade.getInstance(project).findPackage("")?.getSubPackages(originalSearchScope)?.forEach { psiPackage ->
+                        val name = psiPackage.getName()
+                        if (Name.isValidIdentifier(name!!)) {
+                            packageNames.add(FqName(name))
+                        }
+                    }
+                }
+
+                packageNames.forEach { collector.addElement(lookupElementFactory.createLookupElementForPackage(it)) }
+            }
+
             if (completionKind != CompletionKind.KEYWORDS_ONLY) {
                 flushToResultSet()
 
@@ -233,11 +259,11 @@ class BasicCompletionSession(configuration: CompletionSessionConfiguration,
     private companion object {
         object NonAnnotationClassifierExclude : DescriptorKindExclude {
             override fun matches(descriptor: DeclarationDescriptor): Boolean {
-                return if (descriptor is ClassDescriptor)
-                    descriptor.getKind() != ClassKind.ANNOTATION_CLASS
-                else
-                    descriptor !is ClassifierDescriptor
+                if (descriptor !is ClassifierDescriptor) return false
+                return descriptor !is ClassDescriptor || descriptor.getKind() != ClassKind.ANNOTATION_CLASS
             }
+
+            override val fullyExcludedDescriptorKinds: Int get() = 0
         }
 
         val ANNOTATION_TYPES_FILTER = DescriptorKindFilter(DescriptorKindFilter.NON_SINGLETON_CLASSIFIERS_MASK or DescriptorKindFilter.PACKAGES_MASK) exclude NonAnnotationClassifierExclude
diff --git a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/CompletionSession.kt b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/CompletionSession.kt
index 445a2f6d240..5d1cf31aa7a 100644
--- a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/CompletionSession.kt
+++ b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/CompletionSession.kt
@@ -37,14 +37,12 @@ import org.jetbrains.kotlin.idea.codeInsight.DescriptorToSourceUtilsIde
 import org.jetbrains.kotlin.idea.codeInsight.ReferenceVariantsHelper
 import org.jetbrains.kotlin.idea.completion.smart.LambdaItems
 import org.jetbrains.kotlin.idea.completion.smart.SmartCompletion
-import org.jetbrains.kotlin.idea.core.KotlinIndicesHelper
-import org.jetbrains.kotlin.idea.core.comparePossiblyOverridingDescriptors
-import org.jetbrains.kotlin.idea.core.getResolutionScope
-import org.jetbrains.kotlin.idea.core.isVisible
+import org.jetbrains.kotlin.idea.core.*
 import org.jetbrains.kotlin.idea.references.JetSimpleNameReference
+import org.jetbrains.kotlin.idea.references.mainReference
 import org.jetbrains.kotlin.idea.util.CallType
 import org.jetbrains.kotlin.idea.util.ShadowedDeclarationsFilter
-import org.jetbrains.kotlin.idea.util.makeNotNullable
+import org.jetbrains.kotlin.types.typeUtil.makeNotNullable
 import org.jetbrains.kotlin.lexer.JetTokens
 import org.jetbrains.kotlin.load.java.descriptors.SamConstructorDescriptorKindExclude
 import org.jetbrains.kotlin.psi.*
@@ -64,11 +62,15 @@ import kotlin.properties.Delegates
 
 class CompletionSessionConfiguration(
         val completeNonImportedDeclarations: Boolean,
-        val completeNonAccessibleDeclarations: Boolean)
+        val completeNonAccessibleDeclarations: Boolean,
+        val filterOutJavaGettersAndSetters: Boolean
+)
 
 fun CompletionSessionConfiguration(parameters: CompletionParameters) = CompletionSessionConfiguration(
         completeNonImportedDeclarations = parameters.getInvocationCount() >= 2,
-        completeNonAccessibleDeclarations = parameters.getInvocationCount() >= 2)
+        completeNonAccessibleDeclarations = parameters.getInvocationCount() >= 2,
+        filterOutJavaGettersAndSetters = parameters.getInvocationCount() < 2
+)
 
 abstract class CompletionSession(protected val configuration: CompletionSessionConfiguration,
                                      protected val parameters: CompletionParameters,
@@ -79,23 +81,23 @@ abstract class CompletionSession(protected val configuration: CompletionSessionC
     protected val moduleDescriptor: ModuleDescriptor = resolutionFacade.findModuleDescriptor(file)
     protected val project: Project = position.getProject()
 
-    protected val reference: JetSimpleNameReference?
+    protected val nameExpression: JetSimpleNameExpression?
     protected val expression: JetExpression?
 
     init {
-        val reference = position.getParent()?.getReferences()?.firstIsInstanceOrNull<JetSimpleNameReference>()
+        val reference = (position.getParent() as? JetSimpleNameExpression)?.mainReference
         if (reference != null) {
             if (reference.expression is JetLabelReferenceExpression) {
+                this.nameExpression = null
                 this.expression = reference.expression.getParent().getParent() as? JetExpressionWithLabel
-                this.reference = null
             }
             else {
-                this.expression = reference.expression
-                this.reference = reference
+                this.nameExpression = reference.expression
+                this.expression = nameExpression
             }
         }
         else {
-            this.reference = null
+            this.nameExpression = null
             this.expression = null
         }
     }
@@ -130,7 +132,7 @@ abstract class CompletionSession(protected val configuration: CompletionSessionC
 
     protected val referenceVariantsHelper: ReferenceVariantsHelper = ReferenceVariantsHelper(bindingContext, moduleDescriptor, project, isVisibleFilter)
 
-    protected val receiversData: ReferenceVariantsHelper.ReceiversData? = reference?.let { referenceVariantsHelper.getReferenceVariantsReceivers(it.expression) }
+    protected val receiversData: ReferenceVariantsHelper.ReceiversData? = nameExpression?.let { referenceVariantsHelper.getReferenceVariantsReceivers(it) }
 
     protected val lookupElementFactory: LookupElementFactory = run {
         if (receiversData != null) {
@@ -168,13 +170,13 @@ abstract class CompletionSession(protected val configuration: CompletionSessionC
     }
 
     protected val indicesHelper: KotlinIndicesHelper
-        get() = KotlinIndicesHelper(project, resolutionFacade, searchScope, moduleDescriptor, isVisibleFilter)
+        get() = KotlinIndicesHelper(project, resolutionFacade, searchScope, moduleDescriptor, isVisibleFilter, true)
 
     protected fun isVisibleDescriptor(descriptor: DeclarationDescriptor): Boolean {
         if (descriptor is TypeParameterDescriptor && !isTypeParameterVisible(descriptor)) return false
 
         if (descriptor is DeclarationDescriptorWithVisibility) {
-            val visible = descriptor.isVisible(inDescriptor, bindingContext, reference?.expression)
+            val visible = descriptor.isVisible(inDescriptor, bindingContext, nameExpression)
             if (visible) return true
             if (!configuration.completeNonAccessibleDeclarations) return false
             return DescriptorToSourceUtilsIde.getAnyDeclaration(project, descriptor) !is PsiCompiledElement
@@ -208,12 +210,14 @@ abstract class CompletionSession(protected val configuration: CompletionSessionC
 
     protected abstract val descriptorKindFilter: DescriptorKindFilter?
 
-    // set is used only for completion in code fragments
     protected val referenceVariants: Collection<DeclarationDescriptor> by Delegates.lazy {
         if (descriptorKindFilter != null) {
-            val expression = reference!!.expression
-            referenceVariantsHelper.getReferenceVariants(expression, descriptorKindFilter!!, false, prefixMatcher.asNameFilter())
-                    .excludeNonInitializedVariable(expression)
+            referenceVariantsHelper.getReferenceVariants(
+                    nameExpression!!,
+                    descriptorKindFilter!!,
+                    prefixMatcher.asNameFilter(),
+                    filterOutJavaGettersAndSetters = configuration.filterOutJavaGettersAndSetters
+            ).excludeNonInitializedVariable(nameExpression)
         }
         else {
             emptyList()
@@ -234,7 +238,8 @@ abstract class CompletionSession(protected val configuration: CompletionSessionC
     }
 
     protected fun getRuntimeReceiverTypeReferenceVariants(): Collection<DeclarationDescriptor> {
-        val descriptors = referenceVariantsHelper.getReferenceVariants(reference!!.expression, descriptorKindFilter!!, true, prefixMatcher.asNameFilter())
+        val restrictedKindFilter = descriptorKindFilter!!.restrictedToKinds(DescriptorKindFilter.FUNCTIONS_MASK or DescriptorKindFilter.VARIABLES_MASK) // optimization
+        val descriptors = referenceVariantsHelper.getReferenceVariants(nameExpression!!, restrictedKindFilter, prefixMatcher.asNameFilter(), useRuntimeReceiverType = true)
         return descriptors.filter { descriptor ->
             referenceVariants.none { comparePossiblyOverridingDescriptors(project, it, descriptor) }
         }
@@ -249,17 +254,17 @@ abstract class CompletionSession(protected val configuration: CompletionSessionC
     }
 
     protected fun getTopLevelCallables(): Collection<DeclarationDescriptor> {
-        val descriptors = indicesHelper.getTopLevelCallables({ prefixMatcher.prefixMatches(it) })
-        return filterShadowedNonImported(descriptors, reference!!)
+        return indicesHelper.getTopLevelCallables({ prefixMatcher.prefixMatches(it) })
+                .filterShadowedNonImported()
     }
 
     protected fun getTopLevelExtensions(): Collection<CallableDescriptor> {
-        val descriptors = indicesHelper.getCallableTopLevelExtensions({ prefixMatcher.prefixMatches(it) }, reference!!.expression, bindingContext)
-        return filterShadowedNonImported(descriptors, reference)
+        return indicesHelper.getCallableTopLevelExtensions({ prefixMatcher.prefixMatches(it) }, nameExpression!!, bindingContext)
+                .filterShadowedNonImported()
     }
 
-    private fun filterShadowedNonImported(descriptors: Collection<CallableDescriptor>, reference: JetSimpleNameReference): Collection<CallableDescriptor> {
-        return ShadowedDeclarationsFilter(bindingContext, moduleDescriptor, project).filterNonImported(descriptors, referenceVariants, reference.expression)
+    private fun Collection<CallableDescriptor>.filterShadowedNonImported(): Collection<CallableDescriptor> {
+        return ShadowedDeclarationsFilter(bindingContext, moduleDescriptor, project).filterNonImported(this, referenceVariants, nameExpression!!)
     }
 
     protected fun addAllClasses(kindFilter: (ClassKind) -> Boolean) {
diff --git a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/CompletionSorting.kt b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/CompletionSorting.kt
index 442c27c115b..892eed26ee8 100644
--- a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/CompletionSorting.kt
+++ b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/CompletionSorting.kt
@@ -51,7 +51,7 @@ public fun CompletionResultSet.addKotlinSorting(parameters: CompletionParameters
         sorter = sorter.weighBefore("kotlin.kind", NameSimilarityWeigher, SmartCompletionPriorityWeigher)
     }
 
-    sorter = sorter.weighAfter("stats", JetDeclarationRemotenessWeigher(parameters.getOriginalFile() as JetFile))
+    sorter = sorter.weighAfter("stats", DeclarationRemotenessWeigher(parameters.getOriginalFile() as JetFile))
 
     sorter = sorter.weighBefore("middleMatching", PreferMatchingItemWeigher)
 
@@ -121,7 +121,7 @@ private object PreferMatchingItemWeigher : LookupElementWeigher("kotlin.preferMa
     }
 }
 
-private class JetDeclarationRemotenessWeigher(private val file: JetFile) : LookupElementWeigher("kotlin.declarationRemoteness") {
+private class DeclarationRemotenessWeigher(private val file: JetFile) : LookupElementWeigher("kotlin.declarationRemoteness") {
     private val importCache = ImportCache()
 
     private enum class Weight {
@@ -143,11 +143,10 @@ private class JetDeclarationRemotenessWeigher(private val file: JetFile) : Looku
             return Weight.thisFile
         }
 
-        val qualifiedName = o.qualifiedName()
+        val fqName = o.importableFqName
         // Invalid name can be met for companion object descriptor: Test.MyTest.A.<no name provided>.testOther
-        if (qualifiedName != null && isValidJavaFqName(qualifiedName)) {
-            val importPath = ImportPath(qualifiedName)
-            val fqName = importPath.fqnPart()
+        if (fqName != null) {
+            val importPath = ImportPath(fqName, false)
             return when {
                 JavaToKotlinClassMap.INSTANCE.mapPlatformClass(fqName).isNotEmpty() -> Weight.notToBeUsedInKotlin
                 ImportInsertHelper.getInstance(file.getProject()).isImportedWithDefault(importPath, file) -> Weight.kotlinDefaultImport
diff --git a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/CompletionUtils.kt b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/CompletionUtils.kt
index e4b0d7583fe..21178f1bb34 100644
--- a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/CompletionUtils.kt
+++ b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/CompletionUtils.kt
@@ -31,7 +31,6 @@ import org.jetbrains.kotlin.idea.caches.resolve.ResolutionFacade
 import org.jetbrains.kotlin.idea.completion.handlers.CastReceiverInsertHandler
 import org.jetbrains.kotlin.idea.completion.handlers.WithTailInsertHandler
 import org.jetbrains.kotlin.idea.util.*
-import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.parentsWithSelf
@@ -42,9 +41,9 @@ import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils
 import org.jetbrains.kotlin.resolve.DescriptorUtils
 import org.jetbrains.kotlin.resolve.inline.InlineUtil
 import org.jetbrains.kotlin.types.JetType
-import org.jetbrains.kotlin.types.TypeConstructor
-import org.jetbrains.kotlin.types.checker.JetTypeChecker
-import org.jetbrains.kotlin.types.typeUtil.equalTypesOrNulls
+import org.jetbrains.kotlin.types.typeUtil.TypeNullability
+import org.jetbrains.kotlin.types.typeUtil.makeNotNullable
+import org.jetbrains.kotlin.types.typeUtil.nullability
 import java.util.ArrayList
 
 enum class ItemPriority {
@@ -140,42 +139,6 @@ enum class CallableWeight {
 
 val CALLABLE_WEIGHT_KEY = Key<CallableWeight>("CALLABLE_WEIGHT_KEY")
 
-fun descriptorsEqualWithSubstitution(descriptor1: DeclarationDescriptor?, descriptor2: DeclarationDescriptor?): Boolean {
-    if (descriptor1 == descriptor2) return true
-    if (descriptor1 == null || descriptor2 == null) return false
-    if (descriptor1.getOriginal() != descriptor2.getOriginal()) return false
-    if (descriptor1 !is CallableDescriptor) return true
-    descriptor2 as CallableDescriptor
-
-    // optimization:
-    if (descriptor1 == descriptor1.getOriginal() && descriptor2 == descriptor2.getOriginal()) return true
-
-    val typeChecker = JetTypeChecker.withAxioms(object: JetTypeChecker.TypeConstructorEquality {
-        override fun equals(a: TypeConstructor, b: TypeConstructor): Boolean {
-            val typeParam1 = a.getDeclarationDescriptor() as? TypeParameterDescriptor
-            val typeParam2 = b.getDeclarationDescriptor() as? TypeParameterDescriptor
-            if (typeParam1 != null
-                && typeParam2 != null
-                && typeParam1.getContainingDeclaration() == descriptor1
-                && typeParam2.getContainingDeclaration() == descriptor2) {
-                return typeParam1.getIndex() == typeParam2.getIndex()
-            }
-
-            return a == b
-        }
-    })
-
-    if (!typeChecker.equalTypesOrNulls(descriptor1.getReturnType(), descriptor2.getReturnType())) return false
-
-    val parameters1 = descriptor1.getValueParameters()
-    val parameters2 = descriptor2.getValueParameters()
-    if (parameters1.size() != parameters2.size()) return false
-    for ((param1, param2) in parameters1.zip(parameters2)) {
-        if (!typeChecker.equalTypes(param1.getType(), param2.getType())) return false
-    }
-    return true
-}
-
 fun InsertionContext.isAfterDot(): Boolean {
     var offset = getStartOffset()
     val chars = getDocument().getCharsSequence()
@@ -325,7 +288,7 @@ fun LookupElementFactory.createBackingFieldLookupElement(
     if (accessors.all { it.getBodyExpression() == null }) return null // makes no sense to access backing field - it's the same as accessing property directly
 
     val bindingContext = resolutionFacade.analyze(declaration)
-    if (!bindingContext[BindingContext.BACKING_FIELD_REQUIRED, property]) return null
+    if (!bindingContext[BindingContext.BACKING_FIELD_REQUIRED, property]!!) return null
 
     val lookupElement = createLookupElement(property, true)
     return object : LookupElementDecorator<LookupElement>(lookupElement) {
diff --git a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/DeclarationLookupObjectImpl.kt b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/DeclarationLookupObjectImpl.kt
index 6a17db302ff..0b81c5d001f 100644
--- a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/DeclarationLookupObjectImpl.kt
+++ b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/DeclarationLookupObjectImpl.kt
@@ -18,12 +18,18 @@ package org.jetbrains.kotlin.idea.completion
 
 import com.intellij.openapi.diagnostic.Logger
 import com.intellij.openapi.util.Iconable
+import com.intellij.psi.PsiClass
 import com.intellij.psi.PsiDocCommentOwner
 import com.intellij.psi.PsiElement
+import com.intellij.psi.PsiNamedElement
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 import org.jetbrains.kotlin.idea.caches.resolve.ResolutionFacade
 import org.jetbrains.kotlin.idea.core.completion.DeclarationLookupObject
+import org.jetbrains.kotlin.idea.imports.importableFqName
+import org.jetbrains.kotlin.name.FqName
+import org.jetbrains.kotlin.name.Name
+import org.jetbrains.kotlin.util.descriptorsEqualWithSubstitution
 import javax.swing.Icon
 
 /**
@@ -39,6 +45,17 @@ public abstract class DeclarationLookupObjectImpl(
         assert(descriptor != null || psiElement != null)
     }
 
+    override val name: Name?
+        get() = descriptor?.getName() ?: (psiElement as? PsiNamedElement)?.getName()?.let { Name.identifier(it) }
+
+    override val importableFqName: FqName?
+        get() {
+            return if (descriptor != null)
+                descriptor.importableFqName
+            else
+                (psiElement as? PsiClass)?.getQualifiedName()?.let { FqName(it) }
+        }
+
     override fun toString() = super<DeclarationLookupObject>.toString() + " " + (descriptor ?: psiElement)
 
     override fun hashCode(): Int {
diff --git a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/ExpectedInfos.kt b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/ExpectedInfos.kt
index 06bcd5885ad..67a10814495 100644
--- a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/ExpectedInfos.kt
+++ b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/ExpectedInfos.kt
@@ -23,7 +23,7 @@ import org.jetbrains.kotlin.frontend.di.createContainerForMacros
 import org.jetbrains.kotlin.idea.caches.resolve.ResolutionFacade
 import org.jetbrains.kotlin.idea.completion.smart.toList
 import org.jetbrains.kotlin.idea.core.mapArgumentsToParameters
-import org.jetbrains.kotlin.idea.util.makeNotNullable
+import org.jetbrains.kotlin.types.typeUtil.makeNotNullable
 import org.jetbrains.kotlin.lexer.JetTokens
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.psi.*
@@ -188,7 +188,7 @@ class ExpectedInfos(
                 if (parameter.hasDefaultValue()) return false // parameter is optional
                 if (parameter.getVarargElementType() != null) return false // vararg arguments list can be empty
                 // last parameter of functional type can be placed outside parenthesis:
-                if (parameter == parameters.last() && KotlinBuiltIns.isFunctionOrExtensionFunctionType(parameter.getType())) return false
+                if (parameter == parameters.last() && KotlinBuiltIns.isExactFunctionOrExtensionFunctionType(parameter.getType())) return false
                 return true
             }
 
diff --git a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/KDocCompletionContributor.kt b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/KDocCompletionContributor.kt
index a033e8b712b..98984a5cde9 100644
--- a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/KDocCompletionContributor.kt
+++ b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/KDocCompletionContributor.kt
@@ -64,7 +64,7 @@ class KDocNameCompletionSession(parameters: CompletionParameters,
         val position = parameters.getPosition().getParentOfType<KDocName>(false) ?: return
         val declaration = position.getContainingDoc().getOwner() ?: return
         val kdocLink = position.getStrictParentOfType<KDocLink>()!!
-        val declarationDescriptor = bindingContext[BindingContext.DECLARATION_TO_DESCRIPTOR, declaration]
+        val declarationDescriptor = bindingContext[BindingContext.DECLARATION_TO_DESCRIPTOR, declaration]!!
         if (kdocLink.getTagIfSubject()?.knownTag == KDocKnownTag.PARAM) {
             addParamCompletions(position, declarationDescriptor)
         } else {
diff --git a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/KotlinCompletionContributor.kt b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/KotlinCompletionContributor.kt
index e5c785dbe22..6bbb421b308 100644
--- a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/KotlinCompletionContributor.kt
+++ b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/KotlinCompletionContributor.kt
@@ -22,10 +22,7 @@ import com.intellij.openapi.progress.ProcessCanceledException
 import com.intellij.patterns.PlatformPatterns
 import com.intellij.patterns.PsiJavaPatterns.elementType
 import com.intellij.patterns.PsiJavaPatterns.psiElement
-import com.intellij.psi.PsiComment
-import com.intellij.psi.PsiElement
-import com.intellij.psi.PsiErrorElement
-import com.intellij.psi.TokenType
+import com.intellij.psi.*
 import com.intellij.psi.search.PsiElementProcessor
 import com.intellij.psi.tree.TokenSet
 import com.intellij.psi.util.PsiTreeUtil
@@ -73,11 +70,10 @@ public class KotlinCompletionContributor : CompletionContributor() {
 
             PackageDirectiveCompletion.ACTIVATION_PATTERN.accepts(tokenBefore) -> PackageDirectiveCompletion.DUMMY_IDENTIFIER
 
-            isInFunctionLiteralParameterList(tokenBefore) -> CompletionUtilCore.DUMMY_IDENTIFIER_TRIMMED
-
             isInClassHeader(tokenBefore) -> CompletionUtilCore.DUMMY_IDENTIFIER // do not add '$' to not interrupt class declaration parsing
 
-            else -> specialExtensionReceiverDummyIdentifier(tokenBefore)
+            else -> specialLambdaSignatureDummyIdentifier(tokenBefore)
+                    ?: specialExtensionReceiverDummyIdentifier(tokenBefore)
                     ?: specialInTypeArgsDummyIdentifier(tokenBefore)
                     ?: specialInParameterListDummyIdentifier(tokenBefore)
                     ?: specialInArgumentListDummyIdentifier(tokenBefore)
@@ -137,12 +133,6 @@ public class KotlinCompletionContributor : CompletionContributor() {
         return expression.getTextRange()!!.getEndOffset()
     }
 
-    private fun isInFunctionLiteralParameterList(tokenBefore: PsiElement?): Boolean {
-        val parameterList = tokenBefore?.parents?.firstOrNull { it is JetParameterList } ?: return false
-        val parent = parameterList.getParent()
-        return parent is JetFunctionLiteral && parent.getValueParameterList() == parameterList
-    }
-
     private fun isInClassHeader(tokenBefore: PsiElement?): Boolean {
         val classOrObject = tokenBefore?.parents?.firstIsInstanceOrNull<JetClassOrObject>() ?: return false
         val name = classOrObject.getNameIdentifier() ?: return false
@@ -151,6 +141,31 @@ public class KotlinCompletionContributor : CompletionContributor() {
         return name.endOffset <= offset && offset <= body.startOffset
     }
 
+    private fun specialLambdaSignatureDummyIdentifier(tokenBefore: PsiElement?): String? {
+        var leaf = tokenBefore
+        while (leaf is PsiWhiteSpace || leaf is PsiComment) {
+            leaf = leaf.prevLeaf(true)
+        }
+
+        val lambda = leaf?.parents?.firstOrNull { it is JetFunctionLiteral } ?: return null
+
+        val lambdaChild = leaf!!.parents.takeWhile { it != lambda }.lastOrNull() ?: return null
+        if (lambdaChild is JetParameterList) return CompletionUtilCore.DUMMY_IDENTIFIER_TRIMMED
+
+        if (lambdaChild !is JetBlockExpression) return null
+        val blockChild = leaf.parents.takeWhile { it != lambdaChild }.lastOrNull()
+        if (blockChild !is PsiErrorElement) return null
+        val inIncompleteSignature = blockChild.siblings(forward = false, withItself = false).all {
+            when (it) {
+                is PsiWhiteSpace, is PsiComment -> true
+                is JetBinaryExpressionWithTypeRHS -> it.getOperationReference().getReferencedNameElementType() == JetTokens.COLON
+                else -> false
+            }
+        }
+        return if (inIncompleteSignature) CompletionUtilCore.DUMMY_IDENTIFIER_TRIMMED + "->" else null
+
+    }
+
     private val declarationKeywords = TokenSet.create(JetTokens.FUN_KEYWORD, JetTokens.VAL_KEYWORD, JetTokens.VAR_KEYWORD)
     private val declarationTokens = TokenSet.orSet(TokenSet.create(JetTokens.IDENTIFIER, JetTokens.LT, JetTokens.GT,
                                                                    JetTokens.COMMA, JetTokens.DOT, JetTokens.QUEST, JetTokens.COLON,
@@ -234,7 +249,8 @@ public class KotlinCompletionContributor : CompletionContributor() {
                 if (!somethingAdded && parameters.getInvocationCount() < 2) {
                     // Rerun completion if nothing was found
                     val newConfiguration = CompletionSessionConfiguration(completeNonImportedDeclarations = true,
-                                                                          completeNonAccessibleDeclarations = false)
+                                                                          completeNonAccessibleDeclarations = false,
+                                                                          filterOutJavaGettersAndSetters = false)
                     BasicCompletionSession(newConfiguration, parameters, result).complete()
                 }
             }
diff --git a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/KotlinExcludeFromCompletionLookupActionProvider.kt b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/KotlinExcludeFromCompletionLookupActionProvider.kt
new file mode 100644
index 00000000000..079030bd870
--- /dev/null
+++ b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/KotlinExcludeFromCompletionLookupActionProvider.kt
@@ -0,0 +1,59 @@
+/*
+ * Copyright 2010-2015 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.kotlin.idea.completion
+
+import com.intellij.codeInsight.completion.ExcludeFromCompletionLookupActionProvider
+import com.intellij.codeInsight.daemon.impl.actions.AddImportAction
+import com.intellij.codeInsight.lookup.Lookup
+import com.intellij.codeInsight.lookup.LookupActionProvider
+import com.intellij.codeInsight.lookup.LookupElement
+import com.intellij.codeInsight.lookup.LookupElementAction
+import com.intellij.openapi.project.Project
+import com.intellij.psi.*
+import com.intellij.psi.util.PsiUtil
+import com.intellij.util.Consumer
+import org.jetbrains.kotlin.idea.core.completion.DeclarationLookupObject
+import org.jetbrains.kotlin.idea.imports.importableFqName
+import org.jetbrains.kotlin.name.FqName
+
+public class KotlinExcludeFromCompletionLookupActionProvider : LookupActionProvider {
+    override fun fillActions(element: LookupElement, lookup: Lookup, consumer: Consumer<LookupElementAction>) {
+        val lookupObject = element.getObject() as? DeclarationLookupObject ?: return
+
+        val project = lookup.getPsiFile().getProject()
+
+        lookupObject.importableFqName?.let {
+            addExcludes(consumer, project, it.asString())
+            return
+        }
+    }
+
+    private fun addExcludes(consumer: Consumer<LookupElementAction>, project: Project, fqName: String) {
+        for (s in AddImportAction.getAllExcludableStrings(fqName)) {
+            consumer.consume(ExcludeFromCompletionAction(project, s))
+        }
+    }
+
+    private class ExcludeFromCompletionAction(
+            private val project: Project,
+            private val exclude: String
+    ) : LookupElementAction(null, "Exclude '$exclude' from completion") {
+        override fun performLookupAction(): LookupElementAction.Result {
+            AddImportAction.excludeFromImport(project, exclude)
+            return LookupElementAction.Result.HIDE_LOOKUP
+        }
+    }
+}
diff --git a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/LookupElementFactory.kt b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/LookupElementFactory.kt
index bf7422df44a..2f4bb767736 100644
--- a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/LookupElementFactory.kt
+++ b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/LookupElementFactory.kt
@@ -21,21 +21,26 @@ import com.intellij.codeInsight.lookup.*
 import com.intellij.codeInsight.lookup.impl.LookupCellRenderer
 import com.intellij.psi.PsiClass
 import com.intellij.psi.PsiElement
+import com.intellij.util.PlatformIcons
 import org.jetbrains.kotlin.asJava.KotlinLightClass
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns
 import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.idea.JetDescriptorIconProvider
 import org.jetbrains.kotlin.idea.caches.resolve.ResolutionFacade
 import org.jetbrains.kotlin.idea.completion.handlers.*
-import org.jetbrains.kotlin.idea.util.TypeNullability
-import org.jetbrains.kotlin.idea.util.nullability
+import org.jetbrains.kotlin.idea.core.completion.DeclarationLookupObject
+import org.jetbrains.kotlin.types.typeUtil.TypeNullability
+import org.jetbrains.kotlin.types.typeUtil.nullability
 import org.jetbrains.kotlin.name.FqName
+import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.psi.psiUtil.parents
 import org.jetbrains.kotlin.renderer.DescriptorRenderer
 import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils
 import org.jetbrains.kotlin.resolve.DescriptorUtils
+import org.jetbrains.kotlin.synthetic.SyntheticJavaPropertyDescriptor
 import org.jetbrains.kotlin.types.JetType
 import org.jetbrains.kotlin.types.TypeUtils
+import javax.swing.Icon
 
 public class LookupElementFactory(
         private val resolutionFacade: ResolutionFacade,
@@ -104,7 +109,7 @@ public class LookupElementFactory(
         val lookupObject = object : DeclarationLookupObjectImpl(null, psiClass, resolutionFacade) {
             override fun getIcon(flags: Int) = psiClass.getIcon(flags)
         }
-        var element = LookupElementBuilder.create(lookupObject, psiClass.getName())
+        var element = LookupElementBuilder.create(lookupObject, psiClass.getName()!!)
                 .withInsertHandler(KotlinClassInsertHandler)
 
         val typeParams = psiClass.getTypeParameters()
@@ -123,7 +128,7 @@ public class LookupElementFactory(
                     itemText = containerName.substringAfterLast('.') + "." + itemText
                     containerName = containerName.substringBeforeLast('.', FqName.ROOT.toString())
                 }
-                element = element.withPresentableText(itemText)
+                element = element.withPresentableText(itemText!!)
             }
         }
 
@@ -136,6 +141,31 @@ public class LookupElementFactory(
         return element.withIconFromLookupObject()
     }
 
+    public fun createLookupElementForPackage(name: FqName): LookupElement {
+        val shortName = name.shortName()
+        var element = LookupElementBuilder.create(PackageLookupObject(shortName), shortName.asString())
+
+        element = element.withInsertHandler(BaseDeclarationInsertHandler())
+
+        if (!name.parent().isRoot()) {
+            element = element.appendTailText(" (${name.asString()})", true)
+        }
+
+        return element.withIconFromLookupObject()
+    }
+
+    private data class PackageLookupObject(override val name: Name) : DeclarationLookupObject {
+        override val psiElement: PsiElement? get() = null
+
+        override val descriptor: DeclarationDescriptor? get() = null
+
+        override val importableFqName: FqName? get() = null
+
+        override val isDeprecated: Boolean get() = false
+
+        override fun getIcon(flags: Int) = PlatformIcons.PACKAGE_ICON
+    }
+
     private fun createLookupElement(
             descriptor: DeclarationDescriptor,
             declaration: PsiElement?,
@@ -151,6 +181,13 @@ public class LookupElementFactory(
             return createLookupElementForJavaClass(declaration, qualifyNestedClasses, includeClassTypeArguments)
         }
 
+        if (descriptor is PackageViewDescriptor) {
+            return createLookupElementForPackage(descriptor.fqName)
+        }
+        if (descriptor is PackageFragmentDescriptor) {
+            return createLookupElementForPackage(descriptor.fqName)
+        }
+
         // for constructor use name and icon of containing class
         val nameAndIconDescriptor: DeclarationDescriptor
         val iconDeclaration: PsiElement?
@@ -169,11 +206,20 @@ public class LookupElementFactory(
         }
         var element = LookupElementBuilder.create(lookupObject, name)
 
+        val insertHandler = getDefaultInsertHandler(descriptor)
+        element = element.withInsertHandler(insertHandler)
+
         when (descriptor) {
             is FunctionDescriptor -> {
                 val returnType = descriptor.getReturnType()
                 element = element.withTypeText(if (returnType != null) DescriptorRenderer.SHORT_NAMES_IN_TYPES.renderType(returnType) else "")
-                element = element.appendTailText(DescriptorRenderer.SHORT_NAMES_IN_TYPES.renderFunctionParameters(descriptor), false)
+
+                val insertsLambda = (insertHandler as KotlinFunctionInsertHandler).lambdaInfo != null
+                if (insertsLambda) {
+                    element = element.appendTailText(" {...} ", false)
+                }
+
+                element = element.appendTailText(DescriptorRenderer.SHORT_NAMES_IN_TYPES.renderFunctionParameters(descriptor), insertsLambda)
             }
 
             is VariableDescriptor -> {
@@ -207,23 +253,37 @@ public class LookupElementFactory(
         }
 
         if (descriptor is CallableDescriptor) {
-            if (descriptor.getExtensionReceiverParameter() != null) {
-                val container = descriptor.getContainingDeclaration()
-                val containerPresentation = if (container is ClassDescriptor) {
-                    DescriptorUtils.getFqNameFromTopLevelClass(container).toString()
+            val original = descriptor.original
+            when {
+                original is SyntheticJavaPropertyDescriptor -> {
+                    var from = original.getMethod.getName().asString() + "()"
+                    original.setMethod?.let { from += "/" + it.getName().asString() + "()" }
+                    element = element.appendTailText(" (from $from)", true)
                 }
-                else {
-                    DescriptorUtils.getFqName(container).toString()
+
+                descriptor.getExtensionReceiverParameter() != null -> {
+                    val originalReceiver = descriptor.getOriginal().getExtensionReceiverParameter()!!
+                    val receiverPresentation = DescriptorRenderer.SHORT_NAMES_IN_TYPES.renderType(originalReceiver.getType())
+                    element = element.appendTailText(" for $receiverPresentation", true)
+
+                    val container = descriptor.getContainingDeclaration()
+                    val containerPresentation = if (container is ClassDescriptor)
+                        DescriptorUtils.getFqNameFromTopLevelClass(container).toString()
+                    else if (container is PackageFragmentDescriptor)
+                        container.fqName.toString()
+                    else
+                        null
+                    if (containerPresentation != null) {
+                        element = element.appendTailText(" in $containerPresentation", true)
+                    }
                 }
-                val originalReceiver = descriptor.getOriginal().getExtensionReceiverParameter()!!
-                val receiverPresentation = DescriptorRenderer.SHORT_NAMES_IN_TYPES.renderType(originalReceiver.getType())
-                element = element.appendTailText(" for $receiverPresentation in $containerPresentation", true)
-            }
-            else {
-                val container = descriptor.getContainingDeclaration()
-                if (container is PackageFragmentDescriptor) { // we show container only for global functions and properties
-                    //TODO: it would be probably better to show it also for static declarations which are not from the current class (imported)
-                    element = element.appendTailText(" (${container.fqName})", true)
+
+                else -> {
+                    val container = descriptor.getContainingDeclaration()
+                    if (container is PackageFragmentDescriptor) { // we show container only for global functions and properties
+                        //TODO: it would be probably better to show it also for static declarations which are not from the current class (imported)
+                        element = element.appendTailText(" (${container.fqName})", true)
+                    }
                 }
             }
         }
@@ -232,9 +292,6 @@ public class LookupElementFactory(
             element = element.withStrikeoutness(true)
         }
 
-        val insertHandler = getDefaultInsertHandler(descriptor)
-        element = element.withInsertHandler(insertHandler)
-
         if (insertHandler is KotlinFunctionInsertHandler && insertHandler.lambdaInfo != null) {
             element.putUserData(KotlinCompletionCharFilter.ACCEPT_OPENING_BRACE, Unit)
         }
@@ -303,7 +360,7 @@ public class LookupElementFactory(
 
                         1 -> {
                             val parameterType = parameters.single().getType()
-                            if (KotlinBuiltIns.isFunctionOrExtensionFunctionType(parameterType)) {
+                            if (KotlinBuiltIns.isExactFunctionOrExtensionFunctionType(parameterType)) {
                                 val parameterCount = KotlinBuiltIns.getParameterTypeProjectionsFromFunctionType(parameterType).size()
                                 if (parameterCount <= 1) {
                                     // otherwise additional item with lambda template is to be added
diff --git a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/LookupElementsCollector.kt b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/LookupElementsCollector.kt
index 1f3f3b24620..d69cc0df920 100644
--- a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/LookupElementsCollector.kt
+++ b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/LookupElementsCollector.kt
@@ -29,6 +29,7 @@ import org.jetbrains.kotlin.descriptors.FunctionDescriptor
 import org.jetbrains.kotlin.descriptors.PropertyDescriptor
 import org.jetbrains.kotlin.idea.caches.resolve.ResolutionFacade
 import org.jetbrains.kotlin.idea.completion.handlers.*
+import org.jetbrains.kotlin.types.JetType
 import java.util.ArrayList
 import java.util.LinkedHashMap
 
@@ -103,37 +104,7 @@ class LookupElementsCollector(
 
         // add special item for function with one argument of function type with more than one parameter
         if (context != Context.INFIX_CALL && descriptor is FunctionDescriptor) {
-            val parameters = descriptor.getValueParameters()
-            if (parameters.size() == 1) {
-                val parameterType = parameters.get(0).getType()
-                if (KotlinBuiltIns.isFunctionOrExtensionFunctionType(parameterType)) {
-                    val parameterCount = KotlinBuiltIns.getParameterTypeProjectionsFromFunctionType(parameterType).size()
-                    if (parameterCount > 1) {
-                        var lookupElement = lookupElementFactory.createLookupElement(descriptor, true)
-
-                        lookupElement = object : LookupElementDecorator<LookupElement>(lookupElement) {
-                            override fun renderElement(presentation: LookupElementPresentation) {
-                                super.renderElement(presentation)
-
-                                val tails = presentation.getTailFragments()
-                                presentation.clearTail()
-                                presentation.appendTailText(" " + buildLambdaPresentation(parameterType), false)
-                                tails.drop(1)/*drop old function signature*/.forEach { presentation.appendTailText(it.text, it.isGrayed()) }
-                            }
-
-                            override fun handleInsert(context: InsertionContext) {
-                                KotlinFunctionInsertHandler(CaretPosition.IN_BRACKETS, GenerateLambdaInfo(parameterType, true)).handleInsert(context, this)
-                            }
-                        }
-
-                        if (context == Context.STRING_TEMPLATE_AFTER_DOLLAR) {
-                            lookupElement = lookupElement.withBracesSurrounding()
-                        }
-
-                        addElement(lookupElement)
-                    }
-                }
-            }
+            addSpecialFunctionDescriptorElementIfNeeded(descriptor)
         }
 
         if (descriptor is PropertyDescriptor) {
@@ -147,6 +118,44 @@ class LookupElementsCollector(
         }
     }
 
+    private fun addSpecialFunctionDescriptorElementIfNeeded(descriptor: FunctionDescriptor) {
+        val parameters = descriptor.getValueParameters()
+        if (parameters.size() == 1) {
+            val parameterType = parameters.get(0).getType()
+            if (KotlinBuiltIns.isExactFunctionOrExtensionFunctionType(parameterType)) {
+                val parameterCount = KotlinBuiltIns.getParameterTypeProjectionsFromFunctionType(parameterType).size()
+                if (parameterCount > 1) {
+                    addSpecialFunctionDescriptorElement(descriptor, parameterType)
+                }
+            }
+        }
+    }
+
+    private fun addSpecialFunctionDescriptorElement(descriptor: FunctionDescriptor, parameterType: JetType) {
+        var lookupElement = lookupElementFactory.createLookupElement(descriptor, true)
+
+        lookupElement = object : LookupElementDecorator<LookupElement>(lookupElement) {
+            override fun renderElement(presentation: LookupElementPresentation) {
+                super.renderElement(presentation)
+
+                val tails = presentation.getTailFragments()
+                presentation.clearTail()
+                presentation.appendTailText(" " + buildLambdaPresentation(parameterType) + " ", false)
+                tails.forEach { presentation.appendTailText(it.text, true) }
+            }
+
+            override fun handleInsert(context: InsertionContext) {
+                KotlinFunctionInsertHandler(CaretPosition.IN_BRACKETS, GenerateLambdaInfo(parameterType, true)).handleInsert(context, this)
+            }
+        }
+
+        if (context == Context.STRING_TEMPLATE_AFTER_DOLLAR) {
+            lookupElement = lookupElement.withBracesSurrounding()
+        }
+
+        addElement(lookupElement)
+    }
+
     public fun addElement(element: LookupElement, prefixMatcher: PrefixMatcher = defaultPrefixMatcher) {
         if (prefixMatcher.prefixMatches(element)) {
             val decorated = object : LookupElementDecorator<LookupElement>(element) {
diff --git a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/NamedArgumentCompletion.kt b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/NamedArgumentCompletion.kt
index 1911f49d556..b292e979329 100644
--- a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/NamedArgumentCompletion.kt
+++ b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/NamedArgumentCompletion.kt
@@ -31,6 +31,7 @@ import org.jetbrains.kotlin.idea.JetIcons
 import org.jetbrains.kotlin.idea.completion.handlers.WithTailInsertHandler
 import org.jetbrains.kotlin.idea.core.mapArgumentsToParameters
 import org.jetbrains.kotlin.idea.references.JetReference
+import org.jetbrains.kotlin.idea.references.mainReference
 import org.jetbrains.kotlin.idea.util.IdeDescriptorRenderers
 import org.jetbrains.kotlin.lexer.JetTokens
 import org.jetbrains.kotlin.name.Name
@@ -80,9 +81,8 @@ object NamedArgumentCompletion {
         val callElement = valueArgument.getStrictParentOfType<JetCallElement>() ?: return
         val callSimpleName = callElement.getCallNameExpression() ?: return
 
-        val callReference = callSimpleName.getReference() as JetReference
-
-        val functionDescriptors = callReference.resolveToDescriptors(bindingContext).map { it as? FunctionDescriptor }.filterNotNull()
+        val functionDescriptors = callSimpleName.mainReference.resolveToDescriptors(bindingContext)
+                .filterIsInstance<FunctionDescriptor>()
 
         for (funDescriptor in functionDescriptors) {
             if (!funDescriptor.hasStableParameterNames()) continue
diff --git a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/PackageDirectiveCompletion.kt b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/PackageDirectiveCompletion.kt
index 57dc2d30122..907701e62d1 100644
--- a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/PackageDirectiveCompletion.kt
+++ b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/PackageDirectiveCompletion.kt
@@ -24,8 +24,10 @@ import com.intellij.patterns.PlatformPatterns
 import org.jetbrains.kotlin.idea.caches.resolve.getResolutionFacade
 import org.jetbrains.kotlin.idea.codeInsight.ReferenceVariantsHelper
 import org.jetbrains.kotlin.idea.references.JetSimpleNameReference
+import org.jetbrains.kotlin.idea.references.mainReference
 import org.jetbrains.kotlin.psi.JetFile
 import org.jetbrains.kotlin.psi.JetPackageDirective
+import org.jetbrains.kotlin.psi.JetSimpleNameExpression
 
 /**
  * Performs completion in package directive. Should suggest only packages and avoid showing fake package produced by
@@ -41,19 +43,19 @@ object PackageDirectiveCompletion {
 
         val file = position.getContainingFile() as JetFile
 
-        val ref = file.findReferenceAt(parameters.getOffset()) as? JetSimpleNameReference ?: return false
-        val name = ref.expression.getText()!!
+        val expression = file.findElementAt(parameters.getOffset())?.getParent() as? JetSimpleNameExpression ?: return false
 
         try {
-            val prefixLength = parameters.getOffset() - ref.expression.getTextOffset()
-            val prefixMatcher = PlainPrefixMatcher(name.substring(0, prefixLength))
+            val prefixLength = parameters.getOffset() - expression.getTextOffset()
+            val prefix = expression.getText()!!
+            val prefixMatcher = PlainPrefixMatcher(prefix.substring(0, prefixLength))
             val result = result.withPrefixMatcher(prefixMatcher)
 
-            val resolutionFacade = ref.expression.getResolutionFacade()
-            val bindingContext = resolutionFacade.analyze(ref.expression)
+            val resolutionFacade = expression.getResolutionFacade()
+            val bindingContext = resolutionFacade.analyze(expression)
             val moduleDescriptor = resolutionFacade.findModuleDescriptor(file)
 
-            val variants = ReferenceVariantsHelper(bindingContext, moduleDescriptor, file.getProject(), { true }).getPackageReferenceVariants(ref.expression, prefixMatcher.asNameFilter())
+            val variants = ReferenceVariantsHelper(bindingContext, moduleDescriptor, file.getProject(), { true }).getPackageReferenceVariants(expression, prefixMatcher.asNameFilter())
             for (variant in variants) {
                 val lookupElement = LookupElementFactory(resolutionFacade, listOf()).createLookupElement(variant, false)
                 if (!lookupElement.getLookupString().contains(DUMMY_IDENTIFIER)) {
diff --git a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/ParameterNameAndTypeCompletion.kt b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/ParameterNameAndTypeCompletion.kt
index 9efd2dcdf8f..142215099cf 100644
--- a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/ParameterNameAndTypeCompletion.kt
+++ b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/ParameterNameAndTypeCompletion.kt
@@ -117,7 +117,7 @@ class ParameterNameAndTypeCompletion(
                     if (parameterType.isVisible(visibilityFilter)) {
                         val lookupElement = MyLookupElement.create("", name, ArbitraryType(parameterType), lookupElementFactory)
                         val count = lookupElementToCount[lookupElement] ?: 0
-                        lookupElementToCount[lookupElement] = count + 1
+                        lookupElementToCount[lookupElement!!] = count + 1
                     }
                 }
             }
@@ -134,7 +134,7 @@ class ParameterNameAndTypeCompletion(
     }
 
     private fun addSuggestionsForJavaClass(psiClass: PsiClass, userPrefix: String, prefixMatcher: PrefixMatcher) {
-        addSuggestions(psiClass.getName(), userPrefix, prefixMatcher, JavaClassType(psiClass))
+        addSuggestions(psiClass.getName()!!, userPrefix, prefixMatcher, JavaClassType(psiClass))
     }
 
     private fun addSuggestions(className: String, userPrefix: String, prefixMatcher: PrefixMatcher, type: Type) {
diff --git a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/SmartCompletionSession.kt b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/SmartCompletionSession.kt
index fd370e8ee82..cf55743eb26 100644
--- a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/SmartCompletionSession.kt
+++ b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/SmartCompletionSession.kt
@@ -51,13 +51,13 @@ class SmartCompletionSession(configuration: CompletionSessionConfiguration, para
             addFunctionLiteralArgumentCompletions()
 
             val completion = SmartCompletion(expression, resolutionFacade, moduleDescriptor,
-                                                                                        bindingContext, isVisibleFilter, inDescriptor, prefixMatcher, originalSearchScope,
-                                                                                        mapper, lookupElementFactory)
+                                             bindingContext, isVisibleFilter, inDescriptor, prefixMatcher, originalSearchScope,
+                                             mapper, lookupElementFactory)
             val result = completion.execute()
             if (result != null) {
                 collector.addElements(result.additionalItems)
 
-                if (reference != null) {
+                if (nameExpression != null) {
                     val filter = result.declarationFilter
                     if (filter != null) {
                         referenceVariants.forEach { collector.addElements(filter(it)) }
@@ -86,8 +86,8 @@ class SmartCompletionSession(configuration: CompletionSessionConfiguration, para
 
     // special completion for outside parenthesis lambda argument
     private fun addFunctionLiteralArgumentCompletions() {
-        if (reference != null) {
-            val receiverData = ReferenceVariantsHelper.getExplicitReceiverData(reference.expression)
+        if (nameExpression != null) {
+            val receiverData = ReferenceVariantsHelper.getExplicitReceiverData(nameExpression)
             if (receiverData != null && receiverData.second == CallType.INFIX) {
                 val call = receiverData.first.getCall(bindingContext)
                 if (call != null && call.getFunctionLiteralArguments().isEmpty()) {
diff --git a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/handlers/BaseDeclarationInsertHandler.kt b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/handlers/BaseDeclarationInsertHandler.kt
index 83b231a7145..c5e97cceca3 100644
--- a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/handlers/BaseDeclarationInsertHandler.kt
+++ b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/handlers/BaseDeclarationInsertHandler.kt
@@ -26,9 +26,8 @@ import org.jetbrains.kotlin.renderer.render
 
 open class BaseDeclarationInsertHandler : InsertHandler<LookupElement> {
     override fun handleInsert(context: InsertionContext, item: LookupElement) {
-        val descriptor = (item.getObject() as? DeclarationLookupObject)?.descriptor
-        if (descriptor != null) {
-            val name = descriptor.getName()
+        val name = (item.getObject() as? DeclarationLookupObject)?.name
+        if (name != null) {
             val nameInCode = name.render()
             val document = context.getDocument()
             val needEscaping = nameInCode != name.asString()
diff --git a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/handlers/CastReceiverInsertHandler.kt b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/handlers/CastReceiverInsertHandler.kt
index c4cc8f98f86..7fdcf59652d 100644
--- a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/handlers/CastReceiverInsertHandler.kt
+++ b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/handlers/CastReceiverInsertHandler.kt
@@ -39,7 +39,7 @@ object CastReceiverInsertHandler : KotlinCallableInsertHandler() {
             val project = context.getProject()
 
             val thisObj = if (descriptor.getExtensionReceiverParameter() != null) descriptor.getExtensionReceiverParameter() else descriptor.getDispatchReceiverParameter()
-            val fqName = IdeDescriptorRenderers.SOURCE_CODE.renderClassifierName(thisObj.getType().getConstructor().getDeclarationDescriptor())
+            val fqName = IdeDescriptorRenderers.SOURCE_CODE.renderClassifierName(thisObj!!.getType().getConstructor().getDeclarationDescriptor()!!)
 
             val parentCast = JetPsiFactory(project).createExpression("(expr as $fqName)") as JetParenthesizedExpression
             val cast = parentCast.getExpression() as JetBinaryExpressionWithTypeRHS
@@ -51,7 +51,7 @@ object CastReceiverInsertHandler : KotlinCallableInsertHandler() {
 
             val expr = receiver.replace(parentCast) as JetParenthesizedExpression
 
-            ShortenReferences.DEFAULT.process((expr.getExpression() as JetBinaryExpressionWithTypeRHS).getRight())
+            ShortenReferences.DEFAULT.process((expr.getExpression() as JetBinaryExpressionWithTypeRHS).getRight()!!)
         }
     }
 }
\ No newline at end of file
diff --git a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/handlers/KotlinClassInsertHandler.kt b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/handlers/KotlinClassInsertHandler.kt
index 7d71886227f..8a942149637 100644
--- a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/handlers/KotlinClassInsertHandler.kt
+++ b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/handlers/KotlinClassInsertHandler.kt
@@ -50,7 +50,7 @@ object KotlinClassInsertHandler : BaseDeclarationInsertHandler() {
 
                 // first try to resolve short name for faster handling
                 val token = file.findElementAt(startOffset)
-                val nameRef = token.getParent() as? JetNameReferenceExpression
+                val nameRef = token!!.getParent() as? JetNameReferenceExpression
                 if (nameRef != null) {
                     val bindingContext = nameRef.getResolutionFacade().analyze(nameRef, BodyResolveMode.PARTIAL)
                     val target = bindingContext[BindingContext.SHORT_REFERENCE_TO_COMPANION_OBJECT, nameRef]
diff --git a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/smart/SmartCompletion.kt b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/smart/SmartCompletion.kt
index 50bf4e5f953..0b7de60ffcd 100644
--- a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/smart/SmartCompletion.kt
+++ b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/smart/SmartCompletion.kt
@@ -16,7 +16,6 @@
 
 package org.jetbrains.kotlin.idea.completion.smart
 
-import com.intellij.codeInsight.completion.InsertHandler
 import com.intellij.codeInsight.completion.InsertionContext
 import com.intellij.codeInsight.completion.OffsetKey
 import com.intellij.codeInsight.completion.PrefixMatcher
@@ -32,7 +31,10 @@ import org.jetbrains.kotlin.idea.caches.resolve.resolveToDescriptor
 import org.jetbrains.kotlin.idea.completion.*
 import org.jetbrains.kotlin.idea.core.IterableTypesDetector
 import org.jetbrains.kotlin.idea.core.SmartCastCalculator
-import org.jetbrains.kotlin.idea.util.*
+import org.jetbrains.kotlin.idea.util.FuzzyType
+import org.jetbrains.kotlin.idea.util.fuzzyReturnType
+import org.jetbrains.kotlin.idea.util.makeNotNullable
+import org.jetbrains.kotlin.idea.util.nullability
 import org.jetbrains.kotlin.lexer.JetTokens
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.getReceiverExpression
@@ -40,7 +42,10 @@ import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.DescriptorUtils
 import org.jetbrains.kotlin.types.JetType
 import org.jetbrains.kotlin.types.TypeUtils
+import org.jetbrains.kotlin.types.typeUtil.TypeNullability
 import org.jetbrains.kotlin.types.typeUtil.isSubtypeOf
+import org.jetbrains.kotlin.types.typeUtil.makeNotNullable
+import org.jetbrains.kotlin.types.typeUtil.makeNullable
 import java.util.ArrayList
 import java.util.HashSet
 
@@ -391,7 +396,7 @@ class SmartCompletion(
             null
         }
 
-        val scope = bindingContext.get(BindingContext.RESOLUTION_SCOPE, expressionWithType)
+        val scope = bindingContext.get(BindingContext.RESOLUTION_SCOPE, expressionWithType)!!
         val iterableDetector = IterableTypesDetector(project, moduleDescriptor, scope)
 
         return buildResultByTypeFilter(expressionWithType, receiver, Tail.RPARENTH) { iterableDetector.isIterable(it, loopVarType) }
@@ -403,7 +408,7 @@ class SmartCompletion(
         if (operationToken != JetTokens.IN_KEYWORD && operationToken != JetTokens.NOT_IN || expressionWithType != binaryExpression.getRight()) return null
 
         val leftOperandType = binaryExpression.getLeft()?.let { bindingContext.getType(it) } ?: return null
-        val scope = bindingContext.get(BindingContext.RESOLUTION_SCOPE, expressionWithType)
+        val scope = bindingContext.get(BindingContext.RESOLUTION_SCOPE, expressionWithType)!!
         val detector = TypesWithContainsDetector(scope, leftOperandType, project, moduleDescriptor)
 
         return buildResultByTypeFilter(expressionWithType, receiver, null) { detector.hasContains(it) }
diff --git a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/smart/TypeInstantiationItems.kt b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/smart/TypeInstantiationItems.kt
index 23d3e9f76c0..3e5fe197101 100644
--- a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/smart/TypeInstantiationItems.kt
+++ b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/smart/TypeInstantiationItems.kt
@@ -35,7 +35,7 @@ import org.jetbrains.kotlin.idea.completion.handlers.KotlinFunctionInsertHandler
 import org.jetbrains.kotlin.idea.core.codeInsight.ImplementMethodsHandler
 import org.jetbrains.kotlin.idea.core.psiClassToDescriptor
 import org.jetbrains.kotlin.idea.util.IdeDescriptorRenderers
-import org.jetbrains.kotlin.idea.util.makeNotNullable
+import org.jetbrains.kotlin.types.typeUtil.makeNotNullable
 import org.jetbrains.kotlin.load.java.descriptors.SamConstructorDescriptor
 import org.jetbrains.kotlin.platform.JavaToKotlinClassMap
 import org.jetbrains.kotlin.psi.JetClassOrObject
diff --git a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/smart/TypesWithContainsDetector.kt b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/smart/TypesWithContainsDetector.kt
index 985c2a7ba34..a08366ff98b 100644
--- a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/smart/TypesWithContainsDetector.kt
+++ b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/smart/TypesWithContainsDetector.kt
@@ -23,13 +23,14 @@ import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.descriptors.FunctionDescriptor
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns
 import org.jetbrains.kotlin.types.TypeUtils
-import org.jetbrains.kotlin.idea.util.nullability
-import org.jetbrains.kotlin.idea.util.TypeNullability
+import org.jetbrains.kotlin.types.typeUtil.nullability
+import org.jetbrains.kotlin.types.typeUtil.TypeNullability
 import org.jetbrains.kotlin.idea.util.FuzzyType
 import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor
 import com.intellij.openapi.project.Project
 import org.jetbrains.kotlin.idea.completion.HeuristicSignatures
+import org.jetbrains.kotlin.idea.util.nullability
 
 class TypesWithContainsDetector(
         private val scope: JetScope,
@@ -56,7 +57,7 @@ class TypesWithContainsDetector(
     }
 
     private fun isGoodContainsFunction(function: FunctionDescriptor, freeTypeParams: Collection<TypeParameterDescriptor>): Boolean {
-        if (!TypeUtils.equalTypes(function.getReturnType(), booleanType)) return false
+        if (!TypeUtils.equalTypes(function.getReturnType()!!, booleanType)) return false
         val parameter = function.getValueParameters().singleOrNull() ?: return false
         val parameterType = HeuristicSignatures.correctedParameterType(function, parameter, moduleDescriptor, project) ?: parameter.getType()
         val fuzzyParameterType = FuzzyType(parameterType, function.getTypeParameters() + freeTypeParams)
diff --git a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/smart/Utils.kt b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/smart/Utils.kt
index 7248aacd28b..9bc71fb5727 100644
--- a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/smart/Utils.kt
+++ b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/smart/Utils.kt
@@ -22,17 +22,19 @@ import com.intellij.codeInsight.lookup.LookupElement
 import com.intellij.codeInsight.lookup.LookupElementDecorator
 import com.intellij.codeInsight.lookup.LookupElementPresentation
 import com.intellij.openapi.util.Key
-import com.intellij.psi.PsiDocumentManager
 import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.idea.completion.*
 import org.jetbrains.kotlin.idea.completion.handlers.WithExpressionPrefixInsertHandler
 import org.jetbrains.kotlin.idea.completion.handlers.WithTailInsertHandler
-import org.jetbrains.kotlin.idea.util.*
-import org.jetbrains.kotlin.psi.JetFile
+import org.jetbrains.kotlin.idea.util.FuzzyType
+import org.jetbrains.kotlin.idea.util.makeNotNullable
+import org.jetbrains.kotlin.idea.util.nullability
 import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.descriptorUtil.builtIns
 import org.jetbrains.kotlin.types.JetType
 import org.jetbrains.kotlin.types.TypeSubstitutor
+import org.jetbrains.kotlin.types.typeUtil.TypeNullability
+import org.jetbrains.kotlin.util.descriptorsEqualWithSubstitution
 import java.util.ArrayList
 import java.util.HashMap
 import java.util.HashSet
@@ -210,7 +212,7 @@ private fun lookupElementsForNullable(factory: () -> LookupElement?): Collection
         }
         lookupElement = lookupElement!!.suppressAutoInsertion()
         lookupElement = lookupElement!!.assignSmartCompletionPriority(SmartCompletionItemPriority.NULLABLE)
-        result.add(lookupElement)
+        result.add(lookupElement!!)
     }
 
     lookupElement = factory()
@@ -226,7 +228,7 @@ private fun lookupElementsForNullable(factory: () -> LookupElement?): Collection
         }
         lookupElement = lookupElement!!.suppressAutoInsertion()
         lookupElement = lookupElement!!.assignSmartCompletionPriority(SmartCompletionItemPriority.NULLABLE)
-        result.add(lookupElement)
+        result.add(lookupElement!!)
     }
 
     return result
@@ -269,7 +271,7 @@ fun LookupElementFactory.createLookupElement(
         element = element.keepOldArgumentListOnTab()
     }
 
-    if (descriptor is ValueParameterDescriptor && bindingContext[BindingContext.AUTO_CREATED_IT, descriptor]) {
+    if (descriptor is ValueParameterDescriptor && bindingContext[BindingContext.AUTO_CREATED_IT, descriptor]!!) {
         element = element.assignSmartCompletionPriority(SmartCompletionItemPriority.IT)
     }
 
diff --git a/idea/idea-completion/testData/basic/codeFragments/elementAt.kt b/idea/idea-completion/testData/basic/codeFragments/elementAt.kt
new file mode 100644
index 00000000000..45cae3892e1
--- /dev/null
+++ b/idea/idea-completion/testData/basic/codeFragments/elementAt.kt
@@ -0,0 +1,9 @@
+fun foo() {
+    val aaaB = 1
+    <caret>val aaaC = 1
+    val aaaD = 1
+}
+
+// INVOCATION_COUNT: 1
+// EXIST: aaaB
+// ABSENT: aaaC, aaaD
\ No newline at end of file
diff --git a/idea/idea-completion/testData/basic/codeFragments/elementAt.kt.fragment b/idea/idea-completion/testData/basic/codeFragments/elementAt.kt.fragment
new file mode 100644
index 00000000000..1a83755fab1
--- /dev/null
+++ b/idea/idea-completion/testData/basic/codeFragments/elementAt.kt.fragment
@@ -0,0 +1 @@
+aaa<caret>
\ No newline at end of file
diff --git a/idea/idea-completion/testData/basic/codeFragments/elementAtFirstInBlock.kt b/idea/idea-completion/testData/basic/codeFragments/elementAtFirstInBlock.kt
new file mode 100644
index 00000000000..3083066d049
--- /dev/null
+++ b/idea/idea-completion/testData/basic/codeFragments/elementAtFirstInBlock.kt
@@ -0,0 +1,6 @@
+fun foo() {
+    <caret>val aaaB = 1
+}
+
+// INVOCATION_COUNT: 1
+// ABSENT: aaaB
\ No newline at end of file
diff --git a/idea/idea-completion/testData/basic/codeFragments/elementAtFirstInBlock.kt.fragment b/idea/idea-completion/testData/basic/codeFragments/elementAtFirstInBlock.kt.fragment
new file mode 100644
index 00000000000..1a83755fab1
--- /dev/null
+++ b/idea/idea-completion/testData/basic/codeFragments/elementAtFirstInBlock.kt.fragment
@@ -0,0 +1 @@
+aaa<caret>
\ No newline at end of file
diff --git a/idea/idea-completion/testData/basic/common/FunctionLiteralParameterName1.kt b/idea/idea-completion/testData/basic/common/FunctionLiteralParameterName1.kt
deleted file mode 100644
index c5121c132de..00000000000
--- a/idea/idea-completion/testData/basic/common/FunctionLiteralParameterName1.kt
+++ /dev/null
@@ -1,7 +0,0 @@
-fun bar() {
-    val handler = { (<caret>) }
-}
-
-// INVOCATION_COUNT: 0
-// EXIST: bar
-// EXIST: null
diff --git a/idea/idea-completion/testData/basic/common/FunctionLiteralParameterName2.kt b/idea/idea-completion/testData/basic/common/FunctionLiteralParameterName2.kt
deleted file mode 100644
index 55db1b4c8ab..00000000000
--- a/idea/idea-completion/testData/basic/common/FunctionLiteralParameterName2.kt
+++ /dev/null
@@ -1,5 +0,0 @@
-fun bar() {
-    val handler = { (i: Int, <caret>) }
-}
-
-// NUMBER: 0
diff --git a/idea/idea-completion/testData/basic/common/FunctionLiteralParameterName3.kt b/idea/idea-completion/testData/basic/common/FunctionLiteralParameterName3.kt
deleted file mode 100644
index 8bc5663f4c1..00000000000
--- a/idea/idea-completion/testData/basic/common/FunctionLiteralParameterName3.kt
+++ /dev/null
@@ -1,5 +0,0 @@
-fun bar() {
-    val handler = { (i, <caret>) }
-}
-
-// NUMBER: 0
diff --git a/idea/idea-completion/testData/basic/common/FunctionLiteralParameterType5.kt b/idea/idea-completion/testData/basic/common/FunctionLiteralParameterType5.kt
deleted file mode 100644
index d9199af455b..00000000000
--- a/idea/idea-completion/testData/basic/common/FunctionLiteralParameterType5.kt
+++ /dev/null
@@ -1,8 +0,0 @@
-fun bar() {
-    val handler = { (i: Map<String, <caret> }
-}
-
-// EXIST: Int
-// EXIST: String
-// ABSENT: bar
-// ABSENT: handler
\ No newline at end of file
diff --git a/idea/idea-completion/testData/basic/common/HigherOrderFunction1.kt b/idea/idea-completion/testData/basic/common/HigherOrderFunction1.kt
index 0f040ffe8ce..b1294efbb1a 100644
--- a/idea/idea-completion/testData/basic/common/HigherOrderFunction1.kt
+++ b/idea/idea-completion/testData/basic/common/HigherOrderFunction1.kt
@@ -5,4 +5,4 @@ fun test() {
 }
 
 // EXIST: { lookupString:"foo", itemText: "foo", tailText: "(p: (String, Char) -> Unit) (<root>)", typeText:"Unit" }
-// EXIST: { lookupString:"foo", itemText: "foo", tailText: " { String, Char -> ... } (<root>)", typeText:"Unit" }
+// EXIST: { lookupString:"foo", itemText: "foo", tailText: " { String, Char -> ... } (p: (String, Char) -> Unit) (<root>)", typeText:"Unit" }
diff --git a/idea/idea-completion/testData/basic/common/HigherOrderFunction2.kt b/idea/idea-completion/testData/basic/common/HigherOrderFunction2.kt
index ee9b2aad939..187b40286b0 100644
--- a/idea/idea-completion/testData/basic/common/HigherOrderFunction2.kt
+++ b/idea/idea-completion/testData/basic/common/HigherOrderFunction2.kt
@@ -5,4 +5,4 @@ fun test() {
 }
 
 // EXIST: { lookupString:"foo", itemText: "foo", tailText: "(p: (String, Char) -> Unit) for String in <root>", typeText:"Unit" }
-// EXIST: { lookupString:"foo", itemText: "foo", tailText: " { String, Char -> ... } for String in <root>", typeText:"Unit" }
+// EXIST: { lookupString:"foo", itemText: "foo", tailText: " { String, Char -> ... } (p: (String, Char) -> Unit) for String in <root>", typeText:"Unit" }
diff --git a/idea/idea-completion/testData/basic/common/InFunctionLiteral.kt b/idea/idea-completion/testData/basic/common/InLambda.kt
similarity index 100%
rename from idea/idea-completion/testData/basic/common/InFunctionLiteral.kt
rename to idea/idea-completion/testData/basic/common/InLambda.kt
diff --git a/idea/idea-completion/testData/basic/common/SubstitutedSignature3.kt b/idea/idea-completion/testData/basic/common/SubstitutedSignature3.kt
index 01cfde847bf..f0af4361c6c 100644
--- a/idea/idea-completion/testData/basic/common/SubstitutedSignature3.kt
+++ b/idea/idea-completion/testData/basic/common/SubstitutedSignature3.kt
@@ -1,5 +1,5 @@
 fun foo(list: List<String>) {
     list.<caret>
 }
-// EXIST: { itemText: "firstOrNull", tailText: "(predicate: (String) -> Boolean) for Iterable<T> in kotlin", typeText: "String?" }
-// EXIST: { itemText: "toMap", tailText: "(selector: (String) -> K) for Iterable<T> in kotlin", typeText: "Map<K, String>" }
+// EXIST: { itemText: "firstOrNull", tailText: " {...} (predicate: (String) -> Boolean) for Iterable<T> in kotlin", typeText: "String?" }
+// EXIST: { itemText: "toMap", tailText: " {...} (selector: (String) -> K) for Iterable<T> in kotlin", typeText: "Map<K, String>" }
diff --git a/idea/idea-completion/testData/basic/common/TopLevelPackageInClassBody.kt b/idea/idea-completion/testData/basic/common/TopLevelPackageInClassBody.kt
new file mode 100644
index 00000000000..adf75a918cf
--- /dev/null
+++ b/idea/idea-completion/testData/basic/common/TopLevelPackageInClassBody.kt
@@ -0,0 +1,5 @@
+class A {
+    kot<caret>
+}
+
+// EXIST: "kotlin"
diff --git a/idea/idea-completion/testData/basic/common/annotations/Annotated.kt b/idea/idea-completion/testData/basic/common/annotations/Annotated.kt
new file mode 100644
index 00000000000..f2cd74d106d
--- /dev/null
+++ b/idea/idea-completion/testData/basic/common/annotations/Annotated.kt
@@ -0,0 +1,3 @@
+<caret> class Annotated
+
+// EXIST: annotation
\ No newline at end of file
diff --git a/idea/idea-completion/testData/basic/common/annotations/AnnotationArguments.kt b/idea/idea-completion/testData/basic/common/annotations/AnnotationArguments.kt
new file mode 100644
index 00000000000..c978d07c743
--- /dev/null
+++ b/idea/idea-completion/testData/basic/common/annotations/AnnotationArguments.kt
@@ -0,0 +1,4 @@
+annotation(<caret>) class Annotated
+
+// EXIST: retention
+// EXIST: repeatable
diff --git a/idea/idea-completion/testData/basic/common/annotations/AnnotationTarget.kt b/idea/idea-completion/testData/basic/common/annotations/AnnotationTarget.kt
new file mode 100644
index 00000000000..b5aeaea8b6c
--- /dev/null
+++ b/idea/idea-completion/testData/basic/common/annotations/AnnotationTarget.kt
@@ -0,0 +1,3 @@
+<caret> annotation class Annotated
+
+// EXIST: target
diff --git a/idea/idea-completion/testData/basic/common/BackingFields1.kt b/idea/idea-completion/testData/basic/common/backingFields/BackingFields1.kt
similarity index 100%
rename from idea/idea-completion/testData/basic/common/BackingFields1.kt
rename to idea/idea-completion/testData/basic/common/backingFields/BackingFields1.kt
diff --git a/idea/idea-completion/testData/basic/common/BackingFields2.kt b/idea/idea-completion/testData/basic/common/backingFields/BackingFields2.kt
similarity index 100%
rename from idea/idea-completion/testData/basic/common/BackingFields2.kt
rename to idea/idea-completion/testData/basic/common/backingFields/BackingFields2.kt
diff --git a/idea/idea-completion/testData/basic/common/BackingFields3.kt b/idea/idea-completion/testData/basic/common/backingFields/BackingFields3.kt
similarity index 100%
rename from idea/idea-completion/testData/basic/common/BackingFields3.kt
rename to idea/idea-completion/testData/basic/common/backingFields/BackingFields3.kt
diff --git a/idea/idea-completion/testData/basic/common/BackingFields4.kt b/idea/idea-completion/testData/basic/common/backingFields/BackingFields4.kt
similarity index 100%
rename from idea/idea-completion/testData/basic/common/BackingFields4.kt
rename to idea/idea-completion/testData/basic/common/backingFields/BackingFields4.kt
diff --git a/idea/idea-completion/testData/basic/common/BackingFields5.kt b/idea/idea-completion/testData/basic/common/backingFields/BackingFields5.kt
similarity index 100%
rename from idea/idea-completion/testData/basic/common/BackingFields5.kt
rename to idea/idea-completion/testData/basic/common/backingFields/BackingFields5.kt
diff --git a/idea/idea-completion/testData/basic/common/BackingFields6.kt b/idea/idea-completion/testData/basic/common/backingFields/BackingFields6.kt
similarity index 100%
rename from idea/idea-completion/testData/basic/common/BackingFields6.kt
rename to idea/idea-completion/testData/basic/common/backingFields/BackingFields6.kt
diff --git a/idea/idea-completion/testData/basic/common/BackingFieldsInStringTemplate.kt b/idea/idea-completion/testData/basic/common/backingFields/BackingFieldsInStringTemplate.kt
similarity index 100%
rename from idea/idea-completion/testData/basic/common/BackingFieldsInStringTemplate.kt
rename to idea/idea-completion/testData/basic/common/backingFields/BackingFieldsInStringTemplate.kt
diff --git a/idea/idea-completion/testData/basic/common/extensions/DoNotHideGetterWhenExtensionCannotBeUsed.kt b/idea/idea-completion/testData/basic/common/extensions/DoNotHideGetterWhenExtensionCannotBeUsed.kt
new file mode 100644
index 00000000000..72f81972745
--- /dev/null
+++ b/idea/idea-completion/testData/basic/common/extensions/DoNotHideGetterWhenExtensionCannotBeUsed.kt
@@ -0,0 +1,8 @@
+import java.io.File
+
+fun File.foo(absolutePath: String?) {
+    <caret>
+}
+
+// EXIST_JAVA_ONLY: getAbsolutePath
+// ABSENT: { itemText: "absolutePath", typeText: "String" }
diff --git a/idea/idea-completion/testData/basic/common/extensions/Extensions.kt b/idea/idea-completion/testData/basic/common/extensions/Extensions.kt
index 2da87f2994a..bc09d2cd9b9 100644
--- a/idea/idea-completion/testData/basic/common/extensions/Extensions.kt
+++ b/idea/idea-completion/testData/basic/common/extensions/Extensions.kt
@@ -3,6 +3,8 @@ package a.b
 class Some {
     inner class Inner {
         fun foo() {
+            fun String.localExtension() = 1
+
             "".<caret>
         }
 
@@ -19,3 +21,4 @@ val String.extProp: Int get() = 1
 // EXIST: { lookupString: "extProp", itemText: "extProp", tailText: " for String in a.b", typeText: "Int" }
 // EXIST: { lookupString: "memberExtFun", itemText: "memberExtFun", tailText: "() for String in Some.Inner", typeText: "Unit" }
 // EXIST: { lookupString: "memberExtProp", itemText: "memberExtProp", tailText: " for String in Some", typeText: "Int" }
+// EXIST: { lookupString: "localExtension", itemText: "localExtension", tailText: "() for String", typeText: "Int" }
diff --git a/idea/idea-completion/testData/basic/common/extensions/ShowGetMethodWhenNothingElseMatch.kt b/idea/idea-completion/testData/basic/common/extensions/ShowGetMethodWhenNothingElseMatch.kt
new file mode 100644
index 00000000000..bc619e05fd9
--- /dev/null
+++ b/idea/idea-completion/testData/basic/common/extensions/ShowGetMethodWhenNothingElseMatch.kt
@@ -0,0 +1,5 @@
+fun foo(thread: Thread) {
+    thread.get<caret>
+}
+
+// EXIST_JAVA_ONLY: getPriority
diff --git a/idea/idea-completion/testData/basic/common/extensions/ShowGetSetOnSecondCompletion.kt b/idea/idea-completion/testData/basic/common/extensions/ShowGetSetOnSecondCompletion.kt
new file mode 100644
index 00000000000..3c286d2bd9f
--- /dev/null
+++ b/idea/idea-completion/testData/basic/common/extensions/ShowGetSetOnSecondCompletion.kt
@@ -0,0 +1,8 @@
+fun foo(thread: Thread) {
+    thread.<caret>
+}
+
+// INVOCATION_COUNT: 2
+// EXIST_JAVA_ONLY: { lookupString: "priority", itemText: "priority", tailText: " (from getPriority()/setPriority())", typeText: "Int" }
+// EXIST_JAVA_ONLY: getPriority
+// EXIST_JAVA_ONLY: setPriority
diff --git a/idea/idea-completion/testData/basic/common/extensions/StarTypeArg.kt b/idea/idea-completion/testData/basic/common/extensions/StarTypeArg.kt
new file mode 100644
index 00000000000..56632edad6b
--- /dev/null
+++ b/idea/idea-completion/testData/basic/common/extensions/StarTypeArg.kt
@@ -0,0 +1,9 @@
+class MyClass<T>
+
+fun <T> MyClass<T>.ext() = ""
+
+fun foo(t: MyClass<*>) {
+    t.<caret>
+}
+
+// EXIST: ext
diff --git a/idea/idea-completion/testData/basic/common/extensions/SyntheticExtensions1.kt b/idea/idea-completion/testData/basic/common/extensions/SyntheticExtensions1.kt
new file mode 100644
index 00000000000..8eec756323e
--- /dev/null
+++ b/idea/idea-completion/testData/basic/common/extensions/SyntheticExtensions1.kt
@@ -0,0 +1,8 @@
+import java.io.File
+
+fun foo(file: File) {
+    file.<caret>
+}
+
+// EXIST_JAVA_ONLY: { lookupString: "absolutePath", itemText: "absolutePath", tailText: " (from getAbsolutePath())", typeText: "String!" }
+// ABSENT: getAbsolutePath
diff --git a/idea/idea-completion/testData/basic/common/extensions/SyntheticExtensions2.kt b/idea/idea-completion/testData/basic/common/extensions/SyntheticExtensions2.kt
new file mode 100644
index 00000000000..5c1e4726cba
--- /dev/null
+++ b/idea/idea-completion/testData/basic/common/extensions/SyntheticExtensions2.kt
@@ -0,0 +1,14 @@
+fun Thread.foo(urlConnection: java.net.URLConnection) {
+    with (urlConnection) {
+        <caret>
+    }
+}
+
+// EXIST_JAVA_ONLY: { lookupString: "priority", itemText: "priority", tailText: " (from getPriority()/setPriority())", typeText: "Int" }
+// EXIST_JAVA_ONLY: { lookupString: "isDaemon", itemText: "isDaemon", tailText: " (from isDaemon()/setDaemon())", typeText: "Boolean" }
+// EXIST_JAVA_ONLY: { lookupString: "url", itemText: "url", tailText: " (from getURL())", typeText: "URL!" }
+// ABSENT: getPriority
+// ABSENT: setPriority
+// ABSENT: { itemText: "isDaemon", tailText: "()" }
+// ABSENT: setDaemon
+// ABSENT: getURL
diff --git a/idea/idea-completion/testData/basic/common/extensions/SyntheticExtensionsInGenericClass.kt b/idea/idea-completion/testData/basic/common/extensions/SyntheticExtensionsInGenericClass.kt
new file mode 100644
index 00000000000..92a33673845
--- /dev/null
+++ b/idea/idea-completion/testData/basic/common/extensions/SyntheticExtensionsInGenericClass.kt
@@ -0,0 +1,10 @@
+fun foo(klass: Class<*>) {
+    klass.<caret>
+}
+
+// EXIST_JAVA_ONLY: simpleName
+// ABSENT: getSimpleName
+// EXIST_JAVA_ONLY: enclosingClass
+// ABSENT: getEnclosingClass
+// EXIST_JAVA_ONLY: annotations
+// ABSENT: getAnnotations
diff --git a/idea/idea-completion/testData/basic/common/extensions/SyntheticExtensionsSafeCall.kt b/idea/idea-completion/testData/basic/common/extensions/SyntheticExtensionsSafeCall.kt
new file mode 100644
index 00000000000..dd92a12b02a
--- /dev/null
+++ b/idea/idea-completion/testData/basic/common/extensions/SyntheticExtensionsSafeCall.kt
@@ -0,0 +1,8 @@
+import java.io.File
+
+fun foo(file: File?) {
+    file?.<caret>
+}
+
+// EXIST_JAVA_ONLY: { lookupString: "absolutePath", itemText: "absolutePath", tailText: " (from getAbsolutePath())", typeText: "String!" }
+// ABSENT: getAbsolutePath
diff --git a/idea/idea-completion/testData/basic/common/extensions/SyntheticExtensionsSmartCast.kt b/idea/idea-completion/testData/basic/common/extensions/SyntheticExtensionsSmartCast.kt
new file mode 100644
index 00000000000..f45fcd3870f
--- /dev/null
+++ b/idea/idea-completion/testData/basic/common/extensions/SyntheticExtensionsSmartCast.kt
@@ -0,0 +1,10 @@
+import java.io.File
+
+fun foo(o: Any) {
+    if (o is File) {
+        o.<caret>
+    }
+}
+
+// EXIST_JAVA_ONLY: { lookupString: "absolutePath", itemText: "absolutePath", tailText: " (from getAbsolutePath())", typeText: "String!" }
+// ABSENT: getAbsolutePath
diff --git a/idea/idea-completion/testData/basic/common/extensions/SyntheticExtensionsSmartCast2.kt b/idea/idea-completion/testData/basic/common/extensions/SyntheticExtensionsSmartCast2.kt
new file mode 100644
index 00000000000..807fe0eb505
--- /dev/null
+++ b/idea/idea-completion/testData/basic/common/extensions/SyntheticExtensionsSmartCast2.kt
@@ -0,0 +1,10 @@
+import java.io.File
+
+fun Any.foo() {
+    if (this is File) {
+        <caret>
+    }
+}
+
+// EXIST_JAVA_ONLY: { lookupString: "absolutePath", itemText: "absolutePath", tailText: " (from getAbsolutePath())", typeText: "String!" }
+// ABSENT: getAbsolutePath
diff --git a/idea/idea-completion/testData/basic/common/ImmediateExtensionMembers1.kt b/idea/idea-completion/testData/basic/common/immediateMembers/ImmediateExtensionMembers1.kt
similarity index 100%
rename from idea/idea-completion/testData/basic/common/ImmediateExtensionMembers1.kt
rename to idea/idea-completion/testData/basic/common/immediateMembers/ImmediateExtensionMembers1.kt
diff --git a/idea/idea-completion/testData/basic/common/ImmediateExtensionMembers2.kt b/idea/idea-completion/testData/basic/common/immediateMembers/ImmediateExtensionMembers2.kt
similarity index 100%
rename from idea/idea-completion/testData/basic/common/ImmediateExtensionMembers2.kt
rename to idea/idea-completion/testData/basic/common/immediateMembers/ImmediateExtensionMembers2.kt
diff --git a/idea/idea-completion/testData/basic/common/ImmediateExtensionMembers3.kt b/idea/idea-completion/testData/basic/common/immediateMembers/ImmediateExtensionMembers3.kt
similarity index 100%
rename from idea/idea-completion/testData/basic/common/ImmediateExtensionMembers3.kt
rename to idea/idea-completion/testData/basic/common/immediateMembers/ImmediateExtensionMembers3.kt
diff --git a/idea/idea-completion/testData/basic/common/ImmediateExtensionMembers4.kt b/idea/idea-completion/testData/basic/common/immediateMembers/ImmediateExtensionMembers4.kt
similarity index 100%
rename from idea/idea-completion/testData/basic/common/ImmediateExtensionMembers4.kt
rename to idea/idea-completion/testData/basic/common/immediateMembers/ImmediateExtensionMembers4.kt
diff --git a/idea/idea-completion/testData/basic/common/ImmediateMembers1.kt b/idea/idea-completion/testData/basic/common/immediateMembers/ImmediateMembers1.kt
similarity index 100%
rename from idea/idea-completion/testData/basic/common/ImmediateMembers1.kt
rename to idea/idea-completion/testData/basic/common/immediateMembers/ImmediateMembers1.kt
diff --git a/idea/idea-completion/testData/basic/common/ImmediateMembers2.kt b/idea/idea-completion/testData/basic/common/immediateMembers/ImmediateMembers2.kt
similarity index 100%
rename from idea/idea-completion/testData/basic/common/ImmediateMembers2.kt
rename to idea/idea-completion/testData/basic/common/immediateMembers/ImmediateMembers2.kt
diff --git a/idea/idea-completion/testData/basic/common/ImmediateMembers3.kt b/idea/idea-completion/testData/basic/common/immediateMembers/ImmediateMembers3.kt
similarity index 100%
rename from idea/idea-completion/testData/basic/common/ImmediateMembers3.kt
rename to idea/idea-completion/testData/basic/common/immediateMembers/ImmediateMembers3.kt
diff --git a/idea/idea-completion/testData/basic/common/ImmediateMembers4.kt b/idea/idea-completion/testData/basic/common/immediateMembers/ImmediateMembers4.kt
similarity index 100%
rename from idea/idea-completion/testData/basic/common/ImmediateMembers4.kt
rename to idea/idea-completion/testData/basic/common/immediateMembers/ImmediateMembers4.kt
diff --git a/idea/idea-completion/testData/basic/common/ImmediateMembers5.kt b/idea/idea-completion/testData/basic/common/immediateMembers/ImmediateMembers5.kt
similarity index 100%
rename from idea/idea-completion/testData/basic/common/ImmediateMembers5.kt
rename to idea/idea-completion/testData/basic/common/immediateMembers/ImmediateMembers5.kt
diff --git a/idea/idea-completion/testData/basic/common/FunctionLiteralParameterName0.kt b/idea/idea-completion/testData/basic/common/lambdaSignature/ParameterName1.kt
similarity index 100%
rename from idea/idea-completion/testData/basic/common/FunctionLiteralParameterName0.kt
rename to idea/idea-completion/testData/basic/common/lambdaSignature/ParameterName1.kt
diff --git a/idea/idea-completion/testData/basic/common/lambdaSignature/ParameterName2.kt b/idea/idea-completion/testData/basic/common/lambdaSignature/ParameterName2.kt
new file mode 100644
index 00000000000..c69b8158009
--- /dev/null
+++ b/idea/idea-completion/testData/basic/common/lambdaSignature/ParameterName2.kt
@@ -0,0 +1,5 @@
+fun bar() {
+    val handler = { i: Int, <caret> }
+}
+
+// NUMBER: 0
diff --git a/idea/idea-completion/testData/basic/common/FunctionLiteralParameterName4.kt b/idea/idea-completion/testData/basic/common/lambdaSignature/ParameterName3.kt
similarity index 100%
rename from idea/idea-completion/testData/basic/common/FunctionLiteralParameterName4.kt
rename to idea/idea-completion/testData/basic/common/lambdaSignature/ParameterName3.kt
diff --git a/idea/idea-completion/testData/basic/common/FunctionLiteralParameterName5.kt b/idea/idea-completion/testData/basic/common/lambdaSignature/ParameterName4.kt
similarity index 100%
rename from idea/idea-completion/testData/basic/common/FunctionLiteralParameterName5.kt
rename to idea/idea-completion/testData/basic/common/lambdaSignature/ParameterName4.kt
diff --git a/idea/idea-completion/testData/basic/common/lambdaSignature/ParameterName5.kt b/idea/idea-completion/testData/basic/common/lambdaSignature/ParameterName5.kt
new file mode 100644
index 00000000000..a8d58c9dc4f
--- /dev/null
+++ b/idea/idea-completion/testData/basic/common/lambdaSignature/ParameterName5.kt
@@ -0,0 +1,5 @@
+fun bar() {
+    val handler = { p1: Int, p2: List<String>, <caret> }
+}
+
+// NUMBER: 0
diff --git a/idea/idea-completion/testData/basic/common/FunctionLiteralParameterType2.kt b/idea/idea-completion/testData/basic/common/lambdaSignature/ParameterType1.kt
similarity index 69%
rename from idea/idea-completion/testData/basic/common/FunctionLiteralParameterType2.kt
rename to idea/idea-completion/testData/basic/common/lambdaSignature/ParameterType1.kt
index fc207cd39db..ec68c3abffe 100644
--- a/idea/idea-completion/testData/basic/common/FunctionLiteralParameterType2.kt
+++ b/idea/idea-completion/testData/basic/common/lambdaSignature/ParameterType1.kt
@@ -1,5 +1,5 @@
 fun bar() {
-    val handler = { (i: <caret> }
+    val handler = { i: <caret> }
 }
 
 // EXIST: Int
diff --git a/idea/idea-completion/testData/basic/common/FunctionLiteralParameterType4.kt b/idea/idea-completion/testData/basic/common/lambdaSignature/ParameterType2.kt
similarity index 65%
rename from idea/idea-completion/testData/basic/common/FunctionLiteralParameterType4.kt
rename to idea/idea-completion/testData/basic/common/lambdaSignature/ParameterType2.kt
index 9829505c48a..060a49f860b 100644
--- a/idea/idea-completion/testData/basic/common/FunctionLiteralParameterType4.kt
+++ b/idea/idea-completion/testData/basic/common/lambdaSignature/ParameterType2.kt
@@ -1,5 +1,5 @@
 fun bar() {
-    val handler = { (i: List<<caret>>) }
+    val handler = { i: Int, s: <caret> }
 }
 
 // EXIST: Int
diff --git a/idea/idea-completion/testData/basic/common/FunctionLiteralParameterType1.kt b/idea/idea-completion/testData/basic/common/lambdaSignature/ParameterType3.kt
similarity index 66%
rename from idea/idea-completion/testData/basic/common/FunctionLiteralParameterType1.kt
rename to idea/idea-completion/testData/basic/common/lambdaSignature/ParameterType3.kt
index de166f1fe4a..d36cdebac48 100644
--- a/idea/idea-completion/testData/basic/common/FunctionLiteralParameterType1.kt
+++ b/idea/idea-completion/testData/basic/common/lambdaSignature/ParameterType3.kt
@@ -1,5 +1,5 @@
 fun bar() {
-    val handler = { (i: <caret>) }
+    val handler = { i: List<<caret>> }
 }
 
 // EXIST: Int
diff --git a/idea/idea-completion/testData/basic/common/FunctionLiteralParameterType3.kt b/idea/idea-completion/testData/basic/common/lambdaSignature/ParameterType4.kt
similarity index 63%
rename from idea/idea-completion/testData/basic/common/FunctionLiteralParameterType3.kt
rename to idea/idea-completion/testData/basic/common/lambdaSignature/ParameterType4.kt
index 17af74fc398..7c6325deb21 100644
--- a/idea/idea-completion/testData/basic/common/FunctionLiteralParameterType3.kt
+++ b/idea/idea-completion/testData/basic/common/lambdaSignature/ParameterType4.kt
@@ -1,5 +1,5 @@
 fun bar() {
-    val handler = { (i: Int, s: <caret> }
+    val handler = { i: Map<String, <caret> }
 }
 
 // EXIST: Int
diff --git a/idea/idea-completion/testData/basic/common/lambdaSignature/ParameterType5.kt b/idea/idea-completion/testData/basic/common/lambdaSignature/ParameterType5.kt
new file mode 100644
index 00000000000..c334dd3ba3b
--- /dev/null
+++ b/idea/idea-completion/testData/basic/common/lambdaSignature/ParameterType5.kt
@@ -0,0 +1,8 @@
+fun bar() {
+    val handler = { i: Int, list: List<String>, s: <caret> }
+}
+
+// EXIST: Int
+// EXIST: String
+// ABSENT: bar
+// ABSENT: handler
\ No newline at end of file
diff --git a/idea/idea-completion/testData/basic/common/parameterNameAndType/URLConnection.kt b/idea/idea-completion/testData/basic/common/parameterNameAndType/URLConnection.kt
new file mode 100644
index 00000000000..b746eca68f9
--- /dev/null
+++ b/idea/idea-completion/testData/basic/common/parameterNameAndType/URLConnection.kt
@@ -0,0 +1,6 @@
+import java.net.URLConnection
+
+fun foo(url<caret>){}
+
+// EXIST_JAVA_ONLY: { lookupString: "urlConnection", itemText: "urlConnection: URLConnection", tailText: " (java.net)" }
+// ABSENT: urlconnection
diff --git a/idea/idea-completion/testData/basic/common/shadowing/PreferCloserReceiverGeneric.kt b/idea/idea-completion/testData/basic/common/shadowing/PreferCloserReceiverGeneric.kt
new file mode 100644
index 00000000000..ee7ce332369
--- /dev/null
+++ b/idea/idea-completion/testData/basic/common/shadowing/PreferCloserReceiverGeneric.kt
@@ -0,0 +1,14 @@
+interface I<T> {
+    fun xxx(): T
+}
+
+fun foo(i1: I<Int>, i2: I<String>) {
+    with (i1) {
+        with (i2) {
+           xx<caret>
+        }
+    }
+}
+
+// EXIST: { lookupString: "xxx", itemText: "xxx", tailText: "()", typeText: "String" }
+// NOTHING_ELSE
diff --git a/idea/idea-completion/testData/basic/common/shadowing/PreferMoreSpecificExtensionGeneric.kt b/idea/idea-completion/testData/basic/common/shadowing/PreferMoreSpecificExtensionGeneric.kt
new file mode 100644
index 00000000000..6227f2ec54f
--- /dev/null
+++ b/idea/idea-completion/testData/basic/common/shadowing/PreferMoreSpecificExtensionGeneric.kt
@@ -0,0 +1,9 @@
+fun <T> List<T>.xxx(){}
+fun <T> Iterable<T>.xxx(){}
+
+fun foo() {
+    listOf(1).xx<caret>
+}
+
+// EXIST: { lookupString: "xxx", itemText: "xxx", tailText: "() for List<T> in <root>", typeText: "Unit" }
+// NOTHING_ELSE
diff --git a/idea/idea-completion/testData/basic/common/shadowing/PreferMoreSpecificExtensionGenericWithParam.kt b/idea/idea-completion/testData/basic/common/shadowing/PreferMoreSpecificExtensionGenericWithParam.kt
new file mode 100644
index 00000000000..780455b69ff
--- /dev/null
+++ b/idea/idea-completion/testData/basic/common/shadowing/PreferMoreSpecificExtensionGenericWithParam.kt
@@ -0,0 +1,9 @@
+fun <T> List<T>.xxx(t: T){}
+fun <T> Iterable<T>.xxx(t: T){}
+
+fun foo() {
+    listOf(1).xx<caret>
+}
+
+// EXIST: { lookupString: "xxx", itemText: "xxx", tailText: "(t: Int) for List<T> in <root>", typeText: "Unit" }
+// NOTHING_ELSE
diff --git a/idea/idea-completion/testData/basic/multifile/CallablesInExcludedPackage/CallablesInExcludedPackage.dependency1.kt b/idea/idea-completion/testData/basic/multifile/CallablesInExcludedPackage/CallablesInExcludedPackage.dependency1.kt
new file mode 100644
index 00000000000..76bd2d486f0
--- /dev/null
+++ b/idea/idea-completion/testData/basic/multifile/CallablesInExcludedPackage/CallablesInExcludedPackage.dependency1.kt
@@ -0,0 +1,6 @@
+package excludedPackage
+
+fun someFunction() {
+}
+
+val someProperty: Int = 5
\ No newline at end of file
diff --git a/idea/idea-completion/testData/basic/multifile/CallablesInExcludedPackage/CallablesInExcludedPackage.dependency2.kt b/idea/idea-completion/testData/basic/multifile/CallablesInExcludedPackage/CallablesInExcludedPackage.dependency2.kt
new file mode 100644
index 00000000000..9729ec11a82
--- /dev/null
+++ b/idea/idea-completion/testData/basic/multifile/CallablesInExcludedPackage/CallablesInExcludedPackage.dependency2.kt
@@ -0,0 +1,6 @@
+package notExcludedPackage
+
+fun someOtherFunction() {
+}
+
+val someOtherProperty: Int = 5
\ No newline at end of file
diff --git a/idea/idea-completion/testData/basic/multifile/CallablesInExcludedPackage/CallablesInExcludedPackage.kt b/idea/idea-completion/testData/basic/multifile/CallablesInExcludedPackage/CallablesInExcludedPackage.kt
new file mode 100644
index 00000000000..9c3bf15ce5f
--- /dev/null
+++ b/idea/idea-completion/testData/basic/multifile/CallablesInExcludedPackage/CallablesInExcludedPackage.kt
@@ -0,0 +1,5 @@
+val x = some<caret>
+
+// NUMBER: 2
+// ABSENT: someFunction, someProperty
+// EXIST: someOtherFunction, someOtherProperty
\ No newline at end of file
diff --git a/idea/idea-completion/testData/basic/multifile/ClassInExcludedPackage/ClassInExcludedPackage.dependency1.kt b/idea/idea-completion/testData/basic/multifile/ClassInExcludedPackage/ClassInExcludedPackage.dependency1.kt
new file mode 100644
index 00000000000..00f79598da5
--- /dev/null
+++ b/idea/idea-completion/testData/basic/multifile/ClassInExcludedPackage/ClassInExcludedPackage.dependency1.kt
@@ -0,0 +1,3 @@
+package excludedPackage
+
+class SomeClass
\ No newline at end of file
diff --git a/idea/idea-completion/testData/basic/multifile/ClassInExcludedPackage/ClassInExcludedPackage.dependency2.kt b/idea/idea-completion/testData/basic/multifile/ClassInExcludedPackage/ClassInExcludedPackage.dependency2.kt
new file mode 100644
index 00000000000..d578d706eb3
--- /dev/null
+++ b/idea/idea-completion/testData/basic/multifile/ClassInExcludedPackage/ClassInExcludedPackage.dependency2.kt
@@ -0,0 +1,3 @@
+package notExcludedPackage
+
+class SomeOtherClass
\ No newline at end of file
diff --git a/idea/idea-completion/testData/basic/multifile/ClassInExcludedPackage/ClassInExcludedPackage.kt b/idea/idea-completion/testData/basic/multifile/ClassInExcludedPackage/ClassInExcludedPackage.kt
new file mode 100644
index 00000000000..5baec3ae0c8
--- /dev/null
+++ b/idea/idea-completion/testData/basic/multifile/ClassInExcludedPackage/ClassInExcludedPackage.kt
@@ -0,0 +1,5 @@
+val x = Some<caret>
+
+// NUMBER: 1
+// ABSENT: SomeClass
+// EXIST: SomeOtherClass
\ No newline at end of file
diff --git a/idea/idea-completion/testData/basic/multifile/ExcludedClass/ExcludedClass.dependency.kt b/idea/idea-completion/testData/basic/multifile/ExcludedClass/ExcludedClass.dependency.kt
new file mode 100644
index 00000000000..4983cec7adf
--- /dev/null
+++ b/idea/idea-completion/testData/basic/multifile/ExcludedClass/ExcludedClass.dependency.kt
@@ -0,0 +1,5 @@
+package somePackage
+
+class ExcludedClass
+
+class ExtraClass
\ No newline at end of file
diff --git a/idea/idea-completion/testData/basic/multifile/ExcludedClass/ExcludedClass.kt b/idea/idea-completion/testData/basic/multifile/ExcludedClass/ExcludedClass.kt
new file mode 100644
index 00000000000..f342359fe2d
--- /dev/null
+++ b/idea/idea-completion/testData/basic/multifile/ExcludedClass/ExcludedClass.kt
@@ -0,0 +1,4 @@
+val x = Ex<caret>
+
+// ABSENT: ExcludedClass
+// EXIST: ExtraClass
\ No newline at end of file
diff --git a/idea/idea-completion/testData/basic/multifile/ExcludedJavaClass/ExcludedJavaClass.kt b/idea/idea-completion/testData/basic/multifile/ExcludedJavaClass/ExcludedJavaClass.kt
new file mode 100644
index 00000000000..f342359fe2d
--- /dev/null
+++ b/idea/idea-completion/testData/basic/multifile/ExcludedJavaClass/ExcludedJavaClass.kt
@@ -0,0 +1,4 @@
+val x = Ex<caret>
+
+// ABSENT: ExcludedClass
+// EXIST: ExtraClass
\ No newline at end of file
diff --git a/idea/idea-completion/testData/basic/multifile/ExcludedJavaClass/somePackage/ExcludedClass.java b/idea/idea-completion/testData/basic/multifile/ExcludedJavaClass/somePackage/ExcludedClass.java
new file mode 100644
index 00000000000..a3272a3f71f
--- /dev/null
+++ b/idea/idea-completion/testData/basic/multifile/ExcludedJavaClass/somePackage/ExcludedClass.java
@@ -0,0 +1,5 @@
+package somePackage;
+
+public class ExcludedClass {
+
+}
\ No newline at end of file
diff --git a/idea/idea-completion/testData/basic/multifile/ExcludedJavaClass/somePackage/ExtraClass.java b/idea/idea-completion/testData/basic/multifile/ExcludedJavaClass/somePackage/ExtraClass.java
new file mode 100644
index 00000000000..8e27c9baf5d
--- /dev/null
+++ b/idea/idea-completion/testData/basic/multifile/ExcludedJavaClass/somePackage/ExtraClass.java
@@ -0,0 +1,5 @@
+package somePackage;
+
+public class ExtraClass {
+
+}
\ No newline at end of file
diff --git a/idea/idea-completion/testData/basic/multifile/IncorrectGetters/IncorrectGetters.dependency.java b/idea/idea-completion/testData/basic/multifile/IncorrectGetters/IncorrectGetters.dependency.java
new file mode 100644
index 00000000000..366ce6faf45
--- /dev/null
+++ b/idea/idea-completion/testData/basic/multifile/IncorrectGetters/IncorrectGetters.dependency.java
@@ -0,0 +1,4 @@
+class JavaClass {
+    public int get() { return 1; }
+    public int get1() { return 1; }
+}
\ No newline at end of file
diff --git a/idea/idea-completion/testData/basic/multifile/IncorrectGetters/IncorrectGetters.kt b/idea/idea-completion/testData/basic/multifile/IncorrectGetters/IncorrectGetters.kt
new file mode 100644
index 00000000000..1618af5451f
--- /dev/null
+++ b/idea/idea-completion/testData/basic/multifile/IncorrectGetters/IncorrectGetters.kt
@@ -0,0 +1,6 @@
+fun foo(javaClass: JavaClass) {
+    javaClass.<caret>
+}
+
+// ABSENT: ""
+// ABSENT: "1"
diff --git a/idea/idea-completion/testData/basic/multifile/MoreSpecificExtensionGeneric/MoreSpecificExtensionGeneric.dependency.kt b/idea/idea-completion/testData/basic/multifile/MoreSpecificExtensionGeneric/MoreSpecificExtensionGeneric.dependency.kt
new file mode 100644
index 00000000000..32d8a983113
--- /dev/null
+++ b/idea/idea-completion/testData/basic/multifile/MoreSpecificExtensionGeneric/MoreSpecificExtensionGeneric.dependency.kt
@@ -0,0 +1,7 @@
+package dependency
+
+interface Iterable<T>
+interface List<T> : Iterable<T>
+
+fun <T> List<T>.xxx(t: T){}
+fun <T> Iterable<T>.xxx(t: T){}
diff --git a/idea/idea-completion/testData/basic/multifile/MoreSpecificExtensionGeneric/MoreSpecificExtensionGeneric.kt b/idea/idea-completion/testData/basic/multifile/MoreSpecificExtensionGeneric/MoreSpecificExtensionGeneric.kt
new file mode 100644
index 00000000000..54651e1bb41
--- /dev/null
+++ b/idea/idea-completion/testData/basic/multifile/MoreSpecificExtensionGeneric/MoreSpecificExtensionGeneric.kt
@@ -0,0 +1,6 @@
+fun foo(list: dependency.List<Int>) {
+    list.xx<caret>
+}
+
+// EXIST: { lookupString: "xxx", itemText: "xxx", tailText: "(t: Int) for List<T> in dependency", typeText: "Unit" }
+// NOTHING_ELSE
diff --git a/idea/idea-completion/testData/basic/multifile/SyntheticExtensionForGenericClass/SyntheticExtensionForGenericClass.dependency.java b/idea/idea-completion/testData/basic/multifile/SyntheticExtensionForGenericClass/SyntheticExtensionForGenericClass.dependency.java
new file mode 100644
index 00000000000..6d641e919ce
--- /dev/null
+++ b/idea/idea-completion/testData/basic/multifile/SyntheticExtensionForGenericClass/SyntheticExtensionForGenericClass.dependency.java
@@ -0,0 +1,8 @@
+class JavaClass<T> {
+    public T getSomething() {
+        return null;
+    }
+
+    public void setSomething(T t) {
+    }
+}
\ No newline at end of file
diff --git a/idea/idea-completion/testData/basic/multifile/SyntheticExtensionForGenericClass/SyntheticExtensionForGenericClass.kt b/idea/idea-completion/testData/basic/multifile/SyntheticExtensionForGenericClass/SyntheticExtensionForGenericClass.kt
new file mode 100644
index 00000000000..f4129d0185c
--- /dev/null
+++ b/idea/idea-completion/testData/basic/multifile/SyntheticExtensionForGenericClass/SyntheticExtensionForGenericClass.kt
@@ -0,0 +1,5 @@
+fun foo(javaClass: JavaClass<String>) {
+    javaClass.<caret>
+}
+
+// EXIST: { lookupString: "something", itemText: "something", tailText: " (from getSomething()/setSomething())", typeText: "String!" }
diff --git a/idea/idea-completion/testData/handlers/basic/SyntheticExtension.kt b/idea/idea-completion/testData/handlers/basic/SyntheticExtension.kt
new file mode 100644
index 00000000000..a4f68a36f93
--- /dev/null
+++ b/idea/idea-completion/testData/handlers/basic/SyntheticExtension.kt
@@ -0,0 +1,7 @@
+import java.io.File
+
+fun foo(file: File) {
+    file.abs<caret>
+}
+
+// ELEMENT: absolutePath
diff --git a/idea/idea-completion/testData/handlers/basic/SyntheticExtension.kt.after b/idea/idea-completion/testData/handlers/basic/SyntheticExtension.kt.after
new file mode 100644
index 00000000000..69f9eb2d9b1
--- /dev/null
+++ b/idea/idea-completion/testData/handlers/basic/SyntheticExtension.kt.after
@@ -0,0 +1,7 @@
+import java.io.File
+
+fun foo(file: File) {
+    file.absolutePath<caret>
+}
+
+// ELEMENT: absolutePath
diff --git a/idea/idea-completion/testData/handlers/basic/highOrderFunctions/HigherOrderFunctionWithArgs1.kt b/idea/idea-completion/testData/handlers/basic/highOrderFunctions/HigherOrderFunctionWithArgs1.kt
index 4f853bc548d..61cc344f32d 100644
--- a/idea/idea-completion/testData/handlers/basic/highOrderFunctions/HigherOrderFunctionWithArgs1.kt
+++ b/idea/idea-completion/testData/handlers/basic/highOrderFunctions/HigherOrderFunctionWithArgs1.kt
@@ -5,4 +5,4 @@ fun main(args: Array<String>) {
 }
 
 // ELEMENT: foo
-// TAIL_TEXT: " { String, Char -> ... } (<root>)"
+// TAIL_TEXT: " { String, Char -> ... } (p: (String, Char) -> Boolean) (<root>)"
diff --git a/idea/idea-completion/testData/handlers/basic/highOrderFunctions/HigherOrderFunctionWithArgs1.kt.after b/idea/idea-completion/testData/handlers/basic/highOrderFunctions/HigherOrderFunctionWithArgs1.kt.after
index dcc55fac961..f01aed33a0d 100644
--- a/idea/idea-completion/testData/handlers/basic/highOrderFunctions/HigherOrderFunctionWithArgs1.kt.after
+++ b/idea/idea-completion/testData/handlers/basic/highOrderFunctions/HigherOrderFunctionWithArgs1.kt.after
@@ -5,4 +5,4 @@ fun main(args: Array<String>) {
 }
 
 // ELEMENT: foo
-// TAIL_TEXT: " { String, Char -> ... } (<root>)"
+// TAIL_TEXT: " { String, Char -> ... } (p: (String, Char) -> Boolean) (<root>)"
diff --git a/idea/idea-completion/testData/handlers/basic/highOrderFunctions/HigherOrderFunctionWithArgs3.kt b/idea/idea-completion/testData/handlers/basic/highOrderFunctions/HigherOrderFunctionWithArgs3.kt
index f8ece805cfb..5812622ae3a 100644
--- a/idea/idea-completion/testData/handlers/basic/highOrderFunctions/HigherOrderFunctionWithArgs3.kt
+++ b/idea/idea-completion/testData/handlers/basic/highOrderFunctions/HigherOrderFunctionWithArgs3.kt
@@ -6,5 +6,5 @@ fun main(args: Array<String>) {
 }
 
 // ELEMENT: foo
-// TAIL_TEXT: " { String, Char -> ... } (<root>)"
+// TAIL_TEXT: " { String, Char -> ... } (p: (String, Char) -> Boolean) (<root>)"
 
diff --git a/idea/idea-completion/testData/handlers/basic/highOrderFunctions/HigherOrderFunctionWithArgs3.kt.after b/idea/idea-completion/testData/handlers/basic/highOrderFunctions/HigherOrderFunctionWithArgs3.kt.after
index bc480d4e9e9..d93c83af6b4 100644
--- a/idea/idea-completion/testData/handlers/basic/highOrderFunctions/HigherOrderFunctionWithArgs3.kt.after
+++ b/idea/idea-completion/testData/handlers/basic/highOrderFunctions/HigherOrderFunctionWithArgs3.kt.after
@@ -6,5 +6,5 @@ fun main(args: Array<String>) {
 }
 
 // ELEMENT: foo
-// TAIL_TEXT: " { String, Char -> ... } (<root>)"
+// TAIL_TEXT: " { String, Char -> ... } (p: (String, Char) -> Boolean) (<root>)"
 
diff --git a/idea/idea-completion/testData/handlers/basic/highOrderFunctions/ParameterTypeIsDerivedFromFunction.kt b/idea/idea-completion/testData/handlers/basic/highOrderFunctions/ParameterTypeIsDerivedFromFunction.kt
new file mode 100644
index 00000000000..0e5f6da65c8
--- /dev/null
+++ b/idea/idea-completion/testData/handlers/basic/highOrderFunctions/ParameterTypeIsDerivedFromFunction.kt
@@ -0,0 +1,9 @@
+interface I : () -> Unit
+
+fun foo(i: I){}
+
+fun bar() {
+    <caret>
+}
+
+// ELEMENT: foo
diff --git a/idea/idea-completion/testData/handlers/basic/highOrderFunctions/ParameterTypeIsDerivedFromFunction.kt.after b/idea/idea-completion/testData/handlers/basic/highOrderFunctions/ParameterTypeIsDerivedFromFunction.kt.after
new file mode 100644
index 00000000000..14ea2219a60
--- /dev/null
+++ b/idea/idea-completion/testData/handlers/basic/highOrderFunctions/ParameterTypeIsDerivedFromFunction.kt.after
@@ -0,0 +1,9 @@
+interface I : () -> Unit
+
+fun foo(i: I){}
+
+fun bar() {
+    foo(<caret>)
+}
+
+// ELEMENT: foo
diff --git a/idea/idea-completion/testData/handlers/basic/highOrderFunctions/ReplaceByLambdaTemplateNoClosingParenth.kt b/idea/idea-completion/testData/handlers/basic/highOrderFunctions/ReplaceByLambdaTemplateNoClosingParenth.kt
index 1e6481d03d6..bb24097bda3 100644
--- a/idea/idea-completion/testData/handlers/basic/highOrderFunctions/ReplaceByLambdaTemplateNoClosingParenth.kt
+++ b/idea/idea-completion/testData/handlers/basic/highOrderFunctions/ReplaceByLambdaTemplateNoClosingParenth.kt
@@ -5,5 +5,5 @@ fun main(args: Array<String>) {
 }
 
 // ELEMENT: "foo"
-// TAIL_TEXT: " { String, Char -> ... } (<root>)"
+// TAIL_TEXT: " { String, Char -> ... } (p: (String, Char) -> Boolean) (<root>)"
 // CHAR: '\t'
diff --git a/idea/idea-completion/testData/handlers/basic/highOrderFunctions/ReplaceByLambdaTemplateNoClosingParenth.kt.after b/idea/idea-completion/testData/handlers/basic/highOrderFunctions/ReplaceByLambdaTemplateNoClosingParenth.kt.after
index d7a7884dcdf..84c3a3a45ab 100644
--- a/idea/idea-completion/testData/handlers/basic/highOrderFunctions/ReplaceByLambdaTemplateNoClosingParenth.kt.after
+++ b/idea/idea-completion/testData/handlers/basic/highOrderFunctions/ReplaceByLambdaTemplateNoClosingParenth.kt.after
@@ -5,5 +5,5 @@ fun main(args: Array<String>) {
 }
 
 // ELEMENT: "foo"
-// TAIL_TEXT: " { String, Char -> ... } (<root>)"
+// TAIL_TEXT: " { String, Char -> ... } (p: (String, Char) -> Boolean) (<root>)"
 // CHAR: '\t'
diff --git a/idea/idea-completion/testData/handlers/basic/highOrderFunctions/WithArgsEmptyLambdaAfter.kt b/idea/idea-completion/testData/handlers/basic/highOrderFunctions/WithArgsEmptyLambdaAfter.kt
index 327a06bba0f..fabc6e2ca4f 100644
--- a/idea/idea-completion/testData/handlers/basic/highOrderFunctions/WithArgsEmptyLambdaAfter.kt
+++ b/idea/idea-completion/testData/handlers/basic/highOrderFunctions/WithArgsEmptyLambdaAfter.kt
@@ -5,4 +5,4 @@ fun main(args: Array<String>) {
 }
 
 // ELEMENT: foo
-// TAIL_TEXT: " { String, Char -> ... } (<root>)"
+// TAIL_TEXT: " { String, Char -> ... } (p: (String, Char) -> Boolean) (<root>)"
diff --git a/idea/idea-completion/testData/handlers/basic/highOrderFunctions/WithArgsEmptyLambdaAfter.kt.after b/idea/idea-completion/testData/handlers/basic/highOrderFunctions/WithArgsEmptyLambdaAfter.kt.after
index 42a9678079b..afa51f761e8 100644
--- a/idea/idea-completion/testData/handlers/basic/highOrderFunctions/WithArgsEmptyLambdaAfter.kt.after
+++ b/idea/idea-completion/testData/handlers/basic/highOrderFunctions/WithArgsEmptyLambdaAfter.kt.after
@@ -5,4 +5,4 @@ fun main(args: Array<String>) {
 }
 
 // ELEMENT: foo
-// TAIL_TEXT: " { String, Char -> ... } (<root>)"
+// TAIL_TEXT: " { String, Char -> ... } (p: (String, Char) -> Boolean) (<root>)"
diff --git a/idea/idea-completion/testData/handlers/basic/highOrderFunctions/WithArgsNonEmptyLambdaAfter.kt b/idea/idea-completion/testData/handlers/basic/highOrderFunctions/WithArgsNonEmptyLambdaAfter.kt
index 880d6e96240..ccfb1509882 100644
--- a/idea/idea-completion/testData/handlers/basic/highOrderFunctions/WithArgsNonEmptyLambdaAfter.kt
+++ b/idea/idea-completion/testData/handlers/basic/highOrderFunctions/WithArgsNonEmptyLambdaAfter.kt
@@ -5,4 +5,4 @@ fun main(args: Array<String>) {
 }
 
 // ELEMENT: foo
-// TAIL_TEXT: " { String, Char -> ... } (<root>)"
+// TAIL_TEXT: " { String, Char -> ... } (p: (String, Char) -> Boolean) (<root>)"
diff --git a/idea/idea-completion/testData/handlers/basic/highOrderFunctions/WithArgsNonEmptyLambdaAfter.kt.after b/idea/idea-completion/testData/handlers/basic/highOrderFunctions/WithArgsNonEmptyLambdaAfter.kt.after
index ecb94d95e39..0cdd9c1d123 100644
--- a/idea/idea-completion/testData/handlers/basic/highOrderFunctions/WithArgsNonEmptyLambdaAfter.kt.after
+++ b/idea/idea-completion/testData/handlers/basic/highOrderFunctions/WithArgsNonEmptyLambdaAfter.kt.after
@@ -5,4 +5,4 @@ fun main(args: Array<String>) {
 }
 
 // ELEMENT: foo
-// TAIL_TEXT: " { String, Char -> ... } (<root>)"
+// TAIL_TEXT: " { String, Char -> ... } (p: (String, Char) -> Boolean) (<root>)"
diff --git a/idea/idea-completion/testData/handlers/keywords/FileKeyword.kt.after b/idea/idea-completion/testData/handlers/keywords/FileKeyword.kt.after
index 65e3a90a0a1..bd66ff5d579 100644
--- a/idea/idea-completion/testData/handlers/keywords/FileKeyword.kt.after
+++ b/idea/idea-completion/testData/handlers/keywords/FileKeyword.kt.after
@@ -1 +1 @@
-@final 
+@fi
diff --git a/idea/idea-completion/testData/handlers/smart/SAMExpected1.kt b/idea/idea-completion/testData/handlers/smart/SAMExpected1.kt
index 3bd44948bd8..b717b24dcf3 100644
--- a/idea/idea-completion/testData/handlers/smart/SAMExpected1.kt
+++ b/idea/idea-completion/testData/handlers/smart/SAMExpected1.kt
@@ -1,4 +1,4 @@
 var a : Runnable = <caret>
 
 // ELEMENT_TEXT: Runnable
-// TAIL_TEXT: "(function: () -> Unit) (java.lang)"
+// TAIL_TEXT: " {...} (function: () -> Unit) (java.lang)"
diff --git a/idea/idea-completion/testData/handlers/smart/SAMExpected1.kt.after b/idea/idea-completion/testData/handlers/smart/SAMExpected1.kt.after
index dd80a9ada21..dd389f324f5 100644
--- a/idea/idea-completion/testData/handlers/smart/SAMExpected1.kt.after
+++ b/idea/idea-completion/testData/handlers/smart/SAMExpected1.kt.after
@@ -1,4 +1,4 @@
 var a : Runnable = Runnable { <caret> }
 
 // ELEMENT_TEXT: Runnable
-// TAIL_TEXT: "(function: () -> Unit) (java.lang)"
+// TAIL_TEXT: " {...} (function: () -> Unit) (java.lang)"
diff --git a/idea/idea-completion/testData/handlers/smart/kt6179filterTo.kt b/idea/idea-completion/testData/handlers/smart/kt6179filterTo.kt
new file mode 100644
index 00000000000..bb10324dc66
--- /dev/null
+++ b/idea/idea-completion/testData/handlers/smart/kt6179filterTo.kt
@@ -0,0 +1,10 @@
+import java.util.ArrayList
+
+fun foo(c: Collection<String>) {
+    val list = ArrayList<String>()
+    c.filterTo0(<caret>)
+}
+
+fun <T, C : MutableCollection<in T>> Iterable<T>.filterTo0(destination: C, predicate: (T) -> Boolean): C = destination
+
+//ELEMENT: list
\ No newline at end of file
diff --git a/idea/idea-completion/testData/handlers/smart/kt6179filterTo.kt.after b/idea/idea-completion/testData/handlers/smart/kt6179filterTo.kt.after
new file mode 100644
index 00000000000..8b056cd34df
--- /dev/null
+++ b/idea/idea-completion/testData/handlers/smart/kt6179filterTo.kt.after
@@ -0,0 +1,10 @@
+import java.util.ArrayList
+
+fun foo(c: Collection<String>) {
+    val list = ArrayList<String>()
+    c.filterTo0(list)
+}
+
+fun <T, C : MutableCollection<in T>> Iterable<T>.filterTo0(destination: C, predicate: (T) -> Boolean): C = destination
+
+//ELEMENT: list
\ No newline at end of file
diff --git a/idea/idea-completion/testData/injava/ClassObjectField.java b/idea/idea-completion/testData/injava/ClassObjectField.java
index 0173f41c06f..a5ae5f15cd8 100644
--- a/idea/idea-completion/testData/injava/ClassObjectField.java
+++ b/idea/idea-completion/testData/injava/ClassObjectField.java
@@ -5,4 +5,3 @@ public class Testing {
 }
 
 // EXIST: Companion
-// EXIST: OBJECT$
\ No newline at end of file
diff --git a/idea/idea-completion/testData/keywords/AfterClassProperty.kt b/idea/idea-completion/testData/keywords/AfterClassProperty.kt
index e1c48a3f01b..93f3851a6e9 100644
--- a/idea/idea-completion/testData/keywords/AfterClassProperty.kt
+++ b/idea/idea-completion/testData/keywords/AfterClassProperty.kt
@@ -5,7 +5,6 @@ class MouseMovedEventArgs
 }
 
 // EXIST:  abstract
-// EXIST:  annotation
 // EXIST:  as
 // EXIST:  class
 // EXIST:  enum
diff --git a/idea/idea-completion/testData/keywords/AfterClasses.kt b/idea/idea-completion/testData/keywords/AfterClasses.kt
index 40c822bde0e..46b0c294c42 100644
--- a/idea/idea-completion/testData/keywords/AfterClasses.kt
+++ b/idea/idea-completion/testData/keywords/AfterClasses.kt
@@ -13,7 +13,6 @@ class B {
 <caret>
 
 // EXIST:  abstract
-// EXIST:  annotation
 // EXIST:  class
 // EXIST:  enum
 // EXIST:  final
diff --git a/idea/idea-completion/testData/keywords/AfterFuns.kt b/idea/idea-completion/testData/keywords/AfterFuns.kt
index 3cb320a7ab4..d7cde5ea482 100644
--- a/idea/idea-completion/testData/keywords/AfterFuns.kt
+++ b/idea/idea-completion/testData/keywords/AfterFuns.kt
@@ -11,7 +11,6 @@ class A {
 }
 
 // EXIST:  abstract
-// EXIST:  annotation
 // EXIST:  class
 // EXIST:  enum
 // EXIST:  final
diff --git a/idea/idea-completion/testData/keywords/FileKeyword.kt b/idea/idea-completion/testData/keywords/FileKeyword.kt
index d7163b48ad8..78d5ef641ec 100644
--- a/idea/idea-completion/testData/keywords/FileKeyword.kt
+++ b/idea/idea-completion/testData/keywords/FileKeyword.kt
@@ -1,7 +1,6 @@
 @<caret>[]
 
 // EXIST: {"lookupString":"abstract","itemText":"abstract","attributes":"bold"}
-// EXIST: {"lookupString":"annotation","itemText":"annotation","attributes":"bold"}
 // EXIST: {"lookupString":"class","itemText":"class","attributes":"bold"}
 // EXIST: {"lookupString":"companion object","itemText":"companion object","attributes":"bold"}
 // EXIST: {"lookupString":"enum","itemText":"enum","attributes":"bold"}
diff --git a/idea/idea-completion/testData/keywords/GlobalPropertyAccessors.kt b/idea/idea-completion/testData/keywords/GlobalPropertyAccessors.kt
index 1071377222e..26e88f60f75 100644
--- a/idea/idea-completion/testData/keywords/GlobalPropertyAccessors.kt
+++ b/idea/idea-completion/testData/keywords/GlobalPropertyAccessors.kt
@@ -10,7 +10,6 @@ var a : Int
   <caret>
 
 // EXIST:  abstract
-// EXIST:  annotation
 // EXIST: by
 // EXIST:  class
 // EXIST:  enum
diff --git a/idea/idea-completion/testData/keywords/InClassBeforeFun.kt b/idea/idea-completion/testData/keywords/InClassBeforeFun.kt
index 7a59f949c52..32a9133121d 100644
--- a/idea/idea-completion/testData/keywords/InClassBeforeFun.kt
+++ b/idea/idea-completion/testData/keywords/InClassBeforeFun.kt
@@ -9,7 +9,6 @@ public class Test {
 
 
 // EXIST:  abstract
-// EXIST:  annotation
 // EXIST:  class
 // EXIST:  enum
 // EXIST:  final
diff --git a/idea/idea-completion/testData/keywords/InClassScope.kt b/idea/idea-completion/testData/keywords/InClassScope.kt
index 9158b047cf0..93ea7db0a6b 100644
--- a/idea/idea-completion/testData/keywords/InClassScope.kt
+++ b/idea/idea-completion/testData/keywords/InClassScope.kt
@@ -3,7 +3,6 @@ class TestClass {
 }
 
 // EXIST:  abstract
-// EXIST:  annotation
 // EXIST:  class
 // EXIST:  enum
 // EXIST:  final
diff --git a/idea/idea-completion/testData/keywords/InTopScopeAfterPackage.kt b/idea/idea-completion/testData/keywords/InTopScopeAfterPackage.kt
index cfd2c497048..139a7da2242 100644
--- a/idea/idea-completion/testData/keywords/InTopScopeAfterPackage.kt
+++ b/idea/idea-completion/testData/keywords/InTopScopeAfterPackage.kt
@@ -3,7 +3,6 @@ package Test
 <caret>
 
 // EXIST:  abstract
-// EXIST:  annotation
 // EXIST:  class
 // EXIST:  enum
 // EXIST:  final
diff --git a/idea/idea-completion/testData/keywords/PropertyAccessors.kt b/idea/idea-completion/testData/keywords/PropertyAccessors.kt
index 97fed3ffa6c..8d1a7f35848 100644
--- a/idea/idea-completion/testData/keywords/PropertyAccessors.kt
+++ b/idea/idea-completion/testData/keywords/PropertyAccessors.kt
@@ -4,7 +4,6 @@ class Some {
 }
 
 // EXIST:  abstract
-// EXIST:  annotation
 // EXIST: by
 // EXIST:  class
 // EXIST:  enum
diff --git a/idea/idea-completion/testData/keywords/PropertyAccessors2.kt b/idea/idea-completion/testData/keywords/PropertyAccessors2.kt
index d0f18e763f3..5c00b0b9f28 100644
--- a/idea/idea-completion/testData/keywords/PropertyAccessors2.kt
+++ b/idea/idea-completion/testData/keywords/PropertyAccessors2.kt
@@ -4,7 +4,6 @@ class Some {
 }
 
 // EXIST:  abstract
-// EXIST:  annotation
 // EXIST:  as
 // EXIST:  class
 // EXIST:  enum
diff --git a/idea/idea-completion/testData/keywords/PropertySetter.kt b/idea/idea-completion/testData/keywords/PropertySetter.kt
index d1c3ac16d2e..024f79c4062 100644
--- a/idea/idea-completion/testData/keywords/PropertySetter.kt
+++ b/idea/idea-completion/testData/keywords/PropertySetter.kt
@@ -5,7 +5,6 @@ class Some {
 }
 
 // EXIST:  abstract
-// EXIST:  annotation
 // EXIST:  as
 // EXIST:  class
 // EXIST:  enum
diff --git a/idea/idea-completion/testData/keywords/TopScope.kt b/idea/idea-completion/testData/keywords/TopScope.kt
index df2f8c318ca..470e9e640d5 100644
--- a/idea/idea-completion/testData/keywords/TopScope.kt
+++ b/idea/idea-completion/testData/keywords/TopScope.kt
@@ -1,7 +1,6 @@
 <caret>
 
 // EXIST:  abstract
-// EXIST:  annotation
 // EXIST:  class
 // EXIST:  enum
 // EXIST:  final
diff --git a/idea/idea-completion/testData/smart/SAMExpected1.kt b/idea/idea-completion/testData/smart/SAMExpected1.kt
index 977ce676675..55c9bfde739 100644
--- a/idea/idea-completion/testData/smart/SAMExpected1.kt
+++ b/idea/idea-completion/testData/smart/SAMExpected1.kt
@@ -1,3 +1,3 @@
 var a : Runnable = <caret>
 
-// EXIST: {"lookupString":"Runnable", "itemText":"Runnable", "tailText":"(function: () -> Unit) (java.lang)", "typeText":"Runnable"}
+// EXIST: {"lookupString":"Runnable", "itemText":"Runnable", "tailText":" {...} (function: () -> Unit) (java.lang)", "typeText":"Runnable"}
diff --git a/idea/idea-completion/testData/smart/generics/GenericFunction3.kt b/idea/idea-completion/testData/smart/generics/GenericFunction3.kt
index 02509c6ccfc..2c4f26e6a6a 100644
--- a/idea/idea-completion/testData/smart/generics/GenericFunction3.kt
+++ b/idea/idea-completion/testData/smart/generics/GenericFunction3.kt
@@ -6,4 +6,4 @@ fun f(){
 
 // EXIST: { lookupString: "listOf", tailText: "() (kotlin)", typeText: "List<String>" }
 // EXIST: { lookupString: "listOf", tailText: "(vararg values: String) (kotlin)", typeText: "List<String>" }
-// EXIST: { lookupString: "arrayListOf", tailText: "(vararg values: String!) (kotlin)", typeText: "ArrayList<String!>" }
+// EXIST: { lookupString: "arrayListOf", tailText: "(vararg values: String) (kotlin)", typeText: "ArrayList<String>" }
diff --git a/idea/idea-completion/testData/smart/generics/GenericFunction4.kt b/idea/idea-completion/testData/smart/generics/GenericFunction4.kt
index 6b2f65c5274..3dcc801f313 100644
--- a/idea/idea-completion/testData/smart/generics/GenericFunction4.kt
+++ b/idea/idea-completion/testData/smart/generics/GenericFunction4.kt
@@ -2,5 +2,5 @@ fun foo(list: List<String>): Collection<Int> {
     return list.<caret>
 }
 
-// EXIST: { lookupString: "map", tailText: "(transform: (String) -> Int) for Iterable<T> in kotlin", typeText: "List<Int>" }
+// EXIST: { lookupString: "map", tailText: " {...} (transform: (String) -> Int) for Iterable<T> in kotlin", typeText: "List<Int>" }
 // ABSENT: filter
diff --git a/idea/idea-completion/testData/smartMultiFile/CallablesInExcludedPackage/CallablesInExcludedPackage.dependency1.kt b/idea/idea-completion/testData/smartMultiFile/CallablesInExcludedPackage/CallablesInExcludedPackage.dependency1.kt
new file mode 100644
index 00000000000..49700a0c597
--- /dev/null
+++ b/idea/idea-completion/testData/smartMultiFile/CallablesInExcludedPackage/CallablesInExcludedPackage.dependency1.kt
@@ -0,0 +1,6 @@
+package excludedPackage
+
+fun someFunction(): Int {
+}
+
+val someProperty: Int = 5
\ No newline at end of file
diff --git a/idea/idea-completion/testData/smartMultiFile/CallablesInExcludedPackage/CallablesInExcludedPackage.dependency2.kt b/idea/idea-completion/testData/smartMultiFile/CallablesInExcludedPackage/CallablesInExcludedPackage.dependency2.kt
new file mode 100644
index 00000000000..d1f7be0696e
--- /dev/null
+++ b/idea/idea-completion/testData/smartMultiFile/CallablesInExcludedPackage/CallablesInExcludedPackage.dependency2.kt
@@ -0,0 +1,6 @@
+package notExcludedPackage
+
+fun someOtherFunction(): Int {
+}
+
+val someOtherProperty: Int = 5
\ No newline at end of file
diff --git a/idea/idea-completion/testData/smartMultiFile/CallablesInExcludedPackage/CallablesInExcludedPackage.kt b/idea/idea-completion/testData/smartMultiFile/CallablesInExcludedPackage/CallablesInExcludedPackage.kt
new file mode 100644
index 00000000000..4df799939b6
--- /dev/null
+++ b/idea/idea-completion/testData/smartMultiFile/CallablesInExcludedPackage/CallablesInExcludedPackage.kt
@@ -0,0 +1,6 @@
+val x: Int = some<caret>
+
+// INVOCATION_COUNT: 2
+// NUMBER: 2
+// ABSENT: someFunction, someProperty
+// EXIST: someOtherFunction, someOtherProperty
\ No newline at end of file
diff --git a/idea/idea-completion/testData/weighers/smart/SmartPriority.kt b/idea/idea-completion/testData/weighers/smart/SmartPriority.kt
index 6db78fb1537..e207c075655 100644
--- a/idea/idea-completion/testData/weighers/smart/SmartPriority.kt
+++ b/idea/idea-completion/testData/weighers/smart/SmartPriority.kt
@@ -16,6 +16,7 @@ class C {
 // ORDER: nullableFoo
 // ORDER: this
 // ORDER: local
+// ORDER: apply
 // ORDER: nonNullable
 // ORDER: nullableX
 // ORDER: nullableX
diff --git a/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/JSBasicCompletionTestGenerated.java b/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/JSBasicCompletionTestGenerated.java
index 1ddb34d33aa..7774d5abeec 100644
--- a/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/JSBasicCompletionTestGenerated.java
+++ b/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/JSBasicCompletionTestGenerated.java
@@ -67,48 +67,6 @@ public class JSBasicCompletionTestGenerated extends AbstractJSBasicCompletionTes
             JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("idea/idea-completion/testData/basic/common"), Pattern.compile("^(.+)\\.kt$"), true);
         }
 
-        @TestMetadata("BackingFields1.kt")
-        public void testBackingFields1() throws Exception {
-            String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/BackingFields1.kt");
-            doTest(fileName);
-        }
-
-        @TestMetadata("BackingFields2.kt")
-        public void testBackingFields2() throws Exception {
-            String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/BackingFields2.kt");
-            doTest(fileName);
-        }
-
-        @TestMetadata("BackingFields3.kt")
-        public void testBackingFields3() throws Exception {
-            String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/BackingFields3.kt");
-            doTest(fileName);
-        }
-
-        @TestMetadata("BackingFields4.kt")
-        public void testBackingFields4() throws Exception {
-            String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/BackingFields4.kt");
-            doTest(fileName);
-        }
-
-        @TestMetadata("BackingFields5.kt")
-        public void testBackingFields5() throws Exception {
-            String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/BackingFields5.kt");
-            doTest(fileName);
-        }
-
-        @TestMetadata("BackingFields6.kt")
-        public void testBackingFields6() throws Exception {
-            String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/BackingFields6.kt");
-            doTest(fileName);
-        }
-
-        @TestMetadata("BackingFieldsInStringTemplate.kt")
-        public void testBackingFieldsInStringTemplate() throws Exception {
-            String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/BackingFieldsInStringTemplate.kt");
-            doTest(fileName);
-        }
-
         @TestMetadata("BasicAny.kt")
         public void testBasicAny() throws Exception {
             String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/BasicAny.kt");
@@ -259,72 +217,6 @@ public class JSBasicCompletionTestGenerated extends AbstractJSBasicCompletionTes
             doTest(fileName);
         }
 
-        @TestMetadata("FunctionLiteralParameterName0.kt")
-        public void testFunctionLiteralParameterName0() throws Exception {
-            String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/FunctionLiteralParameterName0.kt");
-            doTest(fileName);
-        }
-
-        @TestMetadata("FunctionLiteralParameterName1.kt")
-        public void testFunctionLiteralParameterName1() throws Exception {
-            String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/FunctionLiteralParameterName1.kt");
-            doTest(fileName);
-        }
-
-        @TestMetadata("FunctionLiteralParameterName2.kt")
-        public void testFunctionLiteralParameterName2() throws Exception {
-            String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/FunctionLiteralParameterName2.kt");
-            doTest(fileName);
-        }
-
-        @TestMetadata("FunctionLiteralParameterName3.kt")
-        public void testFunctionLiteralParameterName3() throws Exception {
-            String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/FunctionLiteralParameterName3.kt");
-            doTest(fileName);
-        }
-
-        @TestMetadata("FunctionLiteralParameterName4.kt")
-        public void testFunctionLiteralParameterName4() throws Exception {
-            String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/FunctionLiteralParameterName4.kt");
-            doTest(fileName);
-        }
-
-        @TestMetadata("FunctionLiteralParameterName5.kt")
-        public void testFunctionLiteralParameterName5() throws Exception {
-            String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/FunctionLiteralParameterName5.kt");
-            doTest(fileName);
-        }
-
-        @TestMetadata("FunctionLiteralParameterType1.kt")
-        public void testFunctionLiteralParameterType1() throws Exception {
-            String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/FunctionLiteralParameterType1.kt");
-            doTest(fileName);
-        }
-
-        @TestMetadata("FunctionLiteralParameterType2.kt")
-        public void testFunctionLiteralParameterType2() throws Exception {
-            String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/FunctionLiteralParameterType2.kt");
-            doTest(fileName);
-        }
-
-        @TestMetadata("FunctionLiteralParameterType3.kt")
-        public void testFunctionLiteralParameterType3() throws Exception {
-            String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/FunctionLiteralParameterType3.kt");
-            doTest(fileName);
-        }
-
-        @TestMetadata("FunctionLiteralParameterType4.kt")
-        public void testFunctionLiteralParameterType4() throws Exception {
-            String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/FunctionLiteralParameterType4.kt");
-            doTest(fileName);
-        }
-
-        @TestMetadata("FunctionLiteralParameterType5.kt")
-        public void testFunctionLiteralParameterType5() throws Exception {
-            String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/FunctionLiteralParameterType5.kt");
-            doTest(fileName);
-        }
-
         @TestMetadata("FunctionVariableCallArgument.kt")
         public void testFunctionVariableCallArgument() throws Exception {
             String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/FunctionVariableCallArgument.kt");
@@ -373,60 +265,6 @@ public class JSBasicCompletionTestGenerated extends AbstractJSBasicCompletionTes
             doTest(fileName);
         }
 
-        @TestMetadata("ImmediateExtensionMembers1.kt")
-        public void testImmediateExtensionMembers1() throws Exception {
-            String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/ImmediateExtensionMembers1.kt");
-            doTest(fileName);
-        }
-
-        @TestMetadata("ImmediateExtensionMembers2.kt")
-        public void testImmediateExtensionMembers2() throws Exception {
-            String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/ImmediateExtensionMembers2.kt");
-            doTest(fileName);
-        }
-
-        @TestMetadata("ImmediateExtensionMembers3.kt")
-        public void testImmediateExtensionMembers3() throws Exception {
-            String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/ImmediateExtensionMembers3.kt");
-            doTest(fileName);
-        }
-
-        @TestMetadata("ImmediateExtensionMembers4.kt")
-        public void testImmediateExtensionMembers4() throws Exception {
-            String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/ImmediateExtensionMembers4.kt");
-            doTest(fileName);
-        }
-
-        @TestMetadata("ImmediateMembers1.kt")
-        public void testImmediateMembers1() throws Exception {
-            String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/ImmediateMembers1.kt");
-            doTest(fileName);
-        }
-
-        @TestMetadata("ImmediateMembers2.kt")
-        public void testImmediateMembers2() throws Exception {
-            String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/ImmediateMembers2.kt");
-            doTest(fileName);
-        }
-
-        @TestMetadata("ImmediateMembers3.kt")
-        public void testImmediateMembers3() throws Exception {
-            String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/ImmediateMembers3.kt");
-            doTest(fileName);
-        }
-
-        @TestMetadata("ImmediateMembers4.kt")
-        public void testImmediateMembers4() throws Exception {
-            String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/ImmediateMembers4.kt");
-            doTest(fileName);
-        }
-
-        @TestMetadata("ImmediateMembers5.kt")
-        public void testImmediateMembers5() throws Exception {
-            String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/ImmediateMembers5.kt");
-            doTest(fileName);
-        }
-
         @TestMetadata("ImportedEnumMembers.kt")
         public void testImportedEnumMembers() throws Exception {
             String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/ImportedEnumMembers.kt");
@@ -499,12 +337,6 @@ public class JSBasicCompletionTestGenerated extends AbstractJSBasicCompletionTes
             doTest(fileName);
         }
 
-        @TestMetadata("InFunctionLiteral.kt")
-        public void testInFunctionLiteral() throws Exception {
-            String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/InFunctionLiteral.kt");
-            doTest(fileName);
-        }
-
         @TestMetadata("InGlobalPropertyInitializer.kt")
         public void testInGlobalPropertyInitializer() throws Exception {
             String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/InGlobalPropertyInitializer.kt");
@@ -529,6 +361,12 @@ public class JSBasicCompletionTestGenerated extends AbstractJSBasicCompletionTes
             doTest(fileName);
         }
 
+        @TestMetadata("InLambda.kt")
+        public void testInLambda() throws Exception {
+            String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/InLambda.kt");
+            doTest(fileName);
+        }
+
         @TestMetadata("InLocalObjectDeclaration.kt")
         public void testInLocalObjectDeclaration() throws Exception {
             String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/InLocalObjectDeclaration.kt");
@@ -1027,6 +865,12 @@ public class JSBasicCompletionTestGenerated extends AbstractJSBasicCompletionTes
             doTest(fileName);
         }
 
+        @TestMetadata("TopLevelPackageInClassBody.kt")
+        public void testTopLevelPackageInClassBody() throws Exception {
+            String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/TopLevelPackageInClassBody.kt");
+            doTest(fileName);
+        }
+
         @TestMetadata("TypeParameterFromOuterClass.kt")
         public void testTypeParameterFromOuterClass() throws Exception {
             String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/TypeParameterFromOuterClass.kt");
@@ -1047,6 +891,24 @@ public class JSBasicCompletionTestGenerated extends AbstractJSBasicCompletionTes
                 JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("idea/idea-completion/testData/basic/common/annotations"), Pattern.compile("^(.+)\\.kt$"), true);
             }
 
+            @TestMetadata("Annotated.kt")
+            public void testAnnotated() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/annotations/Annotated.kt");
+                doTest(fileName);
+            }
+
+            @TestMetadata("AnnotationArguments.kt")
+            public void testAnnotationArguments() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/annotations/AnnotationArguments.kt");
+                doTest(fileName);
+            }
+
+            @TestMetadata("AnnotationTarget.kt")
+            public void testAnnotationTarget() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/annotations/AnnotationTarget.kt");
+                doTest(fileName);
+            }
+
             @TestMetadata("FunctionAnnotation1.kt")
             public void testFunctionAnnotation1() throws Exception {
                 String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/annotations/FunctionAnnotation1.kt");
@@ -1180,6 +1042,57 @@ public class JSBasicCompletionTestGenerated extends AbstractJSBasicCompletionTes
             }
         }
 
+        @TestMetadata("idea/idea-completion/testData/basic/common/backingFields")
+        @TestDataPath("$PROJECT_ROOT")
+        @RunWith(JUnit3RunnerWithInners.class)
+        public static class BackingFields extends AbstractJSBasicCompletionTest {
+            public void testAllFilesPresentInBackingFields() throws Exception {
+                JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("idea/idea-completion/testData/basic/common/backingFields"), Pattern.compile("^(.+)\\.kt$"), true);
+            }
+
+            @TestMetadata("BackingFields1.kt")
+            public void testBackingFields1() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/backingFields/BackingFields1.kt");
+                doTest(fileName);
+            }
+
+            @TestMetadata("BackingFields2.kt")
+            public void testBackingFields2() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/backingFields/BackingFields2.kt");
+                doTest(fileName);
+            }
+
+            @TestMetadata("BackingFields3.kt")
+            public void testBackingFields3() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/backingFields/BackingFields3.kt");
+                doTest(fileName);
+            }
+
+            @TestMetadata("BackingFields4.kt")
+            public void testBackingFields4() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/backingFields/BackingFields4.kt");
+                doTest(fileName);
+            }
+
+            @TestMetadata("BackingFields5.kt")
+            public void testBackingFields5() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/backingFields/BackingFields5.kt");
+                doTest(fileName);
+            }
+
+            @TestMetadata("BackingFields6.kt")
+            public void testBackingFields6() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/backingFields/BackingFields6.kt");
+                doTest(fileName);
+            }
+
+            @TestMetadata("BackingFieldsInStringTemplate.kt")
+            public void testBackingFieldsInStringTemplate() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/backingFields/BackingFieldsInStringTemplate.kt");
+                doTest(fileName);
+            }
+        }
+
         @TestMetadata("idea/idea-completion/testData/basic/common/extensions")
         @TestDataPath("$PROJECT_ROOT")
         @RunWith(JUnit3RunnerWithInners.class)
@@ -1200,6 +1113,12 @@ public class JSBasicCompletionTestGenerated extends AbstractJSBasicCompletionTes
                 doTest(fileName);
             }
 
+            @TestMetadata("DoNotHideGetterWhenExtensionCannotBeUsed.kt")
+            public void testDoNotHideGetterWhenExtensionCannotBeUsed() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/extensions/DoNotHideGetterWhenExtensionCannotBeUsed.kt");
+                doTest(fileName);
+            }
+
             @TestMetadata("ExtensionInExtendedClass.kt")
             public void testExtensionInExtendedClass() throws Exception {
                 String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/extensions/ExtensionInExtendedClass.kt");
@@ -1302,6 +1221,60 @@ public class JSBasicCompletionTestGenerated extends AbstractJSBasicCompletionTes
                 doTest(fileName);
             }
 
+            @TestMetadata("ShowGetMethodWhenNothingElseMatch.kt")
+            public void testShowGetMethodWhenNothingElseMatch() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/extensions/ShowGetMethodWhenNothingElseMatch.kt");
+                doTest(fileName);
+            }
+
+            @TestMetadata("ShowGetSetOnSecondCompletion.kt")
+            public void testShowGetSetOnSecondCompletion() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/extensions/ShowGetSetOnSecondCompletion.kt");
+                doTest(fileName);
+            }
+
+            @TestMetadata("StarTypeArg.kt")
+            public void testStarTypeArg() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/extensions/StarTypeArg.kt");
+                doTest(fileName);
+            }
+
+            @TestMetadata("SyntheticExtensions1.kt")
+            public void testSyntheticExtensions1() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/extensions/SyntheticExtensions1.kt");
+                doTest(fileName);
+            }
+
+            @TestMetadata("SyntheticExtensions2.kt")
+            public void testSyntheticExtensions2() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/extensions/SyntheticExtensions2.kt");
+                doTest(fileName);
+            }
+
+            @TestMetadata("SyntheticExtensionsInGenericClass.kt")
+            public void testSyntheticExtensionsInGenericClass() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/extensions/SyntheticExtensionsInGenericClass.kt");
+                doTest(fileName);
+            }
+
+            @TestMetadata("SyntheticExtensionsSafeCall.kt")
+            public void testSyntheticExtensionsSafeCall() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/extensions/SyntheticExtensionsSafeCall.kt");
+                doTest(fileName);
+            }
+
+            @TestMetadata("SyntheticExtensionsSmartCast.kt")
+            public void testSyntheticExtensionsSmartCast() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/extensions/SyntheticExtensionsSmartCast.kt");
+                doTest(fileName);
+            }
+
+            @TestMetadata("SyntheticExtensionsSmartCast2.kt")
+            public void testSyntheticExtensionsSmartCast2() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/extensions/SyntheticExtensionsSmartCast2.kt");
+                doTest(fileName);
+            }
+
             @TestMetadata("WrongExplicitReceiver.kt")
             public void testWrongExplicitReceiver() throws Exception {
                 String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/extensions/WrongExplicitReceiver.kt");
@@ -1315,6 +1288,138 @@ public class JSBasicCompletionTestGenerated extends AbstractJSBasicCompletionTes
             }
         }
 
+        @TestMetadata("idea/idea-completion/testData/basic/common/immediateMembers")
+        @TestDataPath("$PROJECT_ROOT")
+        @RunWith(JUnit3RunnerWithInners.class)
+        public static class ImmediateMembers extends AbstractJSBasicCompletionTest {
+            public void testAllFilesPresentInImmediateMembers() throws Exception {
+                JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("idea/idea-completion/testData/basic/common/immediateMembers"), Pattern.compile("^(.+)\\.kt$"), true);
+            }
+
+            @TestMetadata("ImmediateExtensionMembers1.kt")
+            public void testImmediateExtensionMembers1() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/immediateMembers/ImmediateExtensionMembers1.kt");
+                doTest(fileName);
+            }
+
+            @TestMetadata("ImmediateExtensionMembers2.kt")
+            public void testImmediateExtensionMembers2() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/immediateMembers/ImmediateExtensionMembers2.kt");
+                doTest(fileName);
+            }
+
+            @TestMetadata("ImmediateExtensionMembers3.kt")
+            public void testImmediateExtensionMembers3() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/immediateMembers/ImmediateExtensionMembers3.kt");
+                doTest(fileName);
+            }
+
+            @TestMetadata("ImmediateExtensionMembers4.kt")
+            public void testImmediateExtensionMembers4() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/immediateMembers/ImmediateExtensionMembers4.kt");
+                doTest(fileName);
+            }
+
+            @TestMetadata("ImmediateMembers1.kt")
+            public void testImmediateMembers1() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/immediateMembers/ImmediateMembers1.kt");
+                doTest(fileName);
+            }
+
+            @TestMetadata("ImmediateMembers2.kt")
+            public void testImmediateMembers2() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/immediateMembers/ImmediateMembers2.kt");
+                doTest(fileName);
+            }
+
+            @TestMetadata("ImmediateMembers3.kt")
+            public void testImmediateMembers3() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/immediateMembers/ImmediateMembers3.kt");
+                doTest(fileName);
+            }
+
+            @TestMetadata("ImmediateMembers4.kt")
+            public void testImmediateMembers4() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/immediateMembers/ImmediateMembers4.kt");
+                doTest(fileName);
+            }
+
+            @TestMetadata("ImmediateMembers5.kt")
+            public void testImmediateMembers5() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/immediateMembers/ImmediateMembers5.kt");
+                doTest(fileName);
+            }
+        }
+
+        @TestMetadata("idea/idea-completion/testData/basic/common/lambdaSignature")
+        @TestDataPath("$PROJECT_ROOT")
+        @RunWith(JUnit3RunnerWithInners.class)
+        public static class LambdaSignature extends AbstractJSBasicCompletionTest {
+            public void testAllFilesPresentInLambdaSignature() throws Exception {
+                JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("idea/idea-completion/testData/basic/common/lambdaSignature"), Pattern.compile("^(.+)\\.kt$"), true);
+            }
+
+            @TestMetadata("ParameterName1.kt")
+            public void testParameterName1() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/lambdaSignature/ParameterName1.kt");
+                doTest(fileName);
+            }
+
+            @TestMetadata("ParameterName2.kt")
+            public void testParameterName2() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/lambdaSignature/ParameterName2.kt");
+                doTest(fileName);
+            }
+
+            @TestMetadata("ParameterName3.kt")
+            public void testParameterName3() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/lambdaSignature/ParameterName3.kt");
+                doTest(fileName);
+            }
+
+            @TestMetadata("ParameterName4.kt")
+            public void testParameterName4() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/lambdaSignature/ParameterName4.kt");
+                doTest(fileName);
+            }
+
+            @TestMetadata("ParameterName5.kt")
+            public void testParameterName5() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/lambdaSignature/ParameterName5.kt");
+                doTest(fileName);
+            }
+
+            @TestMetadata("ParameterType1.kt")
+            public void testParameterType1() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/lambdaSignature/ParameterType1.kt");
+                doTest(fileName);
+            }
+
+            @TestMetadata("ParameterType2.kt")
+            public void testParameterType2() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/lambdaSignature/ParameterType2.kt");
+                doTest(fileName);
+            }
+
+            @TestMetadata("ParameterType3.kt")
+            public void testParameterType3() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/lambdaSignature/ParameterType3.kt");
+                doTest(fileName);
+            }
+
+            @TestMetadata("ParameterType4.kt")
+            public void testParameterType4() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/lambdaSignature/ParameterType4.kt");
+                doTest(fileName);
+            }
+
+            @TestMetadata("ParameterType5.kt")
+            public void testParameterType5() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/lambdaSignature/ParameterType5.kt");
+                doTest(fileName);
+            }
+        }
+
         @TestMetadata("idea/idea-completion/testData/basic/common/namedArguments")
         @TestDataPath("$PROJECT_ROOT")
         @RunWith(JUnit3RunnerWithInners.class)
@@ -1524,6 +1629,12 @@ public class JSBasicCompletionTestGenerated extends AbstractJSBasicCompletionTes
                 doTest(fileName);
             }
 
+            @TestMetadata("URLConnection.kt")
+            public void testURLConnection() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/parameterNameAndType/URLConnection.kt");
+                doTest(fileName);
+            }
+
             @TestMetadata("UserPrefix1.kt")
             public void testUserPrefix1() throws Exception {
                 String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/parameterNameAndType/UserPrefix1.kt");
@@ -1629,6 +1740,12 @@ public class JSBasicCompletionTestGenerated extends AbstractJSBasicCompletionTes
                 doTest(fileName);
             }
 
+            @TestMetadata("PreferCloserReceiverGeneric.kt")
+            public void testPreferCloserReceiverGeneric() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/shadowing/PreferCloserReceiverGeneric.kt");
+                doTest(fileName);
+            }
+
             @TestMetadata("PreferMemberExtension.kt")
             public void testPreferMemberExtension() throws Exception {
                 String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/shadowing/PreferMemberExtension.kt");
@@ -1652,6 +1769,18 @@ public class JSBasicCompletionTestGenerated extends AbstractJSBasicCompletionTes
                 String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/shadowing/PreferMoreSpecificExtension.kt");
                 doTest(fileName);
             }
+
+            @TestMetadata("PreferMoreSpecificExtensionGeneric.kt")
+            public void testPreferMoreSpecificExtensionGeneric() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/shadowing/PreferMoreSpecificExtensionGeneric.kt");
+                doTest(fileName);
+            }
+
+            @TestMetadata("PreferMoreSpecificExtensionGenericWithParam.kt")
+            public void testPreferMoreSpecificExtensionGenericWithParam() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/shadowing/PreferMoreSpecificExtensionGenericWithParam.kt");
+                doTest(fileName);
+            }
         }
 
         @TestMetadata("idea/idea-completion/testData/basic/common/typeArgsOrNot")
diff --git a/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/JvmBasicCompletionTestGenerated.java b/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/JvmBasicCompletionTestGenerated.java
index cf2aebc8ef5..6f4be44d652 100644
--- a/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/JvmBasicCompletionTestGenerated.java
+++ b/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/JvmBasicCompletionTestGenerated.java
@@ -67,48 +67,6 @@ public class JvmBasicCompletionTestGenerated extends AbstractJvmBasicCompletionT
             JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("idea/idea-completion/testData/basic/common"), Pattern.compile("^(.+)\\.kt$"), true);
         }
 
-        @TestMetadata("BackingFields1.kt")
-        public void testBackingFields1() throws Exception {
-            String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/BackingFields1.kt");
-            doTest(fileName);
-        }
-
-        @TestMetadata("BackingFields2.kt")
-        public void testBackingFields2() throws Exception {
-            String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/BackingFields2.kt");
-            doTest(fileName);
-        }
-
-        @TestMetadata("BackingFields3.kt")
-        public void testBackingFields3() throws Exception {
-            String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/BackingFields3.kt");
-            doTest(fileName);
-        }
-
-        @TestMetadata("BackingFields4.kt")
-        public void testBackingFields4() throws Exception {
-            String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/BackingFields4.kt");
-            doTest(fileName);
-        }
-
-        @TestMetadata("BackingFields5.kt")
-        public void testBackingFields5() throws Exception {
-            String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/BackingFields5.kt");
-            doTest(fileName);
-        }
-
-        @TestMetadata("BackingFields6.kt")
-        public void testBackingFields6() throws Exception {
-            String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/BackingFields6.kt");
-            doTest(fileName);
-        }
-
-        @TestMetadata("BackingFieldsInStringTemplate.kt")
-        public void testBackingFieldsInStringTemplate() throws Exception {
-            String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/BackingFieldsInStringTemplate.kt");
-            doTest(fileName);
-        }
-
         @TestMetadata("BasicAny.kt")
         public void testBasicAny() throws Exception {
             String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/BasicAny.kt");
@@ -259,72 +217,6 @@ public class JvmBasicCompletionTestGenerated extends AbstractJvmBasicCompletionT
             doTest(fileName);
         }
 
-        @TestMetadata("FunctionLiteralParameterName0.kt")
-        public void testFunctionLiteralParameterName0() throws Exception {
-            String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/FunctionLiteralParameterName0.kt");
-            doTest(fileName);
-        }
-
-        @TestMetadata("FunctionLiteralParameterName1.kt")
-        public void testFunctionLiteralParameterName1() throws Exception {
-            String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/FunctionLiteralParameterName1.kt");
-            doTest(fileName);
-        }
-
-        @TestMetadata("FunctionLiteralParameterName2.kt")
-        public void testFunctionLiteralParameterName2() throws Exception {
-            String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/FunctionLiteralParameterName2.kt");
-            doTest(fileName);
-        }
-
-        @TestMetadata("FunctionLiteralParameterName3.kt")
-        public void testFunctionLiteralParameterName3() throws Exception {
-            String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/FunctionLiteralParameterName3.kt");
-            doTest(fileName);
-        }
-
-        @TestMetadata("FunctionLiteralParameterName4.kt")
-        public void testFunctionLiteralParameterName4() throws Exception {
-            String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/FunctionLiteralParameterName4.kt");
-            doTest(fileName);
-        }
-
-        @TestMetadata("FunctionLiteralParameterName5.kt")
-        public void testFunctionLiteralParameterName5() throws Exception {
-            String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/FunctionLiteralParameterName5.kt");
-            doTest(fileName);
-        }
-
-        @TestMetadata("FunctionLiteralParameterType1.kt")
-        public void testFunctionLiteralParameterType1() throws Exception {
-            String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/FunctionLiteralParameterType1.kt");
-            doTest(fileName);
-        }
-
-        @TestMetadata("FunctionLiteralParameterType2.kt")
-        public void testFunctionLiteralParameterType2() throws Exception {
-            String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/FunctionLiteralParameterType2.kt");
-            doTest(fileName);
-        }
-
-        @TestMetadata("FunctionLiteralParameterType3.kt")
-        public void testFunctionLiteralParameterType3() throws Exception {
-            String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/FunctionLiteralParameterType3.kt");
-            doTest(fileName);
-        }
-
-        @TestMetadata("FunctionLiteralParameterType4.kt")
-        public void testFunctionLiteralParameterType4() throws Exception {
-            String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/FunctionLiteralParameterType4.kt");
-            doTest(fileName);
-        }
-
-        @TestMetadata("FunctionLiteralParameterType5.kt")
-        public void testFunctionLiteralParameterType5() throws Exception {
-            String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/FunctionLiteralParameterType5.kt");
-            doTest(fileName);
-        }
-
         @TestMetadata("FunctionVariableCallArgument.kt")
         public void testFunctionVariableCallArgument() throws Exception {
             String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/FunctionVariableCallArgument.kt");
@@ -373,60 +265,6 @@ public class JvmBasicCompletionTestGenerated extends AbstractJvmBasicCompletionT
             doTest(fileName);
         }
 
-        @TestMetadata("ImmediateExtensionMembers1.kt")
-        public void testImmediateExtensionMembers1() throws Exception {
-            String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/ImmediateExtensionMembers1.kt");
-            doTest(fileName);
-        }
-
-        @TestMetadata("ImmediateExtensionMembers2.kt")
-        public void testImmediateExtensionMembers2() throws Exception {
-            String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/ImmediateExtensionMembers2.kt");
-            doTest(fileName);
-        }
-
-        @TestMetadata("ImmediateExtensionMembers3.kt")
-        public void testImmediateExtensionMembers3() throws Exception {
-            String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/ImmediateExtensionMembers3.kt");
-            doTest(fileName);
-        }
-
-        @TestMetadata("ImmediateExtensionMembers4.kt")
-        public void testImmediateExtensionMembers4() throws Exception {
-            String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/ImmediateExtensionMembers4.kt");
-            doTest(fileName);
-        }
-
-        @TestMetadata("ImmediateMembers1.kt")
-        public void testImmediateMembers1() throws Exception {
-            String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/ImmediateMembers1.kt");
-            doTest(fileName);
-        }
-
-        @TestMetadata("ImmediateMembers2.kt")
-        public void testImmediateMembers2() throws Exception {
-            String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/ImmediateMembers2.kt");
-            doTest(fileName);
-        }
-
-        @TestMetadata("ImmediateMembers3.kt")
-        public void testImmediateMembers3() throws Exception {
-            String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/ImmediateMembers3.kt");
-            doTest(fileName);
-        }
-
-        @TestMetadata("ImmediateMembers4.kt")
-        public void testImmediateMembers4() throws Exception {
-            String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/ImmediateMembers4.kt");
-            doTest(fileName);
-        }
-
-        @TestMetadata("ImmediateMembers5.kt")
-        public void testImmediateMembers5() throws Exception {
-            String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/ImmediateMembers5.kt");
-            doTest(fileName);
-        }
-
         @TestMetadata("ImportedEnumMembers.kt")
         public void testImportedEnumMembers() throws Exception {
             String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/ImportedEnumMembers.kt");
@@ -499,12 +337,6 @@ public class JvmBasicCompletionTestGenerated extends AbstractJvmBasicCompletionT
             doTest(fileName);
         }
 
-        @TestMetadata("InFunctionLiteral.kt")
-        public void testInFunctionLiteral() throws Exception {
-            String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/InFunctionLiteral.kt");
-            doTest(fileName);
-        }
-
         @TestMetadata("InGlobalPropertyInitializer.kt")
         public void testInGlobalPropertyInitializer() throws Exception {
             String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/InGlobalPropertyInitializer.kt");
@@ -529,6 +361,12 @@ public class JvmBasicCompletionTestGenerated extends AbstractJvmBasicCompletionT
             doTest(fileName);
         }
 
+        @TestMetadata("InLambda.kt")
+        public void testInLambda() throws Exception {
+            String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/InLambda.kt");
+            doTest(fileName);
+        }
+
         @TestMetadata("InLocalObjectDeclaration.kt")
         public void testInLocalObjectDeclaration() throws Exception {
             String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/InLocalObjectDeclaration.kt");
@@ -1027,6 +865,12 @@ public class JvmBasicCompletionTestGenerated extends AbstractJvmBasicCompletionT
             doTest(fileName);
         }
 
+        @TestMetadata("TopLevelPackageInClassBody.kt")
+        public void testTopLevelPackageInClassBody() throws Exception {
+            String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/TopLevelPackageInClassBody.kt");
+            doTest(fileName);
+        }
+
         @TestMetadata("TypeParameterFromOuterClass.kt")
         public void testTypeParameterFromOuterClass() throws Exception {
             String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/TypeParameterFromOuterClass.kt");
@@ -1047,6 +891,24 @@ public class JvmBasicCompletionTestGenerated extends AbstractJvmBasicCompletionT
                 JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("idea/idea-completion/testData/basic/common/annotations"), Pattern.compile("^(.+)\\.kt$"), true);
             }
 
+            @TestMetadata("Annotated.kt")
+            public void testAnnotated() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/annotations/Annotated.kt");
+                doTest(fileName);
+            }
+
+            @TestMetadata("AnnotationArguments.kt")
+            public void testAnnotationArguments() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/annotations/AnnotationArguments.kt");
+                doTest(fileName);
+            }
+
+            @TestMetadata("AnnotationTarget.kt")
+            public void testAnnotationTarget() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/annotations/AnnotationTarget.kt");
+                doTest(fileName);
+            }
+
             @TestMetadata("FunctionAnnotation1.kt")
             public void testFunctionAnnotation1() throws Exception {
                 String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/annotations/FunctionAnnotation1.kt");
@@ -1180,6 +1042,57 @@ public class JvmBasicCompletionTestGenerated extends AbstractJvmBasicCompletionT
             }
         }
 
+        @TestMetadata("idea/idea-completion/testData/basic/common/backingFields")
+        @TestDataPath("$PROJECT_ROOT")
+        @RunWith(JUnit3RunnerWithInners.class)
+        public static class BackingFields extends AbstractJvmBasicCompletionTest {
+            public void testAllFilesPresentInBackingFields() throws Exception {
+                JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("idea/idea-completion/testData/basic/common/backingFields"), Pattern.compile("^(.+)\\.kt$"), true);
+            }
+
+            @TestMetadata("BackingFields1.kt")
+            public void testBackingFields1() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/backingFields/BackingFields1.kt");
+                doTest(fileName);
+            }
+
+            @TestMetadata("BackingFields2.kt")
+            public void testBackingFields2() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/backingFields/BackingFields2.kt");
+                doTest(fileName);
+            }
+
+            @TestMetadata("BackingFields3.kt")
+            public void testBackingFields3() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/backingFields/BackingFields3.kt");
+                doTest(fileName);
+            }
+
+            @TestMetadata("BackingFields4.kt")
+            public void testBackingFields4() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/backingFields/BackingFields4.kt");
+                doTest(fileName);
+            }
+
+            @TestMetadata("BackingFields5.kt")
+            public void testBackingFields5() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/backingFields/BackingFields5.kt");
+                doTest(fileName);
+            }
+
+            @TestMetadata("BackingFields6.kt")
+            public void testBackingFields6() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/backingFields/BackingFields6.kt");
+                doTest(fileName);
+            }
+
+            @TestMetadata("BackingFieldsInStringTemplate.kt")
+            public void testBackingFieldsInStringTemplate() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/backingFields/BackingFieldsInStringTemplate.kt");
+                doTest(fileName);
+            }
+        }
+
         @TestMetadata("idea/idea-completion/testData/basic/common/extensions")
         @TestDataPath("$PROJECT_ROOT")
         @RunWith(JUnit3RunnerWithInners.class)
@@ -1200,6 +1113,12 @@ public class JvmBasicCompletionTestGenerated extends AbstractJvmBasicCompletionT
                 doTest(fileName);
             }
 
+            @TestMetadata("DoNotHideGetterWhenExtensionCannotBeUsed.kt")
+            public void testDoNotHideGetterWhenExtensionCannotBeUsed() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/extensions/DoNotHideGetterWhenExtensionCannotBeUsed.kt");
+                doTest(fileName);
+            }
+
             @TestMetadata("ExtensionInExtendedClass.kt")
             public void testExtensionInExtendedClass() throws Exception {
                 String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/extensions/ExtensionInExtendedClass.kt");
@@ -1302,6 +1221,60 @@ public class JvmBasicCompletionTestGenerated extends AbstractJvmBasicCompletionT
                 doTest(fileName);
             }
 
+            @TestMetadata("ShowGetMethodWhenNothingElseMatch.kt")
+            public void testShowGetMethodWhenNothingElseMatch() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/extensions/ShowGetMethodWhenNothingElseMatch.kt");
+                doTest(fileName);
+            }
+
+            @TestMetadata("ShowGetSetOnSecondCompletion.kt")
+            public void testShowGetSetOnSecondCompletion() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/extensions/ShowGetSetOnSecondCompletion.kt");
+                doTest(fileName);
+            }
+
+            @TestMetadata("StarTypeArg.kt")
+            public void testStarTypeArg() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/extensions/StarTypeArg.kt");
+                doTest(fileName);
+            }
+
+            @TestMetadata("SyntheticExtensions1.kt")
+            public void testSyntheticExtensions1() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/extensions/SyntheticExtensions1.kt");
+                doTest(fileName);
+            }
+
+            @TestMetadata("SyntheticExtensions2.kt")
+            public void testSyntheticExtensions2() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/extensions/SyntheticExtensions2.kt");
+                doTest(fileName);
+            }
+
+            @TestMetadata("SyntheticExtensionsInGenericClass.kt")
+            public void testSyntheticExtensionsInGenericClass() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/extensions/SyntheticExtensionsInGenericClass.kt");
+                doTest(fileName);
+            }
+
+            @TestMetadata("SyntheticExtensionsSafeCall.kt")
+            public void testSyntheticExtensionsSafeCall() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/extensions/SyntheticExtensionsSafeCall.kt");
+                doTest(fileName);
+            }
+
+            @TestMetadata("SyntheticExtensionsSmartCast.kt")
+            public void testSyntheticExtensionsSmartCast() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/extensions/SyntheticExtensionsSmartCast.kt");
+                doTest(fileName);
+            }
+
+            @TestMetadata("SyntheticExtensionsSmartCast2.kt")
+            public void testSyntheticExtensionsSmartCast2() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/extensions/SyntheticExtensionsSmartCast2.kt");
+                doTest(fileName);
+            }
+
             @TestMetadata("WrongExplicitReceiver.kt")
             public void testWrongExplicitReceiver() throws Exception {
                 String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/extensions/WrongExplicitReceiver.kt");
@@ -1315,6 +1288,138 @@ public class JvmBasicCompletionTestGenerated extends AbstractJvmBasicCompletionT
             }
         }
 
+        @TestMetadata("idea/idea-completion/testData/basic/common/immediateMembers")
+        @TestDataPath("$PROJECT_ROOT")
+        @RunWith(JUnit3RunnerWithInners.class)
+        public static class ImmediateMembers extends AbstractJvmBasicCompletionTest {
+            public void testAllFilesPresentInImmediateMembers() throws Exception {
+                JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("idea/idea-completion/testData/basic/common/immediateMembers"), Pattern.compile("^(.+)\\.kt$"), true);
+            }
+
+            @TestMetadata("ImmediateExtensionMembers1.kt")
+            public void testImmediateExtensionMembers1() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/immediateMembers/ImmediateExtensionMembers1.kt");
+                doTest(fileName);
+            }
+
+            @TestMetadata("ImmediateExtensionMembers2.kt")
+            public void testImmediateExtensionMembers2() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/immediateMembers/ImmediateExtensionMembers2.kt");
+                doTest(fileName);
+            }
+
+            @TestMetadata("ImmediateExtensionMembers3.kt")
+            public void testImmediateExtensionMembers3() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/immediateMembers/ImmediateExtensionMembers3.kt");
+                doTest(fileName);
+            }
+
+            @TestMetadata("ImmediateExtensionMembers4.kt")
+            public void testImmediateExtensionMembers4() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/immediateMembers/ImmediateExtensionMembers4.kt");
+                doTest(fileName);
+            }
+
+            @TestMetadata("ImmediateMembers1.kt")
+            public void testImmediateMembers1() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/immediateMembers/ImmediateMembers1.kt");
+                doTest(fileName);
+            }
+
+            @TestMetadata("ImmediateMembers2.kt")
+            public void testImmediateMembers2() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/immediateMembers/ImmediateMembers2.kt");
+                doTest(fileName);
+            }
+
+            @TestMetadata("ImmediateMembers3.kt")
+            public void testImmediateMembers3() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/immediateMembers/ImmediateMembers3.kt");
+                doTest(fileName);
+            }
+
+            @TestMetadata("ImmediateMembers4.kt")
+            public void testImmediateMembers4() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/immediateMembers/ImmediateMembers4.kt");
+                doTest(fileName);
+            }
+
+            @TestMetadata("ImmediateMembers5.kt")
+            public void testImmediateMembers5() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/immediateMembers/ImmediateMembers5.kt");
+                doTest(fileName);
+            }
+        }
+
+        @TestMetadata("idea/idea-completion/testData/basic/common/lambdaSignature")
+        @TestDataPath("$PROJECT_ROOT")
+        @RunWith(JUnit3RunnerWithInners.class)
+        public static class LambdaSignature extends AbstractJvmBasicCompletionTest {
+            public void testAllFilesPresentInLambdaSignature() throws Exception {
+                JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("idea/idea-completion/testData/basic/common/lambdaSignature"), Pattern.compile("^(.+)\\.kt$"), true);
+            }
+
+            @TestMetadata("ParameterName1.kt")
+            public void testParameterName1() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/lambdaSignature/ParameterName1.kt");
+                doTest(fileName);
+            }
+
+            @TestMetadata("ParameterName2.kt")
+            public void testParameterName2() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/lambdaSignature/ParameterName2.kt");
+                doTest(fileName);
+            }
+
+            @TestMetadata("ParameterName3.kt")
+            public void testParameterName3() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/lambdaSignature/ParameterName3.kt");
+                doTest(fileName);
+            }
+
+            @TestMetadata("ParameterName4.kt")
+            public void testParameterName4() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/lambdaSignature/ParameterName4.kt");
+                doTest(fileName);
+            }
+
+            @TestMetadata("ParameterName5.kt")
+            public void testParameterName5() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/lambdaSignature/ParameterName5.kt");
+                doTest(fileName);
+            }
+
+            @TestMetadata("ParameterType1.kt")
+            public void testParameterType1() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/lambdaSignature/ParameterType1.kt");
+                doTest(fileName);
+            }
+
+            @TestMetadata("ParameterType2.kt")
+            public void testParameterType2() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/lambdaSignature/ParameterType2.kt");
+                doTest(fileName);
+            }
+
+            @TestMetadata("ParameterType3.kt")
+            public void testParameterType3() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/lambdaSignature/ParameterType3.kt");
+                doTest(fileName);
+            }
+
+            @TestMetadata("ParameterType4.kt")
+            public void testParameterType4() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/lambdaSignature/ParameterType4.kt");
+                doTest(fileName);
+            }
+
+            @TestMetadata("ParameterType5.kt")
+            public void testParameterType5() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/lambdaSignature/ParameterType5.kt");
+                doTest(fileName);
+            }
+        }
+
         @TestMetadata("idea/idea-completion/testData/basic/common/namedArguments")
         @TestDataPath("$PROJECT_ROOT")
         @RunWith(JUnit3RunnerWithInners.class)
@@ -1524,6 +1629,12 @@ public class JvmBasicCompletionTestGenerated extends AbstractJvmBasicCompletionT
                 doTest(fileName);
             }
 
+            @TestMetadata("URLConnection.kt")
+            public void testURLConnection() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/parameterNameAndType/URLConnection.kt");
+                doTest(fileName);
+            }
+
             @TestMetadata("UserPrefix1.kt")
             public void testUserPrefix1() throws Exception {
                 String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/parameterNameAndType/UserPrefix1.kt");
@@ -1629,6 +1740,12 @@ public class JvmBasicCompletionTestGenerated extends AbstractJvmBasicCompletionT
                 doTest(fileName);
             }
 
+            @TestMetadata("PreferCloserReceiverGeneric.kt")
+            public void testPreferCloserReceiverGeneric() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/shadowing/PreferCloserReceiverGeneric.kt");
+                doTest(fileName);
+            }
+
             @TestMetadata("PreferMemberExtension.kt")
             public void testPreferMemberExtension() throws Exception {
                 String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/shadowing/PreferMemberExtension.kt");
@@ -1652,6 +1769,18 @@ public class JvmBasicCompletionTestGenerated extends AbstractJvmBasicCompletionT
                 String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/shadowing/PreferMoreSpecificExtension.kt");
                 doTest(fileName);
             }
+
+            @TestMetadata("PreferMoreSpecificExtensionGeneric.kt")
+            public void testPreferMoreSpecificExtensionGeneric() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/shadowing/PreferMoreSpecificExtensionGeneric.kt");
+                doTest(fileName);
+            }
+
+            @TestMetadata("PreferMoreSpecificExtensionGenericWithParam.kt")
+            public void testPreferMoreSpecificExtensionGenericWithParam() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/shadowing/PreferMoreSpecificExtensionGenericWithParam.kt");
+                doTest(fileName);
+            }
         }
 
         @TestMetadata("idea/idea-completion/testData/basic/common/typeArgsOrNot")
diff --git a/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/KotlinCompletionTestCase.java b/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/KotlinCompletionTestCase.java
index bc050dda1d3..97f1ca6afb4 100644
--- a/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/KotlinCompletionTestCase.java
+++ b/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/KotlinCompletionTestCase.java
@@ -16,8 +16,10 @@
 
 package org.jetbrains.kotlin.idea.completion.test;
 
+import com.intellij.codeInsight.CodeInsightSettings;
 import com.intellij.codeInsight.completion.CompletionTestCase;
 import com.intellij.openapi.vfs.newvfs.impl.VfsRootAccess;
+import com.intellij.util.ArrayUtil;
 import org.jetbrains.kotlin.test.JetTestUtils;
 
 abstract public class KotlinCompletionTestCase extends CompletionTestCase {
@@ -25,10 +27,12 @@ abstract public class KotlinCompletionTestCase extends CompletionTestCase {
     protected void setUp() throws Exception {
         super.setUp();
         VfsRootAccess.allowRootAccess(JetTestUtils.getHomeDirectory());
+        CodeInsightSettings.getInstance().EXCLUDED_PACKAGES = new String[]{"excludedPackage", "somePackage.ExcludedClass"};
     }
 
     @Override
     protected void tearDown() throws Exception {
+        CodeInsightSettings.getInstance().EXCLUDED_PACKAGES = ArrayUtil.EMPTY_STRING_ARRAY;
         VfsRootAccess.disallowRootAccess(JetTestUtils.getHomeDirectory());
         super.tearDown();
     }
diff --git a/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/MultiFileJvmBasicCompletionTestGenerated.java b/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/MultiFileJvmBasicCompletionTestGenerated.java
index a4427324377..dc47865b47f 100644
--- a/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/MultiFileJvmBasicCompletionTestGenerated.java
+++ b/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/MultiFileJvmBasicCompletionTestGenerated.java
@@ -35,6 +35,18 @@ public class MultiFileJvmBasicCompletionTestGenerated extends AbstractMultiFileJ
         JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("idea/idea-completion/testData/basic/multifile"), Pattern.compile("^([^\\.]+)$"), false);
     }
 
+    @TestMetadata("CallablesInExcludedPackage")
+    public void testCallablesInExcludedPackage() throws Exception {
+        String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/multifile/CallablesInExcludedPackage/");
+        doTest(fileName);
+    }
+
+    @TestMetadata("ClassInExcludedPackage")
+    public void testClassInExcludedPackage() throws Exception {
+        String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/multifile/ClassInExcludedPackage/");
+        doTest(fileName);
+    }
+
     @TestMetadata("CompleteFunctionWithNoSpecifiedType")
     public void testCompleteFunctionWithNoSpecifiedType() throws Exception {
         String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/multifile/CompleteFunctionWithNoSpecifiedType/");
@@ -65,6 +77,18 @@ public class MultiFileJvmBasicCompletionTestGenerated extends AbstractMultiFileJ
         doTest(fileName);
     }
 
+    @TestMetadata("ExcludedClass")
+    public void testExcludedClass() throws Exception {
+        String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/multifile/ExcludedClass/");
+        doTest(fileName);
+    }
+
+    @TestMetadata("ExcludedJavaClass")
+    public void testExcludedJavaClass() throws Exception {
+        String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/multifile/ExcludedJavaClass/");
+        doTest(fileName);
+    }
+
     @TestMetadata("ExtensionFunction")
     public void testExtensionFunction() throws Exception {
         String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/multifile/ExtensionFunction/");
@@ -107,12 +131,24 @@ public class MultiFileJvmBasicCompletionTestGenerated extends AbstractMultiFileJ
         doTest(fileName);
     }
 
+    @TestMetadata("IncorrectGetters")
+    public void testIncorrectGetters() throws Exception {
+        String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/multifile/IncorrectGetters/");
+        doTest(fileName);
+    }
+
     @TestMetadata("JavaInnerClasses")
     public void testJavaInnerClasses() throws Exception {
         String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/multifile/JavaInnerClasses/");
         doTest(fileName);
     }
 
+    @TestMetadata("MoreSpecificExtensionGeneric")
+    public void testMoreSpecificExtensionGeneric() throws Exception {
+        String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/multifile/MoreSpecificExtensionGeneric/");
+        doTest(fileName);
+    }
+
     @TestMetadata("MoreSpecificExtensionInDifferentPackage")
     public void testMoreSpecificExtensionInDifferentPackage() throws Exception {
         String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/multifile/MoreSpecificExtensionInDifferentPackage/");
@@ -251,6 +287,12 @@ public class MultiFileJvmBasicCompletionTestGenerated extends AbstractMultiFileJ
         doTest(fileName);
     }
 
+    @TestMetadata("SyntheticExtensionForGenericClass")
+    public void testSyntheticExtensionForGenericClass() throws Exception {
+        String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/multifile/SyntheticExtensionForGenericClass/");
+        doTest(fileName);
+    }
+
     @TestMetadata("TopLevelFunction")
     public void testTopLevelFunction() throws Exception {
         String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/multifile/TopLevelFunction/");
diff --git a/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/MultiFileSmartCompletionTestGenerated.java b/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/MultiFileSmartCompletionTestGenerated.java
index 44a8e4b6f6c..7caa52e3573 100644
--- a/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/MultiFileSmartCompletionTestGenerated.java
+++ b/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/MultiFileSmartCompletionTestGenerated.java
@@ -41,6 +41,12 @@ public class MultiFileSmartCompletionTestGenerated extends AbstractMultiFileSmar
         doTest(fileName);
     }
 
+    @TestMetadata("CallablesInExcludedPackage")
+    public void testCallablesInExcludedPackage() throws Exception {
+        String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/smartMultiFile/CallablesInExcludedPackage/");
+        doTest(fileName);
+    }
+
     @TestMetadata("FunctionFromAnotherPackage")
     public void testFunctionFromAnotherPackage() throws Exception {
         String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/smartMultiFile/FunctionFromAnotherPackage/");
diff --git a/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/handlers/BasicCompletionHandlerTestGenerated.java b/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/handlers/BasicCompletionHandlerTestGenerated.java
index 7ceff4eafc6..7f62698685d 100644
--- a/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/handlers/BasicCompletionHandlerTestGenerated.java
+++ b/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/handlers/BasicCompletionHandlerTestGenerated.java
@@ -119,6 +119,12 @@ public class BasicCompletionHandlerTestGenerated extends AbstractBasicCompletion
         doTest(fileName);
     }
 
+    @TestMetadata("SyntheticExtension.kt")
+    public void testSyntheticExtension() throws Exception {
+        String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/handlers/basic/SyntheticExtension.kt");
+        doTest(fileName);
+    }
+
     @TestMetadata("idea/idea-completion/testData/handlers/basic/exclChar")
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
@@ -220,6 +226,12 @@ public class BasicCompletionHandlerTestGenerated extends AbstractBasicCompletion
             doTest(fileName);
         }
 
+        @TestMetadata("ParameterTypeIsDerivedFromFunction.kt")
+        public void testParameterTypeIsDerivedFromFunction() throws Exception {
+            String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/handlers/basic/highOrderFunctions/ParameterTypeIsDerivedFromFunction.kt");
+            doTest(fileName);
+        }
+
         @TestMetadata("ReplaceByLambdaTemplateNoClosingParenth.kt")
         public void testReplaceByLambdaTemplateNoClosingParenth() throws Exception {
             String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/handlers/basic/highOrderFunctions/ReplaceByLambdaTemplateNoClosingParenth.kt");
diff --git a/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/handlers/SmartCompletionHandlerTestGenerated.java b/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/handlers/SmartCompletionHandlerTestGenerated.java
index a1116032f39..f49c5a68b8a 100644
--- a/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/handlers/SmartCompletionHandlerTestGenerated.java
+++ b/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/handlers/SmartCompletionHandlerTestGenerated.java
@@ -443,6 +443,12 @@ public class SmartCompletionHandlerTestGenerated extends AbstractSmartCompletion
         doTest(fileName);
     }
 
+    @TestMetadata("kt6179filterTo.kt")
+    public void testKt6179filterTo() throws Exception {
+        String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/handlers/smart/kt6179filterTo.kt");
+        doTest(fileName);
+    }
+
     @TestMetadata("Lambda1.kt")
     public void testLambda1() throws Exception {
         String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/handlers/smart/Lambda1.kt");
diff --git a/idea/idea-core/src/org/jetbrains/kotlin/idea/core/KotlinIndicesHelper.kt b/idea/idea-core/src/org/jetbrains/kotlin/idea/core/KotlinIndicesHelper.kt
index f66331389cd..09f9f8b248b 100644
--- a/idea/idea-core/src/org/jetbrains/kotlin/idea/core/KotlinIndicesHelper.kt
+++ b/idea/idea-core/src/org/jetbrains/kotlin/idea/core/KotlinIndicesHelper.kt
@@ -16,12 +16,16 @@
 
 package org.jetbrains.kotlin.idea.core
 
+import com.intellij.codeInsight.CodeInsightSettings
 import com.intellij.openapi.project.Project
 import com.intellij.psi.search.GlobalSearchScope
+import com.intellij.psi.search.PsiShortNamesCache
 import com.intellij.psi.stubs.StringStubIndexExtension
 import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.idea.caches.resolve.ResolutionFacade
+import org.jetbrains.kotlin.idea.caches.resolve.getResolutionFacade
 import org.jetbrains.kotlin.idea.codeInsight.ReferenceVariantsHelper
+import org.jetbrains.kotlin.idea.imports.importableFqName
 import org.jetbrains.kotlin.idea.stubindex.*
 import org.jetbrains.kotlin.idea.util.CallType
 import org.jetbrains.kotlin.idea.util.getImplicitReceiversWithInstance
@@ -48,8 +52,15 @@ public class KotlinIndicesHelper(
         private val resolutionFacade: ResolutionFacade,
         private val scope: GlobalSearchScope,
         private val moduleDescriptor: ModuleDescriptor,
-        private val visibilityFilter: (DeclarationDescriptor) -> Boolean
+        visibilityFilter: (DeclarationDescriptor) -> Boolean,
+        applyExcludeSettings: Boolean
 ) {
+    private val descriptorFilter =
+            if (applyExcludeSettings)
+                { d -> visibilityFilter(d) && !isExcludedFromAutoImport(d) }
+            else
+                visibilityFilter
+
     public fun getTopLevelCallablesByName(name: String): Collection<CallableDescriptor> {
         val declarations = HashSet<JetNamedDeclaration>()
         declarations.addTopLevelNonExtensionCallablesByName(JetFunctionShortNameIndex.getInstance(), name)
@@ -61,7 +72,7 @@ public class KotlinIndicesHelper(
             else {
                 (resolutionFacade.resolveToDescriptor(it) as? CallableDescriptor).singletonOrEmptyList()
             }
-        }.filter { it.getExtensionReceiverParameter() == null && visibilityFilter(it) }
+        }.filter { it.getExtensionReceiverParameter() == null && descriptorFilter(it) }
     }
 
     private fun MutableSet<JetNamedDeclaration>.addTopLevelNonExtensionCallablesByName(
@@ -77,7 +88,7 @@ public class KotlinIndicesHelper(
                 .map { FqName(it) }
                 .filter { nameFilter(it.shortName().asString()) }
                 .toSet()
-                .flatMap { findTopLevelCallables(it).filter(visibilityFilter) }
+                .flatMap { findTopLevelCallables(it).filter(descriptorFilter) }
     }
 
     public fun getCallableTopLevelExtensions(nameFilter: (String) -> Boolean, expression: JetSimpleNameExpression, bindingContext: BindingContext): Collection<CallableDescriptor> {
@@ -147,7 +158,7 @@ public class KotlinIndicesHelper(
         val result = LinkedHashSet<CallableDescriptor>()
 
         fun processDescriptor(descriptor: CallableDescriptor) {
-            if (visibilityFilter(descriptor)) {
+            if (descriptorFilter(descriptor)) {
                 for ((receiverValue, callType) in receiverValues) {
                     result.addAll(descriptor.substituteExtensionIfCallable(receiverValue, callType, bindingContext, dataFlowInfo, moduleDescriptor))
                 }
@@ -171,7 +182,14 @@ public class KotlinIndicesHelper(
         return result
     }
 
-    public fun getClassDescriptors(nameFilter: (String) -> Boolean, kindFilter: (ClassKind) -> Boolean): Collection<ClassDescriptor> {
+    public fun getJvmClassesByName(name: String): Collection<ClassifierDescriptor>
+            = PsiShortNamesCache.getInstance(project).getClassesByName(name, scope)
+            .map { resolutionFacade.psiClassToDescriptor(it) }
+            .filterNotNull()
+            .filter(descriptorFilter)
+            .toSet()
+
+    public fun getKotlinClasses(nameFilter: (String) -> Boolean, kindFilter: (ClassKind) -> Boolean): Collection<ClassDescriptor> {
         return JetFullClassNameIndex.getInstance().getAllKeys(project).asSequence()
                 .map { FqName(it) }
                 .filter { nameFilter(it.shortName().asString()) }
@@ -189,7 +207,7 @@ public class KotlinIndicesHelper(
 
         // Note: Can't search with psi element as analyzer could be built over temp files
         return ResolveSessionUtils.getClassOrObjectDescriptorsByFqName(moduleDescriptor, classFQName) { kindFilter(it.getKind()) }
-                .filter(visibilityFilter)
+                .filter(descriptorFilter)
     }
 
     private fun findTopLevelCallables(fqName: FqName): Collection<CallableDescriptor> {
@@ -197,4 +215,12 @@ public class KotlinIndicesHelper(
                 .filterIsInstance<CallableDescriptor>()
                 .filter { it.getExtensionReceiverParameter() == null }
     }
+
+    private fun isExcludedFromAutoImport(descriptor: DeclarationDescriptor): Boolean {
+        val fqName = descriptor.importableFqName?.asString() ?: return false
+
+        return CodeInsightSettings.getInstance().EXCLUDED_PACKAGES
+                .any { excluded -> fqName == excluded || (fqName.startsWith(excluded) && fqName[excluded.length()] == '.') }
+    }
 }
+
diff --git a/idea/idea-core/src/org/jetbrains/kotlin/idea/core/KotlinNameSuggester.kt b/idea/idea-core/src/org/jetbrains/kotlin/idea/core/KotlinNameSuggester.kt
index f3e064b0f12..0c184a5fe8e 100644
--- a/idea/idea-core/src/org/jetbrains/kotlin/idea/core/KotlinNameSuggester.kt
+++ b/idea/idea-core/src/org/jetbrains/kotlin/idea/core/KotlinNameSuggester.kt
@@ -26,6 +26,7 @@ import org.jetbrains.kotlin.types.ErrorUtils
 import org.jetbrains.kotlin.types.JetType
 import org.jetbrains.kotlin.types.TypeUtils
 import org.jetbrains.kotlin.types.checker.JetTypeChecker
+import org.jetbrains.kotlin.util.capitalizeDecapitalize.decapitalizeSmart
 import java.util.*
 import java.util.regex.Pattern
 
@@ -240,12 +241,12 @@ public object KotlinNameSuggester {
             val upperCaseLetter = Character.isUpperCase(c)
 
             if (i == 0) {
-                addName(if (startLowerCase) decapitalize(s) else s, validator)
+                addName(if (startLowerCase) s.decapitalizeSmart() else s, validator)
             }
             else {
                 if (upperCaseLetter && !upperCaseLetterBefore) {
                     val substring = s.substring(i)
-                    addName(if (startLowerCase) decapitalize(substring) else substring, validator)
+                    addName(if (startLowerCase) substring.decapitalizeSmart() else substring, validator)
                 }
             }
 
@@ -253,27 +254,6 @@ public object KotlinNameSuggester {
         }
     }
 
-    private fun decapitalize(s: String): String {
-        var c = s.charAt(0)
-        if (!Character.isUpperCase(c)) return s
-
-        val builder = StringBuilder(s.length())
-        var decapitalize = true
-        for (i in 0..s.length() - 1) {
-            c = s.charAt(i)
-            if (decapitalize) {
-                if (Character.isUpperCase(c)) {
-                    c = Character.toLowerCase(c)
-                }
-                else {
-                    decapitalize = false
-                }
-            }
-            builder.append(c)
-        }
-        return builder.toString()
-    }
-
     private fun deleteNonLetterFromString(s: String): String {
         val pattern = Pattern.compile("[^a-zA-Z]")
         val matcher = pattern.matcher(s)
diff --git a/idea/idea-core/src/org/jetbrains/kotlin/idea/core/SmartCastCalculator.kt b/idea/idea-core/src/org/jetbrains/kotlin/idea/core/SmartCastCalculator.kt
index 4f0ffc01eed..057f44d30db 100644
--- a/idea/idea-core/src/org/jetbrains/kotlin/idea/core/SmartCastCalculator.kt
+++ b/idea/idea-core/src/org/jetbrains/kotlin/idea/core/SmartCastCalculator.kt
@@ -32,7 +32,7 @@ import java.util.HashMap
 import java.util.HashSet
 import com.intellij.openapi.util.Pair
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
-import org.jetbrains.kotlin.idea.util.makeNotNullable
+import org.jetbrains.kotlin.types.typeUtil.makeNotNullable
 import org.jetbrains.kotlin.resolve.calls.context.ResolutionContext
 import org.jetbrains.kotlin.utils.singletonOrEmptyList
 
diff --git a/idea/idea-core/src/org/jetbrains/kotlin/idea/core/completion/DeclarationLookupObject.kt b/idea/idea-core/src/org/jetbrains/kotlin/idea/core/completion/DeclarationLookupObject.kt
index 654eafb4247..d775f073b8f 100644
--- a/idea/idea-core/src/org/jetbrains/kotlin/idea/core/completion/DeclarationLookupObject.kt
+++ b/idea/idea-core/src/org/jetbrains/kotlin/idea/core/completion/DeclarationLookupObject.kt
@@ -19,9 +19,13 @@ package org.jetbrains.kotlin.idea.core.completion
 import com.intellij.openapi.util.Iconable
 import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
+import org.jetbrains.kotlin.name.FqName
+import org.jetbrains.kotlin.name.Name
 
 public interface DeclarationLookupObject : Iconable {
     public val psiElement: PsiElement?
     public val descriptor: DeclarationDescriptor?
+    public val name: Name?
+    public val importableFqName: FqName?
     public val isDeprecated: Boolean
 }
diff --git a/idea/idea-core/src/org/jetbrains/kotlin/idea/core/descriptorUtils.kt b/idea/idea-core/src/org/jetbrains/kotlin/idea/core/descriptorUtils.kt
index 9a39a6ba284..ffee1ebd989 100644
--- a/idea/idea-core/src/org/jetbrains/kotlin/idea/core/descriptorUtils.kt
+++ b/idea/idea-core/src/org/jetbrains/kotlin/idea/core/descriptorUtils.kt
@@ -38,7 +38,7 @@ fun DeclarationDescriptorWithVisibility.isVisible(
 
     val receiver = element.getReceiverExpression()
     val type = receiver?.let { bindingContext.getType(it) }
-    val explicitReceiver = type?.let { ExpressionReceiver(receiver, it) }
+    val explicitReceiver = type?.let { ExpressionReceiver(receiver!!, it) }
 
     if (explicitReceiver != null) {
         val normalizeReceiver = ExpressionTypingUtils.normalizeReceiverValueForVisibility(explicitReceiver, bindingContext)
diff --git a/idea/idea-test-framework/src/org/jetbrains/kotlin/idea/test/KotlinCodeInsightTestCase.java b/idea/idea-test-framework/src/org/jetbrains/kotlin/idea/test/KotlinCodeInsightTestCase.java
index cf6072516e0..5eca6676619 100644
--- a/idea/idea-test-framework/src/org/jetbrains/kotlin/idea/test/KotlinCodeInsightTestCase.java
+++ b/idea/idea-test-framework/src/org/jetbrains/kotlin/idea/test/KotlinCodeInsightTestCase.java
@@ -23,13 +23,13 @@ import org.jetbrains.kotlin.test.JetTestUtils;
 public abstract class KotlinCodeInsightTestCase extends CodeInsightTestCase {
     @Override
     protected void setUp() throws Exception {
-        super.setUp();
         VfsRootAccess.allowRootAccess(JetTestUtils.getHomeDirectory());
+        super.setUp();
     }
 
     @Override
     protected void tearDown() throws Exception {
-        VfsRootAccess.disallowRootAccess(JetTestUtils.getHomeDirectory());
         super.tearDown();
+        VfsRootAccess.disallowRootAccess(JetTestUtils.getHomeDirectory());
     }
 }
diff --git a/idea/kotlin-android-plugin/kotlin-android-plugin.iml b/idea/kotlin-android-plugin/kotlin-android-plugin.iml
index 00cb2b04cd1..894dae4c845 100644
--- a/idea/kotlin-android-plugin/kotlin-android-plugin.iml
+++ b/idea/kotlin-android-plugin/kotlin-android-plugin.iml
@@ -11,5 +11,6 @@
     <orderEntry type="library" name="idea-full" level="project" />
     <orderEntry type="module" module-name="frontend" />
     <orderEntry type="module" module-name="util" />
+    <orderEntry type="module" module-name="idea-analysis" />
   </component>
 </module>
\ No newline at end of file
diff --git a/idea/kotlin-android-plugin/src/org/jetbrains/kotlin/android/KotlinOutputParserHelper.kt b/idea/kotlin-android-plugin/src/org/jetbrains/kotlin/android/KotlinOutputParserHelper.kt
index d0f6aed7714..df22920317b 100644
--- a/idea/kotlin-android-plugin/src/org/jetbrains/kotlin/android/KotlinOutputParserHelper.kt
+++ b/idea/kotlin-android-plugin/src/org/jetbrains/kotlin/android/KotlinOutputParserHelper.kt
@@ -212,7 +212,7 @@ object KotlinOutputParserHelper {
                                else
                                     Class.forName("$packagePrefix.GradleMessage\$Kind")
 
-        val messageKindConstants = messageKindClass.getEnumConstants()
+        val messageKindConstants = messageKindClass.getEnumConstants() as Array<Any>
         for (kind in messageKindConstants) {
             when(kind.toString()) {
                 "ERROR" -> severityObjectMap.put("e", kind)
diff --git a/idea/kotlin-android-plugin/src/org/jetbrains/kotlin/android/navigation/gotoResourceHelper.kt b/idea/kotlin-android-plugin/src/org/jetbrains/kotlin/android/navigation/gotoResourceHelper.kt
index 02706282ea4..8ca8649ef67 100644
--- a/idea/kotlin-android-plugin/src/org/jetbrains/kotlin/android/navigation/gotoResourceHelper.kt
+++ b/idea/kotlin-android-plugin/src/org/jetbrains/kotlin/android/navigation/gotoResourceHelper.kt
@@ -25,6 +25,7 @@ import com.intellij.psi.PsiClass
 import org.jetbrains.android.util.AndroidUtils
 import com.android.SdkConstants
 import org.jetbrains.android.augment.AndroidPsiElementFinder
+import org.jetbrains.kotlin.idea.references.mainReference
 import org.jetbrains.kotlin.psi.JetDotQualifiedExpression
 import org.jetbrains.kotlin.psi.psiUtil.getReceiverExpression
 import org.jetbrains.kotlin.psi.JetExpression
@@ -65,9 +66,7 @@ private fun getReferredInfo(
 
     val firstPart = getReceiverAsSimpleNameExpression(middlePart) ?: return null
 
-    val reference = firstPart.getReference() ?: return null
-
-    val resolvedClass = reference.resolve() as? PsiClass ?: return null
+    val resolvedClass = firstPart.mainReference.resolve() as? PsiClass ?: return null
 
     //the following code is copied from
     // org.jetbrains.android.util.AndroidResourceUtil.getReferredResourceOrManifestField
diff --git a/idea/resources/inspectionDescriptions/UsePropertyAccessSyntax.html b/idea/resources/inspectionDescriptions/UsePropertyAccessSyntax.html
new file mode 100644
index 00000000000..718fb306473
--- /dev/null
+++ b/idea/resources/inspectionDescriptions/UsePropertyAccessSyntax.html
@@ -0,0 +1,5 @@
+<html>
+<body>
+This inspection reports calls to java get and set methods that can be replaced with use of Kotlin synthetic properties.
+</body>
+</html>
diff --git a/idea/resources/intentionDescriptions/UsePropertyAccessSyntaxIntention/after.kt.template b/idea/resources/intentionDescriptions/UsePropertyAccessSyntaxIntention/after.kt.template
new file mode 100644
index 00000000000..3351cf05bec
--- /dev/null
+++ b/idea/resources/intentionDescriptions/UsePropertyAccessSyntaxIntention/after.kt.template
@@ -0,0 +1,3 @@
+fun foo(thread: Thread) {
+    <spot>thread.daemon = true</spot>
+}
diff --git a/idea/resources/intentionDescriptions/UsePropertyAccessSyntaxIntention/before.kt.template b/idea/resources/intentionDescriptions/UsePropertyAccessSyntaxIntention/before.kt.template
new file mode 100644
index 00000000000..17249916001
--- /dev/null
+++ b/idea/resources/intentionDescriptions/UsePropertyAccessSyntaxIntention/before.kt.template
@@ -0,0 +1,3 @@
+fun foo(thread: Thread) {
+    <spot>thread.setDaemon(true)</spot>
+}
diff --git a/idea/resources/intentionDescriptions/UsePropertyAccessSyntaxIntention/description.html b/idea/resources/intentionDescriptions/UsePropertyAccessSyntaxIntention/description.html
new file mode 100644
index 00000000000..cca81724012
--- /dev/null
+++ b/idea/resources/intentionDescriptions/UsePropertyAccessSyntaxIntention/description.html
@@ -0,0 +1,5 @@
+<html>
+<body>
+This inspection replaces calls to java get and set methods with use of Kotlin synthetic properties.
+</body>
+</html>
\ No newline at end of file
diff --git a/idea/resources/org/jetbrains/kotlin/idea/icons/interfaceKotlin.png b/idea/resources/org/jetbrains/kotlin/idea/icons/interfaceKotlin.png
new file mode 100644
index 00000000000..24f2572f35d
Binary files /dev/null and b/idea/resources/org/jetbrains/kotlin/idea/icons/interfaceKotlin.png differ
diff --git a/idea/resources/org/jetbrains/kotlin/idea/icons/interfaceKotlin@2x.png b/idea/resources/org/jetbrains/kotlin/idea/icons/interfaceKotlin@2x.png
new file mode 100644
index 00000000000..54dd8814fb4
Binary files /dev/null and b/idea/resources/org/jetbrains/kotlin/idea/icons/interfaceKotlin@2x.png differ
diff --git a/idea/resources/org/jetbrains/kotlin/idea/icons/interfaceKotlin@2x_dark.png b/idea/resources/org/jetbrains/kotlin/idea/icons/interfaceKotlin@2x_dark.png
new file mode 100644
index 00000000000..af7dd90b81c
Binary files /dev/null and b/idea/resources/org/jetbrains/kotlin/idea/icons/interfaceKotlin@2x_dark.png differ
diff --git a/idea/resources/org/jetbrains/kotlin/idea/icons/interfaceKotlin_dark.png b/idea/resources/org/jetbrains/kotlin/idea/icons/interfaceKotlin_dark.png
new file mode 100644
index 00000000000..107044ac0a4
Binary files /dev/null and b/idea/resources/org/jetbrains/kotlin/idea/icons/interfaceKotlin_dark.png differ
diff --git a/idea/resources/org/jetbrains/kotlin/idea/icons/traitKotlin.png b/idea/resources/org/jetbrains/kotlin/idea/icons/traitKotlin.png
deleted file mode 100644
index fe77edfa20a..00000000000
Binary files a/idea/resources/org/jetbrains/kotlin/idea/icons/traitKotlin.png and /dev/null differ
diff --git a/idea/resources/org/jetbrains/kotlin/idea/icons/traitKotlin@2x.png b/idea/resources/org/jetbrains/kotlin/idea/icons/traitKotlin@2x.png
deleted file mode 100644
index 96dfd969eaf..00000000000
Binary files a/idea/resources/org/jetbrains/kotlin/idea/icons/traitKotlin@2x.png and /dev/null differ
diff --git a/idea/resources/org/jetbrains/kotlin/idea/icons/traitKotlin@2x_dark.png b/idea/resources/org/jetbrains/kotlin/idea/icons/traitKotlin@2x_dark.png
deleted file mode 100644
index 11e1afdcebf..00000000000
Binary files a/idea/resources/org/jetbrains/kotlin/idea/icons/traitKotlin@2x_dark.png and /dev/null differ
diff --git a/idea/resources/org/jetbrains/kotlin/idea/icons/traitKotlin_dark.png b/idea/resources/org/jetbrains/kotlin/idea/icons/traitKotlin_dark.png
deleted file mode 100644
index fa29550504a..00000000000
Binary files a/idea/resources/org/jetbrains/kotlin/idea/icons/traitKotlin_dark.png and /dev/null differ
diff --git a/idea/src/META-INF/extensions/common.xml b/idea/src/META-INF/extensions/common.xml
index 13707352502..f33953893b8 100644
--- a/idea/src/META-INF/extensions/common.xml
+++ b/idea/src/META-INF/extensions/common.xml
@@ -23,5 +23,7 @@
         <extensionPoint name="classBuilderInterceptorExtension"
                         interface="org.jetbrains.kotlin.codegen.extensions.ClassBuilderInterceptorExtension"
                         area="IDEA_PROJECT"/>
+        <extensionPoint name="quickFixContributor"
+                        interface="org.jetbrains.kotlin.idea.quickfix.QuickFixContributor"/>
     </extensionPoints>
 </idea-plugin>
diff --git a/idea/src/META-INF/junit.xml b/idea/src/META-INF/junit.xml
index fe8cea18191..7484657e0f0 100644
--- a/idea/src/META-INF/junit.xml
+++ b/idea/src/META-INF/junit.xml
@@ -1,5 +1,5 @@
 <idea-plugin>
   <extensions defaultExtensionNs="com.intellij">
-    <configurationProducer implementation="org.jetbrains.kotlin.idea.run.JetJUnitConfigurationProducer"/>
+    <runConfigurationProducer implementation="org.jetbrains.kotlin.idea.run.KotlinJUnitRunConfigurationProducer"/>
   </extensions>
 </idea-plugin>
diff --git a/idea/src/META-INF/plugin.xml b/idea/src/META-INF/plugin.xml
index e16b0715bf2..4e29e4aeba4 100644
--- a/idea/src/META-INF/plugin.xml
+++ b/idea/src/META-INF/plugin.xml
@@ -34,11 +34,8 @@
       <implementation-class>org.jetbrains.kotlin.idea.ktSignature.KotlinSignatureInJavaMarkerUpdater</implementation-class>
     </component>
     <component>
-      <implementation-class>org.jetbrains.kotlin.idea.configuration.ui.AbsentJdkAnnotationsComponent</implementation-class>
+      <implementation-class>org.jetbrains.kotlin.idea.js.KotlinJavaScriptLibraryManager</implementation-class>
     </component>
-      <component>
-          <implementation-class>org.jetbrains.kotlin.idea.js.KotlinJavaScriptLibraryManager</implementation-class>
-      </component>
   </project-components>
 
  <application-components>
@@ -168,6 +165,9 @@
     <applicationService serviceInterface="org.jetbrains.kotlin.idea.configuration.JetModuleTypeManager"
                         serviceImplementation="org.jetbrains.kotlin.idea.JetModuleTypeManagerImpl"/>
 
+    <applicationService serviceInterface="org.jetbrains.kotlin.idea.quickfix.QuickFixes"
+                        serviceImplementation="org.jetbrains.kotlin.idea.quickfix.QuickFixes"/>
+
     <projectService serviceInterface="org.jetbrains.kotlin.idea.util.ImportInsertHelper"
                         serviceImplementation="org.jetbrains.kotlin.util.ImportInsertHelperImpl"/>
 
@@ -290,7 +290,7 @@
     <inlineActionHandler implementation="org.jetbrains.kotlin.idea.refactoring.inline.KotlinInlineValHandler"/>
     <treeStructureProvider implementation="org.jetbrains.kotlin.idea.projectView.JetProjectViewProvider"/>
 
-    <colorSettingsPage implementation="org.jetbrains.kotlin.idea.highlighter.JetColorSettingsPage"/>
+    <colorSettingsPage implementation="org.jetbrains.kotlin.idea.highlighter.KotlinColorSettingsPage"/>
     <additionalTextAttributes scheme="Default" file="colorScheme/Default_Kotlin.xml"/>
     <additionalTextAttributes scheme="Darcula" file="colorScheme/Darcula_Kotlin.xml"/>
 
@@ -322,6 +322,7 @@
     <completion.confidence language="jet" implementationClass="com.intellij.codeInsight.completion.AlwaysFocusLookup" order="last"/>
 
     <lookup.charFilter implementation="org.jetbrains.kotlin.idea.completion.KotlinCompletionCharFilter"/>
+    <lookup.actionProvider implementation="org.jetbrains.kotlin.idea.completion.KotlinExcludeFromCompletionLookupActionProvider"/>
 
     <psi.referenceContributor language="jet" implementation="org.jetbrains.kotlin.idea.references.JetReferenceContributor"/>
 
@@ -391,7 +392,7 @@
     <configurationType implementation="org.jetbrains.kotlin.idea.run.JetRunConfigurationType"/>
     <configurationType implementation="org.jetbrains.kotlin.idea.k2jsrun.K2JSRunConfigurationType"/>
     <programRunner implementation="org.jetbrains.kotlin.idea.k2jsrun.K2JSBrowserProgramRunner"/>
-    <configurationProducer implementation="org.jetbrains.kotlin.idea.run.JetRunConfigurationProducer"/>
+    <runConfigurationProducer implementation="org.jetbrains.kotlin.idea.run.KotlinRunConfigurationProducer"/>
     <codeInsight.lineMarkerProvider language="jet" implementationClass="org.jetbrains.kotlin.idea.highlighter.markers.KotlinLineMarkerProvider"/>
     <codeInsight.lineMarkerProvider language="jet" implementationClass="org.jetbrains.kotlin.idea.highlighter.KotlinRecursiveCallLineMarkerProvider"/>
     <codeInsight.lineMarkerProvider language="JAVA"
@@ -498,7 +499,7 @@
     <directClassInheritorsSearch implementation="org.jetbrains.kotlin.idea.search.ideaExtensions.KotlinDirectInheritorsSearcher"/>
     <definitionsScopedSearch implementation="org.jetbrains.kotlin.idea.search.ideaExtensions.KotlinDefinitionsSearcher"/>
     <annotatedElementsSearch implementation="org.jetbrains.kotlin.idea.search.ideaExtensions.KotlinAnnotatedElementsSearcher"/>
-    <methodReferencesSearch implementation="org.jetbrains.kotlin.idea.search.ideaExtensions.KotlinLightPropertyAccessorsReferenceSearcher"/>
+    <methodReferencesSearch implementation="org.jetbrains.kotlin.idea.search.ideaExtensions.KotlinPropertyAccessorsReferenceSearcher"/>
     <methodReferencesSearch implementation="org.jetbrains.kotlin.idea.search.ideaExtensions.KotlinConstructorDelegationCallReferenceSearcher"/>
     <methodReferencesSearch implementation="org.jetbrains.kotlin.idea.search.ideaExtensions.KotlinOverridingMethodReferenceSearcher"/>
 
@@ -948,6 +949,11 @@
           <category>Kotlin</category>
       </intentionAction>
 
+    <intentionAction>
+      <className>org.jetbrains.kotlin.idea.intentions.UsePropertyAccessSyntaxIntention</className>
+      <category>Kotlin</category>
+    </intentionAction>
+
     <localInspection implementationClass="org.jetbrains.kotlin.idea.intentions.DeprecatedCallableAddReplaceWithInspection"
                      displayName="Add 'replaceWith' argument to 'deprecated' annotation"
                      groupName="Kotlin"
@@ -1032,6 +1038,13 @@
                        level="WEAK WARNING"
           />
 
+    <localInspection implementationClass="org.jetbrains.kotlin.idea.intentions.UsePropertyAccessSyntaxInspection"
+                     displayName="Use property access syntax"
+                     groupName="Kotlin"
+                     enabledByDefault="true"
+                     level="WEAK WARNING"
+    />
+
     <localInspection implementationClass="org.jetbrains.kotlin.idea.inspections.UnusedSymbolInspection"
         displayName="Unused Symbol"
         groupName="Kotlin"
@@ -1053,13 +1066,6 @@
         level="WARNING"
         />
 
-    <localInspection implementationClass="org.jetbrains.kotlin.idea.inspections.ReflectionNotFoundInspection"
-        displayName="Reflection not found"
-        groupName="Kotlin"
-        enabledByDefault="true"
-        level="WARNING"
-        />
-
     <localInspection implementationClass="org.jetbrains.kotlin.idea.refactoring.move.changePackage.PackageDirectoryMismatchInspection"
         displayName="Package name does not match containing directory"
         groupName="Kotlin"
@@ -1097,6 +1103,7 @@
   <extensions defaultExtensionNs="org.jetbrains.kotlin">
       <xi:include href="extensions/kotlin2jvm.xml" xpointer="xpointer(/idea-plugin/extensions/*)"/>
       <xi:include href="extensions/kotlin2js.xml" xpointer="xpointer(/idea-plugin/extensions/*)"/>
+    <quickFixContributor implementation="org.jetbrains.kotlin.idea.quickfix.QuickFixRegistrar"/>
   </extensions>
 
 </idea-plugin>
diff --git a/idea/src/org/jetbrains/kotlin/idea/ExtraSteppingFilter.kt b/idea/src/org/jetbrains/kotlin/idea/ExtraSteppingFilter.kt
index ad52b721093..7ceb7d9087d 100644
--- a/idea/src/org/jetbrains/kotlin/idea/ExtraSteppingFilter.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/ExtraSteppingFilter.kt
@@ -37,8 +37,8 @@ public class ExtraSteppingFilter : engine.ExtraSteppingFilter {
         }
 
         val debugProcess = context.getDebugProcess()
-        val positionManager = JetPositionManager(debugProcess)
-        val location = context.getFrameProxy().location()
+        val positionManager = JetPositionManager(debugProcess!!)
+        val location = context.getFrameProxy()!!.location()
         return runReadAction {
             shouldFilter(positionManager, location)
         }
diff --git a/idea/src/org/jetbrains/kotlin/idea/PluginStartupComponent.java b/idea/src/org/jetbrains/kotlin/idea/PluginStartupComponent.java
index ee8d6ef5535..b8edca12729 100644
--- a/idea/src/org/jetbrains/kotlin/idea/PluginStartupComponent.java
+++ b/idea/src/org/jetbrains/kotlin/idea/PluginStartupComponent.java
@@ -20,7 +20,6 @@ import com.intellij.openapi.application.PathMacros;
 import com.intellij.openapi.components.ApplicationComponent;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.idea.debugger.filter.FilterPackage;
-import org.jetbrains.kotlin.idea.quickfix.QuickFixRegistrar;
 import org.jetbrains.kotlin.utils.PathUtil;
 
 public class PluginStartupComponent implements ApplicationComponent {
@@ -35,7 +34,6 @@ public class PluginStartupComponent implements ApplicationComponent {
     @Override
     public void initComponent() {
         registerPathVariable();
-        QuickFixRegistrar.registerQuickFixes();
 
         FilterPackage.addKotlinStdlibDebugFilterIfNeeded();
     }
diff --git a/idea/src/org/jetbrains/kotlin/idea/actions/ConfigureKotlinInProjectAction.kt b/idea/src/org/jetbrains/kotlin/idea/actions/ConfigureKotlinInProjectAction.kt
index 9808c6faa10..be7f8237291 100644
--- a/idea/src/org/jetbrains/kotlin/idea/actions/ConfigureKotlinInProjectAction.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/actions/ConfigureKotlinInProjectAction.kt
@@ -34,7 +34,7 @@ public abstract class ConfigureKotlinInProjectAction : AnAction() {
         if (project == null) return
 
         if (ConfigureKotlinInProjectUtils.isProjectConfigured(project)) {
-            Messages.showInfoMessage("All modules with kotlin files are configured", e.getPresentation().getText())
+            Messages.showInfoMessage("All modules with kotlin files are configured", e.getPresentation().getText()!!)
             return
         }
 
@@ -42,9 +42,9 @@ public abstract class ConfigureKotlinInProjectAction : AnAction() {
 
         when {
             configurators.size() == 1 -> configurators.first().configure(project)
-            configurators.isEmpty() -> Messages.showErrorDialog("There aren't configurators available", e.getPresentation().getText())
+            configurators.isEmpty() -> Messages.showErrorDialog("There aren't configurators available", e.getPresentation().getText()!!)
             else -> {
-                Messages.showErrorDialog("More than one configurator is available", e.getPresentation().getText())
+                Messages.showErrorDialog("More than one configurator is available", e.getPresentation().getText()!!)
                 ConfigureKotlinInProjectUtils.showConfigureKotlinNotificationIfNeeded(project)
             }
         }
diff --git a/idea/src/org/jetbrains/kotlin/idea/actions/JavaToKotlinAction.kt b/idea/src/org/jetbrains/kotlin/idea/actions/JavaToKotlinAction.kt
index 5f39de3725f..18d099e631a 100644
--- a/idea/src/org/jetbrains/kotlin/idea/actions/JavaToKotlinAction.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/actions/JavaToKotlinAction.kt
@@ -19,6 +19,7 @@ package org.jetbrains.kotlin.idea.actions
 import com.intellij.openapi.actionSystem.AnAction
 import com.intellij.openapi.actionSystem.AnActionEvent
 import com.intellij.openapi.actionSystem.CommonDataKeys
+import com.intellij.openapi.application.ApplicationManager
 import com.intellij.openapi.command.CommandProcessor
 import com.intellij.openapi.fileEditor.FileEditorManager
 import com.intellij.openapi.progress.ProgressManager
@@ -44,6 +45,8 @@ import java.util.ArrayList
 
 public class JavaToKotlinAction : AnAction() {
     override fun actionPerformed(e: AnActionEvent) {
+        ApplicationManager.getApplication().saveAll()
+
         val javaFiles = selectedJavaFiles(e).toList()
         val project = CommonDataKeys.PROJECT.getData(e.getDataContext())!!
 
diff --git a/idea/src/org/jetbrains/kotlin/idea/actions/JetAddImportAction.kt b/idea/src/org/jetbrains/kotlin/idea/actions/JetAddImportAction.kt
index e99cbc5cf7e..23e5d3af082 100644
--- a/idea/src/org/jetbrains/kotlin/idea/actions/JetAddImportAction.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/actions/JetAddImportAction.kt
@@ -43,6 +43,7 @@ import org.jetbrains.kotlin.idea.imports.importableFqNameSafe
 import org.jetbrains.kotlin.idea.references.JetSimpleNameReference
 import org.jetbrains.kotlin.idea.JetDescriptorIconProvider
 import org.jetbrains.kotlin.idea.codeInsight.DescriptorToSourceUtilsIde
+import org.jetbrains.kotlin.idea.references.mainReference
 import org.jetbrains.kotlin.idea.util.application.executeWriteCommand
 
 /**
@@ -106,7 +107,7 @@ public class JetAddImportAction(
         // TODO: Validate resolution variants. See AddImportAction.execute()
 
         if (variants.size() == 1 || ApplicationManager.getApplication().isUnitTestMode()) {
-            addImport(element, project, variants.first())
+            addImport(variants.first())
         }
         else {
             chooseCandidateAndImport()
@@ -123,7 +124,7 @@ public class JetAddImportAction(
                 if (selectedValue == null) return null
 
                 if (finalChoice) {
-                    addImport(element, project, selectedValue)
+                    addImport(selectedValue)
                     return null
                 }
 
@@ -155,25 +156,20 @@ public class JetAddImportAction(
         JBPopupFactory.getInstance().createListPopup(getImportSelectionPopup()).showInBestPositionFor(editor)
     }
 
-    companion object {
+    private fun addImport(selectedVariant: Variant) {
+        PsiDocumentManager.getInstance(project).commitAllDocuments()
 
-        protected fun addImport(element: PsiElement, project: Project, selectedVariant: Variant) {
-            PsiDocumentManager.getInstance(project).commitAllDocuments()
+        project.executeWriteCommand(QuickFixBundle.message("add.import")) {
+            if (!element.isValid()) return@executeWriteCommand
 
-            project.executeWriteCommand(QuickFixBundle.message("add.import")) {
-                if (!element.isValid()) return@executeWriteCommand
-
-                val file = element.getContainingFile() as JetFile
-                val descriptor = selectedVariant.descriptorToImport
-                // for class or package we use ShortenReferences because we not necessary insert an import but may want to insert partly qualified name
-                if (descriptor is ClassDescriptor || descriptor is PackageViewDescriptor) {
-                    val fqName = descriptor.importableFqNameSafe
-                    val reference = element.getReference() as JetSimpleNameReference
-                    reference.bindToFqName(fqName, JetSimpleNameReference.ShorteningMode.FORCED_SHORTENING)
-                }
-                else {
-                    ImportInsertHelper.getInstance(project).importDescriptor(file, descriptor)
-                }
+            val file = element.getContainingFile() as JetFile
+            val descriptor = selectedVariant.descriptorToImport
+            // for class or package we use ShortenReferences because we not necessary insert an import but may want to insert partly qualified name
+            if (descriptor is ClassDescriptor || descriptor is PackageViewDescriptor) {
+                element.mainReference.bindToFqName(descriptor.importableFqNameSafe, JetSimpleNameReference.ShorteningMode.FORCED_SHORTENING)
+            }
+            else {
+                ImportInsertHelper.getInstance(project).importDescriptor(file, descriptor)
             }
         }
     }
diff --git a/idea/src/org/jetbrains/kotlin/idea/actions/NewKotlinFileAction.java b/idea/src/org/jetbrains/kotlin/idea/actions/NewKotlinFileAction.java
index 2028eeaa738..245d908ab8d 100644
--- a/idea/src/org/jetbrains/kotlin/idea/actions/NewKotlinFileAction.java
+++ b/idea/src/org/jetbrains/kotlin/idea/actions/NewKotlinFileAction.java
@@ -39,7 +39,7 @@ import java.util.Map;
 
 public class NewKotlinFileAction extends CreateFileFromTemplateAction implements DumbAware {
     public NewKotlinFileAction() {
-        super(JetBundle.message("new.kotlin.file.action"), "Creates new Kotlin file", JetFileType.INSTANCE.getIcon());
+        super(JetBundle.message("new.kotlin.file.action"), "Creates new Kotlin file or class", JetFileType.INSTANCE.getIcon());
     }
 
     @Override
@@ -55,8 +55,8 @@ public class NewKotlinFileAction extends CreateFileFromTemplateAction implements
     @Override
     protected void buildDialog(Project project, PsiDirectory directory, CreateFileFromTemplateDialog.Builder builder) {
         builder
-                .setTitle(JetBundle.message("new.kotlin.file.action"))
-                .addKind("Kotlin file", JetFileType.INSTANCE.getIcon(), "Kotlin File")
+                .setTitle("New Kotlin File/Class")
+                .addKind("File", JetFileType.INSTANCE.getIcon(), "Kotlin File")
                 .addKind("Class", JetIcons.CLASS, "Kotlin Class")
                 .addKind("Interface", JetIcons.TRAIT, "Kotlin Interface")
                 .addKind("Enum class", JetIcons.ENUM, "Kotlin Enum")
diff --git a/idea/src/org/jetbrains/kotlin/idea/codeInsight/KotlinCopyPasteReferenceProcessor.kt b/idea/src/org/jetbrains/kotlin/idea/codeInsight/KotlinCopyPasteReferenceProcessor.kt
index 3780b3a5574..2cb8b806d32 100644
--- a/idea/src/org/jetbrains/kotlin/idea/codeInsight/KotlinCopyPasteReferenceProcessor.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/codeInsight/KotlinCopyPasteReferenceProcessor.kt
@@ -42,15 +42,15 @@ import org.jetbrains.kotlin.idea.conversion.copy.range
 import org.jetbrains.kotlin.idea.conversion.copy.start
 import org.jetbrains.kotlin.idea.imports.canBeReferencedViaImport
 import org.jetbrains.kotlin.idea.imports.importableFqName
-import org.jetbrains.kotlin.idea.references.JetMultiReference
-import org.jetbrains.kotlin.idea.references.JetReference
-import org.jetbrains.kotlin.idea.references.JetSimpleNameReference
+import org.jetbrains.kotlin.idea.references.*
 import org.jetbrains.kotlin.idea.util.ImportInsertHelper
 import org.jetbrains.kotlin.idea.util.application.runWriteAction
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.elementsInRange
+import org.jetbrains.kotlin.psi.psiUtil.forEachDescendantOfType
 import org.jetbrains.kotlin.psi.psiUtil.getReceiverExpression
+import org.jetbrains.kotlin.psi.psiUtil.parentsWithSelf
 import org.jetbrains.kotlin.resolve.DescriptorUtils
 import org.jetbrains.kotlin.resolve.descriptorUtil.isExtension
 import org.jetbrains.kotlin.resolve.scopes.JetScope
@@ -138,37 +138,31 @@ public class KotlinCopyPasteReferenceProcessor() : CopyPastePostProcessor<Kotlin
     ) {
         if (PsiTreeUtil.getNonStrictParentOfType(element, *IGNORE_REFERENCES_INSIDE) != null) return
 
-        element.accept(object : PsiElementVisitor() {
-            override fun visitElement(element: PsiElement) {
-                if (element.javaClass in IGNORE_REFERENCES_INSIDE) return
+        element.forEachDescendantOfType<JetElement>(canGoInside = { it.javaClass !in IGNORE_REFERENCES_INSIDE }) { element ->
+            val reference = element.mainReference ?: return@forEachDescendantOfType
 
-                element.acceptChildren(this)
+            val descriptors = reference.resolveToDescriptors(element.analyze()) //TODO: we could use partial body resolve for all references together
+            //check whether this reference is unambiguous
+            if (reference !is JetMultiReference<*> && descriptors.size() > 1) return@forEachDescendantOfType
 
-                val reference = element.getReference() as? JetReference ?: return
+            for (descriptor in descriptors) {
+                val declarations = DescriptorToSourceUtilsIde.getAllDeclarations(file.getProject(), descriptor)
+                val declaration = declarations.singleOrNull()
+                if (declaration != null && declaration.isInCopiedArea(file, startOffsets, endOffsets)) continue
 
-                val descriptors = reference.resolveToDescriptors((element as JetElement).analyze()) //TODO: we could use partial body resolve for all references together
-                //check whether this reference is unambiguous
-                if (reference !is JetMultiReference<*> && descriptors.size() > 1) return
-
-                for (descriptor in descriptors) {
-                    val declarations = DescriptorToSourceUtilsIde.getAllDeclarations(file.getProject(), descriptor)
-                    val declaration = declarations.singleOrNull()
-                    if (declaration != null && declaration.isInCopiedArea(file, startOffsets, endOffsets)) continue
-
-                    if (!descriptor.isExtension) {
-                        if (element !is JetNameReferenceExpression) continue
-                        if (element.getIdentifier() == null) continue // skip 'this' etc
-                        if (element.getReceiverExpression() != null) continue
-                    }
-
-                    val fqName = descriptor.importableFqName ?: continue
-                    if (!descriptor.canBeReferencedViaImport()) continue
-
-                    val kind = KotlinReferenceData.Kind.fromDescriptor(descriptor) ?: continue
-                    add(KotlinReferenceData(element.range.start - startOffset, element.range.end - startOffset, fqName.asString(), kind))
+                if (!descriptor.isExtension) {
+                    if (element !is JetNameReferenceExpression) continue
+                    if (element.getIdentifier() == null) continue // skip 'this' etc
+                    if (element.getReceiverExpression() != null) continue
                 }
+
+                val fqName = descriptor.importableFqName ?: continue
+                if (!descriptor.canBeReferencedViaImport()) continue
+
+                val kind = KotlinReferenceData.Kind.fromDescriptor(descriptor) ?: continue
+                add(KotlinReferenceData(element.range.start - startOffset, element.range.end - startOffset, fqName.asString(), kind))
             }
-        })
+        }
     }
 
     private data class ReferenceToRestoreData(
@@ -213,36 +207,30 @@ public class KotlinCopyPasteReferenceProcessor() : CopyPastePostProcessor<Kotlin
 
         val fileResolutionScope = file.getResolutionFacade().getFileTopLevelScope(file)
         return referenceData.map {
-            val referenceElement = findReference(it, file, blockStart)
-            if (referenceElement != null)
-                createReferenceToRestoreData(referenceElement, it, file, fileResolutionScope)
+            val reference = findReference(it, file, blockStart)
+            if (reference != null)
+                createReferenceToRestoreData(reference, it, file, fileResolutionScope)
             else
                 null
         }.filterNotNull()
     }
 
-    private fun findReference(data: KotlinReferenceData, file: JetFile, blockStart: Int): JetElement? {
+    private fun findReference(data: KotlinReferenceData, file: JetFile, blockStart: Int): JetReference? {
         val startOffset = data.startOffset + blockStart
         val endOffset = data.endOffset + blockStart
-        val element = file.findElementAt(startOffset)
+        val element = file.findElementAt(startOffset) ?: return null
         val desiredRange = TextRange(startOffset, endOffset)
-        var expression = element
-        while (expression != null) {
-            val range = expression!!.range
-            if (range == desiredRange && expression!!.getReference() != null) {
-                return expression as? JetElement
-            }
-            if (range in desiredRange) {
-                expression = expression!!.getParent()
-            }
-            else {
-                return null
+        for (current in element.parentsWithSelf) {
+            val range = current.range
+            if (current is JetElement && range == desiredRange) {
+                current.mainReference?.let { return it }
             }
+            if (range !in desiredRange) return null
         }
         return null
     }
 
-    private fun createReferenceToRestoreData(element: JetElement, refData: KotlinReferenceData, file: JetFile, fileResolutionScope: JetScope): ReferenceToRestoreData? {
+    private fun createReferenceToRestoreData(reference: JetReference, refData: KotlinReferenceData, file: JetFile, fileResolutionScope: JetScope): ReferenceToRestoreData? {
         val originalFqName = FqName(refData.fqName)
 
         if (refData.kind == KotlinReferenceData.Kind.EXTENSION_FUNCTION) {
@@ -252,12 +240,11 @@ public class KotlinCopyPasteReferenceProcessor() : CopyPastePostProcessor<Kotlin
             if (fileResolutionScope.getProperties(originalFqName.shortName()).any { it.importableFqName == originalFqName }) return null // already imported
         }
 
-        val reference = element.getReference() as? JetReference ?: return null
         val referencedDescriptors = try {
-            reference.resolveToDescriptors(element.analyze()) //TODO: we could use partial body resolve for all references together
+            reference.resolveToDescriptors(reference.getElement().analyze()) //TODO: we could use partial body resolve for all references together
         }
         catch (e: Throwable) {
-            LOG.error("Failed to analyze reference (${element.getText()}) after copy paste", e)
+            LOG.error("Failed to analyze reference ($reference) after copy paste", e)
             return null
         }
         val referencedFqNames = referencedDescriptors
@@ -303,7 +290,7 @@ public class KotlinCopyPasteReferenceProcessor() : CopyPastePostProcessor<Kotlin
             importHelper.importDescriptor(file, descriptor)
         }
         for ((pointer, fqName) in bindingRequests) {
-            val reference = pointer.getElement().getReference() as JetSimpleNameReference
+            val reference = pointer.getElement()!!.mainReference
             reference.bindToFqName(fqName, JetSimpleNameReference.ShorteningMode.DELAYED_SHORTENING)
         }
         performDelayedShortening(file.getProject())
diff --git a/idea/src/org/jetbrains/kotlin/idea/codeInsight/OverrideMethodsHandler.java b/idea/src/org/jetbrains/kotlin/idea/codeInsight/OverrideMethodsHandler.java
index c18e016f439..38aa59bb999 100644
--- a/idea/src/org/jetbrains/kotlin/idea/codeInsight/OverrideMethodsHandler.java
+++ b/idea/src/org/jetbrains/kotlin/idea/codeInsight/OverrideMethodsHandler.java
@@ -25,7 +25,7 @@ import org.jetbrains.kotlin.descriptors.DeclarationDescriptor;
 import org.jetbrains.kotlin.idea.core.codeInsight.OverrideImplementMethodsHandler;
 import org.jetbrains.kotlin.resolve.OverrideResolver;
 import org.jetbrains.kotlin.resolve.OverridingUtil;
-import org.jetbrains.kotlin.resolve.calls.CallResolverUtil;
+import org.jetbrains.kotlin.resolve.calls.callResolverUtil.CallResolverUtilPackage;
 import org.jetbrains.kotlin.types.JetType;
 
 import java.util.HashSet;
@@ -49,7 +49,7 @@ public class OverrideMethodsHandler extends OverrideImplementMethodsHandler {
         Set<CallableMemberDescriptor> result = new HashSet<CallableMemberDescriptor>();
         for (CallableMemberDescriptor superMethod : superMethods) {
             if (superMethod.getModality().isOverridable()) {
-                if (!CallResolverUtil.isOrOverridesSynthesized(superMethod)) {
+                if (!CallResolverUtilPackage.isOrOverridesSynthesized(superMethod)) {
                     result.add(superMethod);
                 }
             }
diff --git a/idea/src/org/jetbrains/kotlin/idea/codeInsight/surroundWith/expression/KotlinRuntimeTypeCastSurrounder.kt b/idea/src/org/jetbrains/kotlin/idea/codeInsight/surroundWith/expression/KotlinRuntimeTypeCastSurrounder.kt
index 11251562acb..209a6d30be3 100644
--- a/idea/src/org/jetbrains/kotlin/idea/codeInsight/surroundWith/expression/KotlinRuntimeTypeCastSurrounder.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/codeInsight/surroundWith/expression/KotlinRuntimeTypeCastSurrounder.kt
@@ -87,7 +87,7 @@ public class KotlinRuntimeTypeCastSurrounder: KotlinExpressionSurrounder() {
                             try {
                                 val factory = JetPsiFactory(myElement.getProject())
 
-                                val fqName = DescriptorUtils.getFqName(type.getConstructor().getDeclarationDescriptor())
+                                val fqName = DescriptorUtils.getFqName(type.getConstructor().getDeclarationDescriptor()!!)
                                 val parentCast = factory.createExpression("(expr as " + fqName.asString() + ")") as JetParenthesizedExpression
                                 val cast = parentCast.getExpression() as JetBinaryExpressionWithTypeRHS
                                 cast.getLeft().replace(myElement)
diff --git a/idea/src/org/jetbrains/kotlin/idea/configuration/ConfigureKotlinNotificationManager.kt b/idea/src/org/jetbrains/kotlin/idea/configuration/ConfigureKotlinNotificationManager.kt
index 2964160cc6c..a0907626655 100644
--- a/idea/src/org/jetbrains/kotlin/idea/configuration/ConfigureKotlinNotificationManager.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/configuration/ConfigureKotlinNotificationManager.kt
@@ -28,6 +28,7 @@ object ConfigureKotlinNotificationManager: KotlinSingleNotificationManager<Confi
     }
 }
 
+@deprecated("Deprecated after moving to platform types")
 object AbsentSdkAnnotationsNotificationManager: KotlinSingleNotificationManager<AbsentSdkAnnotationsNotification> {
     fun notify(project: Project, sdks: Collection<Sdk>) {
         notify(project, AbsentSdkAnnotationsNotification(sdks, getNotificationTitle(sdks), getNotificationString(sdks)))
diff --git a/idea/src/org/jetbrains/kotlin/idea/configuration/ui/AbsentJdkAnnotationsComponent.java b/idea/src/org/jetbrains/kotlin/idea/configuration/ui/AbsentJdkAnnotationsComponent.java
index d0010673d7f..c24a1586937 100644
--- a/idea/src/org/jetbrains/kotlin/idea/configuration/ui/AbsentJdkAnnotationsComponent.java
+++ b/idea/src/org/jetbrains/kotlin/idea/configuration/ui/AbsentJdkAnnotationsComponent.java
@@ -32,6 +32,7 @@ import com.intellij.openapi.vfs.VirtualFileManager;
 import com.intellij.openapi.vfs.newvfs.BulkFileListener;
 import com.intellij.openapi.vfs.newvfs.events.*;
 import com.intellij.util.Alarm;
+import com.intellij.util.PlatformUtils;
 import com.intellij.util.messages.MessageBusConnection;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.idea.configuration.AbsentSdkAnnotationsNotificationManager;
@@ -45,6 +46,10 @@ import java.util.List;
 import java.util.Set;
 import java.util.concurrent.TimeUnit;
 
+/**
+ * Deprecated after moving to platform types.
+ */
+@Deprecated
 public class AbsentJdkAnnotationsComponent extends AbstractProjectComponent {
     public static final String EXTERNAL_ANNOTATIONS_GROUP_ID = "Kotlin External annotations";
     private volatile Alarm notificationAlarm;
@@ -133,8 +138,19 @@ public class AbsentJdkAnnotationsComponent extends AbstractProjectComponent {
     }
 
     private static boolean areAnnotationsCorrect(@NotNull Sdk sdk) {
-        return NotificationsPackage.isAndroidSdk(sdk)
-               ? KotlinRuntimeLibraryUtil.androidSdkAnnotationsArePresent(sdk) && !KotlinRuntimeLibraryUtil.jdkAnnotationsArePresent(sdk)
-               : KotlinRuntimeLibraryUtil.jdkAnnotationsArePresent(sdk);
+        if (NotificationsPackage.isAndroidSdk(sdk)) {
+            return KotlinRuntimeLibraryUtil.androidSdkAnnotationsArePresent(sdk) && !KotlinRuntimeLibraryUtil.jdkAnnotationsArePresent(sdk);
+        }
+        else if (!isAndroidStudio()) {
+            return KotlinRuntimeLibraryUtil.jdkAnnotationsArePresent(sdk);
+        }
+        else {
+            // Android studio always recreates standard sdk from scratch so any addition configuration will be lost
+            return true;
+        }
+    }
+
+    private static boolean isAndroidStudio() {
+        return "AndroidStudio".equals(PlatformUtils.getPlatformPrefix());
     }
 }
diff --git a/idea/src/org/jetbrains/kotlin/idea/configuration/ui/notifications/AbsentSdkAnnotationsNotification.kt b/idea/src/org/jetbrains/kotlin/idea/configuration/ui/notifications/AbsentSdkAnnotationsNotification.kt
index 13737e4f4a5..8794b72870f 100644
--- a/idea/src/org/jetbrains/kotlin/idea/configuration/ui/notifications/AbsentSdkAnnotationsNotification.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/configuration/ui/notifications/AbsentSdkAnnotationsNotification.kt
@@ -20,9 +20,9 @@ import com.intellij.notification.Notification
 import com.intellij.notification.NotificationListener
 import com.intellij.notification.NotificationType
 import com.intellij.openapi.projectRoots.Sdk
+import org.jetbrains.kotlin.idea.configuration.ui.AbsentJdkAnnotationsComponent
 import org.jetbrains.kotlin.idea.versions.KotlinRuntimeLibraryUtil
 import javax.swing.event.HyperlinkEvent
-import org.jetbrains.kotlin.idea.configuration.ui.AbsentJdkAnnotationsComponent
 
 public class AbsentSdkAnnotationsNotification(sdks: Collection<Sdk>, title: String, val text: String) :
     Notification(
diff --git a/idea/src/org/jetbrains/kotlin/idea/coverage/KotlinCoverageExtension.kt b/idea/src/org/jetbrains/kotlin/idea/coverage/KotlinCoverageExtension.kt
index 32ee802ba5f..251b9deeaaf 100644
--- a/idea/src/org/jetbrains/kotlin/idea/coverage/KotlinCoverageExtension.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/coverage/KotlinCoverageExtension.kt
@@ -126,7 +126,7 @@ public class KotlinCoverageExtension(): JavaCoverageEngineExtension() {
             }
             LOG.debug("Classfiles: [${existingClassFiles.map { it.getName() }.join()}]")
             return existingClassFiles.map {
-                val relativePath = VfsUtilCore.getRelativePath(it, outputRoot)
+                val relativePath = VfsUtilCore.getRelativePath(it, outputRoot!!)!!
                 StringUtil.trimEnd(relativePath, ".class").replace("/", ".")
             }
         }
@@ -175,13 +175,13 @@ public class KotlinCoverageExtension(): JavaCoverageEngineExtension() {
             val inTests = fileIndex.isInTestSourceContent(file.getVirtualFile())
             val compilerOutputExtension = CompilerModuleExtension.getInstance(module)
             return if (inTests)
-                compilerOutputExtension.getCompilerOutputPathForTests()
+                compilerOutputExtension!!.getCompilerOutputPathForTests()
             else
-                compilerOutputExtension.getCompilerOutputPath()
+                compilerOutputExtension!!.getCompilerOutputPath()
         }
 
         private fun collectClassFilePrefixes(file: JetFile): Collection<String> {
-            val result = file.getChildren().filter { it is JetClassOrObject }.map { (it as JetClassOrObject).getName() }
+            val result = file.getChildren().filter { it is JetClassOrObject }.map { (it as JetClassOrObject).getName()!! }
             val packagePartFqName = PackagePartClassUtils.getPackagePartFqName(file)
             return result.union(arrayListOf(packagePartFqName.shortName().asString()))
         }
diff --git a/idea/src/org/jetbrains/kotlin/idea/debugger/JetPositionManager.kt b/idea/src/org/jetbrains/kotlin/idea/debugger/JetPositionManager.kt
index 410af8f4aae..f79fe006813 100644
--- a/idea/src/org/jetbrains/kotlin/idea/debugger/JetPositionManager.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/debugger/JetPositionManager.kt
@@ -107,7 +107,7 @@ public class JetPositionManager(private val myDebugProcess: DebugProcess) : Mult
         if (lineNumber >= 0) {
             val lambdaOrFunIfInside = getLambdaOrFunIfInside(location, psiFile as JetFile, lineNumber)
             if (lambdaOrFunIfInside != null) {
-                return SourcePosition.createFromElement(lambdaOrFunIfInside.getBodyExpression())
+                return SourcePosition.createFromElement(lambdaOrFunIfInside.getBodyExpression()!!)
             }
             return SourcePosition.createFromLine(psiFile, lineNumber)
         }
diff --git a/idea/src/org/jetbrains/kotlin/idea/debugger/KotlinEditorTextProvider.kt b/idea/src/org/jetbrains/kotlin/idea/debugger/KotlinEditorTextProvider.kt
index 2e27c137231..15d8e16a975 100644
--- a/idea/src/org/jetbrains/kotlin/idea/debugger/KotlinEditorTextProvider.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/debugger/KotlinEditorTextProvider.kt
@@ -56,9 +56,7 @@ class KotlinEditorTextProvider : EditorTextProvider {
         }
 
         fun findExpressionInner(element: PsiElement, allowMethodCalls: Boolean): JetExpression? {
-            if (PsiTreeUtil.getParentOfType(element, javaClass<JetUserType>(), javaClass<JetImportDirective>(), javaClass<JetPackageDirective>()) != null) {
-                return null
-            }
+            if (!isAcceptedAsCodeFragmentContext(element)) return null
 
             val jetElement = PsiTreeUtil.getParentOfType(element, javaClass<JetElement>())
             if (jetElement == null) return null
@@ -104,7 +102,7 @@ class KotlinEditorTextProvider : EditorTextProvider {
                 fun PsiElement.isCall() = this is JetCallExpression || this is JetOperationExpression || this is JetArrayAccessExpression
 
                 if (newExpression.isCall() ||
-                        newExpression is JetQualifiedExpression && newExpression.getSelectorExpression().isCall()) {
+                        newExpression is JetQualifiedExpression && newExpression.getSelectorExpression()!!.isCall()) {
                     return null
                 }
             }
@@ -116,6 +114,14 @@ class KotlinEditorTextProvider : EditorTextProvider {
             }
 
         }
+
+        private val NOT_ACCEPTED_AS_CONTEXT_TYPES =
+                arrayOf(javaClass<JetUserType>(), javaClass<JetImportDirective>(), javaClass<JetPackageDirective>())
+
+        fun isAcceptedAsCodeFragmentContext(element: PsiElement): Boolean {
+            return element.javaClass !in NOT_ACCEPTED_AS_CONTEXT_TYPES &&
+                   PsiTreeUtil.getParentOfType(element, *NOT_ACCEPTED_AS_CONTEXT_TYPES) == null
+        }
     }
 }
 
diff --git a/idea/src/org/jetbrains/kotlin/idea/debugger/KotlinFrameExtraVariablesProvider.kt b/idea/src/org/jetbrains/kotlin/idea/debugger/KotlinFrameExtraVariablesProvider.kt
index a57469c6ca5..fe79d14622a 100644
--- a/idea/src/org/jetbrains/kotlin/idea/debugger/KotlinFrameExtraVariablesProvider.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/debugger/KotlinFrameExtraVariablesProvider.kt
@@ -69,7 +69,7 @@ private fun findAdditionalExpressions(position: SourcePosition): Set<TextWithImp
     if (offset < 0) return emptySet()
 
     val elem = file.findElementAt(offset)
-    val containingElement = getContainingElement(elem) ?: elem
+    val containingElement = getContainingElement(elem!!) ?: elem
 
     if (containingElement == null) return emptySet()
 
@@ -129,7 +129,7 @@ private fun shouldSkipLine(file: PsiFile, doc: Document, line: Int): Boolean {
     }
 
     val elemAtOffset = file.findElementAt(start)
-    val topmostElementAtOffset = CodeInsightUtils.getTopmostElementAtOffset(elemAtOffset, start)
+    val topmostElementAtOffset = CodeInsightUtils.getTopmostElementAtOffset(elemAtOffset!!, start)
     return topmostElementAtOffset !is JetDeclaration
 }
 
diff --git a/idea/src/org/jetbrains/kotlin/idea/debugger/KotlinSourcePositionProvider.kt b/idea/src/org/jetbrains/kotlin/idea/debugger/KotlinSourcePositionProvider.kt
index adcfe5e9681..50274a38518 100644
--- a/idea/src/org/jetbrains/kotlin/idea/debugger/KotlinSourcePositionProvider.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/debugger/KotlinSourcePositionProvider.kt
@@ -34,6 +34,7 @@ import com.sun.jdi.ClassNotPreparedException
 import com.sun.jdi.ReferenceType
 import org.jetbrains.kotlin.codegen.AsmUtil
 import org.jetbrains.kotlin.idea.caches.resolve.analyze
+import org.jetbrains.kotlin.idea.debugger.evaluate.KotlinCodeFragmentFactory
 import org.jetbrains.kotlin.psi.JetClassOrObject
 import org.jetbrains.kotlin.psi.JetElement
 import org.jetbrains.kotlin.psi.JetPsiFactory
@@ -62,7 +63,7 @@ public class KotlinSourcePositionProvider: SourcePositionProvider() {
 
     private fun computeSourcePosition(descriptor: LocalVariableDescriptor, project: Project, context: DebuggerContextImpl, nearest: Boolean): SourcePosition? {
         val place = PositionUtil.getContextElement(context) ?: return null
-        val contextElement = PsiTreeUtil.getParentOfType(place, javaClass<JetElement>()) ?: return null
+        val contextElement = KotlinCodeFragmentFactory.getContextElement(place) ?: return null
 
         val codeFragment = JetPsiFactory(project).createExpressionCodeFragment(descriptor.getName(), contextElement)
         val expression = codeFragment.getContentElement()
diff --git a/idea/src/org/jetbrains/kotlin/idea/debugger/breakpoints/KotlinFieldBreakpoint.kt b/idea/src/org/jetbrains/kotlin/idea/debugger/breakpoints/KotlinFieldBreakpoint.kt
index 3d7418853ae..a0e4bee5ec5 100644
--- a/idea/src/org/jetbrains/kotlin/idea/debugger/breakpoints/KotlinFieldBreakpoint.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/debugger/breakpoints/KotlinFieldBreakpoint.kt
@@ -41,13 +41,12 @@ import com.sun.jdi.event.*
 import com.sun.jdi.request.EventRequest
 import com.sun.jdi.request.MethodEntryRequest
 import org.jetbrains.annotations.TestOnly
-import org.jetbrains.kotlin.codegen.PropertyCodegen
 import org.jetbrains.kotlin.descriptors.PropertyDescriptor
 import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor
 import org.jetbrains.kotlin.idea.caches.resolve.analyzeAndGetResult
 import org.jetbrains.kotlin.idea.util.application.runReadAction
+import org.jetbrains.kotlin.load.java.JvmAbi
 import org.jetbrains.kotlin.load.kotlin.PackageClassUtils
-import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.psi.JetCallableDeclaration
 import org.jetbrains.kotlin.psi.JetClassOrObject
 import org.jetbrains.kotlin.psi.JetParameter
@@ -100,7 +99,7 @@ class KotlinFieldBreakpoint(
     override fun reload(psiFile: PsiFile?) {
         val property = getProperty(getSourcePosition())
         if (property != null) {
-            setFieldName(property.getName())
+            setFieldName(property.getName()!!)
 
             if (property is JetProperty && property.isTopLevel()) {
                 getProperties().myClassName = PackageClassUtils.getPackageClassFqName(property.getContainingJetFile().getPackageFqName()).asString()
@@ -165,17 +164,17 @@ class KotlinFieldBreakpoint(
                     }
                 }
                 BreakpointType.METHOD -> {
-                    val propertyName = Name.identifier(getFieldName())
+                    val fieldName = getFieldName()
 
                     if (getProperties().WATCH_ACCESS) {
-                        val getter = refType.methodsByName(PropertyCodegen.getterName(propertyName)).firstOrNull()
+                        val getter = refType.methodsByName(JvmAbi.getterName(fieldName)).firstOrNull()
                         if (getter != null) {
                             createMethodBreakpoint(debugProcess, refType, getter)
                         }
                     }
 
                     if (getProperties().WATCH_MODIFICATION) {
-                        val setter = refType.methodsByName(PropertyCodegen.setterName(propertyName)).firstOrNull()
+                        val setter = refType.methodsByName(JvmAbi.setterName(fieldName)).firstOrNull()
                         if (setter != null) {
                             createMethodBreakpoint(debugProcess, refType, setter)
                         }
@@ -196,7 +195,7 @@ class KotlinFieldBreakpoint(
                 descriptor = bindingContext.get(BindingContext.VALUE_PARAMETER_AS_PROPERTY, descriptor)
             }
 
-            if (bindingContext.get(BindingContext.BACKING_FIELD_REQUIRED, descriptor as PropertyDescriptor)) {
+            if (bindingContext.get(BindingContext.BACKING_FIELD_REQUIRED, descriptor as PropertyDescriptor)!!) {
                 BreakpointType.FIELD
             }
             else {
@@ -255,9 +254,8 @@ class KotlinFieldBreakpoint(
     }
 
     private fun getMethodsName(): List<String> {
-        val propertyName = Name.identifier(getFieldName())
-        return arrayListOf(PropertyCodegen.getterName(propertyName), PropertyCodegen.setterName(propertyName))
-
+        val fieldName = getFieldName()
+        return listOf(JvmAbi.getterName(fieldName), JvmAbi.setterName(fieldName))
     }
 
     override fun getEventMessage(event: LocatableEvent): String {
diff --git a/idea/src/org/jetbrains/kotlin/idea/debugger/evaluate/KotlinCodeFragmentFactory.kt b/idea/src/org/jetbrains/kotlin/idea/debugger/evaluate/KotlinCodeFragmentFactory.kt
index 0a824a0ac91..02a7f9ba129 100644
--- a/idea/src/org/jetbrains/kotlin/idea/debugger/evaluate/KotlinCodeFragmentFactory.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/debugger/evaluate/KotlinCodeFragmentFactory.kt
@@ -131,10 +131,11 @@ class KotlinCodeFragmentFactory: CodeFragmentFactory() {
             }
 
             val expressionAtOffset = PsiTreeUtil.findElementOfClassAtOffset(elementAt.getContainingFile()!!, elementAt.getTextOffset(), javaClass<JetExpression>(), false)
-            if (expressionAtOffset != null) {
+            if (expressionAtOffset != null && KotlinEditorTextProvider.isAcceptedAsCodeFragmentContext(elementAt)) {
                 return expressionAtOffset
             }
-            return KotlinEditorTextProvider.findExpressionInner(elementAt, true)
+
+            return KotlinEditorTextProvider.findExpressionInner(elementAt, true) ?: elementAt.getContainingFile()
         }
 
         //internal for tests
diff --git a/idea/src/org/jetbrains/kotlin/idea/debugger/evaluate/KotlinEvaluationBuilder.kt b/idea/src/org/jetbrains/kotlin/idea/debugger/evaluate/KotlinEvaluationBuilder.kt
index 4da92b78e4c..8c023a01e53 100644
--- a/idea/src/org/jetbrains/kotlin/idea/debugger/evaluate/KotlinEvaluationBuilder.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/debugger/evaluate/KotlinEvaluationBuilder.kt
@@ -30,6 +30,7 @@ import com.intellij.openapi.progress.ProcessCanceledException
 import com.intellij.openapi.project.Project
 import com.intellij.openapi.vfs.CharsetToolkit
 import com.intellij.psi.JavaPsiFacade
+import com.intellij.psi.PsiDocumentManager
 import com.intellij.psi.PsiElement
 import com.intellij.psi.PsiFileFactory
 import com.intellij.psi.impl.PsiFileFactoryImpl
@@ -101,6 +102,13 @@ object KotlinEvaluationBuilder: EvaluatorBuilder {
             throw EvaluateExceptionUtil.createEvaluateException("Couldn't evaluate kotlin expression at $position")
         }
 
+        val document = PsiDocumentManager.getInstance(file.getProject()).getDocument(file)
+        if (document == null || document.getLineCount() < position.getLine()) {
+            throw EvaluateExceptionUtil.createEvaluateException(
+                    "Couldn't evaluate kotlin expression: breakpoint is placed outside the file. " +
+                    "It may happen when you've changed source file after starting a debug process.")
+        }
+
         if (codeFragment.getContext() !is JetElement) {
             val attachments = arrayOf(attachmentByPsiFile(position.getFile()),
                                       attachmentByPsiFile(codeFragment),
@@ -299,7 +307,7 @@ class KotlinEvaluator(val codeFragment: JetCodeFragment,
                         override fun visitProperty(property: JetProperty) {
                             val value = property.getUserData(KotlinCodeFragmentFactory.LABEL_VARIABLE_VALUE_KEY)
                             if (value != null) {
-                                valuesForLabels.put(property.getName(), value.asValue())
+                                valuesForLabels.put(property.getName()!!, value.asValue())
                             }
                         }
                     })
diff --git a/idea/src/org/jetbrains/kotlin/idea/debugger/evaluate/extractFunctionForDebuggerUtil.kt b/idea/src/org/jetbrains/kotlin/idea/debugger/evaluate/extractFunctionForDebuggerUtil.kt
index 39be2c91a05..3a2a85a80aa 100644
--- a/idea/src/org/jetbrains/kotlin/idea/debugger/evaluate/extractFunctionForDebuggerUtil.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/debugger/evaluate/extractFunctionForDebuggerUtil.kt
@@ -77,11 +77,6 @@ fun getFunctionForExtractedFragment(
         val contextElement = getExpressionToAddDebugExpressionBefore(tmpFile, codeFragment.getContext(), breakpointLine)
         if (contextElement == null) return null
 
-        // Don't evaluate smth when breakpoint is on package directive (ex. for package classes)
-        if (contextElement is JetFile) {
-            throw EvaluateExceptionUtil.createEvaluateException("Cannot perform an action at this breakpoint ${breakpointFile.getName()}:${breakpointLine}")
-        }
-
         addImportsToFile(codeFragment.importsAsImportList(), tmpFile)
 
         val newDebugExpressions = addDebugExpressionBeforeContextElement(codeFragment, contextElement)
@@ -158,7 +153,7 @@ private fun getExpressionToAddDebugExpressionBefore(tmpFile: JetFile, contextEle
         return getExpressionToAddDebugExpressionBefore(tmpFile, containingFile.getContext(), line)
     }
 
-    fun shouldStop(el: PsiElement?, p: PsiElement?) = p is JetBlockExpression || el is JetDeclaration
+    fun shouldStop(el: PsiElement?, p: PsiElement?) = p is JetBlockExpression || el is JetDeclaration || el is JetFile
 
     var elementAt = tmpFile.getElementInCopy(contextElement)
 
@@ -192,6 +187,12 @@ private fun addDebugExpressionBeforeContextElement(codeFragment: JetCodeFragment
     }
 
     val elementBefore = when {
+        contextElement is JetFile -> {
+            val fakeFunction = psiFactory.createFunction("fun _debug_fun_() {}")
+            contextElement.add(psiFactory.createNewLine())
+            val newFakeFun = contextElement.add(fakeFunction) as JetNamedFunction
+            newFakeFun.getBodyExpression()!!.getLastChild()
+        }
         contextElement is JetProperty && !contextElement.isLocal() -> {
             val delegateExpressionOrInitializer = contextElement.getDelegateExpressionOrInitializer()
             if (delegateExpressionOrInitializer != null) {
diff --git a/idea/src/org/jetbrains/kotlin/idea/debugger/filter/DebuggerFiltersUtil.kt b/idea/src/org/jetbrains/kotlin/idea/debugger/filter/DebuggerFiltersUtil.kt
index 1b068957e3e..69d4b94a0e7 100644
--- a/idea/src/org/jetbrains/kotlin/idea/debugger/filter/DebuggerFiltersUtil.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/debugger/filter/DebuggerFiltersUtil.kt
@@ -25,7 +25,7 @@ private val KOTLIN_STDLIB_FILTER = "kotlin.*"
 public fun addKotlinStdlibDebugFilterIfNeeded() {
     if (!KotlinDebuggerSettings.getInstance().DEBUG_IS_FILTER_FOR_STDLIB_ALREADY_ADDED) {
         val settings = DebuggerSettings.getInstance()!!
-        val newFilters = (settings.getSteppingFilters() + ClassFilter(KOTLIN_STDLIB_FILTER)).toTypedArray()
+        val newFilters = (settings.getSteppingFilters() + ClassFilter(KOTLIN_STDLIB_FILTER))
 
         settings.setSteppingFilters(newFilters)
 
diff --git a/idea/src/org/jetbrains/kotlin/idea/debugger/render/DelegatedPropertyFieldDescriptor.kt b/idea/src/org/jetbrains/kotlin/idea/debugger/render/DelegatedPropertyFieldDescriptor.kt
index 2495757e664..3ce3d947600 100644
--- a/idea/src/org/jetbrains/kotlin/idea/debugger/render/DelegatedPropertyFieldDescriptor.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/debugger/render/DelegatedPropertyFieldDescriptor.kt
@@ -27,7 +27,6 @@ import com.sun.jdi.Field
 import com.sun.jdi.Method
 import com.sun.jdi.ObjectReference
 import com.sun.jdi.Value
-import org.jetbrains.kotlin.codegen.PropertyCodegen
 import org.jetbrains.kotlin.load.java.JvmAbi
 import org.jetbrains.kotlin.name.Name
 
@@ -86,8 +85,6 @@ class DelegatedPropertyFieldDescriptor(
         val fieldName = getName()
         if (!Name.isValidIdentifier(fieldName)) return null
 
-        val getterName = PropertyCodegen.getterName(Name.identifier(fieldName))
-        return getObject().referenceType().methodsByName(getterName)?.firstOrNull()
+        return getObject().referenceType().methodsByName(JvmAbi.getterName(fieldName))?.firstOrNull()
     }
 }
-
diff --git a/idea/src/org/jetbrains/kotlin/idea/editor/KotlinSmartEnterHandler.kt b/idea/src/org/jetbrains/kotlin/idea/editor/KotlinSmartEnterHandler.kt
index 10951f1fcbb..c81ba25a5bb 100644
--- a/idea/src/org/jetbrains/kotlin/idea/editor/KotlinSmartEnterHandler.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/editor/KotlinSmartEnterHandler.kt
@@ -106,7 +106,7 @@ public class KotlinSmartEnterHandler: SmartEnterProcessorWithFixers() {
             val settings = CodeStyleSettingsManager.getSettings(file.getProject())
             val old = settings.KEEP_SIMPLE_BLOCKS_IN_ONE_LINE
             settings.KEEP_SIMPLE_BLOCKS_IN_ONE_LINE = false
-            val elt = file.findElementAt(caretOffset - 1).getStrictParentOfType<JetBlockExpression>()
+            val elt = file.findElementAt(caretOffset - 1)!!.getStrictParentOfType<JetBlockExpression>()
             if (elt != null) {
                 reformat(elt)
             }
diff --git a/idea/src/org/jetbrains/kotlin/idea/findUsages/KotlinFindUsagesHandlerFactory.kt b/idea/src/org/jetbrains/kotlin/idea/findUsages/KotlinFindUsagesHandlerFactory.kt
index 85110ddf11b..227be3946fa 100644
--- a/idea/src/org/jetbrains/kotlin/idea/findUsages/KotlinFindUsagesHandlerFactory.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/findUsages/KotlinFindUsagesHandlerFactory.kt
@@ -56,14 +56,14 @@ public class KotlinFindUsagesHandlerFactory(project: Project) : FindUsagesHandle
             is JetNamedFunction, is JetProperty, is JetParameter, is JetConstructor<*> -> {
                 val declaration = element as JetNamedDeclaration
 
-                if (forHighlightUsages) return KotlinFindMemberUsagesHandler.getInstance(declaration, this)
+                if (forHighlightUsages) return KotlinFindMemberUsagesHandler.getInstance(declaration, factory = this)
                 JetRefactoringUtil.checkSuperMethods(declaration, null, "super.methods.action.key.find.usages")?.let { callables ->
                     when (callables.size()) {
                         0 -> FindUsagesHandler.NULL_HANDLER
                         1 -> {
                             val target = callables.first().unwrapped ?: return FindUsagesHandler.NULL_HANDLER
                             if (target is JetNamedDeclaration) {
-                                KotlinFindMemberUsagesHandler.getInstance(target, this)
+                                KotlinFindMemberUsagesHandler.getInstance(target, factory = this)
                             }
                             else {
                                 javaHandlerFactory.createFindUsagesHandler(target, false)
diff --git a/idea/src/org/jetbrains/kotlin/idea/findUsages/KotlinReferenceUsageInfo.kt b/idea/src/org/jetbrains/kotlin/idea/findUsages/KotlinReferenceUsageInfo.kt
new file mode 100644
index 00000000000..9a846f7e005
--- /dev/null
+++ b/idea/src/org/jetbrains/kotlin/idea/findUsages/KotlinReferenceUsageInfo.kt
@@ -0,0 +1,30 @@
+/*
+ * Copyright 2010-2015 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.kotlin.idea.findUsages
+
+import com.intellij.psi.PsiReference
+import com.intellij.usageView.UsageInfo
+import org.jetbrains.kotlin.utils.addToStdlib.firstIsInstanceOrNull
+
+public class KotlinReferenceUsageInfo(reference: PsiReference) : UsageInfo(reference) {
+    private val referenceType = reference.javaClass
+
+    override fun getReference(): PsiReference? {
+        val element = getElement() ?: return null
+        return element.getReferences().singleOrNull { it.javaClass == referenceType }
+    }
+}
\ No newline at end of file
diff --git a/idea/src/org/jetbrains/kotlin/idea/findUsages/handlers/DelegatingFindMemberUsagesHandler.kt b/idea/src/org/jetbrains/kotlin/idea/findUsages/handlers/DelegatingFindMemberUsagesHandler.kt
index 54dea8f5d87..0bc7c3a4e51 100644
--- a/idea/src/org/jetbrains/kotlin/idea/findUsages/handlers/DelegatingFindMemberUsagesHandler.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/findUsages/handlers/DelegatingFindMemberUsagesHandler.kt
@@ -58,7 +58,7 @@ class DelegatingFindMemberUsagesHandler(
         return kotlinHandler.getPrimaryElements()
     }
 
-    override fun getSecondaryElements(): Array<out PsiElement>? {
+    override fun getSecondaryElements(): Array<out PsiElement> {
         return kotlinHandler.getSecondaryElements()
     }
 
diff --git a/idea/src/org/jetbrains/kotlin/idea/findUsages/handlers/KotlinFindClassUsagesHandler.kt b/idea/src/org/jetbrains/kotlin/idea/findUsages/handlers/KotlinFindClassUsagesHandler.kt
index 96044154f13..4a273b7cc20 100644
--- a/idea/src/org/jetbrains/kotlin/idea/findUsages/handlers/KotlinFindClassUsagesHandler.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/findUsages/handlers/KotlinFindClassUsagesHandler.kt
@@ -43,6 +43,7 @@ import com.intellij.psi.search.searches.MethodReferencesSearch
 import com.intellij.util.CommonProcessors
 import org.jetbrains.kotlin.asJava.KotlinLightMethod
 import org.jetbrains.kotlin.asJava.toLightClass
+import org.jetbrains.kotlin.idea.references.mainReference
 import org.jetbrains.kotlin.idea.search.usagesSearch.processDelegationCallConstructorUsages
 import org.jetbrains.kotlin.psi.JetClass
 import org.jetbrains.kotlin.psi.psiUtil.isInheritable
@@ -56,7 +57,7 @@ public class KotlinFindClassUsagesHandler(
     ): AbstractFindUsagesDialog {
         return KotlinFindClassUsagesDialog(getElement(),
                                            getProject(),
-                                           getFactory().findClassOptions,
+                                           factory.findClassOptions,
                                            toShowInNewTab,
                                            mustOpenInNewTab,
                                            isSingleFile,
@@ -98,7 +99,7 @@ public class KotlinFindClassUsagesHandler(
                 for (constructor in constructors) {
                     if (constructor !is KotlinLightMethod) continue
                     constructor.processDelegationCallConstructorUsages(constructor.getUseScope()) {
-                        it.getCalleeExpression()?.getReference()?.let { KotlinFindUsagesHandler.processUsage(uniqueProcessor, it) }
+                        it.getCalleeExpression()?.mainReference?.let { KotlinFindUsagesHandler.processUsage(uniqueProcessor, it) }
                     }
                 }
             }
@@ -119,7 +120,7 @@ public class KotlinFindClassUsagesHandler(
         var stringsToSearch: Collection<String>
         object: JavaFindUsagesHandler(psiClass, JavaFindUsagesHandlerFactory.getInstance(element.getProject())) {
             init {
-                stringsToSearch = getStringsToSearch(psiClass)
+                stringsToSearch = getStringsToSearch(psiClass)!!
             }
         }
         return stringsToSearch
@@ -130,6 +131,6 @@ public class KotlinFindClassUsagesHandler(
     }
 
     public override fun getFindUsagesOptions(dataContext: DataContext?): FindUsagesOptions {
-        return getFactory().findClassOptions
+        return factory.findClassOptions
     }
 }
diff --git a/idea/src/org/jetbrains/kotlin/idea/findUsages/handlers/KotlinFindMemberUsagesHandler.java b/idea/src/org/jetbrains/kotlin/idea/findUsages/handlers/KotlinFindMemberUsagesHandler.java
deleted file mode 100644
index 6467533fe7d..00000000000
--- a/idea/src/org/jetbrains/kotlin/idea/findUsages/handlers/KotlinFindMemberUsagesHandler.java
+++ /dev/null
@@ -1,217 +0,0 @@
-/*
- * Copyright 2010-2015 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.kotlin.idea.findUsages.handlers;
-
-import com.intellij.find.findUsages.AbstractFindUsagesDialog;
-import com.intellij.find.findUsages.FindUsagesOptions;
-import com.intellij.openapi.actionSystem.DataContext;
-import com.intellij.openapi.application.ApplicationManager;
-import com.intellij.openapi.util.Computable;
-import com.intellij.psi.PsiElement;
-import com.intellij.psi.PsiMethod;
-import com.intellij.psi.PsiReference;
-import com.intellij.psi.search.PsiElementProcessor;
-import com.intellij.psi.search.PsiElementProcessorAdapter;
-import com.intellij.psi.search.searches.MethodReferencesSearch;
-import com.intellij.usageView.UsageInfo;
-import com.intellij.util.CommonProcessors;
-import com.intellij.util.Processor;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.asJava.LightClassUtil;
-import org.jetbrains.kotlin.idea.findUsages.*;
-import org.jetbrains.kotlin.idea.findUsages.dialogs.KotlinFindFunctionUsagesDialog;
-import org.jetbrains.kotlin.idea.findUsages.dialogs.KotlinFindPropertyUsagesDialog;
-import org.jetbrains.kotlin.idea.search.declarationsSearch.DeclarationsSearchPackage;
-import org.jetbrains.kotlin.idea.search.declarationsSearch.HierarchySearchRequest;
-import org.jetbrains.kotlin.idea.search.usagesSearch.UsagesSearch;
-import org.jetbrains.kotlin.idea.search.usagesSearch.UsagesSearchHelper;
-import org.jetbrains.kotlin.idea.search.usagesSearch.UsagesSearchRequest;
-import org.jetbrains.kotlin.psi.*;
-
-import java.util.Collection;
-import java.util.Collections;
-import java.util.Iterator;
-
-public abstract class KotlinFindMemberUsagesHandler<T extends JetNamedDeclaration> extends KotlinFindUsagesHandler<T> {
-    private static class Function extends KotlinFindMemberUsagesHandler<JetFunction> {
-        public Function(
-                @NotNull JetFunction declaration,
-                @NotNull Collection<? extends PsiElement> elementsToSearch,
-                @NotNull KotlinFindUsagesHandlerFactory factory
-        ) {
-            super(declaration, elementsToSearch, factory);
-        }
-
-        @Override
-        protected UsagesSearchHelper<JetFunction> getSearchHelper(KotlinCallableFindUsagesOptions options) {
-            return FindUsagesPackage.toHelper((KotlinFunctionFindUsagesOptions) options);
-        }
-
-        @NotNull
-        @Override
-        public FindUsagesOptions getFindUsagesOptions(@Nullable DataContext dataContext) {
-            return getFactory().getFindFunctionOptions();
-        }
-
-        @NotNull
-        @Override
-        public AbstractFindUsagesDialog getFindUsagesDialog(boolean isSingleFile, boolean toShowInNewTab, boolean mustOpenInNewTab) {
-            KotlinFunctionFindUsagesOptions options = getFactory().getFindFunctionOptions();
-            Iterator<PsiMethod> lightMethods = getLightMethods(getElement()).iterator();
-            if (lightMethods.hasNext()) {
-                return new KotlinFindFunctionUsagesDialog(
-                        lightMethods.next(), getProject(), options, toShowInNewTab, mustOpenInNewTab, isSingleFile, this
-                );
-            }
-
-            return super.getFindUsagesDialog(isSingleFile, toShowInNewTab, mustOpenInNewTab);
-        }
-    }
-
-    private static class Property extends KotlinFindMemberUsagesHandler<JetNamedDeclaration> {
-        public Property(
-                @NotNull JetNamedDeclaration declaration,
-                @NotNull Collection<? extends PsiElement> elementsToSearch,
-                @NotNull KotlinFindUsagesHandlerFactory factory
-        ) {
-            super(declaration, elementsToSearch, factory);
-        }
-
-        @Override
-        protected UsagesSearchHelper<JetNamedDeclaration> getSearchHelper(KotlinCallableFindUsagesOptions options) {
-            return FindUsagesPackage.toHelper((KotlinPropertyFindUsagesOptions) options);
-        }
-
-        @NotNull
-        @Override
-        public FindUsagesOptions getFindUsagesOptions(@Nullable DataContext dataContext) {
-            return getFactory().getFindPropertyOptions();
-        }
-
-        @NotNull
-        @Override
-        public AbstractFindUsagesDialog getFindUsagesDialog(boolean isSingleFile, boolean toShowInNewTab, boolean mustOpenInNewTab) {
-            return new KotlinFindPropertyUsagesDialog(
-                    getElement(), getProject(), getFactory().getFindPropertyOptions(), toShowInNewTab, mustOpenInNewTab, isSingleFile, this
-            );
-        }
-    }
-
-    protected KotlinFindMemberUsagesHandler(
-            @NotNull T declaration,
-            @NotNull Collection<? extends PsiElement> elementsToSearch,
-            @NotNull KotlinFindUsagesHandlerFactory factory
-    ) {
-        super(declaration, elementsToSearch, factory);
-    }
-
-    protected abstract UsagesSearchHelper<T> getSearchHelper(KotlinCallableFindUsagesOptions options);
-
-    private static Iterable<PsiMethod> getLightMethods(JetNamedDeclaration element) {
-        if (element instanceof JetFunction) {
-            PsiMethod method = LightClassUtil.getLightClassMethod((JetFunction) element);
-            return method != null ? Collections.singletonList(method) : Collections.<PsiMethod>emptyList();
-        }
-
-        if (element instanceof JetProperty) {
-            return LightClassUtil.getLightClassPropertyMethods((JetProperty) element);
-        }
-
-        if (element instanceof JetParameter) {
-            return LightClassUtil.getLightClassPropertyMethods((JetParameter) element);
-        }
-
-        return null;
-    }
-
-    @Override
-    protected boolean searchReferences(
-            @NotNull final PsiElement element, @NotNull final Processor<UsageInfo> processor, @NotNull final FindUsagesOptions options
-    ) {
-        return ApplicationManager.getApplication().runReadAction(
-                new Computable<Boolean>() {
-                    @Override
-                    public Boolean compute() {
-                        KotlinCallableFindUsagesOptions kotlinOptions = (KotlinCallableFindUsagesOptions) options;
-
-                        @SuppressWarnings("unchecked")
-                        UsagesSearchRequest request =
-                                getSearchHelper(kotlinOptions).newRequest(FindUsagesPackage.<T>toSearchTarget(options, (T) element, true));
-
-                        final CommonProcessors.UniqueProcessor<UsageInfo> uniqueProcessor =
-                                new CommonProcessors.UniqueProcessor<UsageInfo>(processor);
-
-                        for (PsiReference ref : UsagesSearch.INSTANCE$.search(request)) {
-                            processUsage(uniqueProcessor, ref);
-                        }
-
-                        PsiMethod psiMethod =
-                                element instanceof PsiMethod
-                                ? (PsiMethod) element
-                                : element instanceof JetConstructor
-                                  ? LightClassUtil.getLightClassMethod((JetFunction) element)
-                                  : null;
-                        if (psiMethod != null) {
-                            for (PsiReference ref : MethodReferencesSearch.search(psiMethod, options.searchScope, true)) {
-                                processUsage(uniqueProcessor, ref.getElement());
-                            }
-                        }
-
-                        if (kotlinOptions.getSearchOverrides()) {
-                            DeclarationsSearchPackage.searchOverriders(
-                                    new HierarchySearchRequest<PsiElement>(element, options.searchScope, true)
-                            ).forEach(
-                                    new PsiElementProcessorAdapter<PsiMethod>(
-                                            new PsiElementProcessor<PsiMethod>() {
-                                                @Override
-                                                public boolean execute(@NotNull PsiMethod method) {
-                                                    return processUsage(uniqueProcessor, method.getNavigationElement());
-                                                }
-                                            }
-                                    )
-                            );
-                        }
-
-                        return true;
-                    }
-                }
-        );
-    }
-
-    @Override
-    protected boolean isSearchForTextOccurencesAvailable(@NotNull PsiElement psiElement, boolean isSingleFile) {
-        return !isSingleFile;
-    }
-
-    @NotNull
-    public static KotlinFindMemberUsagesHandler<? extends JetNamedDeclaration> getInstance(
-            @NotNull JetNamedDeclaration declaration,
-            @NotNull Collection<? extends PsiElement> elementsToSearch,
-            @NotNull KotlinFindUsagesHandlerFactory factory) {
-        return declaration instanceof JetFunction
-               ? new Function((JetFunction) declaration, elementsToSearch, factory)
-               : new Property(declaration, elementsToSearch, factory);
-    }
-
-    @NotNull
-    public static KotlinFindMemberUsagesHandler<? extends JetNamedDeclaration> getInstance(
-            @NotNull JetNamedDeclaration declaration,
-            @NotNull KotlinFindUsagesHandlerFactory factory) {
-        return getInstance(declaration, Collections.<PsiElement>emptyList(), factory);
-    }
-}
diff --git a/idea/src/org/jetbrains/kotlin/idea/findUsages/handlers/KotlinFindMemberUsagesHandler.kt b/idea/src/org/jetbrains/kotlin/idea/findUsages/handlers/KotlinFindMemberUsagesHandler.kt
new file mode 100644
index 00000000000..f3f8b207d11
--- /dev/null
+++ b/idea/src/org/jetbrains/kotlin/idea/findUsages/handlers/KotlinFindMemberUsagesHandler.kt
@@ -0,0 +1,134 @@
+/*
+ * Copyright 2010-2015 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.kotlin.idea.findUsages.handlers
+
+import com.intellij.find.findUsages.AbstractFindUsagesDialog
+import com.intellij.find.findUsages.FindUsagesOptions
+import com.intellij.openapi.actionSystem.DataContext
+import com.intellij.openapi.application.ApplicationManager
+import com.intellij.openapi.util.Computable
+import com.intellij.psi.PsiElement
+import com.intellij.psi.PsiMethod
+import com.intellij.psi.PsiReference
+import com.intellij.psi.search.PsiElementProcessor
+import com.intellij.psi.search.PsiElementProcessorAdapter
+import com.intellij.psi.search.searches.MethodReferencesSearch
+import com.intellij.usageView.UsageInfo
+import com.intellij.util.CommonProcessors
+import com.intellij.util.Processor
+import org.jetbrains.kotlin.asJava.LightClassUtil
+import org.jetbrains.kotlin.asJava.toLightMethods
+import org.jetbrains.kotlin.idea.findUsages.*
+import org.jetbrains.kotlin.idea.findUsages.dialogs.KotlinFindFunctionUsagesDialog
+import org.jetbrains.kotlin.idea.findUsages.dialogs.KotlinFindPropertyUsagesDialog
+import org.jetbrains.kotlin.idea.search.declarationsSearch.*
+import org.jetbrains.kotlin.idea.search.declarationsSearch.HierarchySearchRequest
+import org.jetbrains.kotlin.idea.search.usagesSearch.UsagesSearch
+import org.jetbrains.kotlin.idea.search.usagesSearch.UsagesSearchHelper
+import org.jetbrains.kotlin.idea.search.usagesSearch.UsagesSearchRequest
+import org.jetbrains.kotlin.idea.util.application.runReadAction
+import org.jetbrains.kotlin.psi.*
+import java.util.Collections
+
+public abstract class KotlinFindMemberUsagesHandler<T : JetNamedDeclaration>
+    protected constructor(declaration: T, elementsToSearch: Collection<PsiElement>, factory: KotlinFindUsagesHandlerFactory)
+    : KotlinFindUsagesHandler<T>(declaration, elementsToSearch, factory) {
+
+    private class Function(declaration: JetFunction,
+                           elementsToSearch: Collection<PsiElement>,
+                           factory: KotlinFindUsagesHandlerFactory) : KotlinFindMemberUsagesHandler<JetFunction>(declaration, elementsToSearch, factory) {
+
+        override fun getSearchHelper(options: KotlinCallableFindUsagesOptions): UsagesSearchHelper<JetFunction> {
+            return (options as KotlinFunctionFindUsagesOptions).toHelper()
+        }
+
+        override fun getFindUsagesOptions(dataContext: DataContext?): FindUsagesOptions = factory.findFunctionOptions
+
+        override fun getFindUsagesDialog(isSingleFile: Boolean, toShowInNewTab: Boolean, mustOpenInNewTab: Boolean): AbstractFindUsagesDialog {
+            val options = factory.findFunctionOptions
+            val lightMethod = getElement().toLightMethods().firstOrNull()
+            if (lightMethod != null) {
+                return KotlinFindFunctionUsagesDialog(lightMethod, getProject(), options, toShowInNewTab, mustOpenInNewTab, isSingleFile, this)
+            }
+
+            return super.getFindUsagesDialog(isSingleFile, toShowInNewTab, mustOpenInNewTab)
+        }
+    }
+
+    private class Property(declaration: JetNamedDeclaration, elementsToSearch: Collection<PsiElement>, factory: KotlinFindUsagesHandlerFactory) : KotlinFindMemberUsagesHandler<JetNamedDeclaration>(declaration, elementsToSearch, factory) {
+
+        override fun getSearchHelper(options: KotlinCallableFindUsagesOptions): UsagesSearchHelper<JetNamedDeclaration> {
+            return (options as KotlinPropertyFindUsagesOptions).toHelper()
+        }
+
+        override fun getFindUsagesOptions(dataContext: DataContext?): FindUsagesOptions = factory.findPropertyOptions
+
+        override fun getFindUsagesDialog(isSingleFile: Boolean, toShowInNewTab: Boolean, mustOpenInNewTab: Boolean): AbstractFindUsagesDialog {
+            return KotlinFindPropertyUsagesDialog(getElement(), getProject(), factory.findPropertyOptions, toShowInNewTab, mustOpenInNewTab, isSingleFile, this)
+        }
+    }
+
+    protected abstract fun getSearchHelper(options: KotlinCallableFindUsagesOptions): UsagesSearchHelper<T>
+
+    override fun searchReferences(element: PsiElement, processor: Processor<UsageInfo>, options: FindUsagesOptions): Boolean {
+        val kotlinOptions = options as KotlinCallableFindUsagesOptions
+
+        val request = runReadAction {
+            @suppress("UNCHECKED_CAST")
+            getSearchHelper(kotlinOptions).newRequest(options.toSearchTarget<T>(element as T, true))
+        }
+
+        val uniqueProcessor = CommonProcessors.UniqueProcessor(processor)
+
+        for (ref in UsagesSearch.search(request)) {
+            KotlinFindUsagesHandler.processUsage(uniqueProcessor, ref)
+        }
+
+        val psiMethod: PsiMethod? = when (element) {
+            is PsiMethod -> element
+            is JetConstructor<*> -> LightClassUtil.getLightClassMethod(element as JetFunction)
+            else -> null
+        }
+        if (psiMethod != null) {
+            for (ref in MethodReferencesSearch.search(psiMethod, options.searchScope, true)) {
+                KotlinFindUsagesHandler.processUsage(uniqueProcessor, ref)
+            }
+        }
+
+        if (kotlinOptions.searchOverrides) {
+            for (method in HierarchySearchRequest(element, options.searchScope, true).searchOverriders()) {
+                if (!KotlinFindUsagesHandler.processUsage(uniqueProcessor, method.getNavigationElement())) break
+            }
+        }
+
+        return true
+    }
+
+    override fun isSearchForTextOccurencesAvailable(psiElement: PsiElement, isSingleFile: Boolean): Boolean = !isSingleFile
+
+    companion object {
+
+        public fun getInstance(declaration: JetNamedDeclaration,
+                               elementsToSearch: Collection<PsiElement> = emptyList(),
+                               factory: KotlinFindUsagesHandlerFactory): KotlinFindMemberUsagesHandler<out JetNamedDeclaration> {
+            return if (declaration is JetFunction)
+                Function(declaration, elementsToSearch, factory)
+            else
+                Property(declaration, elementsToSearch, factory)
+        }
+    }
+}
diff --git a/idea/src/org/jetbrains/kotlin/idea/findUsages/handlers/KotlinFindUsagesHandler.java b/idea/src/org/jetbrains/kotlin/idea/findUsages/handlers/KotlinFindUsagesHandler.java
deleted file mode 100644
index 14761483af2..00000000000
--- a/idea/src/org/jetbrains/kotlin/idea/findUsages/handlers/KotlinFindUsagesHandler.java
+++ /dev/null
@@ -1,118 +0,0 @@
-/*
- * Copyright 2010-2015 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.kotlin.idea.findUsages.handlers;
-
-import com.intellij.find.findUsages.FindUsagesHandler;
-import com.intellij.find.findUsages.FindUsagesOptions;
-import com.intellij.openapi.util.TextRange;
-import com.intellij.psi.PsiElement;
-import com.intellij.psi.PsiReference;
-import com.intellij.psi.search.GlobalSearchScope;
-import com.intellij.psi.search.SearchScope;
-import com.intellij.usageView.UsageInfo;
-import com.intellij.util.Processor;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.kotlin.idea.findUsages.KotlinFindUsagesHandlerFactory;
-
-import java.util.Collection;
-import java.util.Collections;
-
-public abstract class KotlinFindUsagesHandler<T extends PsiElement> extends FindUsagesHandler {
-    private final KotlinFindUsagesHandlerFactory factory;
-    private final Collection<? extends PsiElement> elementsToSearch;
-
-    public KotlinFindUsagesHandler(
-            @NotNull T psiElement,
-            @NotNull Collection<? extends PsiElement> elementsToSearch,
-            @NotNull KotlinFindUsagesHandlerFactory factory
-    ) {
-        super(psiElement);
-        this.factory = factory;
-        this.elementsToSearch = elementsToSearch;
-    }
-
-    @SuppressWarnings("unchecked")
-    @NotNull
-    public T getElement() {
-        return (T)getPsiElement();
-    }
-
-    public KotlinFindUsagesHandler(@NotNull T psiElement, @NotNull KotlinFindUsagesHandlerFactory factory) {
-        this(psiElement, Collections.<PsiElement>emptyList(), factory);
-    }
-
-    @NotNull
-    public final KotlinFindUsagesHandlerFactory getFactory() {
-        return factory;
-    }
-
-    protected static boolean processUsage(Processor<UsageInfo> processor, PsiReference ref) {
-        if (ref == null) return true;
-        TextRange rangeInElement = ref.getRangeInElement();
-        return processor.process(new UsageInfo(ref.getElement(), rangeInElement.getStartOffset(), rangeInElement.getEndOffset(), false));
-    }
-
-    protected static boolean processUsage(@NotNull Processor<UsageInfo> processor, @NotNull PsiElement element) {
-        return processor.process(new UsageInfo(element));
-    }
-
-    @NotNull
-    @Override
-    public PsiElement[] getPrimaryElements() {
-        return elementsToSearch.isEmpty()
-               ? new PsiElement[] {getPsiElement()}
-               : elementsToSearch.toArray(new PsiElement[elementsToSearch.size()]);
-    }
-
-    protected boolean searchTextOccurrences(
-            @NotNull final PsiElement element,
-            @NotNull final Processor<UsageInfo> processor,
-            @NotNull FindUsagesOptions options
-    ) {
-        final SearchScope scope = options.searchScope;
-
-        boolean searchText = options.isSearchForTextOccurrences && scope instanceof GlobalSearchScope;
-
-        if (searchText) {
-            if (options.fastTrack != null) {
-                options.fastTrack.searchCustom(new Processor<Processor<PsiReference>>() {
-                    @Override
-                    public boolean process(Processor<PsiReference> consumer) {
-                        return processUsagesInText(element, processor, (GlobalSearchScope)scope);
-                    }
-                });
-            }
-            else {
-                return processUsagesInText(element, processor, (GlobalSearchScope)scope);
-            }
-        }
-        return true;
-    }
-
-    @Override
-    public boolean processElementUsages(
-            @NotNull PsiElement element,
-            @NotNull Processor<UsageInfo> processor,
-            @NotNull FindUsagesOptions options
-    ) {
-        return searchReferences(element, processor, options) && searchTextOccurrences(element, processor, options);
-    }
-
-    protected abstract boolean searchReferences(
-            @NotNull PsiElement element, @NotNull Processor<UsageInfo> processor, @NotNull FindUsagesOptions options
-    );
-}
diff --git a/idea/src/org/jetbrains/kotlin/idea/findUsages/handlers/KotlinFindUsagesHandler.kt b/idea/src/org/jetbrains/kotlin/idea/findUsages/handlers/KotlinFindUsagesHandler.kt
new file mode 100644
index 00000000000..6318c323845
--- /dev/null
+++ b/idea/src/org/jetbrains/kotlin/idea/findUsages/handlers/KotlinFindUsagesHandler.kt
@@ -0,0 +1,99 @@
+/*
+ * Copyright 2010-2015 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.kotlin.idea.findUsages.handlers
+
+import com.intellij.find.findUsages.FindUsagesHandler
+import com.intellij.find.findUsages.FindUsagesOptions
+import com.intellij.openapi.util.TextRange
+import com.intellij.psi.PsiElement
+import com.intellij.psi.PsiReference
+import com.intellij.psi.search.GlobalSearchScope
+import com.intellij.psi.search.SearchScope
+import com.intellij.usageView.UsageInfo
+import com.intellij.util.Processor
+import org.jetbrains.kotlin.idea.findUsages.KotlinFindUsagesHandlerFactory
+import org.jetbrains.kotlin.idea.findUsages.KotlinReferenceUsageInfo
+import org.jetbrains.kotlin.idea.util.application.runReadAction
+
+import java.util.ArrayList
+import java.util.Collections
+
+public abstract class KotlinFindUsagesHandler<T : PsiElement>(psiElement: T,
+                                                              private val elementsToSearch: Collection<PsiElement>,
+                                                              public val factory: KotlinFindUsagesHandlerFactory)
+    : FindUsagesHandler(psiElement) {
+
+    @suppress("UNCHECKED_CAST")
+    public fun getElement(): T {
+        return getPsiElement() as T
+    }
+
+    public constructor(psiElement: T, factory: KotlinFindUsagesHandlerFactory) : this(psiElement, emptyList(), factory) {
+    }
+
+    override fun getPrimaryElements(): Array<PsiElement> {
+        return if (elementsToSearch.isEmpty())
+            arrayOf(getPsiElement())
+        else
+            elementsToSearch.toTypedArray()
+    }
+
+    protected fun searchTextOccurrences(element: PsiElement, processor: Processor<UsageInfo>, options: FindUsagesOptions): Boolean {
+        val scope = options.searchScope
+
+        if (options.isSearchForTextOccurrences && scope is GlobalSearchScope) {
+            if (options.fastTrack == null) {
+                return processUsagesInText(element, processor, scope)
+            }
+            options.fastTrack.searchCustom {
+                processUsagesInText(element, processor, scope)
+            }
+        }
+        return true
+    }
+
+    override fun processElementUsages(element: PsiElement, processor: Processor<UsageInfo>, options: FindUsagesOptions): Boolean {
+        return searchReferences(element, processor, options) && searchTextOccurrences(element, processor, options)
+    }
+
+    protected abstract fun searchReferences(element: PsiElement, processor: Processor<UsageInfo>, options: FindUsagesOptions): Boolean
+
+    override fun findReferencesToHighlight(target: PsiElement, searchScope: SearchScope): Collection<PsiReference> {
+        val results = ArrayList<PsiReference>()
+        val options = getFindUsagesOptions().clone()
+        options.searchScope = searchScope
+        searchReferences(target, object : Processor<UsageInfo> {
+            override fun process(info: UsageInfo): Boolean {
+                val reference = info.getReference()
+                if (reference != null) {
+                    results.add(reference)
+                }
+                return true
+            }
+        }, options)
+        return results
+    }
+
+    companion object {
+
+        protected fun processUsage(processor: Processor<UsageInfo>, ref: PsiReference): Boolean
+                = processor.process(KotlinReferenceUsageInfo(ref))
+
+        protected fun processUsage(processor: Processor<UsageInfo>, element: PsiElement): Boolean
+                = processor.process(UsageInfo(element))
+    }
+}
diff --git a/idea/src/org/jetbrains/kotlin/idea/findUsages/handlers/KotlinTypeParameterFindUsagesHandler.kt b/idea/src/org/jetbrains/kotlin/idea/findUsages/handlers/KotlinTypeParameterFindUsagesHandler.kt
index d8b9e691f58..f0bef34f4f1 100644
--- a/idea/src/org/jetbrains/kotlin/idea/findUsages/handlers/KotlinTypeParameterFindUsagesHandler.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/findUsages/handlers/KotlinTypeParameterFindUsagesHandler.kt
@@ -51,6 +51,6 @@ public class KotlinTypeParameterFindUsagesHandler(
     }
 
     public override fun getFindUsagesOptions(dataContext: DataContext?): FindUsagesOptions {
-        return getFactory().defaultOptions
+        return factory.defaultOptions
     }
 }
diff --git a/idea/src/org/jetbrains/kotlin/idea/framework/KotlinTemplatesFactory.kt b/idea/src/org/jetbrains/kotlin/idea/framework/KotlinTemplatesFactory.kt
index e417457cf5d..79f7724abf4 100644
--- a/idea/src/org/jetbrains/kotlin/idea/framework/KotlinTemplatesFactory.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/framework/KotlinTemplatesFactory.kt
@@ -30,7 +30,7 @@ public class KotlinTemplatesFactory : ProjectTemplatesFactory() {
     override fun getGroups() = arrayOf(KOTLIN_GROUP_NAME)
     override fun getGroupIcon(group: String) = JetIcons.SMALL_LOGO
 
-    override fun createTemplates(group: String, context: WizardContext?) =
+    override fun createTemplates(group: String?, context: WizardContext?) =
         arrayOf(
                 BuilderBasedTemplate(KotlinModuleBuilder(TargetPlatform.JVM, "Kotlin - JVM", "Kotlin module for JVM target")),
                 BuilderBasedTemplate(KotlinModuleBuilder(TargetPlatform.JS, "Kotlin - JavaScript", "Kotlin module for JavaScript target"))
diff --git a/idea/src/org/jetbrains/kotlin/idea/hierarchy/calls/CalleeReferenceVisitorBase.java b/idea/src/org/jetbrains/kotlin/idea/hierarchy/calls/CalleeReferenceVisitorBase.java
index 83be2af0d7f..735fe766734 100644
--- a/idea/src/org/jetbrains/kotlin/idea/hierarchy/calls/CalleeReferenceVisitorBase.java
+++ b/idea/src/org/jetbrains/kotlin/idea/hierarchy/calls/CalleeReferenceVisitorBase.java
@@ -36,7 +36,7 @@ public abstract class CalleeReferenceVisitorBase extends JetTreeVisitorVoid {
         this.deepTraversal = deepTraversal;
     }
 
-    protected abstract void processDeclaration(JetReferenceExpression reference, PsiElement declaration);
+    protected abstract void processDeclaration(JetSimpleNameExpression reference, PsiElement declaration);
 
     @Override
     public void visitJetElement(@NotNull JetElement element) {
diff --git a/idea/src/org/jetbrains/kotlin/idea/hierarchy/calls/KotlinCallHierarchyNodeDescriptor.java b/idea/src/org/jetbrains/kotlin/idea/hierarchy/calls/KotlinCallHierarchyNodeDescriptor.java
index 5ef28e6f5e9..b0a8ebda856 100644
--- a/idea/src/org/jetbrains/kotlin/idea/hierarchy/calls/KotlinCallHierarchyNodeDescriptor.java
+++ b/idea/src/org/jetbrains/kotlin/idea/hierarchy/calls/KotlinCallHierarchyNodeDescriptor.java
@@ -211,7 +211,7 @@ public class KotlinCallHierarchyNodeDescriptor extends HierarchyNodeDescriptor i
         return containerText != null ? containerText + "." + elementText : elementText;
     }
 
-    private static String renderNamedFunction(FunctionDescriptor descriptor) {
+    public static String renderNamedFunction(FunctionDescriptor descriptor) {
         DeclarationDescriptor descriptorForName = descriptor instanceof ConstructorDescriptor
                                                   ? descriptor.getContainingDeclaration()
                                                   : descriptor;
diff --git a/idea/src/org/jetbrains/kotlin/idea/hierarchy/calls/KotlinCalleeMethodsTreeStructure.java b/idea/src/org/jetbrains/kotlin/idea/hierarchy/calls/KotlinCalleeMethodsTreeStructure.java
index c9b8e0a448d..d1e1b0dcd54 100644
--- a/idea/src/org/jetbrains/kotlin/idea/hierarchy/calls/KotlinCalleeMethodsTreeStructure.java
+++ b/idea/src/org/jetbrains/kotlin/idea/hierarchy/calls/KotlinCalleeMethodsTreeStructure.java
@@ -27,6 +27,7 @@ import com.intellij.psi.PsiReference;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.asJava.KotlinLightMethod;
 import org.jetbrains.kotlin.idea.caches.resolve.ResolvePackage;
+import org.jetbrains.kotlin.idea.references.ReferencesPackage;
 import org.jetbrains.kotlin.psi.*;
 import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode;
 
@@ -90,8 +91,8 @@ public class KotlinCalleeMethodsTreeStructure extends KotlinCallTreeStructure {
             element.accept(
                     new CalleeReferenceVisitorBase(ResolvePackage.analyze(element, BodyResolveMode.FULL), false) {
                         @Override
-                        protected void processDeclaration(JetReferenceExpression reference, PsiElement declaration) {
-                            referencesToCalleeElements.put(reference.getReference(), declaration);
+                        protected void processDeclaration(JetSimpleNameExpression reference, PsiElement declaration) {
+                            referencesToCalleeElements.put(ReferencesPackage.getMainReference(reference), declaration);
                         }
                     }
             );
diff --git a/idea/src/org/jetbrains/kotlin/idea/hierarchy/calls/KotlinCallerMethodsTreeStructure.java b/idea/src/org/jetbrains/kotlin/idea/hierarchy/calls/KotlinCallerMethodsTreeStructure.java
index 6a7770892e1..de3e9fdbb44 100644
--- a/idea/src/org/jetbrains/kotlin/idea/hierarchy/calls/KotlinCallerMethodsTreeStructure.java
+++ b/idea/src/org/jetbrains/kotlin/idea/hierarchy/calls/KotlinCallerMethodsTreeStructure.java
@@ -23,6 +23,7 @@ import com.intellij.openapi.application.ReadActionProcessor;
 import com.intellij.openapi.project.Project;
 import com.intellij.openapi.util.Condition;
 import com.intellij.psi.*;
+import com.intellij.psi.impl.light.LightMemberReference;
 import com.intellij.psi.search.SearchScope;
 import com.intellij.psi.search.searches.MethodReferencesSearch;
 import com.intellij.psi.search.searches.ReferencesSearch;
@@ -38,6 +39,7 @@ import org.jetbrains.kotlin.asJava.LightClassUtil;
 import org.jetbrains.kotlin.idea.caches.resolve.ResolvePackage;
 import org.jetbrains.kotlin.idea.hierarchy.HierarchyUtils;
 import org.jetbrains.kotlin.idea.references.JetReference;
+import org.jetbrains.kotlin.idea.references.ReferencesPackage;
 import org.jetbrains.kotlin.idea.search.usagesSearch.UsagesSearchPackage;
 import org.jetbrains.kotlin.psi.*;
 import org.jetbrains.kotlin.resolve.BindingContext;
@@ -74,7 +76,7 @@ public class KotlinCallerMethodsTreeStructure extends KotlinCallTreeStructure {
             final Map<PsiReference, PsiElement> referencesToElements = new HashMap<PsiReference, PsiElement>();
             codeBlockForLocalDeclaration.accept(new CalleeReferenceVisitorBase(bindingContext, true) {
                 @Override
-                protected void processDeclaration(JetReferenceExpression reference, PsiElement declaration) {
+                protected void processDeclaration(JetSimpleNameExpression reference, PsiElement declaration) {
                     if (!declaration.equals(element)) return;
 
                     //noinspection unchecked
@@ -87,7 +89,7 @@ public class KotlinCallerMethodsTreeStructure extends KotlinCallTreeStructure {
                     }
 
                     if (container != null) {
-                        referencesToElements.put(reference.getReference(), container);
+                        referencesToElements.put(ReferencesPackage.getMainReference(reference), container);
                     }
                 }
             });
@@ -114,7 +116,14 @@ public class KotlinCallerMethodsTreeStructure extends KotlinCallTreeStructure {
             processPsiMethodCallers(propertyMethods, descriptor, methodToDescriptorMap, searchScope, false);
         }
         if (element instanceof JetClassOrObject) {
-            processJetClassOrObjectCallers((JetClassOrObject) element, descriptor, methodToDescriptorMap, searchScope);
+            JetPrimaryConstructor constructor = ((JetClassOrObject) element).getPrimaryConstructor();
+            if (constructor != null) {
+                PsiMethod lightMethod = LightClassUtil.getLightClassMethod(constructor);
+                processPsiMethodCallers(Collections.singleton(lightMethod), descriptor, methodToDescriptorMap, searchScope, false);
+            }
+            else {
+                processJetClassOrObjectCallers((JetClassOrObject) element, descriptor, methodToDescriptorMap, searchScope);
+            }
         }
 
         Object[] callers = methodToDescriptorMap.values().toArray(new Object[methodToDescriptorMap.size()]);
@@ -179,54 +188,74 @@ public class KotlinCallerMethodsTreeStructure extends KotlinCallTreeStructure {
     private Processor<PsiReference> defaultQueryProcessor(
             final HierarchyNodeDescriptor descriptor,
             final Map<PsiElement, HierarchyNodeDescriptor> methodToDescriptorMap,
-            final boolean kotlinOnly
+            boolean kotlinOnly
     ) {
-        return new ReadActionProcessor<PsiReference>() {
+        return new CalleeReferenceProcessor(kotlinOnly) {
             @Override
-            public boolean processInReadAction(PsiReference ref) {
-                // copied from Java
-                if (!(ref instanceof PsiReferenceExpression || ref instanceof JetReference)) {
-                    if (!(ref instanceof PsiElement)) {
-                        return true;
-                    }
-
-                    PsiElement parent = ((PsiElement) ref).getParent();
-                    if (parent instanceof PsiNewExpression) {
-                        if (((PsiNewExpression) parent).getClassReference() != ref) {
-                            return true;
-                        }
-                    }
-                    else if (parent instanceof PsiAnonymousClass) {
-                        if (((PsiAnonymousClass) parent).getBaseClassReference() != ref) {
-                            return true;
-                        }
-                    }
-                    else {
-                        return true;
-                    }
-                }
-
-                PsiElement refElement = ref.getElement();
-                if (PsiTreeUtil.getParentOfType(refElement, JetImportDirective.class, true) != null) return true;
-
-                PsiElement element = HierarchyUtils.getCallHierarchyElement(refElement);
-
-                if (kotlinOnly && !(element instanceof JetNamedDeclaration)) return true;
-
-                // If reference belongs to property initializer, show enclosing declaration instead
-                if (element instanceof JetProperty) {
-                    JetProperty property = (JetProperty) element;
-                    if (PsiTreeUtil.isAncestor(property.getInitializer(), refElement, false)) {
-                        element = HierarchyUtils.getCallHierarchyElement(element.getParent());
-                    }
-                }
-
-                if (element != null) {
-                    addNodeDescriptorForElement(ref, element, methodToDescriptorMap, descriptor);
-                }
-
-                return true;
+            protected void onAccept(@NotNull PsiReference ref, @NotNull PsiElement element) {
+                addNodeDescriptorForElement(ref, element, methodToDescriptorMap, descriptor);
             }
         };
     }
+
+    public static abstract class CalleeReferenceProcessor extends ReadActionProcessor<PsiReference> {
+        private final boolean kotlinOnly;
+
+        public CalleeReferenceProcessor(boolean only) {
+            kotlinOnly = only;
+        }
+
+        @Override
+        public boolean processInReadAction(PsiReference ref) {
+            // copied from Java
+            if (!(ref instanceof PsiReferenceExpression || ref instanceof JetReference)) {
+                if (!(ref instanceof PsiElement)) {
+                    return true;
+                }
+
+                PsiElement parent = ((PsiElement) ref).getParent();
+                if (parent instanceof PsiNewExpression) {
+                    if (((PsiNewExpression) parent).getClassReference() != ref) {
+                        return true;
+                    }
+                }
+                else if (parent instanceof PsiAnonymousClass) {
+                    if (((PsiAnonymousClass) parent).getBaseClassReference() != ref) {
+                        return true;
+                    }
+                }
+                else if (ref instanceof LightMemberReference) {
+                    PsiElement refTarget = ref.resolve();
+                    // Accept implicit superclass constructor reference in Java code
+                    if (!(refTarget instanceof PsiMethod && ((PsiMethod) refTarget).isConstructor())) return true;
+                }
+                else {
+                    return true;
+                }
+            }
+
+            PsiElement refElement = ref.getElement();
+            if (PsiTreeUtil.getParentOfType(refElement, JetImportDirective.class, true) != null) return true;
+
+            PsiElement element = HierarchyUtils.getCallHierarchyElement(refElement);
+
+            if (kotlinOnly && !(element instanceof JetNamedDeclaration)) return true;
+
+            // If reference belongs to property initializer, show enclosing declaration instead
+            if (element instanceof JetProperty) {
+                JetProperty property = (JetProperty) element;
+                if (PsiTreeUtil.isAncestor(property.getInitializer(), refElement, false)) {
+                    element = HierarchyUtils.getCallHierarchyElement(element.getParent());
+                }
+            }
+
+            if (element != null) {
+                onAccept(ref, element);
+            }
+
+            return true;
+        }
+
+        protected abstract void onAccept(@NotNull PsiReference ref, @NotNull PsiElement element);
+    }
 }
diff --git a/idea/src/org/jetbrains/kotlin/idea/highlighter/JetColorSettingsPage.java b/idea/src/org/jetbrains/kotlin/idea/highlighter/JetColorSettingsPage.java
deleted file mode 100644
index 9973ee92441..00000000000
--- a/idea/src/org/jetbrains/kotlin/idea/highlighter/JetColorSettingsPage.java
+++ /dev/null
@@ -1,188 +0,0 @@
-/*
- * Copyright 2010-2015 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.kotlin.idea.highlighter;
-
-import com.intellij.openapi.editor.colors.TextAttributesKey;
-import com.intellij.openapi.fileTypes.SyntaxHighlighter;
-import com.intellij.openapi.options.OptionsBundle;
-import com.intellij.openapi.options.colors.AttributesDescriptor;
-import com.intellij.openapi.options.colors.ColorDescriptor;
-import com.intellij.openapi.options.colors.ColorSettingsPage;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.kotlin.idea.JetBundle;
-import org.jetbrains.kotlin.idea.JetIcons;
-import org.jetbrains.kotlin.idea.JetLanguage;
-
-import javax.swing.*;
-import java.lang.reflect.Field;
-import java.lang.reflect.Modifier;
-import java.util.HashMap;
-import java.util.Map;
-
-public class JetColorSettingsPage implements ColorSettingsPage {
-    @Override
-    public Icon getIcon() {
-        return JetIcons.SMALL_LOGO;
-    }
-
-    @NotNull
-    @Override
-    public SyntaxHighlighter getHighlighter() {
-        return new JetHighlighter();
-    }
-
-    @NotNull
-    @Override
-    public String getDemoText() {
-        return "/* Block comment */\n" +
-               "<KEYWORD>package</KEYWORD> hello\n" +
-               "<KEYWORD>import</KEYWORD> kotlin.util.* // line comment\n" +
-               "\n" +
-               "/**\n" +
-               " * Doc comment here for `SomeClass`\n" +
-               " * @see Iterator#next()\n" +
-               " */\n" +
-               "<ANNOTATION>@deprecated</ANNOTATION>(\"Deprecated class\")\n" +
-               "<BUILTIN_ANNOTATION>public</BUILTIN_ANNOTATION> class <CLASS>MyClass</CLASS><<BUILTIN_ANNOTATION>out</BUILTIN_ANNOTATION> <TYPE_PARAMETER>T</TYPE_PARAMETER> : <TRAIT>Iterable</TRAIT><<TYPE_PARAMETER>T</TYPE_PARAMETER>>>(var <INSTANCE_PROPERTY><MUTABLE_VARIABLE>prop1</MUTABLE_VARIABLE></INSTANCE_PROPERTY> : Int) {\n" +
-               "    fun <FUNCTION_DECLARATION>foo</FUNCTION_DECLARATION>(<PARAMETER>nullable</PARAMETER> : String?, <PARAMETER>r</PARAMETER> : <TRAIT>Runnable</TRAIT>, <PARAMETER>f</PARAMETER> : () -> Int, <PARAMETER>fl</PARAMETER> : <TRAIT>FunctionLike</TRAIT>, dyn: dynamic) {\n" +
-               "        <FUNCTION_CALL><PACKAGE_FUNCTION_CALL>println</PACKAGE_FUNCTION_CALL></FUNCTION_CALL>(\"length\\nis ${<PARAMETER>nullable</PARAMETER><SAFE_ACCESS>?.</SAFE_ACCESS><INSTANCE_PROPERTY>length</INSTANCE_PROPERTY>} <INVALID_STRING_ESCAPE><STRING_ESCAPE>\\e</STRING_ESCAPE></INVALID_STRING_ESCAPE>\")\n" +
-               "        val <LOCAL_VARIABLE>ints</LOCAL_VARIABLE> = java.util.<CONSTRUCTOR_CALL>ArrayList</CONSTRUCTOR_CALL><Int?>(2)\n" +
-               "        <LOCAL_VARIABLE>ints</LOCAL_VARIABLE>[0] = 102 + <PARAMETER><VARIABLE_AS_FUNCTION_CALL>f</VARIABLE_AS_FUNCTION_CALL></PARAMETER>() + <PARAMETER><VARIABLE_AS_FUNCTION_LIKE_CALL>fl</VARIABLE_AS_FUNCTION_LIKE_CALL></PARAMETER>()\n" +
-               "        val <LOCAL_VARIABLE>myFun</LOCAL_VARIABLE> = <FUNCTION_LITERAL_BRACES_AND_ARROW>{</FUNCTION_LITERAL_BRACES_AND_ARROW> <FUNCTION_LITERAL_BRACES_AND_ARROW>-></FUNCTION_LITERAL_BRACES_AND_ARROW> \"\" <FUNCTION_LITERAL_BRACES_AND_ARROW>}</FUNCTION_LITERAL_BRACES_AND_ARROW>;\n" +
-               "        var <LOCAL_VARIABLE><MUTABLE_VARIABLE><WRAPPED_INTO_REF>ref</WRAPPED_INTO_REF></MUTABLE_VARIABLE></LOCAL_VARIABLE> = <LOCAL_VARIABLE>ints</LOCAL_VARIABLE>.<FUNCTION_CALL>size</FUNCTION_CALL>()\n" +
-               "        if (!<LOCAL_VARIABLE>ints</LOCAL_VARIABLE>.<EXTENSION_PROPERTY><PACKAGE_PROPERTY>empty</PACKAGE_PROPERTY></EXTENSION_PROPERTY>) {\n" +
-               "            <LOCAL_VARIABLE>ints</LOCAL_VARIABLE>.<EXTENSION_FUNCTION_CALL><PACKAGE_FUNCTION_CALL><FUNCTION_CALL>forEach</FUNCTION_CALL></PACKAGE_FUNCTION_CALL></EXTENSION_FUNCTION_CALL> <LABEL>lit@</LABEL> <FUNCTION_LITERAL_BRACES_AND_ARROW>{</FUNCTION_LITERAL_BRACES_AND_ARROW>\n" +
-               "                if (<FUNCTION_LITERAL_DEFAULT_PARAMETER>it</FUNCTION_LITERAL_DEFAULT_PARAMETER> == null) return<LABEL>@lit</LABEL>\n" +
-               "                <FUNCTION_CALL><PACKAGE_FUNCTION_CALL>println</PACKAGE_FUNCTION_CALL></FUNCTION_CALL>(<FUNCTION_LITERAL_DEFAULT_PARAMETER><SMART_CAST_VALUE>it</SMART_CAST_VALUE></FUNCTION_LITERAL_DEFAULT_PARAMETER> + <LOCAL_VARIABLE><MUTABLE_VARIABLE><WRAPPED_INTO_REF>ref</WRAPPED_INTO_REF></MUTABLE_VARIABLE></LOCAL_VARIABLE>)\n" +
-               "            <FUNCTION_LITERAL_BRACES_AND_ARROW>}</FUNCTION_LITERAL_BRACES_AND_ARROW>\n" +
-               "        }\n" +
-               "        dyn.<DYNAMIC_FUNCTION_CALL>dynamicCall</DYNAMIC_FUNCTION_CALL>()\n" +
-               "        dyn.<DYNAMIC_PROPERTY_CALL>dynamicProp</DYNAMIC_PROPERTY_CALL> = 5\n" +
-               "    }\n" +
-               "}\n" +
-               "\n" +
-               "var <PROPERTY_WITH_BACKING_FIELD><PACKAGE_PROPERTY><MUTABLE_VARIABLE>globalCounter</MUTABLE_VARIABLE></PACKAGE_PROPERTY></PROPERTY_WITH_BACKING_FIELD> : Int = 5\n" +
-               "    <KEYWORD>get</KEYWORD>() {\n" +
-               "        return <BACKING_FIELD_ACCESS><PACKAGE_PROPERTY><MUTABLE_VARIABLE>$globalCounter</MUTABLE_VARIABLE></PACKAGE_PROPERTY></BACKING_FIELD_ACCESS>\n" +
-               "    }\n" +
-               "\n" +
-               "<KEYWORD>public</KEYWORD> <KEYWORD>abstract</KEYWORD> class <ABSTRACT_CLASS>Abstract</ABSTRACT_CLASS> {\n" +
-               "}\n" +
-               "\n" +
-               "<KEYWORD>object</KEYWORD> <OBJECT>Obj</OBJECT>\n" +
-               "\n" +
-               "<KEYWORD>enum</KEYWORD> <KEYWORD>class</KEYWORD> <CLASS>E</CLASS> { <ENUM_ENTRY>A</ENUM_ENTRY> }\n" +
-               "               Bad character: \\n\n";
-    }
-
-    @Override
-    public Map<String, TextAttributesKey> getAdditionalHighlightingTagToDescriptorMap() {
-        Map<String, TextAttributesKey> map = new HashMap<String, TextAttributesKey>();
-        for (Field field : JetHighlightingColors.class.getFields()) {
-            if (Modifier.isStatic(field.getModifiers())) {
-                try {
-                    map.put(field.getName(), (TextAttributesKey) field.get(null));
-                }
-                catch (IllegalAccessException e) {
-                    assert false;
-                }
-            }
-        }
-        return map;
-    }
-
-    @NotNull
-    @Override
-    public AttributesDescriptor[] getAttributeDescriptors() {
-        return new AttributesDescriptor[]{
-            new AttributesDescriptor(OptionsBundle.message("options.java.attribute.descriptor.keyword"), JetHighlightingColors.KEYWORD),
-            new AttributesDescriptor(JetBundle.message("options.kotlin.attribute.descriptor.builtin.annotation"), JetHighlightingColors.BUILTIN_ANNOTATION),
-            new AttributesDescriptor(OptionsBundle.message("options.java.attribute.descriptor.number"), JetHighlightingColors.NUMBER),
-
-            new AttributesDescriptor(OptionsBundle.message("options.java.attribute.descriptor.string"), JetHighlightingColors.STRING),
-            new AttributesDescriptor(JetBundle.message("options.kotlin.attribute.descriptor.string.escape"), JetHighlightingColors.STRING_ESCAPE),
-            new AttributesDescriptor(OptionsBundle.message("options.java.attribute.descriptor.invalid.escape.in.string"), JetHighlightingColors.INVALID_STRING_ESCAPE),
-
-            new AttributesDescriptor(OptionsBundle.message("options.java.attribute.descriptor.operator.sign"), JetHighlightingColors.OPERATOR_SIGN),
-            new AttributesDescriptor(OptionsBundle.message("options.java.attribute.descriptor.parentheses"), JetHighlightingColors.PARENTHESIS),
-            new AttributesDescriptor(OptionsBundle.message("options.java.attribute.descriptor.braces"), JetHighlightingColors.BRACES),
-            new AttributesDescriptor(JetBundle.message("options.kotlin.attribute.descriptor.closure.braces"), JetHighlightingColors.FUNCTION_LITERAL_BRACES_AND_ARROW),
-            new AttributesDescriptor(JetBundle.message("options.kotlin.attribute.descriptor.arrow"), JetHighlightingColors.ARROW),
-            new AttributesDescriptor(OptionsBundle.message("options.java.attribute.descriptor.brackets"), JetHighlightingColors.BRACKETS),
-            new AttributesDescriptor(OptionsBundle.message("options.java.attribute.descriptor.comma"), JetHighlightingColors.COMMA),
-            new AttributesDescriptor(OptionsBundle.message("options.java.attribute.descriptor.semicolon"), JetHighlightingColors.SEMICOLON),
-            new AttributesDescriptor(OptionsBundle.message("options.java.attribute.descriptor.dot"), JetHighlightingColors.DOT),
-            new AttributesDescriptor(JetBundle.message("options.kotlin.attribute.descriptor.safe.access"), JetHighlightingColors.SAFE_ACCESS),
-
-            new AttributesDescriptor(OptionsBundle.message("options.java.attribute.descriptor.line.comment"), JetHighlightingColors.LINE_COMMENT),
-            new AttributesDescriptor(OptionsBundle.message("options.java.attribute.descriptor.block.comment"), JetHighlightingColors.BLOCK_COMMENT),
-
-            new AttributesDescriptor(JetBundle.message("options.kotlin.attribute.descriptor.kdoc.comment"), JetHighlightingColors.DOC_COMMENT),
-            new AttributesDescriptor(JetBundle.message("options.kotlin.attribute.descriptor.kdoc.tag"), JetHighlightingColors.KDOC_TAG),
-            new AttributesDescriptor(JetBundle.message("options.kotlin.attribute.descriptor.kdoc.value"), JetHighlightingColors.KDOC_LINK),
-
-            new AttributesDescriptor(OptionsBundle.message("options.java.attribute.descriptor.class"), JetHighlightingColors.CLASS),
-            new AttributesDescriptor(OptionsBundle.message("options.java.attribute.descriptor.type.parameter"), JetHighlightingColors.TYPE_PARAMETER),
-            new AttributesDescriptor(OptionsBundle.message("options.java.attribute.descriptor.abstract.class"), JetHighlightingColors.ABSTRACT_CLASS),
-            new AttributesDescriptor("Interface", JetHighlightingColors.TRAIT),
-            new AttributesDescriptor(JetBundle.message("options.kotlin.attribute.descriptor.annotation"), JetHighlightingColors.ANNOTATION),
-            new AttributesDescriptor(JetBundle.message("options.kotlin.attribute.descriptor.object"), JetHighlightingColors.OBJECT),
-            new AttributesDescriptor(JetBundle.message("options.kotlin.attribute.descriptor.enumEntry"), JetHighlightingColors.ENUM_ENTRY),
-
-            new AttributesDescriptor(JetBundle.message("options.kotlin.attribute.descriptor.var"), JetHighlightingColors.MUTABLE_VARIABLE),
-
-            new AttributesDescriptor(JetBundle.message("options.kotlin.attribute.descriptor.local.variable"), JetHighlightingColors.LOCAL_VARIABLE),
-            new AttributesDescriptor(OptionsBundle.message("options.java.attribute.descriptor.parameter"), JetHighlightingColors.PARAMETER),
-            new AttributesDescriptor(JetBundle.message("options.kotlin.attribute.descriptor.captured.variable"), JetHighlightingColors.WRAPPED_INTO_REF),
-
-            new AttributesDescriptor(JetBundle.message("options.kotlin.attribute.descriptor.instance.property"), JetHighlightingColors.INSTANCE_PROPERTY),
-            new AttributesDescriptor(JetBundle.message("options.kotlin.attribute.descriptor.package.property"), JetHighlightingColors.PACKAGE_PROPERTY),
-            new AttributesDescriptor(JetBundle.message("options.kotlin.attribute.descriptor.property.with.backing"), JetHighlightingColors.PROPERTY_WITH_BACKING_FIELD),
-            new AttributesDescriptor(JetBundle.message("options.kotlin.attribute.descriptor.backing.field.access"), JetHighlightingColors.BACKING_FIELD_ACCESS),
-            new AttributesDescriptor(JetBundle.message("options.kotlin.attribute.descriptor.extension.property"), JetHighlightingColors.EXTENSION_PROPERTY),
-            new AttributesDescriptor(JetBundle.message("options.kotlin.attribute.descriptor.dynamic.property"), JetHighlightingColors.DYNAMIC_PROPERTY_CALL),
-
-            new AttributesDescriptor(JetBundle.message("options.kotlin.attribute.descriptor.it"), JetHighlightingColors.FUNCTION_LITERAL_DEFAULT_PARAMETER),
-            new AttributesDescriptor(JetBundle.message("options.kotlin.attribute.descriptor.fun"), JetHighlightingColors.FUNCTION_DECLARATION),
-            new AttributesDescriptor(JetBundle.message("options.kotlin.attribute.descriptor.fun.call"), JetHighlightingColors.FUNCTION_CALL),
-            new AttributesDescriptor(JetBundle.message("options.kotlin.attribute.descriptor.dynamic.fun.call"), JetHighlightingColors.DYNAMIC_FUNCTION_CALL),
-            new AttributesDescriptor(JetBundle.message("options.kotlin.attribute.descriptor.package.fun.call"), JetHighlightingColors.PACKAGE_FUNCTION_CALL),
-            new AttributesDescriptor(JetBundle.message("options.kotlin.attribute.descriptor.extension.fun.call"), JetHighlightingColors.EXTENSION_FUNCTION_CALL),
-            new AttributesDescriptor(JetBundle.message("options.kotlin.attribute.descriptor.constructor.call"), JetHighlightingColors.CONSTRUCTOR_CALL),
-            new AttributesDescriptor(JetBundle.message("options.kotlin.attribute.descriptor.variable.as.function.call"), JetHighlightingColors.VARIABLE_AS_FUNCTION_CALL),
-            new AttributesDescriptor(JetBundle.message("options.kotlin.attribute.descriptor.variable.as.function.like.call"), JetHighlightingColors.VARIABLE_AS_FUNCTION_LIKE_CALL),
-
-            new AttributesDescriptor(OptionsBundle.message("options.java.attribute.descriptor.bad.character"), JetHighlightingColors.BAD_CHARACTER),
-
-            new AttributesDescriptor(JetBundle.message("options.kotlin.attribute.descriptor.smart.cast"), JetHighlightingColors.SMART_CAST_VALUE),
-
-            new AttributesDescriptor(JetBundle.message("options.kotlin.attribute.descriptor.label"), JetHighlightingColors.LABEL),
-        };
-    }
-
-    @NotNull
-    @Override
-    public ColorDescriptor[] getColorDescriptors() {
-        return ColorDescriptor.EMPTY_ARRAY;
-    }
-
-    @NotNull
-    @Override
-    public String getDisplayName() {
-        return JetLanguage.NAME;
-    }
-}
diff --git a/idea/src/org/jetbrains/kotlin/idea/highlighter/KotlinColorSettingsPage.kt b/idea/src/org/jetbrains/kotlin/idea/highlighter/KotlinColorSettingsPage.kt
new file mode 100644
index 00000000000..7dacdb5ac6b
--- /dev/null
+++ b/idea/src/org/jetbrains/kotlin/idea/highlighter/KotlinColorSettingsPage.kt
@@ -0,0 +1,154 @@
+/*
+ * Copyright 2010-2015 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.kotlin.idea.highlighter
+
+import com.intellij.openapi.editor.colors.TextAttributesKey
+import com.intellij.openapi.fileTypes.SyntaxHighlighter
+import com.intellij.openapi.options.OptionsBundle
+import com.intellij.openapi.options.colors.AttributesDescriptor
+import com.intellij.openapi.options.colors.ColorDescriptor
+import com.intellij.openapi.options.colors.ColorSettingsPage
+import org.jetbrains.kotlin.idea.JetBundle
+import org.jetbrains.kotlin.idea.JetIcons
+import org.jetbrains.kotlin.idea.JetLanguage
+
+import javax.swing.*
+import java.lang.reflect.Field
+import java.lang.reflect.Modifier
+import java.util.HashMap
+
+public class KotlinColorSettingsPage : ColorSettingsPage {
+    override fun getIcon() = JetIcons.SMALL_LOGO
+    override fun getHighlighter(): SyntaxHighlighter = JetHighlighter()
+
+    override fun getDemoText(): String {
+        return """/* Block comment */
+<KEYWORD>package</KEYWORD> hello
+<KEYWORD>import</KEYWORD> kotlin.util.* // line comment
+
+/**
+ * Doc comment here for `SomeClass`
+ * @see <KDOC_LINK>Iterator#next()</KDOC_LINK>
+ */
+<ANNOTATION>@deprecated</ANNOTATION>("Deprecated class")
+<BUILTIN_ANNOTATION>public</BUILTIN_ANNOTATION> class <CLASS>MyClass</CLASS><<BUILTIN_ANNOTATION>out</BUILTIN_ANNOTATION> <TYPE_PARAMETER>T</TYPE_PARAMETER> : <TRAIT>Iterable</TRAIT><<TYPE_PARAMETER>T</TYPE_PARAMETER>>>(var <INSTANCE_PROPERTY><MUTABLE_VARIABLE>prop1</MUTABLE_VARIABLE></INSTANCE_PROPERTY> : Int)
+    fun <FUNCTION_DECLARATION>foo</FUNCTION_DECLARATION>(<PARAMETER>nullable</PARAMETER> : String?, <PARAMETER>r</PARAMETER> : <TRAIT>Runnable</TRAIT>, <PARAMETER>f</PARAMETER> : () -> Int, <PARAMETER>fl</PARAMETER> : <TRAIT>FunctionLike</TRAIT>, dyn: dynamic) {
+        <FUNCTION_CALL><PACKAGE_FUNCTION_CALL>println</PACKAGE_FUNCTION_CALL></FUNCTION_CALL>("length\nis ${"$"}{<PARAMETER>nullable</PARAMETER><SAFE_ACCESS>?.</SAFE_ACCESS><INSTANCE_PROPERTY>length</INSTANCE_PROPERTY>} <INVALID_STRING_ESCAPE><STRING_ESCAPE>\e</STRING_ESCAPE></INVALID_STRING_ESCAPE>")
+        val <LOCAL_VARIABLE>ints</LOCAL_VARIABLE> = java.util.<CONSTRUCTOR_CALL>ArrayList</CONSTRUCTOR_CALL><Int?>(2)
+        <LOCAL_VARIABLE>ints</LOCAL_VARIABLE>[0] = 102 + <PARAMETER><VARIABLE_AS_FUNCTION_CALL>f</VARIABLE_AS_FUNCTION_CALL></PARAMETER>() + <PARAMETER><VARIABLE_AS_FUNCTION_LIKE_CALL>fl</VARIABLE_AS_FUNCTION_LIKE_CALL></PARAMETER>()
+        val <LOCAL_VARIABLE>myFun</LOCAL_VARIABLE> = <FUNCTION_LITERAL_BRACES_AND_ARROW>{</FUNCTION_LITERAL_BRACES_AND_ARROW> <FUNCTION_LITERAL_BRACES_AND_ARROW>-></FUNCTION_LITERAL_BRACES_AND_ARROW> "" <FUNCTION_LITERAL_BRACES_AND_ARROW>}</FUNCTION_LITERAL_BRACES_AND_ARROW>;
+        var <LOCAL_VARIABLE><MUTABLE_VARIABLE><WRAPPED_INTO_REF>ref</WRAPPED_INTO_REF></MUTABLE_VARIABLE></LOCAL_VARIABLE> = <LOCAL_VARIABLE>ints</LOCAL_VARIABLE>.<FUNCTION_CALL>size</FUNCTION_CALL>()
+        if (!<LOCAL_VARIABLE>ints</LOCAL_VARIABLE>.<EXTENSION_PROPERTY><PACKAGE_PROPERTY>empty</PACKAGE_PROPERTY></EXTENSION_PROPERTY>) {
+              <LOCAL_VARIABLE>ints</LOCAL_VARIABLE>.<EXTENSION_FUNCTION_CALL><PACKAGE_FUNCTION_CALL><FUNCTION_CALL>forEach</FUNCTION_CALL></PACKAGE_FUNCTION_CALL></EXTENSION_FUNCTION_CALL> <LABEL>lit@</LABEL> <FUNCTION_LITERAL_BRACES_AND_ARROW>{</FUNCTION_LITERAL_BRACES_AND_ARROW>
+                  if (<FUNCTION_LITERAL_DEFAULT_PARAMETER>it</FUNCTION_LITERAL_DEFAULT_PARAMETER> == null) return<LABEL>@lit</LABEL>
+                  <FUNCTION_CALL><PACKAGE_FUNCTION_CALL>println</PACKAGE_FUNCTION_CALL></FUNCTION_CALL>(<FUNCTION_LITERAL_DEFAULT_PARAMETER><SMART_CAST_VALUE>it</SMART_CAST_VALUE></FUNCTION_LITERAL_DEFAULT_PARAMETER> + <LOCAL_VARIABLE><MUTABLE_VARIABLE><WRAPPED_INTO_REF>ref</WRAPPED_INTO_REF></MUTABLE_VARIABLE></LOCAL_VARIABLE>)
+              <FUNCTION_LITERAL_BRACES_AND_ARROW>}</FUNCTION_LITERAL_BRACES_AND_ARROW>
+        }
+        dyn.<DYNAMIC_FUNCTION_CALL>dynamicCall</DYNAMIC_FUNCTION_CALL>()
+        dyn.<DYNAMIC_PROPERTY_CALL>dynamicProp</DYNAMIC_PROPERTY_CALL> = 5
+    }
+}
+
+var <PROPERTY_WITH_BACKING_FIELD><PACKAGE_PROPERTY><MUTABLE_VARIABLE>globalCounter</MUTABLE_VARIABLE></PACKAGE_PROPERTY></PROPERTY_WITH_BACKING_FIELD> : Int = 5
+    <KEYWORD>get</KEYWORD>() {
+        return <BACKING_FIELD_ACCESS><PACKAGE_PROPERTY><MUTABLE_VARIABLE>${"$"}globalCounter</MUTABLE_VARIABLE></PACKAGE_PROPERTY></BACKING_FIELD_ACCESS>
+    }
+
+<KEYWORD>public</KEYWORD> <KEYWORD>abstract</KEYWORD> class <ABSTRACT_CLASS>Abstract</ABSTRACT_CLASS> {
+}
+
+<KEYWORD>object</KEYWORD> <OBJECT>Obj</OBJECT>
+
+<KEYWORD>enum</KEYWORD> <KEYWORD>class</KEYWORD> <CLASS>E</CLASS> { <ENUM_ENTRY>A</ENUM_ENTRY> }
+               Bad character: \n
+"""
+    }
+
+    override fun getAdditionalHighlightingTagToDescriptorMap(): Map<String, TextAttributesKey> {
+        val map = HashMap<String, TextAttributesKey>()
+        for (field in javaClass<JetHighlightingColors>().getFields()) {
+            if (Modifier.isStatic(field.getModifiers())) {
+                try {
+                    map.put(field.getName(), field.get(null) as TextAttributesKey)
+                }
+                catch (e: IllegalAccessException) {
+                    assert(false)
+                }
+
+            }
+        }
+        return map
+    }
+
+    override fun getAttributeDescriptors(): Array<AttributesDescriptor> {
+        fun String.to(key: TextAttributesKey) = AttributesDescriptor(this, key)
+        
+        return arrayOf(OptionsBundle.message("options.java.attribute.descriptor.keyword") to JetHighlightingColors.KEYWORD, 
+                       JetBundle.message("options.kotlin.attribute.descriptor.builtin.annotation") to JetHighlightingColors.BUILTIN_ANNOTATION, 
+                       OptionsBundle.message("options.java.attribute.descriptor.number") to JetHighlightingColors.NUMBER,
+                       OptionsBundle.message("options.java.attribute.descriptor.string") to JetHighlightingColors.STRING, 
+                       JetBundle.message("options.kotlin.attribute.descriptor.string.escape") to JetHighlightingColors.STRING_ESCAPE, 
+                       OptionsBundle.message("options.java.attribute.descriptor.invalid.escape.in.string") to JetHighlightingColors.INVALID_STRING_ESCAPE,
+                       OptionsBundle.message("options.java.attribute.descriptor.operator.sign") to JetHighlightingColors.OPERATOR_SIGN, 
+                       OptionsBundle.message("options.java.attribute.descriptor.parentheses") to JetHighlightingColors.PARENTHESIS, 
+                       OptionsBundle.message("options.java.attribute.descriptor.braces") to JetHighlightingColors.BRACES, 
+                       JetBundle.message("options.kotlin.attribute.descriptor.closure.braces") to JetHighlightingColors.FUNCTION_LITERAL_BRACES_AND_ARROW, 
+                       JetBundle.message("options.kotlin.attribute.descriptor.arrow") to JetHighlightingColors.ARROW, 
+                       OptionsBundle.message("options.java.attribute.descriptor.brackets") to JetHighlightingColors.BRACKETS, 
+                       OptionsBundle.message("options.java.attribute.descriptor.comma") to JetHighlightingColors.COMMA, 
+                       OptionsBundle.message("options.java.attribute.descriptor.semicolon") to JetHighlightingColors.SEMICOLON, 
+                       OptionsBundle.message("options.java.attribute.descriptor.dot") to JetHighlightingColors.DOT, 
+                       JetBundle.message("options.kotlin.attribute.descriptor.safe.access") to JetHighlightingColors.SAFE_ACCESS,
+                       OptionsBundle.message("options.java.attribute.descriptor.line.comment") to JetHighlightingColors.LINE_COMMENT, 
+                       OptionsBundle.message("options.java.attribute.descriptor.block.comment") to JetHighlightingColors.BLOCK_COMMENT,
+                       JetBundle.message("options.kotlin.attribute.descriptor.kdoc.comment") to JetHighlightingColors.DOC_COMMENT, 
+                       JetBundle.message("options.kotlin.attribute.descriptor.kdoc.tag") to JetHighlightingColors.KDOC_TAG, 
+                       JetBundle.message("options.kotlin.attribute.descriptor.kdoc.value") to JetHighlightingColors.KDOC_LINK,
+                       OptionsBundle.message("options.java.attribute.descriptor.class") to JetHighlightingColors.CLASS, 
+                       OptionsBundle.message("options.java.attribute.descriptor.type.parameter") to JetHighlightingColors.TYPE_PARAMETER, 
+                       OptionsBundle.message("options.java.attribute.descriptor.abstract.class") to JetHighlightingColors.ABSTRACT_CLASS, 
+                       "Interface" to JetHighlightingColors.TRAIT, 
+                       JetBundle.message("options.kotlin.attribute.descriptor.annotation") to JetHighlightingColors.ANNOTATION, 
+                       JetBundle.message("options.kotlin.attribute.descriptor.object") to JetHighlightingColors.OBJECT, 
+                       JetBundle.message("options.kotlin.attribute.descriptor.enumEntry") to JetHighlightingColors.ENUM_ENTRY,
+                       JetBundle.message("options.kotlin.attribute.descriptor.var") to JetHighlightingColors.MUTABLE_VARIABLE,
+                       JetBundle.message("options.kotlin.attribute.descriptor.local.variable") to JetHighlightingColors.LOCAL_VARIABLE, 
+                       OptionsBundle.message("options.java.attribute.descriptor.parameter") to JetHighlightingColors.PARAMETER, 
+                       JetBundle.message("options.kotlin.attribute.descriptor.captured.variable") to JetHighlightingColors.WRAPPED_INTO_REF,
+                       JetBundle.message("options.kotlin.attribute.descriptor.instance.property") to JetHighlightingColors.INSTANCE_PROPERTY, 
+                       JetBundle.message("options.kotlin.attribute.descriptor.package.property") to JetHighlightingColors.PACKAGE_PROPERTY, 
+                       JetBundle.message("options.kotlin.attribute.descriptor.property.with.backing") to JetHighlightingColors.PROPERTY_WITH_BACKING_FIELD,
+                       JetBundle.message("options.kotlin.attribute.descriptor.backing.field.access") to JetHighlightingColors.BACKING_FIELD_ACCESS,
+                       JetBundle.message("options.kotlin.attribute.descriptor.extension.property") to JetHighlightingColors.EXTENSION_PROPERTY,
+                       JetBundle.message("options.kotlin.attribute.descriptor.dynamic.property") to JetHighlightingColors.DYNAMIC_PROPERTY_CALL,
+                       JetBundle.message("options.kotlin.attribute.descriptor.it") to JetHighlightingColors.FUNCTION_LITERAL_DEFAULT_PARAMETER,
+                       JetBundle.message("options.kotlin.attribute.descriptor.fun") to JetHighlightingColors.FUNCTION_DECLARATION, 
+                       JetBundle.message("options.kotlin.attribute.descriptor.fun.call") to JetHighlightingColors.FUNCTION_CALL, 
+                       JetBundle.message("options.kotlin.attribute.descriptor.dynamic.fun.call") to JetHighlightingColors.DYNAMIC_FUNCTION_CALL, 
+                       JetBundle.message("options.kotlin.attribute.descriptor.package.fun.call") to JetHighlightingColors.PACKAGE_FUNCTION_CALL, 
+                       JetBundle.message("options.kotlin.attribute.descriptor.extension.fun.call") to JetHighlightingColors.EXTENSION_FUNCTION_CALL, 
+                       JetBundle.message("options.kotlin.attribute.descriptor.constructor.call") to JetHighlightingColors.CONSTRUCTOR_CALL, 
+                       JetBundle.message("options.kotlin.attribute.descriptor.variable.as.function.call") to JetHighlightingColors.VARIABLE_AS_FUNCTION_CALL, 
+                       JetBundle.message("options.kotlin.attribute.descriptor.variable.as.function.like.call") to JetHighlightingColors.VARIABLE_AS_FUNCTION_LIKE_CALL,
+                       OptionsBundle.message("options.java.attribute.descriptor.bad.character") to JetHighlightingColors.BAD_CHARACTER,
+                       JetBundle.message("options.kotlin.attribute.descriptor.smart.cast") to JetHighlightingColors.SMART_CAST_VALUE,
+                       JetBundle.message("options.kotlin.attribute.descriptor.label") to JetHighlightingColors.LABEL)
+    }
+
+    override fun getColorDescriptors(): Array<ColorDescriptor> = ColorDescriptor.EMPTY_ARRAY
+    override fun getDisplayName(): String = JetLanguage.NAME
+}
diff --git a/idea/src/org/jetbrains/kotlin/idea/highlighter/KotlinHighlightExitPointsHandlerFactory.kt b/idea/src/org/jetbrains/kotlin/idea/highlighter/KotlinHighlightExitPointsHandlerFactory.kt
index fe6bca02f7f..5602581d7d4 100644
--- a/idea/src/org/jetbrains/kotlin/idea/highlighter/KotlinHighlightExitPointsHandlerFactory.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/highlighter/KotlinHighlightExitPointsHandlerFactory.kt
@@ -26,6 +26,7 @@ import com.intellij.psi.tree.TokenSet
 import com.intellij.psi.util.PsiTreeUtil
 import com.intellij.util.Consumer
 import org.jetbrains.kotlin.idea.caches.resolve.analyze
+import org.jetbrains.kotlin.idea.references.mainReference
 import org.jetbrains.kotlin.lexer.JetTokens
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.getNonStrictParentOfType
@@ -86,7 +87,7 @@ public class KotlinHighlightExitPointsHandlerFactory: HighlightUsagesHandlerFact
 
 private fun JetExpression.getRelevantFunction(): JetFunction? {
     if (this is JetReturnExpression) {
-        (this.getTargetLabel()?.getReference()?.resolve() as? JetFunction)?.let { return it }
+        (this.getTargetLabel()?.mainReference?.resolve() as? JetFunction)?.let { return it }
     }
     for (parent in parents) {
         if (InlineUtil.canBeInlineArgument(parent) && !InlineUtil.isInlinedArgument(parent as JetFunction, parent.analyze(), false)) {
diff --git a/idea/src/org/jetbrains/kotlin/idea/imports/KotlinImportOptimizer.kt b/idea/src/org/jetbrains/kotlin/idea/imports/KotlinImportOptimizer.kt
index 4a1a1994516..7fff9242ba2 100644
--- a/idea/src/org/jetbrains/kotlin/idea/imports/KotlinImportOptimizer.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/imports/KotlinImportOptimizer.kt
@@ -187,30 +187,31 @@ public class KotlinImportOptimizer() : ImportOptimizer {
                 }
 
                 override fun visitJetElement(element: JetElement) {
-                    val reference = element.getReference()
-                    if (reference is JetReference) {
-                        val referencedName = (element as? JetNameReferenceExpression)?.getReferencedNameAsName() //TODO: other types of references
+                    for (reference in element.getReferences()) {
+                        if (reference is JetReference) {
+                            val referencedName = (element as? JetNameReferenceExpression)?.getReferencedNameAsName() //TODO: other types of references
 
-                        val bindingContext = element.analyze()
-                        //class qualifiers that refer to companion objects should be considered (containing) class references
-                        val targets = bindingContext[BindingContext.SHORT_REFERENCE_TO_COMPANION_OBJECT, element as? JetReferenceExpression]?.let { listOf(it) }
-                                      ?: reference.resolveToDescriptors(bindingContext)
-                        for (target in targets) {
-                            if (!target.canBeReferencedViaImport()) continue
-                            if (target is PackageViewDescriptor && target.fqName.parent() == FqName.ROOT) continue // no need to import top-level packages
+                            val bindingContext = element.analyze()
+                            //class qualifiers that refer to companion objects should be considered (containing) class references
+                            val targets = bindingContext[BindingContext.SHORT_REFERENCE_TO_COMPANION_OBJECT, element as? JetReferenceExpression]?.let { listOf(it) }
+                                          ?: reference.resolveToDescriptors(bindingContext)
+                            for (target in targets) {
+                                if (!target.canBeReferencedViaImport()) continue
+                                if (target is PackageViewDescriptor && target.fqName.parent() == FqName.ROOT) continue // no need to import top-level packages
 
-                            if (!target.isExtension) { // for non-extension targets, count only non-qualified simple name usages
-                                if (element !is JetNameReferenceExpression) continue
-                                if (element.getIdentifier() == null) continue // skip 'this' etc
-                                if (element.getReceiverExpression() != null) continue
+                                if (!target.isExtension) { // for non-extension targets, count only non-qualified simple name usages
+                                    if (element !is JetNameReferenceExpression) continue
+                                    if (element.getIdentifier() == null) continue // skip 'this' etc
+                                    if (element.getReceiverExpression() != null) continue
+                                }
+
+                                val importableDescriptor = target.getImportableDescriptor()
+                                if (referencedName != null && importableDescriptor.getName() != referencedName) continue // resolved via alias
+
+                                if (isAccessibleAsMember(importableDescriptor, element)) continue
+
+                                usedDescriptors.add(importableDescriptor)
                             }
-
-                            val importableDescriptor = target.getImportableDescriptor()
-                            if (referencedName != null && importableDescriptor.getName() != referencedName) continue // resolved via alias
-
-                            if (isAccessibleAsMember(importableDescriptor, element)) continue
-
-                            usedDescriptors.add(importableDescriptor)
                         }
                     }
 
diff --git a/idea/src/org/jetbrains/kotlin/idea/inspections/AddReflectionQuickFix.kt b/idea/src/org/jetbrains/kotlin/idea/inspections/AddReflectionQuickFix.kt
new file mode 100644
index 00000000000..1f115ec83c4
--- /dev/null
+++ b/idea/src/org/jetbrains/kotlin/idea/inspections/AddReflectionQuickFix.kt
@@ -0,0 +1,79 @@
+/*
+ * Copyright 2010-2015 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.kotlin.idea.inspections
+
+import com.intellij.openapi.editor.Editor
+import com.intellij.openapi.extensions.Extensions
+import com.intellij.openapi.project.Project
+import com.intellij.openapi.roots.OrderRootType
+import com.intellij.openapi.vfs.VfsUtil
+import com.intellij.openapi.vfs.VfsUtilCore
+import org.jetbrains.kotlin.diagnostics.Diagnostic
+import org.jetbrains.kotlin.idea.JetBundle
+import org.jetbrains.kotlin.idea.configuration.ConfigureKotlinInProjectUtils
+import org.jetbrains.kotlin.idea.configuration.KotlinJavaModuleConfigurator
+import org.jetbrains.kotlin.idea.configuration.KotlinProjectConfigurator
+import org.jetbrains.kotlin.idea.framework.JavaRuntimePresentationProvider
+import org.jetbrains.kotlin.idea.quickfix.JetIntentionAction
+import org.jetbrains.kotlin.idea.quickfix.JetSingleIntentionActionFactory
+import org.jetbrains.kotlin.idea.quickfix.quickfixUtil.createIntentionForFirstParentOfType
+import org.jetbrains.kotlin.idea.versions.KotlinRuntimeLibraryUtil
+import org.jetbrains.kotlin.psi.JetElement
+import org.jetbrains.kotlin.psi.JetFile
+import org.jetbrains.kotlin.utils.PathUtil
+import org.jetbrains.kotlin.utils.addToStdlib.firstIsInstanceOrNull
+import java.io.File
+
+public class AddReflectionQuickFix(element: JetElement) : JetIntentionAction<JetElement>(element) {
+    override fun getText() = JetBundle.message("add.reflection.to.classpath")
+    override fun getFamilyName() = getText()
+
+    override fun invoke(project: Project, editor: Editor?, file: JetFile) {
+        val pluginReflectJar = PathUtil.getKotlinPathsForIdeaPlugin().getReflectPath()
+        if (!pluginReflectJar.exists()) return
+
+        val configurator = Extensions.getExtensions(KotlinProjectConfigurator.EP_NAME)
+                                   .firstIsInstanceOrNull<KotlinJavaModuleConfigurator>() ?: return
+
+        for (library in KotlinRuntimeLibraryUtil.findKotlinLibraries(project)) {
+            val runtimeJar = JavaRuntimePresentationProvider.getRuntimeJar(library) ?: continue
+            if (JavaRuntimePresentationProvider.getReflectJar(library) != null) continue
+
+            val model = library.getModifiableModel()
+
+            val libFilesDir = VfsUtilCore.virtualToIoFile(runtimeJar).getParent()
+            val reflectIoFile = File(libFilesDir, PathUtil.KOTLIN_JAVA_REFLECT_JAR)
+            if (reflectIoFile.exists()) {
+                model.addRoot(VfsUtil.getUrlForLibraryRoot(reflectIoFile), OrderRootType.CLASSES)
+            }
+            else {
+                val copied = configurator.copyFileToDir(pluginReflectJar, libFilesDir)!!
+                model.addRoot(VfsUtil.getUrlForLibraryRoot(copied), OrderRootType.CLASSES)
+            }
+
+            model.commit()
+
+            ConfigureKotlinInProjectUtils.showInfoNotification(
+                    "${PathUtil.KOTLIN_JAVA_REFLECT_JAR} was added to the library ${library.getName()}"
+            )
+        }
+    }
+
+    companion object : JetSingleIntentionActionFactory() {
+        override fun createAction(diagnostic: Diagnostic) = diagnostic.createIntentionForFirstParentOfType(::AddReflectionQuickFix)
+    }
+}
diff --git a/idea/src/org/jetbrains/kotlin/idea/inspections/ReflectionNotFoundInspection.kt b/idea/src/org/jetbrains/kotlin/idea/inspections/ReflectionNotFoundInspection.kt
deleted file mode 100644
index 53e9ec236b7..00000000000
--- a/idea/src/org/jetbrains/kotlin/idea/inspections/ReflectionNotFoundInspection.kt
+++ /dev/null
@@ -1,137 +0,0 @@
-/*
- * Copyright 2010-2015 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.kotlin.idea.inspections
-
-import com.intellij.codeInspection.LocalQuickFix
-import com.intellij.codeInspection.ProblemDescriptor
-import com.intellij.codeInspection.ProblemHighlightType
-import com.intellij.codeInspection.ProblemsHolder
-import com.intellij.openapi.extensions.Extensions
-import com.intellij.openapi.module.ModuleUtilCore
-import com.intellij.openapi.project.Project
-import com.intellij.openapi.roots.OrderRootType
-import com.intellij.openapi.vfs.VfsUtil
-import com.intellij.openapi.vfs.VfsUtilCore
-import com.intellij.psi.PsiElementVisitor
-import com.intellij.psi.PsiFile
-import org.jetbrains.kotlin.idea.JetBundle
-import org.jetbrains.kotlin.idea.caches.resolve.analyze
-import org.jetbrains.kotlin.idea.caches.resolve.findModuleDescriptor
-import org.jetbrains.kotlin.idea.configuration.ConfigureKotlinInProjectUtils
-import org.jetbrains.kotlin.idea.configuration.KotlinJavaModuleConfigurator
-import org.jetbrains.kotlin.idea.configuration.KotlinProjectConfigurator
-import org.jetbrains.kotlin.idea.framework.JavaRuntimePresentationProvider
-import org.jetbrains.kotlin.idea.project.ProjectStructureUtil
-import org.jetbrains.kotlin.idea.util.ProjectRootsUtil
-import org.jetbrains.kotlin.idea.versions.KotlinRuntimeLibraryUtil
-import org.jetbrains.kotlin.load.java.JvmAbi
-import org.jetbrains.kotlin.psi.JetDoubleColonExpression
-import org.jetbrains.kotlin.psi.JetFile
-import org.jetbrains.kotlin.psi.JetVisitorVoid
-import org.jetbrains.kotlin.resolve.BindingContext
-import org.jetbrains.kotlin.serialization.deserialization.findClassAcrossModuleDependencies
-import org.jetbrains.kotlin.builtins.ReflectionTypes
-import org.jetbrains.kotlin.psi.JetAnnotationEntry
-import org.jetbrains.kotlin.psi.psiUtil.getStrictParentOfType
-import org.jetbrains.kotlin.utils.PathUtil
-import org.jetbrains.kotlin.utils.addToStdlib.firstIsInstanceOrNull
-import org.jetbrains.kotlin.utils.singletonOrEmptyList
-import java.io.File
-
-public class ReflectionNotFoundInspection : AbstractKotlinInspection() {
-    override fun runForWholeFile() = true
-
-    override fun buildVisitor(holder: ProblemsHolder, isOnTheFly: Boolean): PsiElementVisitor {
-        if (!shouldReportInFile(holder.getFile())) return PsiElementVisitor.EMPTY_VISITOR
-
-        return object : JetVisitorVoid() {
-            private fun createQuickFix(): LocalQuickFix? {
-                val pluginReflectJar = PathUtil.getKotlinPathsForIdeaPlugin().getReflectPath()
-                if (pluginReflectJar.exists()) {
-                    val configurator =
-                            Extensions.getExtensions(KotlinProjectConfigurator.EP_NAME).firstIsInstanceOrNull<KotlinJavaModuleConfigurator>()
-
-                    if (configurator != null) {
-                        return AddReflectJarQuickFix(configurator, pluginReflectJar)
-                    }
-                }
-
-                return null
-            }
-
-            override fun visitDoubleColonExpression(expression: JetDoubleColonExpression) {
-                val expectedType = expression.analyze().get(BindingContext.EXPECTED_EXPRESSION_TYPE, expression)
-                if (expectedType != null && !ReflectionTypes.isReflectionType(expectedType)) return
-
-                if (expression.getStrictParentOfType<JetAnnotationEntry>() != null) return
-
-                // If a callable reference is used where a KFunction/KProperty/... expected, we should report that usage as dangerous
-                // because reflection features will fail without kotlin-reflect.jar in the classpath.
-                // If it's only used as a Function however (for example, "list.map(::function)"), we should not report anything
-                holder.registerProblem(
-                        expression.getDoubleColonTokenReference(),
-                        JetBundle.message("reflection.not.found"),
-                        ProblemHighlightType.GENERIC_ERROR_OR_WARNING,
-                        *(createQuickFix().singletonOrEmptyList().toTypedArray())
-                )
-            }
-        }
-    }
-
-    private fun shouldReportInFile(file: PsiFile): Boolean {
-        if (file !is JetFile || !ProjectRootsUtil.isInProjectSource(file)) return false
-
-        val module = ModuleUtilCore.findModuleForPsiElement(file)
-        if (module == null || !ProjectStructureUtil.isJavaKotlinModule(module)) return false
-
-        return file.findModuleDescriptor().findClassAcrossModuleDependencies(JvmAbi.REFLECTION_FACTORY_IMPL) == null
-    }
-
-    class AddReflectJarQuickFix(
-            val configurator: KotlinJavaModuleConfigurator,
-            val pluginReflectJar: File
-    ) : LocalQuickFix {
-        override fun getName() = JetBundle.message("add.reflection.to.classpath")
-
-        override fun getFamilyName() = getName()
-
-        override fun applyFix(project: Project, descriptor: ProblemDescriptor?) {
-            for (library in KotlinRuntimeLibraryUtil.findKotlinLibraries(project)) {
-                val runtimeJar = JavaRuntimePresentationProvider.getRuntimeJar(library) ?: continue
-                if (JavaRuntimePresentationProvider.getReflectJar(library) != null) continue
-
-                val model = library.getModifiableModel()
-
-                val libFilesDir = VfsUtilCore.virtualToIoFile(runtimeJar).getParent()
-                val reflectIoFile = File(libFilesDir, PathUtil.KOTLIN_JAVA_REFLECT_JAR)
-                if (reflectIoFile.exists()) {
-                    model.addRoot(VfsUtil.getUrlForLibraryRoot(reflectIoFile), OrderRootType.CLASSES)
-                }
-                else {
-                    val copied = configurator.copyFileToDir(pluginReflectJar, libFilesDir)!!
-                    model.addRoot(VfsUtil.getUrlForLibraryRoot(copied), OrderRootType.CLASSES)
-                }
-
-                model.commit()
-
-                ConfigureKotlinInProjectUtils.showInfoNotification(
-                        "${PathUtil.KOTLIN_JAVA_REFLECT_JAR} was added to the library ${library.getName()}"
-                )
-            }
-        }
-    }
-}
diff --git a/idea/src/org/jetbrains/kotlin/idea/inspections/UnusedReceiverParameterInspection.kt b/idea/src/org/jetbrains/kotlin/idea/inspections/UnusedReceiverParameterInspection.kt
index 3d2231f09a6..fcd3e47d85e 100644
--- a/idea/src/org/jetbrains/kotlin/idea/inspections/UnusedReceiverParameterInspection.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/inspections/UnusedReceiverParameterInspection.kt
@@ -95,10 +95,10 @@ public class UnusedReceiverParameterInspection : AbstractKotlinInspection() {
             return JetBundle.message("unused.receiver.parameter.remove")
         }
 
-        override fun applyFix(project: Project, descriptor: ProblemDescriptor?) {
+        override fun applyFix(project: Project, descriptor: ProblemDescriptor) {
             declaration.setReceiverTypeReference(null)
         }
 
-        override fun getFamilyName(): String = "whatever"
+        override fun getFamilyName(): String = getName()
     }
 }
diff --git a/idea/src/org/jetbrains/kotlin/idea/inspections/UnusedSymbolInspection.kt b/idea/src/org/jetbrains/kotlin/idea/inspections/UnusedSymbolInspection.kt
index 8f6283189ab..4aa5f387255 100644
--- a/idea/src/org/jetbrains/kotlin/idea/inspections/UnusedSymbolInspection.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/inspections/UnusedSymbolInspection.kt
@@ -110,9 +110,9 @@ public class UnusedSymbolInspection : AbstractKotlinInspection() {
                 return object : LocalQuickFix {
                     override fun getName() = QuickFixBundle.message("safe.delete.text", declaration.getName())
 
-                    override fun getFamilyName() = "whatever"
+                    override fun getFamilyName() = "Safe delete"
 
-                    override fun applyFix(project: Project, descriptor: ProblemDescriptor?) {
+                    override fun applyFix(project: Project, descriptor: ProblemDescriptor) {
                         if (!FileModificationService.getInstance().prepareFileForWrite(declaration.getContainingFile())) return
                         SafeDeleteHandler.invoke(project, arrayOf(declaration), false)
                     }
@@ -188,7 +188,7 @@ public class UnusedSymbolInspection : AbstractKotlinInspection() {
 
     private fun isConventionalName(namedDeclaration: JetNamedDeclaration): Boolean {
         val name = namedDeclaration.getNameAsName()
-        return name.getOperationSymbolsToSearch().isNotEmpty() || name == OperatorConventions.INVOKE
+        return name!!.getOperationSymbolsToSearch().isNotEmpty() || name == OperatorConventions.INVOKE
     }
 
     private fun hasNonTrivialUsages(declaration: JetNamedDeclaration): Boolean {
@@ -200,7 +200,7 @@ public class UnusedSymbolInspection : AbstractKotlinInspection() {
 
             for (name in listOf(declaration.getName()) + declaration.getAccessorNames() + declaration.getClassNameForCompanionObject().singletonOrEmptyList()) {
                 assert(name != null) { "Name is null for " + declaration.getElementTextWithContext() }
-                when (psiSearchHelper.isCheapEnoughToSearch(name, useScope, null, null)) {
+                when (psiSearchHelper.isCheapEnoughToSearch(name!!, useScope, null, null)) {
                     ZERO_OCCURRENCES -> {} // go on, check other names
                     FEW_OCCURRENCES -> zeroOccurrences = false
                     TOO_MANY_OCCURRENCES -> return true // searching usages is too expensive; behave like it is used
diff --git a/idea/src/org/jetbrains/kotlin/idea/intentions/ConvertFunctionToPropertyIntention.kt b/idea/src/org/jetbrains/kotlin/idea/intentions/ConvertFunctionToPropertyIntention.kt
index 888360dce79..19f3bb5481c 100644
--- a/idea/src/org/jetbrains/kotlin/idea/intentions/ConvertFunctionToPropertyIntention.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/intentions/ConvertFunctionToPropertyIntention.kt
@@ -25,7 +25,6 @@ import com.intellij.psi.*
 import com.intellij.util.containers.MultiMap
 import org.jetbrains.kotlin.asJava.namedUnwrappedElement
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns
-import org.jetbrains.kotlin.codegen.PropertyCodegen
 import org.jetbrains.kotlin.descriptors.CallableDescriptor
 import org.jetbrains.kotlin.descriptors.FunctionDescriptor
 import org.jetbrains.kotlin.idea.caches.resolve.analyze
@@ -43,7 +42,8 @@ import org.jetbrains.kotlin.idea.search.usagesSearch.search
 import org.jetbrains.kotlin.idea.util.IdeDescriptorRenderers
 import org.jetbrains.kotlin.idea.util.ShortenReferences
 import org.jetbrains.kotlin.idea.util.application.executeWriteCommand
-import org.jetbrains.kotlin.idea.util.supertypes
+import org.jetbrains.kotlin.load.java.JvmAbi
+import org.jetbrains.kotlin.types.typeUtil.supertypes
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.getParentOfTypeAndBranch
@@ -85,13 +85,13 @@ public class ConvertFunctionToPropertyIntention : JetSelfTargetingIntention<JetN
 
             val property = originalFunction.replace(psiFactory.createProperty(function.getText())) as JetProperty
             if (needsExplicitType) {
-                elementsToShorten.add(property.getTypeReference())
+                elementsToShorten.add(property.getTypeReference()!!)
             }
         }
 
         override fun performRefactoring(descriptorsForChange: Collection<CallableDescriptor>) {
             val conflicts = MultiMap<PsiElement, String>()
-            val getterName = PropertyCodegen.getterName(callableDescriptor.getName())
+            val getterName = JvmAbi.getterName(callableDescriptor.getName().asString())
             val callables = getAffectedCallables(project, descriptorsForChange)
             val kotlinCalls = ArrayList<JetCallElement>()
             val foreignRefs = ArrayList<PsiReference>()
diff --git a/idea/src/org/jetbrains/kotlin/idea/intentions/ConvertPropertyToFunctionIntention.kt b/idea/src/org/jetbrains/kotlin/idea/intentions/ConvertPropertyToFunctionIntention.kt
index 6a10c55f324..c533ba50d4d 100644
--- a/idea/src/org/jetbrains/kotlin/idea/intentions/ConvertPropertyToFunctionIntention.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/intentions/ConvertPropertyToFunctionIntention.kt
@@ -24,7 +24,6 @@ import com.intellij.psi.*
 import com.intellij.refactoring.util.RefactoringUIUtil
 import com.intellij.util.containers.MultiMap
 import org.jetbrains.kotlin.asJava.namedUnwrappedElement
-import org.jetbrains.kotlin.codegen.PropertyCodegen
 import org.jetbrains.kotlin.descriptors.CallableDescriptor
 import org.jetbrains.kotlin.idea.caches.resolve.analyze
 import org.jetbrains.kotlin.idea.codeInsight.DescriptorToSourceUtilsIde
@@ -39,6 +38,7 @@ import org.jetbrains.kotlin.idea.search.usagesSearch.DefaultSearchHelper
 import org.jetbrains.kotlin.idea.search.usagesSearch.UsagesSearchTarget
 import org.jetbrains.kotlin.idea.search.usagesSearch.search
 import org.jetbrains.kotlin.idea.util.application.executeWriteCommand
+import org.jetbrains.kotlin.load.java.JvmAbi
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.getStrictParentOfType
 import org.jetbrains.kotlin.psi.psiUtil.siblings
@@ -80,7 +80,7 @@ public class ConvertPropertyToFunctionIntention : JetSelfTargetingIntention<JetP
 
         override fun performRefactoring(descriptorsForChange: Collection<CallableDescriptor>) {
             val propertyName = callableDescriptor.getName().asString()
-            val getterName = PropertyCodegen.getterName(callableDescriptor.getName())
+            val getterName = JvmAbi.getterName(callableDescriptor.getName().asString())
             val conflicts = MultiMap<PsiElement, String>()
             val callables = getAffectedCallables(project, descriptorsForChange)
             val kotlinRefs = ArrayList<JetSimpleNameExpression>()
diff --git a/idea/src/org/jetbrains/kotlin/idea/intentions/ConvertToStringTemplateIntention.kt b/idea/src/org/jetbrains/kotlin/idea/intentions/ConvertToStringTemplateIntention.kt
index 52f70e28e34..ca5a53a417a 100644
--- a/idea/src/org/jetbrains/kotlin/idea/intentions/ConvertToStringTemplateIntention.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/intentions/ConvertToStringTemplateIntention.kt
@@ -25,7 +25,6 @@ import org.jetbrains.kotlin.idea.core.replaced
 import org.jetbrains.kotlin.idea.inspections.IntentionBasedInspection
 import org.jetbrains.kotlin.lexer.JetTokens
 import org.jetbrains.kotlin.psi.*
-import org.jetbrains.kotlin.resolve.constants.IntegerValueTypeConstant
 import org.jetbrains.kotlin.resolve.constants.evaluate.ConstantExpressionEvaluator
 
 public class ConvertToStringTemplateInspection : IntentionBasedInspection<JetBinaryExpression>(
@@ -90,13 +89,7 @@ public class ConvertToStringTemplateIntention : JetSelfTargetingOffsetIndependen
             is JetConstantExpression -> {
                 val bindingContext = expression.analyze()
                 val constant = ConstantExpressionEvaluator.getConstant(expression, bindingContext)
-                if (constant is IntegerValueTypeConstant) {
-                    val type = bindingContext.getType(expression)!!
-                    constant.getValue(type).toString()
-                }
-                else {
-                    constant?.getValue().toString()
-                }
+                constant?.getValue(bindingContext.getType(expression)!!).toString()
             }
 
             is JetStringTemplateExpression -> {
diff --git a/idea/src/org/jetbrains/kotlin/idea/intentions/DeprecatedCallableAddReplaceWithIntention.kt b/idea/src/org/jetbrains/kotlin/idea/intentions/DeprecatedCallableAddReplaceWithIntention.kt
index 08334bcac61..d1e79de71d7 100644
--- a/idea/src/org/jetbrains/kotlin/idea/intentions/DeprecatedCallableAddReplaceWithIntention.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/intentions/DeprecatedCallableAddReplaceWithIntention.kt
@@ -31,7 +31,7 @@ import org.jetbrains.kotlin.idea.inspections.IntentionBasedInspection
 import org.jetbrains.kotlin.idea.quickfix.moveCaret
 import org.jetbrains.kotlin.idea.util.ImportInsertHelper
 import org.jetbrains.kotlin.idea.util.ShortenReferences
-import org.jetbrains.kotlin.idea.util.isUnit
+import org.jetbrains.kotlin.types.typeUtil.isUnit
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.getReceiverExpression
 import org.jetbrains.kotlin.resolve.BindingContext
@@ -94,7 +94,7 @@ public class DeprecatedCallableAddReplaceWithIntention : JetSelfTargetingRangeIn
         }.toString()
 
         var argument = psiFactory.createArgument(psiFactory.createExpression(argumentText))
-        argument = annotationEntry.getValueArgumentList().addArgument(argument)
+        argument = annotationEntry.getValueArgumentList()!!.addArgument(argument)
         argument = ShortenReferences.DEFAULT.process(argument) as JetValueArgument
 
         PsiDocumentManager.getInstance(argument.getProject()).doPostponedOperationsAndUnblockDocument(editor.getDocument())
diff --git a/idea/src/org/jetbrains/kotlin/idea/intentions/IfNullToElvisIntention.kt b/idea/src/org/jetbrains/kotlin/idea/intentions/IfNullToElvisIntention.kt
index a1a1b9a55da..9ad9f06d699 100644
--- a/idea/src/org/jetbrains/kotlin/idea/intentions/IfNullToElvisIntention.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/intentions/IfNullToElvisIntention.kt
@@ -24,7 +24,7 @@ import com.intellij.psi.PsiRecursiveElementVisitor
 import org.jetbrains.kotlin.idea.caches.resolve.analyze
 import org.jetbrains.kotlin.idea.inspections.IntentionBasedInspection
 import org.jetbrains.kotlin.idea.intentions.branchedTransformations.expressionComparedToNull
-import org.jetbrains.kotlin.idea.util.isNothing
+import org.jetbrains.kotlin.types.typeUtil.isNothing
 import org.jetbrains.kotlin.lexer.JetTokens
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.endOffset
diff --git a/idea/src/org/jetbrains/kotlin/idea/intentions/InvertIfConditionIntention.kt b/idea/src/org/jetbrains/kotlin/idea/intentions/InvertIfConditionIntention.kt
index 1e8742deb9b..d9e67831790 100644
--- a/idea/src/org/jetbrains/kotlin/idea/intentions/InvertIfConditionIntention.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/intentions/InvertIfConditionIntention.kt
@@ -25,7 +25,7 @@ import org.jetbrains.kotlin.descriptors.FunctionDescriptor
 import org.jetbrains.kotlin.idea.caches.resolve.resolveToDescriptor
 import org.jetbrains.kotlin.idea.core.replaced
 import org.jetbrains.kotlin.idea.quickfix.moveCaret
-import org.jetbrains.kotlin.idea.util.isUnit
+import org.jetbrains.kotlin.types.typeUtil.isUnit
 import org.jetbrains.kotlin.idea.util.psi.patternMatching.matches
 import org.jetbrains.kotlin.lexer.JetTokens
 import org.jetbrains.kotlin.psi.*
diff --git a/idea/src/org/jetbrains/kotlin/idea/intentions/IterateExpressionIntention.kt b/idea/src/org/jetbrains/kotlin/idea/intentions/IterateExpressionIntention.kt
index ec785497546..8c430d1e63a 100644
--- a/idea/src/org/jetbrains/kotlin/idea/intentions/IterateExpressionIntention.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/intentions/IterateExpressionIntention.kt
@@ -50,7 +50,7 @@ public class IterateExpressionIntention : JetSelfTargetingIntention<JetExpressio
         val bindingContext = expression.analyze(BodyResolveMode.PARTIAL)
         val type = bindingContext.getType(expression) ?: return null
         val moduleDescriptor = expression.getResolutionFacade().findModuleDescriptor(expression)
-        val scope = bindingContext[BindingContext.RESOLUTION_SCOPE, expression]
+        val scope = bindingContext[BindingContext.RESOLUTION_SCOPE, expression]!!
         val elementType = IterableTypesDetector(expression.getProject(), moduleDescriptor, scope).elementType(type)?.type ?: return null
         return Data(type, elementType)
     }
diff --git a/idea/src/org/jetbrains/kotlin/idea/intentions/MoveLambdaOutsideParenthesesIntention.kt b/idea/src/org/jetbrains/kotlin/idea/intentions/MoveLambdaOutsideParenthesesIntention.kt
index 53a9a56b0cc..06923854d19 100644
--- a/idea/src/org/jetbrains/kotlin/idea/intentions/MoveLambdaOutsideParenthesesIntention.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/intentions/MoveLambdaOutsideParenthesesIntention.kt
@@ -45,7 +45,7 @@ public class MoveLambdaOutsideParenthesesIntention : JetSelfTargetingIntention<J
             // if there are functions among candidates but none of them have last function parameter then not show the intention
             if (candidates.isNotEmpty() && candidates.none {
                 val lastParameter = it.getValueParameters().lastOrNull()
-                lastParameter != null && KotlinBuiltIns.isFunctionOrExtensionFunctionType(lastParameter.getType())
+                lastParameter != null && KotlinBuiltIns.isExactFunctionOrExtensionFunctionType(lastParameter.getType())
             }) {
                 return false
             }
diff --git a/idea/src/org/jetbrains/kotlin/idea/intentions/ReplaceExplicitFunctionLiteralParamWithItIntention.kt b/idea/src/org/jetbrains/kotlin/idea/intentions/ReplaceExplicitFunctionLiteralParamWithItIntention.kt
index ae2fa4b3bf1..5fff4887cbc 100644
--- a/idea/src/org/jetbrains/kotlin/idea/intentions/ReplaceExplicitFunctionLiteralParamWithItIntention.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/intentions/ReplaceExplicitFunctionLiteralParamWithItIntention.kt
@@ -28,6 +28,7 @@ import org.jetbrains.kotlin.descriptors.ParameterDescriptor
 import org.jetbrains.kotlin.descriptors.impl.AnonymousFunctionDescriptor
 import org.jetbrains.kotlin.idea.caches.resolve.analyze
 import org.jetbrains.kotlin.idea.references.JetReference
+import org.jetbrains.kotlin.idea.references.mainReference
 import org.jetbrains.kotlin.psi.JetFunctionLiteral
 import org.jetbrains.kotlin.psi.JetSimpleNameExpression
 import org.jetbrains.kotlin.psi.psiUtil.endOffset
@@ -57,8 +58,8 @@ public class ReplaceExplicitFunctionLiteralParamWithItIntention() : PsiElementBa
     private fun targetFunctionLiteral(element: PsiElement, caretOffset: Int): JetFunctionLiteral? {
         val expression = element.getParentOfType<JetSimpleNameExpression>(true)
         if (expression != null) {
-            val reference = expression.getReference() as JetReference?
-            val target = reference?.resolveToDescriptors(expression.analyze())?.firstOrNull() as? ParameterDescriptor ?: return null
+            val target = expression.mainReference.resolveToDescriptors(expression.analyze())
+                                 .singleOrNull() as? ParameterDescriptor ?: return null
             val functionDescriptor = target.getContainingDeclaration() as? AnonymousFunctionDescriptor ?: return null
             return DescriptorToSourceUtils.descriptorToDeclaration(functionDescriptor) as? JetFunctionLiteral
         }
diff --git a/idea/src/org/jetbrains/kotlin/idea/intentions/ReplaceItWithExplicitFunctionLiteralParamIntention.kt b/idea/src/org/jetbrains/kotlin/idea/intentions/ReplaceItWithExplicitFunctionLiteralParamIntention.kt
index 3c93a461dfb..6f1384660c0 100644
--- a/idea/src/org/jetbrains/kotlin/idea/intentions/ReplaceItWithExplicitFunctionLiteralParamIntention.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/intentions/ReplaceItWithExplicitFunctionLiteralParamIntention.kt
@@ -22,6 +22,7 @@ import com.intellij.psi.PsiDocumentManager
 import com.intellij.refactoring.rename.inplace.VariableInplaceRenameHandler
 import org.jetbrains.kotlin.idea.caches.resolve.analyze
 import org.jetbrains.kotlin.idea.references.JetReference
+import org.jetbrains.kotlin.idea.references.mainReference
 import org.jetbrains.kotlin.psi.JetFunctionLiteral
 import org.jetbrains.kotlin.psi.JetFunctionLiteralExpression
 import org.jetbrains.kotlin.psi.JetPsiFactory
@@ -35,8 +36,7 @@ public class ReplaceItWithExplicitFunctionLiteralParamIntention() : JetSelfTarge
             = isAutoCreatedItUsage(element)
 
     override fun applyTo(element: JetSimpleNameExpression, editor: Editor) {
-        val reference = element.getReference() as JetReference
-        val target = reference.resolveToDescriptors(element.analyze()).single()
+        val target = element.mainReference.resolveToDescriptors(element.analyze()).single()
 
         val functionLiteral = DescriptorToSourceUtils.descriptorToDeclaration(target.getContainingDeclaration()!!) as JetFunctionLiteral
 
diff --git a/idea/src/org/jetbrains/kotlin/idea/intentions/UsePropertyAccessSyntaxIntention.kt b/idea/src/org/jetbrains/kotlin/idea/intentions/UsePropertyAccessSyntaxIntention.kt
new file mode 100644
index 00000000000..f162840b7f2
--- /dev/null
+++ b/idea/src/org/jetbrains/kotlin/idea/intentions/UsePropertyAccessSyntaxIntention.kt
@@ -0,0 +1,128 @@
+/*
+ * Copyright 2010-2015 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.kotlin.idea.intentions
+
+import com.intellij.codeInspection.ProblemHighlightType
+import com.intellij.openapi.editor.Editor
+import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
+import org.jetbrains.kotlin.descriptors.DeclarationDescriptorWithVisibility
+import org.jetbrains.kotlin.descriptors.FunctionDescriptor
+import org.jetbrains.kotlin.descriptors.PropertyDescriptor
+import org.jetbrains.kotlin.idea.caches.resolve.analyze
+import org.jetbrains.kotlin.idea.caches.resolve.getResolutionFacade
+import org.jetbrains.kotlin.idea.codeInsight.ReferenceVariantsHelper
+import org.jetbrains.kotlin.idea.core.getResolutionScope
+import org.jetbrains.kotlin.idea.core.isVisible
+import org.jetbrains.kotlin.idea.inspections.IntentionBasedInspection
+import org.jetbrains.kotlin.load.java.descriptors.JavaClassDescriptor
+import org.jetbrains.kotlin.name.Name
+import org.jetbrains.kotlin.psi.*
+import org.jetbrains.kotlin.psi.psiUtil.getQualifiedExpressionForSelector
+import org.jetbrains.kotlin.renderer.render
+import org.jetbrains.kotlin.resolve.calls.callUtil.getResolvedCall
+import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode
+import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter
+import org.jetbrains.kotlin.resolve.scopes.JetScope
+import org.jetbrains.kotlin.synthetic.SyntheticJavaPropertyDescriptor
+
+class UsePropertyAccessSyntaxInspection : IntentionBasedInspection<JetCallExpression>(UsePropertyAccessSyntaxIntention())
+
+class UsePropertyAccessSyntaxIntention : JetSelfTargetingOffsetIndependentIntention<JetCallExpression>(javaClass(), "Use property access syntax") {
+    override fun isApplicableTo(element: JetCallExpression): Boolean {
+        if (element.getQualifiedExpressionForSelector()?.getReceiverExpression() is JetSuperExpression) return false // cannot call extensions on "super"
+
+        return findExtensionPropertyToUse(element) != null
+    }
+
+    override fun applyTo(element: JetCallExpression, editor: Editor) {
+        val propertyName = findExtensionPropertyToUse(element)!!.getName()
+        val arguments = element.getValueArguments()
+        when (arguments.size()) {
+            0 -> replaceWithPropertyGet(element, propertyName)
+            1 -> replaceWithPropertySet(element, propertyName, arguments.single())
+            else -> error("More than one argument in call to accessor")
+        }
+    }
+
+    private fun findExtensionPropertyToUse(callExpression: JetCallExpression): PropertyDescriptor? {
+        val callee = callExpression.getCalleeExpression() as? JetSimpleNameExpression ?: return null
+
+        val bindingContext = callExpression.analyze(BodyResolveMode.PARTIAL)
+        val resolvedCall = callExpression.getResolvedCall(bindingContext) ?: return null
+        if (!resolvedCall.getStatus().isSuccess()) return null
+
+        val function = resolvedCall.getResultingDescriptor() as? FunctionDescriptor ?: return null
+        val resolutionScope = callExpression.getResolutionScope(bindingContext, callExpression.getResolutionFacade())
+        val property = findSyntheticProperty(function, resolutionScope) ?: return null
+
+        val moduleDescriptor = callExpression.getResolutionFacade().findModuleDescriptor(callExpression)
+        val inDescriptor = resolutionScope.getContainingDeclaration()
+
+        fun isVisible(descriptor: DeclarationDescriptor): Boolean {
+            return if (descriptor is DeclarationDescriptorWithVisibility)
+                descriptor.isVisible(inDescriptor, bindingContext, callee)
+            else
+                true
+        }
+
+        val referenceVariantsHelper = ReferenceVariantsHelper(bindingContext, moduleDescriptor, callExpression.getProject(), ::isVisible)
+        val propertyName = property.getName()
+        val accessibleVariables = referenceVariantsHelper.getReferenceVariants(callee, DescriptorKindFilter.VARIABLES, { it == propertyName })
+                .map { it.original }
+        if (property !in accessibleVariables) return null // shadowed by something else
+
+        return property
+    }
+
+    private fun findSyntheticProperty(function: FunctionDescriptor, resolutionScope: JetScope): SyntheticJavaPropertyDescriptor? {
+        SyntheticJavaPropertyDescriptor.findByGetterOrSetter(function, resolutionScope)?.let { return it }
+
+        for (overridden in function.getOverriddenDescriptors()) {
+            findSyntheticProperty(overridden, resolutionScope)?.let { return it }
+        }
+
+        return null
+    }
+
+    private fun replaceWithPropertyGet(callExpression: JetCallExpression, propertyName: Name) {
+        val newExpression = JetPsiFactory(callExpression).createExpression(propertyName.render())
+        callExpression.replace(newExpression)
+    }
+
+    //TODO: what if it was used as expression (of type Unit)?
+    private fun replaceWithPropertySet(callExpression: JetCallExpression, propertyName: Name, argument: JetValueArgument) {
+        val qualifiedExpression = callExpression.getQualifiedExpressionForSelector()
+        if (qualifiedExpression != null) {
+            val pattern = when (qualifiedExpression) {
+                is JetDotQualifiedExpression -> "$0.$1=$2"
+                is JetSafeQualifiedExpression -> "$0?.$1=$2"
+                else -> error(qualifiedExpression) //TODO: make it sealed?
+            }
+            val newExpression = JetPsiFactory(callExpression).createExpressionByPattern(
+                    pattern,
+                    qualifiedExpression.getReceiverExpression(),
+                    propertyName,
+                    argument.getArgumentExpression()!!
+            )
+            qualifiedExpression.replace(newExpression)
+        }
+        else {
+            val newExpression = JetPsiFactory(callExpression).createExpressionByPattern("$0=$1", propertyName, argument.getArgumentExpression()!!)
+            callExpression.replace(newExpression)
+        }
+    }
+}
\ No newline at end of file
diff --git a/idea/src/org/jetbrains/kotlin/idea/intentions/Utils.kt b/idea/src/org/jetbrains/kotlin/idea/intentions/Utils.kt
index 4965b9972b0..c45c637b2e6 100644
--- a/idea/src/org/jetbrains/kotlin/idea/intentions/Utils.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/intentions/Utils.kt
@@ -24,6 +24,7 @@ import org.jetbrains.kotlin.descriptors.DeclarationDescriptorWithVisibility
 import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor
 import org.jetbrains.kotlin.idea.caches.resolve.analyze
 import org.jetbrains.kotlin.idea.references.JetReference
+import org.jetbrains.kotlin.idea.references.mainReference
 import org.jetbrains.kotlin.idea.util.IdeDescriptorRenderers
 import org.jetbrains.kotlin.idea.util.ShortenReferences
 import org.jetbrains.kotlin.lexer.JetTokens
@@ -66,9 +67,8 @@ fun JetContainerNode.description(): String? {
 fun isAutoCreatedItUsage(expression: JetSimpleNameExpression): Boolean {
     if (expression.getReferencedName() != "it") return false
     val context = expression.analyze()
-    val reference = expression.getReference() as JetReference?
-    val target = reference?.resolveToDescriptors(context)?.singleOrNull() as? ValueParameterDescriptor? ?: return false
-    return context[BindingContext.AUTO_CREATED_IT, target]
+    val target = expression.mainReference.resolveToDescriptors(context).singleOrNull() as? ValueParameterDescriptor? ?: return false
+    return context[BindingContext.AUTO_CREATED_IT, target]!!
 }
 
 fun JetCallableDeclaration.canRemoveTypeSpecificationByVisibility(): Boolean {
diff --git a/idea/src/org/jetbrains/kotlin/idea/intentions/branchedTransformations/IfThenUtils.kt b/idea/src/org/jetbrains/kotlin/idea/intentions/branchedTransformations/IfThenUtils.kt
index 093a04bff2c..0a2b8ba4917 100644
--- a/idea/src/org/jetbrains/kotlin/idea/intentions/branchedTransformations/IfThenUtils.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/intentions/branchedTransformations/IfThenUtils.kt
@@ -28,6 +28,7 @@ import org.jetbrains.kotlin.idea.refactoring.introduce.introduceVariable.KotlinI
 import org.jetbrains.kotlin.lexer.JetTokens
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.idea.core.replaced
+import org.jetbrains.kotlin.idea.references.mainReference
 import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.BindingContextUtils
 import org.jetbrains.kotlin.resolve.DescriptorUtils
@@ -104,9 +105,7 @@ fun JetIfExpression.introduceValueForCondition(occurrenceInThenClause: JetExpres
 }
 
 fun JetSimpleNameExpression.inlineIfDeclaredLocallyAndOnlyUsedOnceWithPrompt(editor: Editor) {
-    val declaration = this.getReference()?.resolve() as JetDeclaration
-
-    if (declaration !is JetProperty) return
+    val declaration = this.mainReference.resolve() as? JetProperty ?: return
 
     val enclosingElement = JetPsiUtil.getEnclosingElementForLocalDeclaration(declaration)
     val isLocal = enclosingElement != null
diff --git a/idea/src/org/jetbrains/kotlin/idea/intentions/branchedTransformations/branchedTransformationUtils.kt b/idea/src/org/jetbrains/kotlin/idea/intentions/branchedTransformations/branchedTransformationUtils.kt
index bc9eca479ee..4e8e6e54526 100644
--- a/idea/src/org/jetbrains/kotlin/idea/intentions/branchedTransformations/branchedTransformationUtils.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/intentions/branchedTransformations/branchedTransformationUtils.kt
@@ -39,7 +39,7 @@ fun JetWhenCondition.toExpression(subject: JetExpression?): JetExpression {
                 factory.createExpressionByPattern("$0 == $1", subject, getExpression() ?: "")
             }
             else {
-                getExpression()
+                getExpression()!!
             }
         }
 
diff --git a/idea/src/org/jetbrains/kotlin/idea/j2k/J2kPostProcessor.kt b/idea/src/org/jetbrains/kotlin/idea/j2k/J2kPostProcessor.kt
index e3b8588db32..62f4bdd45a0 100644
--- a/idea/src/org/jetbrains/kotlin/idea/j2k/J2kPostProcessor.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/j2k/J2kPostProcessor.kt
@@ -19,6 +19,7 @@ package org.jetbrains.kotlin.idea.j2k
 import com.intellij.openapi.editor.RangeMarker
 import com.intellij.openapi.util.TextRange
 import com.intellij.psi.PsiElement
+import com.intellij.psi.PsiReference
 import com.intellij.psi.codeStyle.CodeStyleManager
 import com.intellij.psi.search.LocalSearchScope
 import com.intellij.psi.search.searches.ReferencesSearch
@@ -34,6 +35,7 @@ import org.jetbrains.kotlin.idea.intentions.branchedTransformations.intentions.I
 import org.jetbrains.kotlin.idea.intentions.branchedTransformations.intentions.IfThenToSafeAccessIntention
 import org.jetbrains.kotlin.idea.quickfix.RemoveModifierFix
 import org.jetbrains.kotlin.idea.quickfix.RemoveRightPartOfBinaryExpressionFix
+import org.jetbrains.kotlin.idea.references.mainReference
 import org.jetbrains.kotlin.idea.util.ImportInsertHelper
 import org.jetbrains.kotlin.j2k.PostProcessor
 import org.jetbrains.kotlin.name.FqName
@@ -188,4 +190,6 @@ public class J2kPostProcessor(private val formatCode: Boolean) : PostProcessor {
             }
         }
     }
+
+    override fun simpleNameReference(nameExpression: JetSimpleNameExpression) = nameExpression.mainReference
 }
diff --git a/idea/src/org/jetbrains/kotlin/idea/parameterInfo/JetFunctionParameterInfoHandler.java b/idea/src/org/jetbrains/kotlin/idea/parameterInfo/JetFunctionParameterInfoHandler.java
index 89606052d28..61df88e3725 100644
--- a/idea/src/org/jetbrains/kotlin/idea/parameterInfo/JetFunctionParameterInfoHandler.java
+++ b/idea/src/org/jetbrains/kotlin/idea/parameterInfo/JetFunctionParameterInfoHandler.java
@@ -38,6 +38,7 @@ import org.jetbrains.kotlin.descriptors.*;
 import org.jetbrains.kotlin.idea.caches.resolve.ResolutionFacade;
 import org.jetbrains.kotlin.idea.caches.resolve.ResolvePackage;
 import org.jetbrains.kotlin.idea.codeInsight.ReferenceVariantsHelper;
+import org.jetbrains.kotlin.idea.core.CorePackage;
 import org.jetbrains.kotlin.lexer.JetTokens;
 import org.jetbrains.kotlin.name.Name;
 import org.jetbrains.kotlin.psi.*;
@@ -45,7 +46,6 @@ import org.jetbrains.kotlin.psi.psiUtil.PsiUtilPackage;
 import org.jetbrains.kotlin.renderer.DescriptorRenderer;
 import org.jetbrains.kotlin.resolve.BindingContext;
 import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils;
-import org.jetbrains.kotlin.resolve.JetVisibilityChecker;
 import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode;
 import org.jetbrains.kotlin.resolve.scopes.DescriptorKindExclude;
 import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter;
@@ -373,7 +373,7 @@ public class JetFunctionParameterInfoHandler implements ParameterInfoHandlerWith
             return null;
         }
 
-        JetSimpleNameExpression callNameExpression = getCallSimpleNameExpression(argumentList);
+        final JetSimpleNameExpression callNameExpression = getCallSimpleNameExpression(argumentList);
         if (callNameExpression == null) {
             return null;
         }
@@ -384,7 +384,7 @@ public class JetFunctionParameterInfoHandler implements ParameterInfoHandlerWith
         }
 
         ResolutionFacade resolutionFacade = ResolvePackage.getResolutionFacade(callNameExpression.getContainingJetFile());
-        BindingContext bindingContext = resolutionFacade.analyze(callNameExpression, BodyResolveMode.FULL);
+        final BindingContext bindingContext = resolutionFacade.analyze(callNameExpression, BodyResolveMode.FULL);
         ModuleDescriptor moduleDescriptor = resolutionFacade.findModuleDescriptor(callNameExpression);
 
         JetScope scope = bindingContext.get(BindingContext.RESOLUTION_SCOPE, callNameExpression);
@@ -398,7 +398,9 @@ public class JetFunctionParameterInfoHandler implements ParameterInfoHandlerWith
         Function1<DeclarationDescriptor, Boolean> visibilityFilter = new Function1<DeclarationDescriptor, Boolean>() {
             @Override
             public Boolean invoke(DeclarationDescriptor descriptor) {
-                return placeDescriptor == null || JetVisibilityChecker.isVisible(placeDescriptor, descriptor);
+                if (placeDescriptor == null) return true;
+                if (!(descriptor instanceof DeclarationDescriptorWithVisibility)) return true;
+                return CorePackage.isVisible((DeclarationDescriptorWithVisibility) descriptor, placeDescriptor, bindingContext, callNameExpression);
             }
         };
 
@@ -412,7 +414,7 @@ public class JetFunctionParameterInfoHandler implements ParameterInfoHandlerWith
         };
         Collection<DeclarationDescriptor> variants = new ReferenceVariantsHelper(bindingContext, moduleDescriptor, file.getProject(), visibilityFilter).getReferenceVariants(
                 callNameExpression, new DescriptorKindFilter(DescriptorKindFilter.FUNCTIONS_MASK | DescriptorKindFilter.CLASSIFIERS_MASK,
-                                                             Collections.<DescriptorKindExclude>emptyList()), false, nameFilter);
+                                                             Collections.<DescriptorKindExclude>emptyList()), nameFilter, false, false);
 
         Collection<Pair<? extends DeclarationDescriptor, ResolutionFacade>> itemsToShow = new ArrayList<Pair<? extends DeclarationDescriptor, ResolutionFacade>>();
         for (DeclarationDescriptor variant : variants) {
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/AddFunctionParametersFix.java b/idea/src/org/jetbrains/kotlin/idea/quickfix/AddFunctionParametersFix.java
index 3aea9c28072..1407e383106 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/AddFunctionParametersFix.java
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/AddFunctionParametersFix.java
@@ -147,7 +147,7 @@ public class AddFunctionParametersFix extends ChangeFunctionSignatureFix {
                                     }
                                     else {
                                         JetParameterInfo parameterInfo =
-                                                getNewParameterInfo(originalDescriptor.getBaseDescriptor(), bindingContext, argument, validator);
+                                                getNewParameterInfo((FunctionDescriptor) originalDescriptor.getBaseDescriptor(), bindingContext, argument, validator);
                                         typesToShorten.add(parameterInfo.getOriginalType());
 
                                         if (expression != null) {
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/AddLoopLabelFix.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/AddLoopLabelFix.kt
index ac0d2b24eca..3c3f57f7b7f 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/AddLoopLabelFix.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/AddLoopLabelFix.kt
@@ -30,11 +30,11 @@ public class AddLoopLabelFix(loop: JetLoopExpression, val jumpExpression: JetEle
     override fun getText() = "Add label to loop"
     override fun getFamilyName() = getText()
 
-    override fun isAvailable(project: Project, editor: Editor?, file: PsiFile?): Boolean {
+    override fun isAvailable(project: Project, editor: Editor, file: PsiFile): Boolean {
         return super.isAvailable(project, editor, file)
     }
 
-    override fun invoke(project: Project, editor: Editor, file: JetFile) {
+    override fun invoke(project: Project, editor: Editor?, file: JetFile) {
         val usedLabels = collectUsedLabels(element)
         val labelName = getUniqueLabelName(usedLabels)
 
@@ -43,7 +43,7 @@ public class AddLoopLabelFix(loop: JetLoopExpression, val jumpExpression: JetEle
 
         // TODO(yole) use createExpressionByPattern() once it's available
         val labeledLoopExpression = JetPsiFactory(project).createLabeledExpression(labelName)
-        labeledLoopExpression.getBaseExpression().replace(element)
+        labeledLoopExpression.getBaseExpression()!!.replace(element)
         element.replace(labeledLoopExpression)
 
         // TODO(yole) We should initiate in-place rename for the label here, but in-place rename for labels is not yet implemented
@@ -54,12 +54,12 @@ public class AddLoopLabelFix(loop: JetLoopExpression, val jumpExpression: JetEle
         element.acceptChildren(object : JetTreeVisitorVoid() {
             override fun visitLabeledExpression(expression: JetLabeledExpression) {
                 super.visitLabeledExpression(expression)
-                usedLabels.add(expression.getLabelName())
+                usedLabels.add(expression.getLabelName()!!)
             }
         })
         element.parents.forEach {
             if (it is JetLabeledExpression) {
-                usedLabels.add(it.getLabelName())
+                usedLabels.add(it.getLabelName()!!)
             }
         }
         return usedLabels
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/AddOpenModifierToClassDeclarationFix.java b/idea/src/org/jetbrains/kotlin/idea/quickfix/AddOpenModifierToClassDeclarationFix.java
index 93a405f1cf3..788895af679 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/AddOpenModifierToClassDeclarationFix.java
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/AddOpenModifierToClassDeclarationFix.java
@@ -29,6 +29,7 @@ import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.diagnostics.Diagnostic;
 import org.jetbrains.kotlin.idea.JetBundle;
 import org.jetbrains.kotlin.idea.core.quickfix.QuickFixUtil;
+import org.jetbrains.kotlin.idea.references.ReferencesPackage;
 import org.jetbrains.kotlin.lexer.JetTokens;
 import org.jetbrains.kotlin.psi.*;
 
@@ -50,16 +51,14 @@ public class AddOpenModifierToClassDeclarationFix extends JetIntentionAction<Jet
             return false;
         }
 
-        PsiReference reference = referenceExpression.getReference();
-        if (reference != null) {
-            PsiElement target = reference.resolve();
-            if (target instanceof JetSecondaryConstructor) {
-                target = ((JetSecondaryConstructor) target).getContainingClassOrObject();
-            }
-            if (target instanceof JetClass && QuickFixUtil.canModifyElement(target)) {
-                classDeclaration = (JetClass) target;
-                return !(classDeclaration.isEnum() || classDeclaration.isInterface());
-            }
+        PsiReference reference = ReferencesPackage.getMainReference(referenceExpression);
+        PsiElement target = reference.resolve();
+        if (target instanceof JetSecondaryConstructor) {
+            target = ((JetSecondaryConstructor) target).getContainingClassOrObject();
+        }
+        if (target instanceof JetClass && QuickFixUtil.canModifyElement(target)) {
+            classDeclaration = (JetClass) target;
+            return !(classDeclaration.isEnum() || classDeclaration.isInterface());
         }
 
         return false;
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/AutoImportFix.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/AutoImportFix.kt
index d9ae0e1215a..20d475b4ff1 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/AutoImportFix.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/AutoImportFix.kt
@@ -24,8 +24,6 @@ import com.intellij.openapi.command.CommandProcessor
 import com.intellij.openapi.editor.Editor
 import com.intellij.openapi.project.Project
 import com.intellij.psi.PsiFile
-import com.intellij.psi.search.GlobalSearchScope
-import com.intellij.psi.search.PsiShortNamesCache
 import com.intellij.psi.util.PsiModificationTracker
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptorWithVisibility
@@ -37,7 +35,6 @@ import org.jetbrains.kotlin.idea.caches.resolve.ResolutionFacade
 import org.jetbrains.kotlin.idea.caches.resolve.getResolutionFacade
 import org.jetbrains.kotlin.idea.core.KotlinIndicesHelper
 import org.jetbrains.kotlin.idea.core.isVisible
-import org.jetbrains.kotlin.idea.core.psiClassToDescriptor
 import org.jetbrains.kotlin.idea.project.ProjectStructureUtil
 import org.jetbrains.kotlin.psi.JetFile
 import org.jetbrains.kotlin.psi.JetPsiUtil
@@ -89,7 +86,7 @@ public class AutoImportFix(element: JetSimpleNameExpression) : JetHintAction<Jet
     override fun isAvailable(project: Project, editor: Editor, file: PsiFile)
             = (super<JetHintAction>.isAvailable(project, editor, file)) && (anySuggestionFound ?: !suggestions.isEmpty())
 
-    override fun invoke(project: Project, editor: Editor?, file: JetFile?) {
+    override fun invoke(project: Project, editor: Editor?, file: JetFile) {
         CommandProcessor.getInstance().runUndoTransparentAction {
             createAction(project, editor!!).execute()
         }
@@ -138,14 +135,14 @@ public class AutoImportFix(element: JetSimpleNameExpression) : JetHintAction<Jet
         val result = ArrayList<DeclarationDescriptor>()
 
         val moduleDescriptor = resolutionFacade.findModuleDescriptor(element)
-        val indicesHelper = KotlinIndicesHelper(file.getProject(), resolutionFacade, searchScope, moduleDescriptor, ::isVisible)
+        val indicesHelper = KotlinIndicesHelper(file.getProject(), resolutionFacade, searchScope, moduleDescriptor, ::isVisible, true)
 
         if (!element.isImportDirectiveExpression() && !JetPsiUtil.isSelectorInQualified(element)) {
             if (ProjectStructureUtil.isJsKotlinModule(file)) {
-                result.addAll(indicesHelper.getClassDescriptors({ it == referenceName }, { true }))
+                result.addAll(indicesHelper.getKotlinClasses({ it == referenceName }, { true }))
             }
             else {
-                getClasses(referenceName, file, searchScope).filterTo(result, ::isVisible)
+                result.addAll(indicesHelper.getJvmClassesByName(referenceName))
             }
             result.addAll(indicesHelper.getTopLevelCallablesByName(referenceName))
         }
@@ -155,14 +152,6 @@ public class AutoImportFix(element: JetSimpleNameExpression) : JetHintAction<Jet
         return result
     }
 
-    private fun getClasses(name: String, file: JetFile, searchScope: GlobalSearchScope): Collection<DeclarationDescriptor>
-            = getShortNamesCache(file).getClassesByName(name, searchScope)
-            .map { element.getResolutionFacade().psiClassToDescriptor(it) }
-            .filterNotNull()
-            .toSet()
-
-    private fun getShortNamesCache(jetFile: JetFile): PsiShortNamesCache = PsiShortNamesCache.getInstance(jetFile.getProject())
-
     companion object {
         private val ERRORS = setOf(Errors.UNRESOLVED_REFERENCE, Errors.UNRESOLVED_REFERENCE_WRONG_RECEIVER)
 
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/DeprecatedEnumEntryDelimiterSyntaxFix.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/DeprecatedEnumEntryDelimiterSyntaxFix.kt
index 0e8d8fc63b1..db0d842e11a 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/DeprecatedEnumEntryDelimiterSyntaxFix.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/DeprecatedEnumEntryDelimiterSyntaxFix.kt
@@ -38,7 +38,7 @@ class DeprecatedEnumEntryDelimiterSyntaxFix(element: JetEnumEntry): JetIntention
 
     override fun getText(): String = "Insert lacking comma(s) / semicolon(s)"
 
-    override fun invoke(project: Project, editor: Editor?, file: JetFile?) = insertLackingCommaSemicolon(element)
+    override fun invoke(project: Project, editor: Editor?, file: JetFile) = insertLackingCommaSemicolon(element)
 
     override fun isAvailable(project: Project, editor: Editor?, file: PsiFile): Boolean
             = super<JetIntentionAction>.isAvailable(project, editor, file) && DeclarationsChecker.enumEntryUsesDeprecatedOrNoDelimiter(element)
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/DeprecatedEnumEntrySuperConstructorSyntaxFix.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/DeprecatedEnumEntrySuperConstructorSyntaxFix.kt
index 6ac30ab803c..b7d52f8d906 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/DeprecatedEnumEntrySuperConstructorSyntaxFix.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/DeprecatedEnumEntrySuperConstructorSyntaxFix.kt
@@ -41,7 +41,7 @@ class DeprecatedEnumEntrySuperConstructorSyntaxFix(element: JetEnumEntry): JetIn
 
     override fun getText(): String = "Change to short enum entry super constructor"
 
-    override fun invoke(project: Project, editor: Editor?, file: JetFile?) = changeConstructorToShort(element)
+    override fun invoke(project: Project, editor: Editor?, file: JetFile) = changeConstructorToShort(element)
 
     override fun isAvailable(project: Project, editor: Editor?, file: PsiFile): Boolean
             = super<JetIntentionAction>.isAvailable(project, editor, file) && DeclarationsChecker.enumEntryUsesDeprecatedSuperConstructor(element)
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/DeprecatedLambdaSyntaxFix.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/DeprecatedLambdaSyntaxFix.kt
index e59d8a89f5a..75da5826ca5 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/DeprecatedLambdaSyntaxFix.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/DeprecatedLambdaSyntaxFix.kt
@@ -107,9 +107,10 @@ private class LambdaToFunctionExpression(
     init {
         val bindingContext = functionLiteralExpression.analyze()
         val functionLiteralType = bindingContext.getType(functionLiteralExpression)
-        assert(functionLiteralType != null && KotlinBuiltIns.isFunctionOrExtensionFunctionType(functionLiteralType)) {
+        assert(functionLiteralType != null && KotlinBuiltIns.isExactFunctionOrExtensionFunctionType(functionLiteralType)) {
             "Broken function type for expression: ${functionLiteralExpression.getText()}, at: ${DiagnosticUtils.atLocation(functionLiteralExpression)}"
         }
+        functionLiteralType!!
         receiverType = KotlinBuiltIns.getReceiverType(functionLiteralType)?.let { IdeDescriptorRenderers.SOURCE_CODE.renderType(it) }
         returnType = KotlinBuiltIns.getReturnTypeFromFunctionType(functionLiteralType).let {
             if (KotlinBuiltIns.isUnit(it))
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/DeprecatedSymbolUsageFixBase.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/DeprecatedSymbolUsageFixBase.kt
index fd9edd37e45..c919b836110 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/DeprecatedSymbolUsageFixBase.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/DeprecatedSymbolUsageFixBase.kt
@@ -112,7 +112,7 @@ public abstract class DeprecatedSymbolUsageFixBase(
             if (pattern.isEmpty()) return null
             val importValues = replaceWithValue.argumentValue("imports"/*TODO: kotlin.ReplaceWith::imports.name*/) as? List<*> ?: return null
             if (importValues.any { it !is StringValue }) return null
-            val imports = importValues.map { (it as StringValue).getValue() }
+            val imports = importValues.map { (it as StringValue).value }
 
             // should not be available for descriptors with optional parameters if we cannot fetch default values for them (currently for library with no sources)
             if (descriptor is CallableDescriptor &&
@@ -132,8 +132,7 @@ public abstract class DeprecatedSymbolUsageFixBase(
             val descriptor = resolvedCall.getResultingDescriptor()
 
             val callExpression = resolvedCall.getCall().getCallElement() as JetExpression
-            val parent = callExpression.getParent()
-            val qualifiedExpression = if (parent is JetQualifiedExpression && callExpression == parent.getSelectorExpression()) parent else null
+            val qualifiedExpression = callExpression.getQualifiedExpressionForSelector()
             val expressionToBeReplaced = qualifiedExpression ?: callExpression
 
             val commentSaver = CommentSaver(expressionToBeReplaced, saveLineBreaks = true)
@@ -681,7 +680,7 @@ public abstract class DeprecatedSymbolUsageFixBase(
                         var explicitType: JetType? = null
                         if (valueType != null && !ErrorUtils.containsErrorType(valueType)) {
                             val valueTypeWithoutExpectedType = value.analyzeInContext(
-                                    resolutionScope,
+                                    resolutionScope!!,
                                     dataFlowInfo = bindingContext.getDataFlowInfo(expressionToBeReplaced)
                             ).getType(value)
                             if (valueTypeWithoutExpectedType == null || ErrorUtils.containsErrorType(valueTypeWithoutExpectedType)) {
@@ -690,7 +689,7 @@ public abstract class DeprecatedSymbolUsageFixBase(
                         }
 
                         val name = suggestName { name ->
-                            resolutionScope.getLocalVariable(Name.identifier(name)) == null && !isNameUsed(name)
+                            resolutionScope!!.getLocalVariable(Name.identifier(name)) == null && !isNameUsed(name)
                         }
 
                         var declaration = psiFactory.createDeclarationByPattern<JetVariableDeclaration>("val $0 = $1", name, value)
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/DeprecatedSymbolUsageInWholeProjectFix.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/DeprecatedSymbolUsageInWholeProjectFix.kt
index 0b6c4c8b21d..4d06f4a234e 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/DeprecatedSymbolUsageInWholeProjectFix.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/DeprecatedSymbolUsageInWholeProjectFix.kt
@@ -37,6 +37,7 @@ import org.jetbrains.kotlin.idea.caches.resolve.analyze
 import org.jetbrains.kotlin.idea.findUsages.KotlinFindUsagesHandlerFactory
 import org.jetbrains.kotlin.idea.findUsages.KotlinFunctionFindUsagesOptions
 import org.jetbrains.kotlin.idea.findUsages.KotlinPropertyFindUsagesOptions
+import org.jetbrains.kotlin.idea.references.mainReference
 import org.jetbrains.kotlin.idea.stubindex.JetSourceFilterScope
 import org.jetbrains.kotlin.idea.util.application.executeCommand
 import org.jetbrains.kotlin.idea.util.application.runReadAction
@@ -68,7 +69,7 @@ public class DeprecatedSymbolUsageInWholeProjectFix(
 
     override fun isAvailable(project: Project, editor: Editor?, file: PsiFile): Boolean {
         if (!super.isAvailable(project, editor, file)) return false
-        val targetPsiElement = element.getReference()?.resolve()
+        val targetPsiElement = element.mainReference.resolve()
         return targetPsiElement is JetNamedFunction || targetPsiElement is JetProperty
     }
 
@@ -79,7 +80,7 @@ public class DeprecatedSymbolUsageInWholeProjectFix(
             project: Project,
             editor: Editor?
     ) {
-        val psiElement = element.getReference()!!.resolve()!!
+        val psiElement = element.mainReference.resolve()!!
 
         ProgressManager.getInstance().run(
                 object : Task.Modal(project, "Applying '$text'", true) {
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/DeprecatedTraitSyntaxFix.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/DeprecatedTraitSyntaxFix.kt
index 8ae58d0594c..96371716e0e 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/DeprecatedTraitSyntaxFix.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/DeprecatedTraitSyntaxFix.kt
@@ -31,7 +31,7 @@ public class DeprecatedTraitSyntaxFix(element: PsiElement): JetIntentionAction<P
     override fun getFamilyName() = "Replace 'trait' with 'interface'"
     override fun getText() = getFamilyName()
 
-    override fun invoke(project: Project, editor: Editor?, file: JetFile?)
+    override fun invoke(project: Project, editor: Editor?, file: JetFile)
             = replaceWithInterfaceKeyword(element)
 
 
@@ -47,7 +47,7 @@ public class DeprecatedTraitSyntaxFix(element: PsiElement): JetIntentionAction<P
         public fun createWholeProjectFixFactory(): JetSingleIntentionActionFactory = createIntentionFactory {
             JetWholeProjectForEachElementOfTypeFix.createByPredicate<JetClass>(
                     predicate = { it.getNode().findChildByType(JetTokens.TRAIT_KEYWORD) != null },
-                    taskProcessor = { replaceWithInterfaceKeyword(it.getNode().findChildByType(JetTokens.TRAIT_KEYWORD).getPsi())},
+                    taskProcessor = { replaceWithInterfaceKeyword(it.getNode().findChildByType(JetTokens.TRAIT_KEYWORD)!!.getPsi())},
                     name = "Replace 'trait' with 'interface' in whole project"
             )
         }
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/ExclExlCallFixes.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/ExclExlCallFixes.kt
index b94d10f4ab7..ad5ff7f157d 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/ExclExlCallFixes.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/ExclExlCallFixes.kt
@@ -50,7 +50,7 @@ public class RemoveExclExclCallFix(val psiElement: PsiElement) : ExclExclCallFix
         if (!FileModificationService.getInstance().prepareFileForWrite(file)) return
 
         val postfixExpression = getExclExclPostfixExpression() ?: return
-        val expression = JetPsiFactory(project).createExpression(postfixExpression.getBaseExpression().getText())
+        val expression = JetPsiFactory(project).createExpression(postfixExpression.getBaseExpression()!!.getText())
         postfixExpression.replace(expression)
     }
 
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/InsertDelegationCallQuickfix.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/InsertDelegationCallQuickfix.kt
index 8525091469d..e0b8b995007 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/InsertDelegationCallQuickfix.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/InsertDelegationCallQuickfix.kt
@@ -41,7 +41,7 @@ public class InsertDelegationCallQuickfix(val isThis: Boolean, element: JetSecon
 
     private val keywordToUse = if (isThis) "this" else "super"
 
-    override fun invoke(project: Project, editor: Editor?, file: JetFile?) {
+    override fun invoke(project: Project, editor: Editor?, file: JetFile) {
         val newDelegationCall = element.replaceImplicitDelegationCallWithExplicit(isThis)
 
         val resolvedCall = newDelegationCall.getResolvedCall(newDelegationCall.analyze())
@@ -55,7 +55,7 @@ public class InsertDelegationCallQuickfix(val isThis: Boolean, element: JetSecon
         editor?.moveCaret(leftParOffset + 1)
     }
 
-    override fun isAvailable(project: Project, editor: Editor?, file: PsiFile?): Boolean {
+    override fun isAvailable(project: Project, editor: Editor?, file: PsiFile): Boolean {
         return super.isAvailable(project, editor, file) && element.hasImplicitDelegationCall()
     }
 
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/MakeClassAnAnnotationClassFix.java b/idea/src/org/jetbrains/kotlin/idea/quickfix/MakeClassAnAnnotationClassFix.java
index b01f9b97b41..e01a849abdf 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/MakeClassAnAnnotationClassFix.java
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/MakeClassAnAnnotationClassFix.java
@@ -26,13 +26,13 @@ import com.intellij.psi.util.PsiTreeUtil;
 import com.intellij.util.IncorrectOperationException;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
+import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
 import org.jetbrains.kotlin.diagnostics.Diagnostic;
 import org.jetbrains.kotlin.idea.JetBundle;
 import org.jetbrains.kotlin.idea.core.quickfix.QuickFixUtil;
+import org.jetbrains.kotlin.idea.references.ReferencesPackage;
 import org.jetbrains.kotlin.psi.*;
 
-import static org.jetbrains.kotlin.lexer.JetTokens.ANNOTATION_KEYWORD;
-
 public class MakeClassAnAnnotationClassFix extends JetIntentionAction<JetAnnotationEntry> {
     private final JetAnnotationEntry annotationEntry;
     private JetClass annotationClass;
@@ -58,13 +58,11 @@ public class MakeClassAnAnnotationClassFix extends JetIntentionAction<JetAnnotat
             return false;
         }
 
-        PsiReference reference = referenceExpression.getReference();
-        if (reference != null) {
-            PsiElement target = reference.resolve();
-            if (target instanceof JetClass) {
-                annotationClass = (JetClass) target;
-                return QuickFixUtil.canModifyElement(annotationClass);
-            }
+        PsiReference reference = ReferencesPackage.getMainReference(referenceExpression);
+        PsiElement target = reference.resolve();
+        if (target instanceof JetClass) {
+            annotationClass = (JetClass) target;
+            return QuickFixUtil.canModifyElement(annotationClass);
         }
 
         return false;
@@ -83,8 +81,20 @@ public class MakeClassAnAnnotationClassFix extends JetIntentionAction<JetAnnotat
     }
 
     @Override
-    public void invoke(@NotNull Project project, Editor editor, JetFile file) throws IncorrectOperationException {
-        annotationClass.addModifier(ANNOTATION_KEYWORD);
+    public void invoke(@NotNull Project project, Editor editor, @NotNull JetFile file) throws IncorrectOperationException {
+        JetPsiFactory factory = new JetPsiFactory(annotationClass.getProject());
+        JetModifierList list = annotationClass.getModifierList();
+        String annotation = KotlinBuiltIns.FQ_NAMES.annotation.shortName().asString();
+        PsiElement added;
+        if (list == null) {
+            JetModifierList newModifierList = factory.createModifierList(annotation);
+            added = annotationClass.addBefore(newModifierList, annotationClass.getClassOrInterfaceKeyword());
+        }
+        else {
+            JetAnnotationEntry entry = factory.createAnnotationEntry(annotation);
+            added = list.addBefore(entry, list.getFirstChild());
+        }
+        annotationClass.addAfter(factory.createWhiteSpace(), added);
     }
 
     @NotNull
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/MigrateAnnotationMethodCallFix.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/MigrateAnnotationMethodCallFix.kt
index 40838b7a53f..c0e4f5dfe0d 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/MigrateAnnotationMethodCallFix.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/MigrateAnnotationMethodCallFix.kt
@@ -35,7 +35,7 @@ public class MigrateAnnotationMethodCallFix(
     override fun getText() = "Replace method call with property access"
     override fun getFamilyName() = getText()
 
-    override fun invoke(project: Project, editor: Editor?, file: JetFile?) = replaceWithSimpleCall(element)
+    override fun invoke(project: Project, editor: Editor?, file: JetFile) = replaceWithSimpleCall(element)
 
     companion object : JetSingleIntentionActionFactory() {
         override fun createAction(diagnostic: Diagnostic) = diagnostic.createIntentionForFirstParentOfType(::MigrateAnnotationMethodCallFix)
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/MissingConstructorKeywordFix.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/MissingConstructorKeywordFix.kt
index a9803eb9693..adcf66ebf8e 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/MissingConstructorKeywordFix.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/MissingConstructorKeywordFix.kt
@@ -30,7 +30,7 @@ public class MissingConstructorKeywordFix(element: JetPrimaryConstructor) : JetI
     override fun getFamilyName(): String = getText()
     override fun getText(): String = "Add 'constructor' keyword"
 
-    override fun invoke(project: Project, editor: Editor?, file: JetFile?) {
+    override fun invoke(project: Project, editor: Editor?, file: JetFile) {
         element.addConstructorKeyword()
     }
 
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/QuickFixFactoryForTypeMismatchError.java b/idea/src/org/jetbrains/kotlin/idea/quickfix/QuickFixFactoryForTypeMismatchError.java
index edf939215f5..aaead43b052 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/QuickFixFactoryForTypeMismatchError.java
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/QuickFixFactoryForTypeMismatchError.java
@@ -39,6 +39,7 @@ import org.jetbrains.kotlin.resolve.calls.callUtil.CallUtilPackage;
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall;
 import org.jetbrains.kotlin.resolve.scopes.JetScope;
 import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.typeUtil.TypeUtilPackage;
 
 import java.util.Collections;
 import java.util.LinkedList;
@@ -74,7 +75,7 @@ public class QuickFixFactoryForTypeMismatchError extends JetIntentionActionsFact
             DiagnosticWithParameters1<JetConstantExpression, JetType> diagnosticWithParameters =
                     Errors.NULL_FOR_NONNULL_TYPE.cast(diagnostic);
             expectedType = diagnosticWithParameters.getA();
-            expressionType = UtilPackage.makeNullable(expectedType);
+            expressionType = TypeUtilPackage.makeNullable(expectedType);
         }
         else if (diagnostic.getFactory() == Errors.CONSTANT_EXPECTED_TYPE_MISMATCH) {
             DiagnosticWithParameters2<JetConstantExpression, String, JetType> diagnosticWithParameters =
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/QuickFixRegistrar.java b/idea/src/org/jetbrains/kotlin/idea/quickfix/QuickFixRegistrar.java
deleted file mode 100644
index 8b26c007e77..00000000000
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/QuickFixRegistrar.java
+++ /dev/null
@@ -1,340 +0,0 @@
-/*
- * Copyright 2010-2015 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.kotlin.idea.quickfix;
-
-import org.jetbrains.kotlin.idea.core.codeInsight.ImplementMethodsHandler;
-import org.jetbrains.kotlin.idea.quickfix.createFromUsage.createCallable.*;
-import org.jetbrains.kotlin.idea.quickfix.createFromUsage.createClass.CreateClassFromCallWithConstructorCalleeActionFactory;
-import org.jetbrains.kotlin.idea.quickfix.createFromUsage.createClass.CreateClassFromConstructorCallActionFactory;
-import org.jetbrains.kotlin.idea.quickfix.createFromUsage.createClass.CreateClassFromReferenceExpressionActionFactory;
-import org.jetbrains.kotlin.idea.quickfix.createFromUsage.createClass.CreateClassFromTypeReferenceActionFactory;
-import org.jetbrains.kotlin.idea.quickfix.createFromUsage.createVariable.CreateLocalVariableActionFactory;
-import org.jetbrains.kotlin.idea.quickfix.createFromUsage.createVariable.CreateParameterActionFactory;
-import org.jetbrains.kotlin.idea.quickfix.createFromUsage.createVariable.CreateParameterByNamedArgumentActionFactory;
-import org.jetbrains.kotlin.psi.JetClass;
-import org.jetbrains.kotlin.resolve.jvm.diagnostics.ErrorsJvm;
-
-import static org.jetbrains.kotlin.diagnostics.Errors.*;
-import static org.jetbrains.kotlin.lexer.JetTokens.*;
-
-public class QuickFixRegistrar {
-    public static void registerQuickFixes() {
-        JetSingleIntentionActionFactory
-                removeAbstractModifierFactory = RemoveModifierFix.createRemoveModifierFromListOwnerFactory(ABSTRACT_KEYWORD);
-        JetSingleIntentionActionFactory addAbstractModifierFactory = AddModifierFix.createFactory(ABSTRACT_KEYWORD);
-
-        QuickFixes.factories.put(ABSTRACT_PROPERTY_IN_PRIMARY_CONSTRUCTOR_PARAMETERS, removeAbstractModifierFactory);
-
-        JetSingleIntentionActionFactory removePartsFromPropertyFactory = RemovePartsFromPropertyFix.createFactory();
-        QuickFixes.factories.put(ABSTRACT_PROPERTY_WITH_INITIALIZER, removeAbstractModifierFactory);
-        QuickFixes.factories.put(ABSTRACT_PROPERTY_WITH_INITIALIZER, removePartsFromPropertyFactory);
-
-        QuickFixes.factories.put(ABSTRACT_PROPERTY_WITH_GETTER, removeAbstractModifierFactory);
-        QuickFixes.factories.put(ABSTRACT_PROPERTY_WITH_GETTER, removePartsFromPropertyFactory);
-
-        QuickFixes.factories.put(ABSTRACT_PROPERTY_WITH_SETTER, removeAbstractModifierFactory);
-        QuickFixes.factories.put(ABSTRACT_PROPERTY_WITH_SETTER, removePartsFromPropertyFactory);
-
-        QuickFixes.factories.put(PROPERTY_INITIALIZER_IN_TRAIT, removePartsFromPropertyFactory);
-
-        QuickFixes.factories.put(MUST_BE_INITIALIZED_OR_BE_ABSTRACT, addAbstractModifierFactory);
-        QuickFixes.factories.put(ABSTRACT_MEMBER_NOT_IMPLEMENTED, addAbstractModifierFactory);
-        QuickFixes.factories.put(MANY_IMPL_MEMBER_NOT_IMPLEMENTED, addAbstractModifierFactory);
-
-        JetSingleIntentionActionFactory removeFinalModifierFactory = RemoveModifierFix.createRemoveModifierFromListOwnerFactory(FINAL_KEYWORD);
-
-        JetSingleIntentionActionFactory addAbstractToClassFactory = AddModifierFix.createFactory(ABSTRACT_KEYWORD, JetClass.class);
-        QuickFixes.factories.put(ABSTRACT_PROPERTY_IN_NON_ABSTRACT_CLASS, removeAbstractModifierFactory);
-        QuickFixes.factories.put(ABSTRACT_PROPERTY_IN_NON_ABSTRACT_CLASS, addAbstractToClassFactory);
-
-        JetSingleIntentionActionFactory removeFunctionBodyFactory = RemoveFunctionBodyFix.createFactory();
-        QuickFixes.factories.put(ABSTRACT_FUNCTION_IN_NON_ABSTRACT_CLASS, removeAbstractModifierFactory);
-        QuickFixes.factories.put(ABSTRACT_FUNCTION_IN_NON_ABSTRACT_CLASS, addAbstractToClassFactory);
-
-        QuickFixes.factories.put(ABSTRACT_FUNCTION_WITH_BODY, removeAbstractModifierFactory);
-        QuickFixes.factories.put(ABSTRACT_FUNCTION_WITH_BODY, removeFunctionBodyFactory);
-
-        QuickFixes.factories.put(FINAL_PROPERTY_IN_TRAIT, removeFinalModifierFactory);
-        QuickFixes.factories.put(FINAL_FUNCTION_WITH_NO_BODY, removeFinalModifierFactory);
-
-        JetSingleIntentionActionFactory addFunctionBodyFactory = AddFunctionBodyFix.createFactory();
-        QuickFixes.factories.put(NON_ABSTRACT_FUNCTION_WITH_NO_BODY, addAbstractModifierFactory);
-        QuickFixes.factories.put(NON_ABSTRACT_FUNCTION_WITH_NO_BODY, addFunctionBodyFactory);
-
-        QuickFixes.factories.put(NON_VARARG_SPREAD, RemovePsiElementSimpleFix.createRemoveSpreadFactory());
-
-        QuickFixes.factories.put(MIXING_NAMED_AND_POSITIONED_ARGUMENTS, AddNameToArgumentFix.createFactory());
-
-        QuickFixes.factories.put(NON_MEMBER_FUNCTION_NO_BODY, addFunctionBodyFactory);
-
-        QuickFixes.factories.put(NOTHING_TO_OVERRIDE, RemoveModifierFix.createRemoveModifierFromListOwnerFactory(OVERRIDE_KEYWORD));
-        QuickFixes.factories.put(NOTHING_TO_OVERRIDE, ChangeMemberFunctionSignatureFix.createFactory());
-        QuickFixes.factories.put(NOTHING_TO_OVERRIDE, AddFunctionToSupertypeFix.createFactory());
-        QuickFixes.factories.put(VIRTUAL_MEMBER_HIDDEN, AddModifierFix.createFactory(OVERRIDE_KEYWORD));
-
-        QuickFixes.factories.put(USELESS_CAST, RemoveRightPartOfBinaryExpressionFix.createRemoveTypeFromBinaryExpressionFactory(
-                "Remove cast"));
-        QuickFixes.factories.put(DEPRECATED_STATIC_ASSERT, RemoveRightPartOfBinaryExpressionFix.createRemoveTypeFromBinaryExpressionFactory(
-                "Remove static type assertion"));
-
-        JetSingleIntentionActionFactory changeAccessorTypeFactory = ChangeAccessorTypeFix.createFactory();
-        QuickFixes.factories.put(WRONG_SETTER_PARAMETER_TYPE, changeAccessorTypeFactory);
-        QuickFixes.factories.put(WRONG_GETTER_RETURN_TYPE, changeAccessorTypeFactory);
-
-        QuickFixes.factories.put(USELESS_ELVIS, RemoveRightPartOfBinaryExpressionFix.createRemoveElvisOperatorFactory());
-
-        JetSingleIntentionActionFactory removeRedundantModifierFactory = RemoveModifierFix.createRemoveModifierFactory(true);
-        QuickFixes.factories.put(REDUNDANT_MODIFIER, removeRedundantModifierFactory);
-        QuickFixes.factories.put(ABSTRACT_MODIFIER_IN_TRAIT, RemoveModifierFix.createRemoveModifierFromListOwnerFactory(ABSTRACT_KEYWORD,
-                                                                                                                        true));
-        QuickFixes.factories.put(OPEN_MODIFIER_IN_TRAIT, RemoveModifierFix.createRemoveModifierFromListOwnerFactory(OPEN_KEYWORD, true));
-        QuickFixes.factories.put(TRAIT_CAN_NOT_BE_FINAL, removeFinalModifierFactory);
-        QuickFixes.factories.put(DEPRECATED_TRAIT_KEYWORD, DeprecatedTraitSyntaxFix.Companion);
-        QuickFixes.factories.put(DEPRECATED_TRAIT_KEYWORD, DeprecatedTraitSyntaxFix.Companion.createWholeProjectFixFactory());
-
-        QuickFixes.factories.put(REDUNDANT_PROJECTION, RemoveModifierFix.createRemoveProjectionFactory(true));
-        QuickFixes.factories.put(INCOMPATIBLE_MODIFIERS, RemoveModifierFix.createRemoveModifierFactory(false));
-        QuickFixes.factories.put(VARIANCE_ON_TYPE_PARAMETER_OF_FUNCTION_OR_PROPERTY, RemoveModifierFix.createRemoveVarianceFactory());
-
-        JetSingleIntentionActionFactory removeOpenModifierFactory = RemoveModifierFix.createRemoveModifierFromListOwnerFactory(OPEN_KEYWORD);
-        QuickFixes.factories.put(NON_FINAL_MEMBER_IN_FINAL_CLASS, AddModifierFix.createFactory(OPEN_KEYWORD, JetClass.class));
-        QuickFixes.factories.put(NON_FINAL_MEMBER_IN_FINAL_CLASS, removeOpenModifierFactory);
-
-        JetSingleIntentionActionFactory removeModifierFactory = RemoveModifierFix.createRemoveModifierFactory();
-        QuickFixes.factories.put(GETTER_VISIBILITY_DIFFERS_FROM_PROPERTY_VISIBILITY, removeModifierFactory);
-        QuickFixes.factories.put(REDUNDANT_MODIFIER_IN_GETTER, removeRedundantModifierFactory);
-        QuickFixes.factories.put(ILLEGAL_MODIFIER, removeModifierFactory);
-        QuickFixes.factories.put(REPEATED_MODIFIER, removeModifierFactory);
-
-        JetSingleIntentionActionFactory removeInnerModifierFactory =
-                RemoveModifierFix.createRemoveModifierFromListOwnerFactory(INNER_KEYWORD);
-        QuickFixes.factories.put(INNER_CLASS_IN_TRAIT, removeInnerModifierFactory);
-        QuickFixes.factories.put(INNER_CLASS_IN_OBJECT, removeInnerModifierFactory);
-
-        JetSingleIntentionActionFactory changeToBackingFieldFactory = ChangeToBackingFieldFix.createFactory();
-        QuickFixes.factories.put(INITIALIZATION_USING_BACKING_FIELD_CUSTOM_SETTER, changeToBackingFieldFactory);
-        QuickFixes.factories.put(INITIALIZATION_USING_BACKING_FIELD_OPEN_SETTER, changeToBackingFieldFactory);
-
-        JetSingleIntentionActionFactory changeToPropertyNameFactory = ChangeToPropertyNameFix.createFactory();
-        QuickFixes.factories.put(NO_BACKING_FIELD_ABSTRACT_PROPERTY, changeToPropertyNameFactory);
-        QuickFixes.factories.put(NO_BACKING_FIELD_CUSTOM_ACCESSORS, changeToPropertyNameFactory);
-        QuickFixes.factories.put(INACCESSIBLE_BACKING_FIELD, changeToPropertyNameFactory);
-
-        JetSingleIntentionActionFactory unresolvedReferenceFactory = AutoImportFix.Companion.createFactory();
-        QuickFixes.factories.put(UNRESOLVED_REFERENCE, unresolvedReferenceFactory);
-        QuickFixes.factories.put(UNRESOLVED_REFERENCE_WRONG_RECEIVER, unresolvedReferenceFactory);
-
-        JetSingleIntentionActionFactory removeImportFixFactory = RemovePsiElementSimpleFix.createRemoveImportFactory();
-        QuickFixes.factories.put(CONFLICTING_IMPORT, removeImportFixFactory);
-
-        QuickFixes.factories.put(SUPERTYPE_NOT_INITIALIZED, SuperClassNotInitialized.INSTANCE$);
-        QuickFixes.factories.put(FUNCTION_CALL_EXPECTED, ChangeToFunctionInvocationFix.createFactory());
-
-        QuickFixes.factories.put(CANNOT_CHANGE_ACCESS_PRIVILEGE, ChangeVisibilityModifierFix.createFactory());
-        QuickFixes.factories.put(CANNOT_WEAKEN_ACCESS_PRIVILEGE, ChangeVisibilityModifierFix.createFactory());
-
-        QuickFixes.factories.put(REDUNDANT_NULLABLE, RemoveNullableFix.createFactory(RemoveNullableFix.NullableKind.REDUNDANT));
-        QuickFixes.factories.put(NULLABLE_SUPERTYPE, RemoveNullableFix.createFactory(RemoveNullableFix.NullableKind.SUPERTYPE));
-        QuickFixes.factories.put(USELESS_NULLABLE_CHECK, RemoveNullableFix.createFactory(RemoveNullableFix.NullableKind.USELESS));
-
-
-        ImplementMethodsHandler implementMethodsHandler = new ImplementMethodsHandler();
-        QuickFixes.actions.put(ABSTRACT_MEMBER_NOT_IMPLEMENTED, implementMethodsHandler);
-        QuickFixes.actions.put(MANY_IMPL_MEMBER_NOT_IMPLEMENTED, implementMethodsHandler);
-
-        QuickFixes.factories.put(VAL_WITH_SETTER, ChangeVariableMutabilityFix.VAL_WITH_SETTER_FACTORY);
-        QuickFixes.factories.put(VAL_REASSIGNMENT, ChangeVariableMutabilityFix.VAL_REASSIGNMENT_FACTORY);
-        QuickFixes.factories.put(VAR_OVERRIDDEN_BY_VAL, ChangeVariableMutabilityFix.VAR_OVERRIDDEN_BY_VAL_FACTORY);
-
-        JetSingleIntentionActionFactory removeValVarFromParameterFixFactory = RemoveValVarFromParameterFix.createFactory();
-        QuickFixes.factories.put(VAL_OR_VAR_ON_FUN_PARAMETER, removeValVarFromParameterFixFactory);
-        QuickFixes.factories.put(VAL_OR_VAR_ON_LOOP_PARAMETER, removeValVarFromParameterFixFactory);
-        QuickFixes.factories.put(VAL_OR_VAR_ON_CATCH_PARAMETER, removeValVarFromParameterFixFactory);
-        QuickFixes.factories.put(VAL_OR_VAR_ON_SECONDARY_CONSTRUCTOR_PARAMETER, removeValVarFromParameterFixFactory);
-
-        QuickFixes.factories.put(VIRTUAL_MEMBER_HIDDEN, AddOverrideToEqualsHashCodeToStringFix.createFactory());
-
-        QuickFixes.factories.put(UNUSED_VARIABLE, RemovePsiElementSimpleFix.createRemoveVariableFactory());
-
-        QuickFixes.factories.put(UNNECESSARY_SAFE_CALL, ReplaceWithDotCallFix.Companion);
-        QuickFixes.factories.put(UNSAFE_CALL, ReplaceWithSafeCallFix.Companion);
-
-        QuickFixes.factories.put(UNSAFE_CALL, AddExclExclCallFix.Companion);
-        QuickFixes.factories.put(UNNECESSARY_NOT_NULL_ASSERTION, RemoveExclExclCallFix.Companion);
-        QuickFixes.factories.put(UNSAFE_INFIX_CALL, ReplaceInfixCallFix.createFactory());
-
-        JetSingleIntentionActionFactory removeProtectedModifierFactory = RemoveModifierFix.createRemoveModifierFromListOwnerFactory(PROTECTED_KEYWORD);
-        QuickFixes.factories.put(PACKAGE_MEMBER_CANNOT_BE_PROTECTED, removeProtectedModifierFactory);
-
-        QuickFixes.actions.put(PUBLIC_MEMBER_SHOULD_SPECIFY_TYPE, new SpecifyTypeExplicitlyFix());
-        QuickFixes.actions.put(AMBIGUOUS_ANONYMOUS_TYPE_INFERRED, new SpecifyTypeExplicitlyFix());
-
-        QuickFixes.factories.put(ELSE_MISPLACED_IN_WHEN, MoveWhenElseBranchFix.createFactory());
-        QuickFixes.factories.put(NO_ELSE_IN_WHEN, AddWhenElseBranchFix.createFactory());
-        QuickFixes.factories.put(BREAK_OR_CONTINUE_IN_WHEN, AddLoopLabelFix.Companion);
-
-        QuickFixes.factories.put(NO_TYPE_ARGUMENTS_ON_RHS, AddStarProjectionsFix.createFactoryForIsExpression());
-        QuickFixes.factories.put(WRONG_NUMBER_OF_TYPE_ARGUMENTS, AddStarProjectionsFix.createFactoryForJavaClass());
-
-        QuickFixes.factories.put(TYPE_ARGUMENTS_REDUNDANT_IN_SUPER_QUALIFIER, RemovePsiElementSimpleFix.createRemoveTypeArgumentsFactory());
-
-        JetSingleIntentionActionFactory changeToStarProjectionFactory = ChangeToStarProjectionFix.createFactory();
-        QuickFixes.factories.put(UNCHECKED_CAST, changeToStarProjectionFactory);
-        QuickFixes.factories.put(CANNOT_CHECK_FOR_ERASED, changeToStarProjectionFactory);
-
-        QuickFixes.factories.put(INACCESSIBLE_OUTER_CLASS_EXPRESSION, AddModifierFix.createFactory(INNER_KEYWORD, JetClass.class));
-
-        JetSingleIntentionActionFactory addOpenModifierToClassDeclarationFix = AddOpenModifierToClassDeclarationFix.createFactory();
-        QuickFixes.factories.put(FINAL_SUPERTYPE, addOpenModifierToClassDeclarationFix);
-        QuickFixes.factories.put(FINAL_UPPER_BOUND, addOpenModifierToClassDeclarationFix);
-
-        QuickFixes.factories.put(OVERRIDING_FINAL_MEMBER, MakeOverriddenMemberOpenFix.createFactory());
-
-        QuickFixes.factories.put(PARAMETER_NAME_CHANGED_ON_OVERRIDE, RenameParameterToMatchOverriddenMethodFix.createFactory());
-
-        QuickFixes.factories.put(OPEN_MODIFIER_IN_ENUM, RemoveModifierFix.createRemoveModifierFromListOwnerFactory(OPEN_KEYWORD));
-        QuickFixes.factories.put(ABSTRACT_MODIFIER_IN_ENUM, RemoveModifierFix.createRemoveModifierFromListOwnerFactory(ABSTRACT_KEYWORD));
-        QuickFixes.factories.put(ILLEGAL_ENUM_ANNOTATION, RemoveModifierFix.createRemoveModifierFromListOwnerFactory(ENUM_KEYWORD));
-
-        QuickFixes.factories.put(NESTED_CLASS_NOT_ALLOWED, AddModifierFix.createFactory(INNER_KEYWORD));
-
-        QuickFixes.factories.put(CONFLICTING_PROJECTION, RemoveModifierFix.createRemoveProjectionFactory(false));
-        QuickFixes.factories.put(PROJECTION_ON_NON_CLASS_TYPE_ARGUMENT, RemoveModifierFix.createRemoveProjectionFactory(false));
-        QuickFixes.factories.put(PROJECTION_IN_IMMEDIATE_ARGUMENT_TO_SUPERTYPE, RemoveModifierFix.createRemoveProjectionFactory(false));
-
-        QuickFixes.factories.put(NOT_AN_ANNOTATION_CLASS, MakeClassAnAnnotationClassFix.createFactory());
-
-        JetIntentionActionsFactory changeVariableTypeFix = ChangeVariableTypeFix.createFactoryForPropertyOrReturnTypeMismatchOnOverride();
-        QuickFixes.factories.put(RETURN_TYPE_MISMATCH_ON_OVERRIDE, changeVariableTypeFix);
-        QuickFixes.factories.put(PROPERTY_TYPE_MISMATCH_ON_OVERRIDE, changeVariableTypeFix);
-        QuickFixes.factories.put(COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH, ChangeVariableTypeFix.createFactoryForComponentFunctionReturnTypeMismatch());
-
-        JetSingleIntentionActionFactory changeFunctionReturnTypeFix = ChangeFunctionReturnTypeFix.createFactoryForChangingReturnTypeToUnit();
-        QuickFixes.factories.put(RETURN_TYPE_MISMATCH, changeFunctionReturnTypeFix);
-        QuickFixes.factories.put(NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY, changeFunctionReturnTypeFix);
-        QuickFixes.factories.put(RETURN_TYPE_MISMATCH_ON_OVERRIDE, ChangeFunctionReturnTypeFix.createFactoryForReturnTypeMismatchOnOverride());
-        QuickFixes.factories.put(COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH, ChangeFunctionReturnTypeFix.createFactoryForComponentFunctionReturnTypeMismatch());
-        QuickFixes.factories.put(HAS_NEXT_FUNCTION_TYPE_MISMATCH, ChangeFunctionReturnTypeFix.createFactoryForHasNextFunctionTypeMismatch());
-        QuickFixes.factories.put(COMPARE_TO_TYPE_MISMATCH, ChangeFunctionReturnTypeFix.createFactoryForCompareToTypeMismatch());
-
-        QuickFixes.factories.put(TOO_MANY_ARGUMENTS, ChangeFunctionSignatureFix.createFactory());
-        QuickFixes.factories.put(NO_VALUE_FOR_PARAMETER, ChangeFunctionSignatureFix.createFactory());
-        QuickFixes.factories.put(UNUSED_PARAMETER, ChangeFunctionSignatureFix.createFactoryForUnusedParameter());
-        QuickFixes.factories.put(EXPECTED_PARAMETERS_NUMBER_MISMATCH, ChangeFunctionSignatureFix.createFactoryForParametersNumberMismatch());
-        QuickFixes.factories.put(DEPRECATED_LAMBDA_SYNTAX, DeprecatedLambdaSyntaxFix.Factory);
-        QuickFixes.factories.put(DEPRECATED_LAMBDA_SYNTAX, DeprecatedLambdaSyntaxFix.Factory.createWholeProjectFixFactory());
-
-        QuickFixes.factories.put(EXPECTED_PARAMETER_TYPE_MISMATCH, ChangeTypeFix.createFactoryForExpectedParameterTypeMismatch());
-        QuickFixes.factories.put(EXPECTED_RETURN_TYPE_MISMATCH, ChangeTypeFix.createFactoryForExpectedReturnTypeMismatch());
-
-        JetSingleIntentionActionFactory changeFunctionLiteralReturnTypeFix = ChangeFunctionLiteralReturnTypeFix.createFactoryForExpectedOrAssignmentTypeMismatch();
-        QuickFixes.factories.put(EXPECTED_TYPE_MISMATCH, changeFunctionLiteralReturnTypeFix);
-        QuickFixes.factories.put(ASSIGNMENT_TYPE_MISMATCH, changeFunctionLiteralReturnTypeFix);
-
-        QuickFixes.factories.put(UNRESOLVED_REFERENCE, CreateUnaryOperationActionFactory.INSTANCE$);
-        QuickFixes.factories.put(UNRESOLVED_REFERENCE_WRONG_RECEIVER, CreateUnaryOperationActionFactory.INSTANCE$);
-        QuickFixes.factories.put(NO_VALUE_FOR_PARAMETER, CreateUnaryOperationActionFactory.INSTANCE$);
-
-        QuickFixes.factories.put(UNRESOLVED_REFERENCE_WRONG_RECEIVER, CreateBinaryOperationActionFactory.INSTANCE$);
-        QuickFixes.factories.put(UNRESOLVED_REFERENCE, CreateBinaryOperationActionFactory.INSTANCE$);
-        QuickFixes.factories.put(NONE_APPLICABLE, CreateBinaryOperationActionFactory.INSTANCE$);
-        QuickFixes.factories.put(NO_VALUE_FOR_PARAMETER, CreateBinaryOperationActionFactory.INSTANCE$);
-        QuickFixes.factories.put(TOO_MANY_ARGUMENTS, CreateBinaryOperationActionFactory.INSTANCE$);
-
-        QuickFixes.factories.put(UNRESOLVED_REFERENCE_WRONG_RECEIVER, CreateCallableFromCallActionFactory.INSTANCE$);
-        QuickFixes.factories.put(UNRESOLVED_REFERENCE, CreateCallableFromCallActionFactory.INSTANCE$);
-        QuickFixes.factories.put(NO_VALUE_FOR_PARAMETER, CreateCallableFromCallActionFactory.INSTANCE$);
-        QuickFixes.factories.put(TOO_MANY_ARGUMENTS, CreateCallableFromCallActionFactory.INSTANCE$);
-        QuickFixes.factories.put(EXPRESSION_EXPECTED_PACKAGE_FOUND, CreateCallableFromCallActionFactory.INSTANCE$);
-
-        QuickFixes.factories.put(NO_VALUE_FOR_PARAMETER, CreateConstructorFromDelegationCallActionFactory.INSTANCE$);
-        QuickFixes.factories.put(TOO_MANY_ARGUMENTS, CreateConstructorFromDelegationCallActionFactory.INSTANCE$);
-
-        QuickFixes.factories.put(NO_VALUE_FOR_PARAMETER, CreateConstructorFromDelegatorToSuperCallActionFactory.INSTANCE$);
-        QuickFixes.factories.put(TOO_MANY_ARGUMENTS, CreateConstructorFromDelegatorToSuperCallActionFactory.INSTANCE$);
-
-        QuickFixes.factories.put(UNRESOLVED_REFERENCE_WRONG_RECEIVER, CreateClassFromConstructorCallActionFactory.INSTANCE$);
-        QuickFixes.factories.put(UNRESOLVED_REFERENCE, CreateClassFromConstructorCallActionFactory.INSTANCE$);
-        QuickFixes.factories.put(EXPRESSION_EXPECTED_PACKAGE_FOUND, CreateClassFromConstructorCallActionFactory.INSTANCE$);
-
-        QuickFixes.factories.put(UNRESOLVED_REFERENCE, CreateLocalVariableActionFactory.INSTANCE$);
-        QuickFixes.factories.put(EXPRESSION_EXPECTED_PACKAGE_FOUND, CreateLocalVariableActionFactory.INSTANCE$);
-
-        QuickFixes.factories.put(UNRESOLVED_REFERENCE, CreateParameterActionFactory.INSTANCE$);
-        QuickFixes.factories.put(UNRESOLVED_REFERENCE_WRONG_RECEIVER, CreateParameterActionFactory.INSTANCE$);
-        QuickFixes.factories.put(EXPRESSION_EXPECTED_PACKAGE_FOUND, CreateParameterActionFactory.INSTANCE$);
-
-        QuickFixes.factories.put(NAMED_PARAMETER_NOT_FOUND, CreateParameterByNamedArgumentActionFactory.INSTANCE$);
-
-        QuickFixes.factories.put(FUNCTION_EXPECTED, CreateInvokeFunctionActionFactory.INSTANCE$);
-
-        QuickFixFactoryForTypeMismatchError factoryForTypeMismatchError = new QuickFixFactoryForTypeMismatchError();
-        QuickFixes.factories.put(TYPE_MISMATCH, factoryForTypeMismatchError);
-        QuickFixes.factories.put(NULL_FOR_NONNULL_TYPE, factoryForTypeMismatchError);
-        QuickFixes.factories.put(CONSTANT_EXPECTED_TYPE_MISMATCH, factoryForTypeMismatchError);
-
-        QuickFixes.factories.put(SMARTCAST_IMPOSSIBLE, CastExpressionFix.createFactoryForSmartCastImpossible());
-
-        QuickFixes.factories.put(PLATFORM_CLASS_MAPPED_TO_KOTLIN, MapPlatformClassToKotlinFix.createFactory());
-
-        QuickFixes.factories.put(MANY_CLASSES_IN_SUPERTYPE_LIST, RemoveSupertypeFix.createFactory());
-
-        QuickFixes.factories.put(NO_GET_METHOD, CreateGetFunctionActionFactory.INSTANCE$);
-        QuickFixes.factories.put(NO_SET_METHOD, CreateSetFunctionActionFactory.INSTANCE$);
-        QuickFixes.factories.put(HAS_NEXT_MISSING, CreateHasNextFunctionActionFactory.INSTANCE$);
-        QuickFixes.factories.put(HAS_NEXT_FUNCTION_NONE_APPLICABLE, CreateHasNextFunctionActionFactory.INSTANCE$);
-        QuickFixes.factories.put(NEXT_MISSING, CreateNextFunctionActionFactory.INSTANCE$);
-        QuickFixes.factories.put(NEXT_NONE_APPLICABLE, CreateNextFunctionActionFactory.INSTANCE$);
-        QuickFixes.factories.put(ITERATOR_MISSING, CreateIteratorFunctionActionFactory.INSTANCE$);
-        QuickFixes.factories.put(COMPONENT_FUNCTION_MISSING, CreateComponentFunctionActionFactory.INSTANCE$);
-
-        QuickFixes.factories.put(DELEGATE_SPECIAL_FUNCTION_MISSING, CreatePropertyDelegateAccessorsActionFactory.INSTANCE$);
-        QuickFixes.factories.put(DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE, CreatePropertyDelegateAccessorsActionFactory.INSTANCE$);
-
-        QuickFixes.factories.put(UNRESOLVED_REFERENCE, CreateClassFromTypeReferenceActionFactory.INSTANCE$);
-        QuickFixes.factories.put(UNRESOLVED_REFERENCE, CreateClassFromReferenceExpressionActionFactory.INSTANCE$);
-        QuickFixes.factories.put(UNRESOLVED_REFERENCE, CreateClassFromCallWithConstructorCalleeActionFactory.INSTANCE$);
-
-        QuickFixes.factories.put(PRIMARY_CONSTRUCTOR_DELEGATION_CALL_EXPECTED, InsertDelegationCallQuickfix.InsertThisDelegationCallFactory.INSTANCE$);
-
-        QuickFixes.factories.put(EXPLICIT_DELEGATION_CALL_REQUIRED, InsertDelegationCallQuickfix.InsertThisDelegationCallFactory.INSTANCE$);
-        QuickFixes.factories.put(EXPLICIT_DELEGATION_CALL_REQUIRED, InsertDelegationCallQuickfix.InsertSuperDelegationCallFactory.INSTANCE$);
-
-        QuickFixes.factories.put(ErrorsJvm.DEPRECATED_ANNOTATION_METHOD_CALL, MigrateAnnotationMethodCallFix.Companion);
-        QuickFixes.factories.put(ErrorsJvm.DEPRECATED_ANNOTATION_METHOD_CALL, MigrateAnnotationMethodCallInWholeFile.Companion);
-
-        QuickFixes.factories.put(ENUM_ENTRY_USES_DEPRECATED_SUPER_CONSTRUCTOR, DeprecatedEnumEntrySuperConstructorSyntaxFix.Companion);
-        QuickFixes.factories.put(ENUM_ENTRY_USES_DEPRECATED_SUPER_CONSTRUCTOR, DeprecatedEnumEntrySuperConstructorSyntaxFix.Companion.createWholeProjectFixFactory());
-
-        QuickFixes.factories.put(ENUM_ENTRY_USES_DEPRECATED_OR_NO_DELIMITER, DeprecatedEnumEntryDelimiterSyntaxFix.Companion);
-        QuickFixes.factories.put(ENUM_ENTRY_USES_DEPRECATED_OR_NO_DELIMITER, DeprecatedEnumEntryDelimiterSyntaxFix.Companion.createWholeProjectFixFactory());
-
-        QuickFixes.factories.put(MISSING_CONSTRUCTOR_KEYWORD, MissingConstructorKeywordFix.Companion);
-        QuickFixes.factories.put(MISSING_CONSTRUCTOR_KEYWORD, MissingConstructorKeywordFix.Companion.createWholeProjectFixFactory());
-
-        QuickFixes.factories.put(FUNCTION_EXPRESSION_WITH_NAME, RemoveNameFromFunctionExpressionFix.Companion);
-        QuickFixes.factories.put(FUNCTION_EXPRESSION_WITH_NAME, RemoveNameFromFunctionExpressionFix.Companion.createWholeProjectFixFactory());
-
-        QuickFixes.factories.put(UNRESOLVED_REFERENCE, ReplaceObsoleteLabelSyntaxFix.Companion);
-        QuickFixes.factories.put(UNRESOLVED_REFERENCE, ReplaceObsoleteLabelSyntaxFix.Companion.createWholeProjectFixFactory());
-
-        QuickFixes.factories.put(DEPRECATED_SYMBOL_WITH_MESSAGE, DeprecatedSymbolUsageFix.Companion);
-        QuickFixes.factories.put(DEPRECATED_SYMBOL_WITH_MESSAGE, DeprecatedSymbolUsageInWholeProjectFix.Companion);
-        
-        QuickFixes.factories.put(ErrorsJvm.POSITIONED_VALUE_ARGUMENT_FOR_JAVA_ANNOTATION, ReplaceJavaAnnotationPositionedArgumentsFix.Companion);
-    }
-}
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/QuickFixRegistrar.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/QuickFixRegistrar.kt
new file mode 100644
index 00000000000..c23ea011a44
--- /dev/null
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/QuickFixRegistrar.kt
@@ -0,0 +1,336 @@
+/*
+ * Copyright 2010-2015 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.kotlin.idea.quickfix
+
+import com.intellij.codeInsight.intention.IntentionAction
+import org.jetbrains.kotlin.diagnostics.DiagnosticFactory
+import org.jetbrains.kotlin.diagnostics.Errors.*
+import org.jetbrains.kotlin.idea.core.codeInsight.ImplementMethodsHandler
+import org.jetbrains.kotlin.idea.inspections.AddReflectionQuickFix
+import org.jetbrains.kotlin.idea.quickfix.createFromUsage.createCallable.*
+import org.jetbrains.kotlin.idea.quickfix.createFromUsage.createClass.CreateClassFromCallWithConstructorCalleeActionFactory
+import org.jetbrains.kotlin.idea.quickfix.createFromUsage.createClass.CreateClassFromConstructorCallActionFactory
+import org.jetbrains.kotlin.idea.quickfix.createFromUsage.createClass.CreateClassFromReferenceExpressionActionFactory
+import org.jetbrains.kotlin.idea.quickfix.createFromUsage.createClass.CreateClassFromTypeReferenceActionFactory
+import org.jetbrains.kotlin.idea.quickfix.createFromUsage.createVariable.CreateLocalVariableActionFactory
+import org.jetbrains.kotlin.idea.quickfix.createFromUsage.createVariable.CreateParameterActionFactory
+import org.jetbrains.kotlin.idea.quickfix.createFromUsage.createVariable.CreateParameterByNamedArgumentActionFactory
+import org.jetbrains.kotlin.lexer.JetTokens.*
+import org.jetbrains.kotlin.psi.JetClass
+import org.jetbrains.kotlin.resolve.jvm.diagnostics.ErrorsJvm.DEPRECATED_ANNOTATION_METHOD_CALL
+import org.jetbrains.kotlin.resolve.jvm.diagnostics.ErrorsJvm.NO_REFLECTION_IN_CLASS_PATH
+import org.jetbrains.kotlin.resolve.jvm.diagnostics.ErrorsJvm.POSITIONED_VALUE_ARGUMENT_FOR_JAVA_ANNOTATION
+
+public class QuickFixRegistrar : QuickFixContributor {
+    public override fun registerQuickFixes(quickFixes: QuickFixes) {
+        fun DiagnosticFactory<*>.registerFactory(vararg factory: JetIntentionActionsFactory) {
+            quickFixes.register(this, *factory)
+        }
+
+        fun DiagnosticFactory<*>.registerActions(vararg action: IntentionAction) {
+            quickFixes.register(this, *action)
+        }
+
+        val removeAbstractModifierFactory = RemoveModifierFix.createRemoveModifierFromListOwnerFactory(ABSTRACT_KEYWORD)
+        val addAbstractModifierFactory = AddModifierFix.createFactory(ABSTRACT_KEYWORD)
+
+        ABSTRACT_PROPERTY_IN_PRIMARY_CONSTRUCTOR_PARAMETERS.registerFactory(removeAbstractModifierFactory)
+
+        val removePartsFromPropertyFactory = RemovePartsFromPropertyFix.createFactory()
+        ABSTRACT_PROPERTY_WITH_INITIALIZER.registerFactory(removeAbstractModifierFactory, removePartsFromPropertyFactory)
+        ABSTRACT_PROPERTY_WITH_GETTER.registerFactory(removeAbstractModifierFactory, removePartsFromPropertyFactory)
+        ABSTRACT_PROPERTY_WITH_SETTER.registerFactory(removeAbstractModifierFactory, removePartsFromPropertyFactory)
+
+        PROPERTY_INITIALIZER_IN_TRAIT.registerFactory(removePartsFromPropertyFactory)
+
+        MUST_BE_INITIALIZED_OR_BE_ABSTRACT.registerFactory(addAbstractModifierFactory)
+        ABSTRACT_MEMBER_NOT_IMPLEMENTED.registerFactory(addAbstractModifierFactory)
+        MANY_IMPL_MEMBER_NOT_IMPLEMENTED.registerFactory(addAbstractModifierFactory)
+
+        val removeFinalModifierFactory = RemoveModifierFix.createRemoveModifierFromListOwnerFactory(FINAL_KEYWORD)
+        val addAbstractToClassFactory = AddModifierFix.createFactory(ABSTRACT_KEYWORD, javaClass<JetClass>())
+        ABSTRACT_PROPERTY_IN_NON_ABSTRACT_CLASS.registerFactory(removeAbstractModifierFactory, addAbstractToClassFactory)
+
+        ABSTRACT_FUNCTION_IN_NON_ABSTRACT_CLASS.registerFactory(removeAbstractModifierFactory, addAbstractToClassFactory)
+
+        val removeFunctionBodyFactory = RemoveFunctionBodyFix.createFactory()
+        ABSTRACT_FUNCTION_WITH_BODY.registerFactory(removeAbstractModifierFactory, removeFunctionBodyFactory)
+
+        FINAL_PROPERTY_IN_TRAIT.registerFactory(removeFinalModifierFactory)
+        FINAL_FUNCTION_WITH_NO_BODY.registerFactory(removeFinalModifierFactory)
+
+        val addFunctionBodyFactory = AddFunctionBodyFix.createFactory()
+        NON_ABSTRACT_FUNCTION_WITH_NO_BODY.registerFactory(addAbstractModifierFactory, addFunctionBodyFactory)
+
+        NON_VARARG_SPREAD.registerFactory(RemovePsiElementSimpleFix.createRemoveSpreadFactory())
+
+        MIXING_NAMED_AND_POSITIONED_ARGUMENTS.registerFactory(AddNameToArgumentFix.createFactory())
+
+        NON_MEMBER_FUNCTION_NO_BODY.registerFactory(addFunctionBodyFactory)
+
+        NOTHING_TO_OVERRIDE.registerFactory( RemoveModifierFix.createRemoveModifierFromListOwnerFactory(OVERRIDE_KEYWORD),
+                                        ChangeMemberFunctionSignatureFix.createFactory(),
+                                        AddFunctionToSupertypeFix.createFactory())
+        VIRTUAL_MEMBER_HIDDEN.registerFactory(AddModifierFix.createFactory(OVERRIDE_KEYWORD))
+
+        USELESS_CAST.registerFactory(RemoveRightPartOfBinaryExpressionFix.createRemoveTypeFromBinaryExpressionFactory("Remove cast"))
+        DEPRECATED_STATIC_ASSERT.registerFactory(RemoveRightPartOfBinaryExpressionFix.createRemoveTypeFromBinaryExpressionFactory("Remove static type assertion"))
+
+        val changeAccessorTypeFactory = ChangeAccessorTypeFix.createFactory()
+        WRONG_SETTER_PARAMETER_TYPE.registerFactory(changeAccessorTypeFactory)
+        WRONG_GETTER_RETURN_TYPE.registerFactory(changeAccessorTypeFactory)
+
+        USELESS_ELVIS.registerFactory(RemoveRightPartOfBinaryExpressionFix.createRemoveElvisOperatorFactory())
+
+        val removeRedundantModifierFactory = RemoveModifierFix.createRemoveModifierFactory(true)
+        REDUNDANT_MODIFIER.registerFactory(removeRedundantModifierFactory)
+        ABSTRACT_MODIFIER_IN_TRAIT.registerFactory(RemoveModifierFix.createRemoveModifierFromListOwnerFactory(ABSTRACT_KEYWORD, true))
+        OPEN_MODIFIER_IN_TRAIT.registerFactory(RemoveModifierFix.createRemoveModifierFromListOwnerFactory(OPEN_KEYWORD, true))
+        TRAIT_CAN_NOT_BE_FINAL.registerFactory(removeFinalModifierFactory)
+        DEPRECATED_TRAIT_KEYWORD.registerFactory(DeprecatedTraitSyntaxFix, DeprecatedTraitSyntaxFix.createWholeProjectFixFactory())
+
+        REDUNDANT_PROJECTION.registerFactory(RemoveModifierFix.createRemoveProjectionFactory(true))
+        INCOMPATIBLE_MODIFIERS.registerFactory(RemoveModifierFix.createRemoveModifierFactory(false))
+        VARIANCE_ON_TYPE_PARAMETER_OF_FUNCTION_OR_PROPERTY.registerFactory(RemoveModifierFix.createRemoveVarianceFactory())
+
+        val removeOpenModifierFactory = RemoveModifierFix.createRemoveModifierFromListOwnerFactory(OPEN_KEYWORD)
+        NON_FINAL_MEMBER_IN_FINAL_CLASS.registerFactory(AddModifierFix.createFactory(OPEN_KEYWORD, javaClass<JetClass>()),
+                                                   removeOpenModifierFactory)
+
+        val removeModifierFactory = RemoveModifierFix.createRemoveModifierFactory()
+        GETTER_VISIBILITY_DIFFERS_FROM_PROPERTY_VISIBILITY.registerFactory(removeModifierFactory)
+        REDUNDANT_MODIFIER_IN_GETTER.registerFactory(removeRedundantModifierFactory)
+        ILLEGAL_MODIFIER.registerFactory(removeModifierFactory)
+        REPEATED_MODIFIER.registerFactory(removeModifierFactory)
+
+        val removeInnerModifierFactory = RemoveModifierFix.createRemoveModifierFromListOwnerFactory(INNER_KEYWORD)
+        INNER_CLASS_IN_TRAIT.registerFactory(removeInnerModifierFactory)
+        INNER_CLASS_IN_OBJECT.registerFactory(removeInnerModifierFactory)
+
+        val changeToBackingFieldFactory = ChangeToBackingFieldFix.createFactory()
+        INITIALIZATION_USING_BACKING_FIELD_CUSTOM_SETTER.registerFactory(changeToBackingFieldFactory)
+        INITIALIZATION_USING_BACKING_FIELD_OPEN_SETTER.registerFactory(changeToBackingFieldFactory)
+
+        val changeToPropertyNameFactory = ChangeToPropertyNameFix.createFactory()
+        NO_BACKING_FIELD_ABSTRACT_PROPERTY.registerFactory(changeToPropertyNameFactory)
+        NO_BACKING_FIELD_CUSTOM_ACCESSORS.registerFactory(changeToPropertyNameFactory)
+        INACCESSIBLE_BACKING_FIELD.registerFactory(changeToPropertyNameFactory)
+
+        val unresolvedReferenceFactory = AutoImportFix.createFactory()
+        UNRESOLVED_REFERENCE.registerFactory(unresolvedReferenceFactory)
+        UNRESOLVED_REFERENCE_WRONG_RECEIVER.registerFactory(unresolvedReferenceFactory)
+
+        val removeImportFixFactory = RemovePsiElementSimpleFix.createRemoveImportFactory()
+        CONFLICTING_IMPORT.registerFactory(removeImportFixFactory)
+
+        SUPERTYPE_NOT_INITIALIZED.registerFactory(SuperClassNotInitialized)
+        FUNCTION_CALL_EXPECTED.registerFactory(ChangeToFunctionInvocationFix.createFactory())
+
+        CANNOT_CHANGE_ACCESS_PRIVILEGE.registerFactory(ChangeVisibilityModifierFix.createFactory())
+        CANNOT_WEAKEN_ACCESS_PRIVILEGE.registerFactory(ChangeVisibilityModifierFix.createFactory())
+
+        REDUNDANT_NULLABLE.registerFactory(RemoveNullableFix.createFactory(RemoveNullableFix.NullableKind.REDUNDANT))
+        NULLABLE_SUPERTYPE.registerFactory(RemoveNullableFix.createFactory(RemoveNullableFix.NullableKind.SUPERTYPE))
+        USELESS_NULLABLE_CHECK.registerFactory(RemoveNullableFix.createFactory(RemoveNullableFix.NullableKind.USELESS))
+
+
+        val implementMethodsHandler = ImplementMethodsHandler()
+        ABSTRACT_MEMBER_NOT_IMPLEMENTED.registerActions(implementMethodsHandler)
+        MANY_IMPL_MEMBER_NOT_IMPLEMENTED.registerActions(implementMethodsHandler)
+
+        VAL_WITH_SETTER.registerFactory(ChangeVariableMutabilityFix.VAL_WITH_SETTER_FACTORY)
+        VAL_REASSIGNMENT.registerFactory(ChangeVariableMutabilityFix.VAL_REASSIGNMENT_FACTORY)
+        VAR_OVERRIDDEN_BY_VAL.registerFactory(ChangeVariableMutabilityFix.VAR_OVERRIDDEN_BY_VAL_FACTORY)
+
+        val removeValVarFromParameterFixFactory = RemoveValVarFromParameterFix.createFactory()
+        VAL_OR_VAR_ON_FUN_PARAMETER.registerFactory(removeValVarFromParameterFixFactory)
+        VAL_OR_VAR_ON_LOOP_PARAMETER.registerFactory(removeValVarFromParameterFixFactory)
+        VAL_OR_VAR_ON_CATCH_PARAMETER.registerFactory(removeValVarFromParameterFixFactory)
+        VAL_OR_VAR_ON_SECONDARY_CONSTRUCTOR_PARAMETER.registerFactory(removeValVarFromParameterFixFactory)
+
+        VIRTUAL_MEMBER_HIDDEN.registerFactory(AddOverrideToEqualsHashCodeToStringFix.createFactory())
+
+        UNUSED_VARIABLE.registerFactory(RemovePsiElementSimpleFix.createRemoveVariableFactory())
+
+        UNNECESSARY_SAFE_CALL.registerFactory(ReplaceWithDotCallFix)
+        UNSAFE_CALL.registerFactory(ReplaceWithSafeCallFix)
+
+        UNSAFE_CALL.registerFactory(AddExclExclCallFix)
+        UNNECESSARY_NOT_NULL_ASSERTION.registerFactory(RemoveExclExclCallFix)
+        UNSAFE_INFIX_CALL.registerFactory(ReplaceInfixCallFix.createFactory())
+
+        val removeProtectedModifierFactory = RemoveModifierFix.createRemoveModifierFromListOwnerFactory(PROTECTED_KEYWORD)
+        PACKAGE_MEMBER_CANNOT_BE_PROTECTED.registerFactory(removeProtectedModifierFactory)
+
+        PUBLIC_MEMBER_SHOULD_SPECIFY_TYPE.registerActions(SpecifyTypeExplicitlyFix())
+        AMBIGUOUS_ANONYMOUS_TYPE_INFERRED.registerActions(SpecifyTypeExplicitlyFix())
+
+        ELSE_MISPLACED_IN_WHEN.registerFactory(MoveWhenElseBranchFix.createFactory())
+        NO_ELSE_IN_WHEN.registerFactory(AddWhenElseBranchFix.createFactory())
+        BREAK_OR_CONTINUE_IN_WHEN.registerFactory(AddLoopLabelFix)
+
+        NO_TYPE_ARGUMENTS_ON_RHS.registerFactory(AddStarProjectionsFix.createFactoryForIsExpression())
+        WRONG_NUMBER_OF_TYPE_ARGUMENTS.registerFactory(AddStarProjectionsFix.createFactoryForJavaClass())
+
+        TYPE_ARGUMENTS_REDUNDANT_IN_SUPER_QUALIFIER.registerFactory(RemovePsiElementSimpleFix.createRemoveTypeArgumentsFactory())
+
+        val changeToStarProjectionFactory = ChangeToStarProjectionFix.createFactory()
+        UNCHECKED_CAST.registerFactory(changeToStarProjectionFactory)
+        CANNOT_CHECK_FOR_ERASED.registerFactory(changeToStarProjectionFactory)
+
+        INACCESSIBLE_OUTER_CLASS_EXPRESSION.registerFactory(AddModifierFix.createFactory(INNER_KEYWORD, javaClass<JetClass>()))
+
+        val addOpenModifierToClassDeclarationFix = AddOpenModifierToClassDeclarationFix.createFactory()
+        FINAL_SUPERTYPE.registerFactory(addOpenModifierToClassDeclarationFix)
+        FINAL_UPPER_BOUND.registerFactory(addOpenModifierToClassDeclarationFix)
+
+        OVERRIDING_FINAL_MEMBER.registerFactory(MakeOverriddenMemberOpenFix.createFactory())
+
+        PARAMETER_NAME_CHANGED_ON_OVERRIDE.registerFactory(RenameParameterToMatchOverriddenMethodFix.createFactory())
+
+        OPEN_MODIFIER_IN_ENUM.registerFactory(RemoveModifierFix.createRemoveModifierFromListOwnerFactory(OPEN_KEYWORD))
+        ABSTRACT_MODIFIER_IN_ENUM.registerFactory(RemoveModifierFix.createRemoveModifierFromListOwnerFactory(ABSTRACT_KEYWORD))
+        ILLEGAL_ENUM_ANNOTATION.registerFactory(RemoveModifierFix.createRemoveModifierFromListOwnerFactory(ENUM_KEYWORD))
+
+        NESTED_CLASS_NOT_ALLOWED.registerFactory(AddModifierFix.createFactory(INNER_KEYWORD))
+
+        CONFLICTING_PROJECTION.registerFactory(RemoveModifierFix.createRemoveProjectionFactory(false))
+        PROJECTION_ON_NON_CLASS_TYPE_ARGUMENT.registerFactory(RemoveModifierFix.createRemoveProjectionFactory(false))
+        PROJECTION_IN_IMMEDIATE_ARGUMENT_TO_SUPERTYPE.registerFactory(RemoveModifierFix.createRemoveProjectionFactory(false))
+
+        NOT_AN_ANNOTATION_CLASS.registerFactory(MakeClassAnAnnotationClassFix.createFactory())
+
+        val changeVariableTypeFix = ChangeVariableTypeFix.createFactoryForPropertyOrReturnTypeMismatchOnOverride()
+        RETURN_TYPE_MISMATCH_ON_OVERRIDE.registerFactory(changeVariableTypeFix)
+        PROPERTY_TYPE_MISMATCH_ON_OVERRIDE.registerFactory(changeVariableTypeFix)
+        COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH.registerFactory(ChangeVariableTypeFix.createFactoryForComponentFunctionReturnTypeMismatch())
+
+        val changeFunctionReturnTypeFix = ChangeFunctionReturnTypeFix.createFactoryForChangingReturnTypeToUnit()
+        RETURN_TYPE_MISMATCH.registerFactory(changeFunctionReturnTypeFix)
+        NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY.registerFactory(changeFunctionReturnTypeFix)
+        RETURN_TYPE_MISMATCH_ON_OVERRIDE.registerFactory(ChangeFunctionReturnTypeFix.createFactoryForReturnTypeMismatchOnOverride())
+        COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH.registerFactory(ChangeFunctionReturnTypeFix.createFactoryForComponentFunctionReturnTypeMismatch())
+        HAS_NEXT_FUNCTION_TYPE_MISMATCH.registerFactory(ChangeFunctionReturnTypeFix.createFactoryForHasNextFunctionTypeMismatch())
+        COMPARE_TO_TYPE_MISMATCH.registerFactory(ChangeFunctionReturnTypeFix.createFactoryForCompareToTypeMismatch())
+
+        TOO_MANY_ARGUMENTS.registerFactory(ChangeFunctionSignatureFix.createFactory())
+        NO_VALUE_FOR_PARAMETER.registerFactory(ChangeFunctionSignatureFix.createFactory())
+        UNUSED_PARAMETER.registerFactory(ChangeFunctionSignatureFix.createFactoryForUnusedParameter())
+        EXPECTED_PARAMETERS_NUMBER_MISMATCH.registerFactory(ChangeFunctionSignatureFix.createFactoryForParametersNumberMismatch())
+        DEPRECATED_LAMBDA_SYNTAX.registerFactory(DeprecatedLambdaSyntaxFix, DeprecatedLambdaSyntaxFix.createWholeProjectFixFactory())
+
+        EXPECTED_PARAMETER_TYPE_MISMATCH.registerFactory(ChangeTypeFix.createFactoryForExpectedParameterTypeMismatch())
+        EXPECTED_RETURN_TYPE_MISMATCH.registerFactory(ChangeTypeFix.createFactoryForExpectedReturnTypeMismatch())
+
+        val changeFunctionLiteralReturnTypeFix = ChangeFunctionLiteralReturnTypeFix.createFactoryForExpectedOrAssignmentTypeMismatch()
+        EXPECTED_TYPE_MISMATCH.registerFactory(changeFunctionLiteralReturnTypeFix)
+        ASSIGNMENT_TYPE_MISMATCH.registerFactory(changeFunctionLiteralReturnTypeFix)
+
+        UNRESOLVED_REFERENCE.registerFactory(CreateUnaryOperationActionFactory)
+        UNRESOLVED_REFERENCE_WRONG_RECEIVER.registerFactory(CreateUnaryOperationActionFactory)
+        NO_VALUE_FOR_PARAMETER.registerFactory(CreateUnaryOperationActionFactory)
+
+        UNRESOLVED_REFERENCE_WRONG_RECEIVER.registerFactory(CreateBinaryOperationActionFactory)
+        UNRESOLVED_REFERENCE.registerFactory(CreateBinaryOperationActionFactory)
+        NONE_APPLICABLE.registerFactory(CreateBinaryOperationActionFactory)
+        NO_VALUE_FOR_PARAMETER.registerFactory(CreateBinaryOperationActionFactory)
+        TOO_MANY_ARGUMENTS.registerFactory(CreateBinaryOperationActionFactory)
+
+        UNRESOLVED_REFERENCE_WRONG_RECEIVER.registerFactory(CreateCallableFromCallActionFactory)
+        UNRESOLVED_REFERENCE.registerFactory(CreateCallableFromCallActionFactory)
+        NO_VALUE_FOR_PARAMETER.registerFactory(CreateCallableFromCallActionFactory)
+        TOO_MANY_ARGUMENTS.registerFactory(CreateCallableFromCallActionFactory)
+        EXPRESSION_EXPECTED_PACKAGE_FOUND.registerFactory(CreateCallableFromCallActionFactory)
+
+        NO_VALUE_FOR_PARAMETER.registerFactory(CreateConstructorFromDelegationCallActionFactory)
+        TOO_MANY_ARGUMENTS.registerFactory(CreateConstructorFromDelegationCallActionFactory)
+
+        NO_VALUE_FOR_PARAMETER.registerFactory(CreateConstructorFromDelegatorToSuperCallActionFactory)
+        TOO_MANY_ARGUMENTS.registerFactory(CreateConstructorFromDelegatorToSuperCallActionFactory)
+
+        UNRESOLVED_REFERENCE_WRONG_RECEIVER.registerFactory(CreateClassFromConstructorCallActionFactory)
+        UNRESOLVED_REFERENCE.registerFactory(CreateClassFromConstructorCallActionFactory)
+        EXPRESSION_EXPECTED_PACKAGE_FOUND.registerFactory(CreateClassFromConstructorCallActionFactory)
+
+        UNRESOLVED_REFERENCE.registerFactory(CreateLocalVariableActionFactory)
+        EXPRESSION_EXPECTED_PACKAGE_FOUND.registerFactory(CreateLocalVariableActionFactory)
+
+        UNRESOLVED_REFERENCE.registerFactory(CreateParameterActionFactory)
+        UNRESOLVED_REFERENCE_WRONG_RECEIVER.registerFactory(CreateParameterActionFactory)
+        EXPRESSION_EXPECTED_PACKAGE_FOUND.registerFactory(CreateParameterActionFactory)
+
+        NAMED_PARAMETER_NOT_FOUND.registerFactory(CreateParameterByNamedArgumentActionFactory)
+
+        FUNCTION_EXPECTED.registerFactory(CreateInvokeFunctionActionFactory)
+
+        val factoryForTypeMismatchError = QuickFixFactoryForTypeMismatchError()
+        TYPE_MISMATCH.registerFactory(factoryForTypeMismatchError)
+        NULL_FOR_NONNULL_TYPE.registerFactory(factoryForTypeMismatchError)
+        CONSTANT_EXPECTED_TYPE_MISMATCH.registerFactory(factoryForTypeMismatchError)
+
+        SMARTCAST_IMPOSSIBLE.registerFactory(CastExpressionFix.createFactoryForSmartCastImpossible())
+
+        PLATFORM_CLASS_MAPPED_TO_KOTLIN.registerFactory(MapPlatformClassToKotlinFix.createFactory())
+
+        MANY_CLASSES_IN_SUPERTYPE_LIST.registerFactory(RemoveSupertypeFix.createFactory())
+
+        NO_GET_METHOD.registerFactory(CreateGetFunctionActionFactory)
+        NO_SET_METHOD.registerFactory(CreateSetFunctionActionFactory)
+        HAS_NEXT_MISSING.registerFactory(CreateHasNextFunctionActionFactory)
+        HAS_NEXT_FUNCTION_NONE_APPLICABLE.registerFactory(CreateHasNextFunctionActionFactory)
+        NEXT_MISSING.registerFactory(CreateNextFunctionActionFactory)
+        NEXT_NONE_APPLICABLE.registerFactory(CreateNextFunctionActionFactory)
+        ITERATOR_MISSING.registerFactory(CreateIteratorFunctionActionFactory)
+        COMPONENT_FUNCTION_MISSING.registerFactory(CreateComponentFunctionActionFactory)
+
+        DELEGATE_SPECIAL_FUNCTION_MISSING.registerFactory(CreatePropertyDelegateAccessorsActionFactory)
+        DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE.registerFactory(CreatePropertyDelegateAccessorsActionFactory)
+
+        UNRESOLVED_REFERENCE.registerFactory(CreateClassFromTypeReferenceActionFactory,
+                                        CreateClassFromReferenceExpressionActionFactory,
+                                        CreateClassFromCallWithConstructorCalleeActionFactory)
+
+        PRIMARY_CONSTRUCTOR_DELEGATION_CALL_EXPECTED.registerFactory(InsertDelegationCallQuickfix.InsertThisDelegationCallFactory)
+
+        EXPLICIT_DELEGATION_CALL_REQUIRED.registerFactory(InsertDelegationCallQuickfix.InsertThisDelegationCallFactory)
+        EXPLICIT_DELEGATION_CALL_REQUIRED.registerFactory(InsertDelegationCallQuickfix.InsertSuperDelegationCallFactory)
+
+        DEPRECATED_ANNOTATION_METHOD_CALL.registerFactory(MigrateAnnotationMethodCallFix, MigrateAnnotationMethodCallInWholeFile)
+
+        ENUM_ENTRY_USES_DEPRECATED_SUPER_CONSTRUCTOR.registerFactory(DeprecatedEnumEntrySuperConstructorSyntaxFix,
+                                                                DeprecatedEnumEntrySuperConstructorSyntaxFix.createWholeProjectFixFactory())
+
+        ENUM_ENTRY_USES_DEPRECATED_OR_NO_DELIMITER.registerFactory(DeprecatedEnumEntryDelimiterSyntaxFix,
+                                                              DeprecatedEnumEntryDelimiterSyntaxFix.createWholeProjectFixFactory())
+
+        MISSING_CONSTRUCTOR_KEYWORD.registerFactory(MissingConstructorKeywordFix,
+                                               MissingConstructorKeywordFix.createWholeProjectFixFactory())
+
+        FUNCTION_EXPRESSION_WITH_NAME.registerFactory(RemoveNameFromFunctionExpressionFix,
+                                                 RemoveNameFromFunctionExpressionFix.createWholeProjectFixFactory())
+
+        UNRESOLVED_REFERENCE.registerFactory(ReplaceObsoleteLabelSyntaxFix,
+                                        ReplaceObsoleteLabelSyntaxFix.createWholeProjectFixFactory())
+
+        DEPRECATED_SYMBOL_WITH_MESSAGE.registerFactory(DeprecatedSymbolUsageFix,
+                                                  DeprecatedSymbolUsageInWholeProjectFix)
+
+        POSITIONED_VALUE_ARGUMENT_FOR_JAVA_ANNOTATION.registerFactory(ReplaceJavaAnnotationPositionedArgumentsFix)
+
+        NO_REFLECTION_IN_CLASS_PATH.registerFactory(AddReflectionQuickFix)
+    }
+}
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/ReplaceObsoleteLabelSyntaxFix.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/ReplaceObsoleteLabelSyntaxFix.kt
index 47598fb4195..488285da8ad 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/ReplaceObsoleteLabelSyntaxFix.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/ReplaceObsoleteLabelSyntaxFix.kt
@@ -29,7 +29,7 @@ import org.jetbrains.kotlin.psi.psiUtil.anyDescendantOfType
 import org.jetbrains.kotlin.psi.psiUtil.getNonStrictParentOfType
 import org.jetbrains.kotlin.resolve.BindingContext
 
-public class ReplaceObsoleteLabelSyntaxFix(element: JetAnnotationEntry?) : JetIntentionAction<JetAnnotationEntry>(element), CleanupFix {
+public class ReplaceObsoleteLabelSyntaxFix(element: JetAnnotationEntry) : JetIntentionAction<JetAnnotationEntry>(element), CleanupFix {
     override fun getFamilyName(): String = "Update obsolete label syntax"
     override fun getText(): String = "Replace with label ${element.getCalleeExpression()?.getText() ?: ""}@"
 
@@ -65,7 +65,7 @@ public class ReplaceObsoleteLabelSyntaxFix(element: JetAnnotationEntry?) : JetIn
 
             val baseExpression = (getParent() as? JetAnnotatedExpression)?.getBaseExpression() ?: return false
 
-            val nameExpression = getCalleeExpression().getConstructorReferenceExpression() ?: return false
+            val nameExpression = getCalleeExpression()?.getConstructorReferenceExpression() ?: return false
             val labelName = nameExpression.getReferencedName()
 
             return baseExpression.anyDescendantOfType<JetExpressionWithLabel> {
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/ReplaceWithAnnotationAnalyzer.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/ReplaceWithAnnotationAnalyzer.kt
index 3594cc4a370..33eeed65747 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/ReplaceWithAnnotationAnalyzer.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/ReplaceWithAnnotationAnalyzer.kt
@@ -42,11 +42,11 @@ import org.jetbrains.kotlin.resolve.FunctionDescriptorUtil
 import org.jetbrains.kotlin.resolve.calls.callUtil.getResolvedCall
 import org.jetbrains.kotlin.resolve.descriptorUtil.isExtension
 import org.jetbrains.kotlin.resolve.descriptorUtil.module
+import org.jetbrains.kotlin.resolve.lazy.descriptors.ClassResolutionScopesSupport
 import org.jetbrains.kotlin.resolve.scopes.*
 import org.jetbrains.kotlin.resolve.scopes.receivers.ThisReceiver
-import org.jetbrains.kotlin.utils.Printer
+import org.jetbrains.kotlin.storage.LockBasedStorageManager
 import org.jetbrains.kotlin.utils.addIfNotNull
-import org.jetbrains.kotlin.utils.addToStdlib.firstIsInstanceOrNull
 import java.util.ArrayList
 import java.util.LinkedHashSet
 
@@ -172,17 +172,22 @@ object ReplaceWithAnnotationAnalyzer {
             is ClassDescriptorWithResolutionScopes ->
                 descriptor.getScopeForMemberDeclarationResolution()
 
+            is ClassDescriptor -> {
+                val outerScope = getResolutionScope(descriptor.getContainingDeclaration())
+                ClassResolutionScopesSupport(descriptor, LockBasedStorageManager.NO_LOCKS, { outerScope }).getScopeForMemberDeclarationResolution()
+            }
+
             is FunctionDescriptor ->
                 FunctionDescriptorUtil.getFunctionInnerScope(getResolutionScope(descriptor.getContainingDeclaration()),
                                                              descriptor, RedeclarationHandler.DO_NOTHING)
 
             is PropertyDescriptor ->
                 JetScopeUtils.getPropertyDeclarationInnerScope(descriptor,
-                                                               getResolutionScope(descriptor.getContainingDeclaration()!!),
+                                                               getResolutionScope(descriptor.getContainingDeclaration()),
                                                                RedeclarationHandler.DO_NOTHING)
             is LocalVariableDescriptor -> {
                 val declaration = DescriptorToSourceUtils.descriptorToDeclaration(descriptor) as JetDeclaration
-                declaration.analyze()[BindingContext.RESOLUTION_SCOPE, declaration]
+                declaration.analyze()[BindingContext.RESOLUTION_SCOPE, declaration]!!
             }
 
             //TODO?
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/SuperClassNotInitialized.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/SuperClassNotInitialized.kt
index 27a00977426..c88709e193c 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/SuperClassNotInitialized.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/SuperClassNotInitialized.kt
@@ -173,7 +173,7 @@ public object SuperClassNotInitialized : JetIntentionActionsFactory() {
 
             for (parameter in parametersToAdd) {
                 val newParameter = parameterList.addParameter(parameter)
-                typeRefsToShorten.add(newParameter.getTypeReference())
+                typeRefsToShorten.add(newParameter.getTypeReference()!!)
             }
 
             val delegatorCall = factory.createDelegatorToSuperCall(element.getText() + "(" + parameterNames.joinToString(",") + ")")
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/callableBuilder/CallableBuilder.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/callableBuilder/CallableBuilder.kt
index 97b71773d8a..413b270489d 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/callableBuilder/CallableBuilder.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/callableBuilder/CallableBuilder.kt
@@ -66,6 +66,8 @@ import org.jetbrains.kotlin.types.JetType
 import org.jetbrains.kotlin.types.TypeProjectionImpl
 import org.jetbrains.kotlin.types.Variance
 import org.jetbrains.kotlin.types.checker.JetTypeChecker
+import org.jetbrains.kotlin.types.typeUtil.isAnyOrNullableAny
+import org.jetbrains.kotlin.types.typeUtil.isUnit
 import org.jetbrains.kotlin.utils.addToStdlib.singletonOrEmptyList
 import java.util.*
 import kotlin.properties.Delegates
@@ -297,7 +299,7 @@ class CallableBuilder(val config: CallableBuilderConfiguration) {
                         .subtract(substitutionMap.keySet())
                 fakeFunction = createFakeFunctionDescriptor(scope, typeArgumentsForFakeFunction.size())
                 collectSubstitutionsForCallableTypeParameters(fakeFunction, typeArgumentsForFakeFunction, substitutionMap)
-                mandatoryTypeParametersAsCandidates = receiverTypeCandidate.singletonOrEmptyList() + typeArgumentsForFakeFunction.map { TypeCandidate(substitutionMap[it], scope) }
+                mandatoryTypeParametersAsCandidates = receiverTypeCandidate.singletonOrEmptyList() + typeArgumentsForFakeFunction.map { TypeCandidate(substitutionMap[it]!!, scope) }
             }
             else {
                 fakeFunction = null
@@ -314,7 +316,7 @@ class CallableBuilder(val config: CallableBuilderConfiguration) {
                 CallableKind.FUNCTION ->
                     returnTypeCandidate?.theType?.isUnit() ?: false
                 CallableKind.CLASS_WITH_PRIMARY_CONSTRUCTOR ->
-                    callableInfo.returnTypeInfo == TypeInfo.Empty || returnTypeCandidate?.theType?.isAny() ?: false
+                    callableInfo.returnTypeInfo == TypeInfo.Empty || returnTypeCandidate?.theType?.isAnyOrNullableAny() ?: false
                 CallableKind.SECONDARY_CONSTRUCTOR -> true
                 CallableKind.PROPERTY -> containingElement is JetBlockExpression
             }
@@ -724,7 +726,7 @@ class CallableBuilder(val config: CallableBuilderConfiguration) {
             }
             else {
                 oldTypeArgumentList.replace(JetPsiFactory(callElement).createTypeArguments(renderedTypeArgs.joinToString(", ", "<", ">")))
-                elementsToShorten.add(callElement.getTypeArgumentList())
+                elementsToShorten.add(callElement.getTypeArgumentList()!!)
             }
         }
 
@@ -949,7 +951,7 @@ class CallableBuilder(val config: CallableBuilderConfiguration) {
                 }
                 is JetProperty -> {
                     if (!declaration.hasInitializer() && containingElement is JetBlockExpression) {
-                        val defaultValueType = typeCandidates[callableInfo.returnTypeInfo].firstOrNull()?.theType
+                        val defaultValueType = typeCandidates[callableInfo.returnTypeInfo]!!.firstOrNull()?.theType
                                                ?: KotlinBuiltIns.getInstance().getAnyType()
                         val defaultValue = CodeInsightUtils.defaultInitializer(defaultValueType) ?: "null"
                         val initializer = declaration.setInitializer(JetPsiFactory(declaration).createExpression(defaultValue))!!
@@ -975,7 +977,7 @@ class CallableBuilder(val config: CallableBuilderConfiguration) {
             val caretModel = containingFileEditor.getCaretModel()
             caretModel.moveToOffset(jetFileToEdit.getNode().getStartOffset())
 
-            val declaration = declarationPointer.getElement()
+            val declaration = declarationPointer.getElement()!!
 
             val builder = TemplateBuilderImpl(jetFileToEdit)
             if (declaration is JetProperty) {
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/callableBuilder/CallableInfo.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/callableBuilder/CallableInfo.kt
index 5b5bedb809e..ed54d5df39d 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/callableBuilder/CallableInfo.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/callableBuilder/CallableInfo.kt
@@ -21,8 +21,8 @@ import com.intellij.util.ArrayUtil
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns
 import org.jetbrains.kotlin.idea.core.KotlinNameSuggester
 import org.jetbrains.kotlin.idea.quickfix.createFromUsage.createClass.ClassInfo
-import org.jetbrains.kotlin.idea.util.makeNotNullable
-import org.jetbrains.kotlin.idea.util.supertypes
+import org.jetbrains.kotlin.types.typeUtil.makeNotNullable
+import org.jetbrains.kotlin.types.typeUtil.supertypes
 import org.jetbrains.kotlin.psi.JetElement
 import org.jetbrains.kotlin.psi.JetExpression
 import org.jetbrains.kotlin.psi.JetTypeReference
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/callableBuilder/typeUtils.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/callableBuilder/typeUtils.kt
index 8e5f1485d09..c5481944753 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/callableBuilder/typeUtils.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/callableBuilder/typeUtils.kt
@@ -24,7 +24,7 @@ import org.jetbrains.kotlin.descriptors.ModuleDescriptor
 import org.jetbrains.kotlin.descriptors.PropertyDescriptor
 import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor
 import org.jetbrains.kotlin.idea.references.JetSimpleNameReference
-import org.jetbrains.kotlin.idea.util.makeNotNullable
+import org.jetbrains.kotlin.types.typeUtil.makeNotNullable
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.getAssignmentByLHS
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createCallable/CreateCallableFromUsageFix.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createCallable/CreateCallableFromUsageFix.kt
index 6005a4456e2..2dcbe735809 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createCallable/CreateCallableFromUsageFix.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createCallable/CreateCallableFromUsageFix.kt
@@ -120,11 +120,11 @@ public abstract class CreateCallableFromUsageFixBase(
         }
     }
 
-    override fun invoke(project: Project, editor: Editor?, file: JetFile?) {
+    override fun invoke(project: Project, editor: Editor?, file: JetFile) {
         val callableInfo = callableInfos.first()
 
         val callableBuilder =
-                CallableBuilderConfiguration(callableInfos, element as JetElement, file!!, editor!!, isExtension).createBuilder()
+                CallableBuilderConfiguration(callableInfos, element as JetElement, file, editor!!, isExtension).createBuilder()
 
         fun runBuilder(placement: CallablePlacement) {
             callableBuilder.placement = placement
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createClass/CreateClassFromUsageFix.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createClass/CreateClassFromUsageFix.kt
index fb77409dad9..2949a68f189 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createClass/CreateClassFromUsageFix.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createClass/CreateClassFromUsageFix.kt
@@ -80,7 +80,7 @@ public class CreateClassFromUsageFix(
         return true
     }
 
-    override fun invoke(project: Project, editor: Editor, file: JetFile) {
+    override fun invoke(project: Project, editor: Editor?, file: JetFile) {
         fun createFileByPackage(psiPackage: PsiPackage): JetFile? {
             val directories = psiPackage.getDirectories().filter { it.canRefactor() }
             assert (directories.isNotEmpty()) { "Package '${psiPackage.getQualifiedName()}' must be refactorable" }
@@ -103,7 +103,7 @@ public class CreateClassFromUsageFix(
                 val filePath = "${targetDirectory.getVirtualFile().getPath()}/$fileName"
                 CodeInsightUtils.showErrorHint(
                         targetDirectory.getProject(),
-                        editor,
+                        editor!!,
                         "File $filePath already exists but does not correspond to Kotlin file",
                         "Create file",
                         null
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createVariable/CreateLocalVariableActionFactory.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createVariable/CreateLocalVariableActionFactory.kt
index 6f2e08a1d8a..b714b19697c 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createVariable/CreateLocalVariableActionFactory.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createVariable/CreateLocalVariableActionFactory.kt
@@ -50,7 +50,7 @@ object CreateLocalVariableActionFactory: JetSingleIntentionActionFactory() {
         return object: CreateFromUsageFixBase(refExpr) {
             override fun getText(): String = JetBundle.message("create.local.variable.from.usage", propertyName)
 
-            override fun invoke(project: Project, editor: Editor, file: JetFile) {
+            override fun invoke(project: Project, editor: Editor?, file: JetFile) {
                 val assignment = refExpr.getAssignmentByLHS()
                 val varExpected = assignment != null
                 var originalElement = assignment ?: refExpr
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createVariable/CreateParameterActionFactory.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createVariable/CreateParameterActionFactory.kt
index 60bfe2d3729..b1ba8e9b60b 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createVariable/CreateParameterActionFactory.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createVariable/CreateParameterActionFactory.kt
@@ -115,7 +115,7 @@ object CreateParameterActionFactory: JetSingleIntentionActionFactory() {
         return CreateParameterFromUsageFix(
                 functionDescriptor,
                 context,
-                JetParameterInfo(functionDescriptor = functionDescriptor,
+                JetParameterInfo(callableDescriptor = functionDescriptor,
                                  name = refExpr.getReferencedName(),
                                  type = paramType,
                                  valOrVar = valOrVar),
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createVariable/CreateParameterByNamedArgumentActionFactory.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createVariable/CreateParameterByNamedArgumentActionFactory.kt
index 25c5fa9d1ac..30a354b6600 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createVariable/CreateParameterByNamedArgumentActionFactory.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createVariable/CreateParameterByNamedArgumentActionFactory.kt
@@ -60,7 +60,7 @@ public object CreateParameterByNamedArgumentActionFactory: JetSingleIntentionAct
         if (paramType.hasTypeParametersToAdd(functionDescriptor, context)) return null
 
         val parameterInfo = JetParameterInfo(
-                functionDescriptor = functionDescriptor,
+                callableDescriptor = functionDescriptor,
                 name = name,
                 type = paramType,
                 defaultValueForCall = argumentExpression
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createVariable/CreateParameterFromUsageFix.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createVariable/CreateParameterFromUsageFix.kt
index ceecb9c301d..9111b5bf729 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createVariable/CreateParameterFromUsageFix.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createVariable/CreateParameterFromUsageFix.kt
@@ -37,7 +37,7 @@ public class CreateParameterFromUsageFix(
         return JetBundle.message("create.parameter.from.usage", parameterInfo.getName())
     }
 
-    override fun invoke(project: Project, editor: Editor?, file: JetFile?) {
+    override fun invoke(project: Project, editor: Editor?, file: JetFile) {
         val config = object : JetChangeSignatureConfiguration {
             override fun configure(originalDescriptor: JetMethodDescriptor, bindingContext: BindingContext): JetMethodDescriptor {
                 return originalDescriptor.modify { it.addParameter(parameterInfo) }
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/CallableRefactoring.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/CallableRefactoring.kt
index 8ec8a4bc1eb..a4cc78d7c8e 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/CallableRefactoring.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/CallableRefactoring.kt
@@ -50,7 +50,7 @@ public abstract class CallableRefactoring<T: CallableDescriptor>(
         val project: Project,
         val callableDescriptor: T,
         val bindingContext: BindingContext,
-        val commandName: String?) {
+        val commandName: String) {
     private val LOG = Logger.getInstance(javaClass<CallableRefactoring<*>>())
 
     private val kind = (callableDescriptor as? CallableMemberDescriptor)?.getKind() ?: CallableMemberDescriptor.Kind.DECLARATION
@@ -150,7 +150,7 @@ public abstract class CallableRefactoring<T: CallableDescriptor>(
             return true
         }
 
-        if (closestModifiableDescriptors.size() == 1 && deepestSuperDeclarations == closestModifiableDescriptors) {
+        if (closestModifiableDescriptors.size() == 1 && deepestSuperDeclarations.subtract(closestModifiableDescriptors).isEmpty()) {
             performRefactoring(closestModifiableDescriptors)
             return true
         }
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/JetChangeInfo.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/JetChangeInfo.kt
index 88ce79e09d2..9a15bb58bd2 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/JetChangeInfo.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/JetChangeInfo.kt
@@ -19,28 +19,36 @@ package org.jetbrains.kotlin.idea.refactoring.changeSignature
 import com.intellij.lang.Language
 import com.intellij.lang.java.JavaLanguage
 import com.intellij.psi.*
+import com.intellij.psi.search.searches.OverridingMethodsSearch
 import com.intellij.refactoring.changeSignature.*
+import com.intellij.refactoring.util.CanonicalTypes
 import com.intellij.usageView.UsageInfo
 import com.intellij.util.VisibilityUtil
-import org.jetbrains.kotlin.asJava.*
-import org.jetbrains.kotlin.descriptors.FunctionDescriptor
+import org.jetbrains.kotlin.asJava.getRepresentativeLightMethod
+import org.jetbrains.kotlin.asJava.toLightMethods
+import org.jetbrains.kotlin.asJava.unwrapped
+import org.jetbrains.kotlin.builtins.KotlinBuiltIns
+import org.jetbrains.kotlin.descriptors.CallableDescriptor
 import org.jetbrains.kotlin.descriptors.Visibilities
 import org.jetbrains.kotlin.descriptors.Visibility
+import org.jetbrains.kotlin.idea.JetLanguage
+import org.jetbrains.kotlin.idea.caches.resolve.getJavaMethodDescriptor
+import org.jetbrains.kotlin.idea.core.refactoring.j2k
+import org.jetbrains.kotlin.idea.project.ProjectStructureUtil
+import org.jetbrains.kotlin.idea.refactoring.changeSignature.JetMethodDescriptor.Kind
+import org.jetbrains.kotlin.idea.refactoring.changeSignature.usages.JetCallableDefinitionUsage
+import org.jetbrains.kotlin.idea.refactoring.changeSignature.usages.KotlinCallerUsage
+import org.jetbrains.kotlin.idea.util.IdeDescriptorRenderers
+import org.jetbrains.kotlin.lexer.JetTokens
+import org.jetbrains.kotlin.load.java.JvmAbi
+import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils
 import org.jetbrains.kotlin.types.JetType
-import org.jetbrains.kotlin.builtins.KotlinBuiltIns
-import org.jetbrains.kotlin.lexer.JetTokens
-import org.jetbrains.kotlin.idea.JetLanguage
-import org.jetbrains.kotlin.idea.caches.resolve.*
-import org.jetbrains.kotlin.idea.core.refactoring.j2k
-import org.jetbrains.kotlin.idea.refactoring.changeSignature.usages.JetFunctionDefinitionUsage
-import org.jetbrains.kotlin.idea.util.IdeDescriptorRenderers
-import java.util.HashMap
-import kotlin.properties.Delegates
 import org.jetbrains.kotlin.utils.addToStdlib.singletonOrEmptyList
-import org.jetbrains.kotlin.idea.project.*
-import org.jetbrains.kotlin.psi.*
-import org.jetbrains.kotlin.idea.refactoring.changeSignature.JetMethodDescriptor.Kind
+import java.util.ArrayList
+import java.util.HashMap
+import java.util.LinkedHashSet
+import kotlin.properties.Delegates
 
 public class JetChangeInfo(
         val methodDescriptor: JetMethodDescriptor,
@@ -50,7 +58,8 @@ public class JetChangeInfo(
         var newVisibility: Visibility = methodDescriptor.getVisibility(),
         parameterInfos: List<JetParameterInfo> = methodDescriptor.getParameters(),
         receiver: JetParameterInfo? = methodDescriptor.receiver,
-        val context: PsiElement
+        val context: PsiElement,
+        primaryPropagationTargets: Collection<PsiElement> = emptyList()
 ): ChangeInfo {
     var receiverParameterInfo: JetParameterInfo? = receiver
         set(value: JetParameterInfo?) {
@@ -61,7 +70,7 @@ public class JetChangeInfo(
         }
 
     private val newParameters = parameterInfos.toArrayList()
-    private val originalPsiMethod: PsiMethod? = getCurrentPsiMethod()
+    private val originalPsiMethods: List<PsiMethod> = getMethod().toLightMethods()
 
     private val oldNameToParameterIndex: Map<String, Int> by Delegates.lazy {
         val map = HashMap<String, Int>()
@@ -80,13 +89,7 @@ public class JetChangeInfo(
     }
 
     private var isPrimaryMethodUpdated: Boolean = false
-    private var javaChangeInfo: JavaChangeInfo? = null
-
-    private fun getCurrentPsiMethod(): PsiMethod? {
-        val psiMethods = getMethod().toLightMethods()
-        assert(psiMethods.size() <= 1) { "Multiple light methods: " + getMethod().getText() }
-        return psiMethods.firstOrNull()
-    }
+    private var javaChangeInfos: List<JavaChangeInfo>? = null
 
     public fun getOldParameterIndex(oldParameterName: String): Int? = oldNameToParameterIndex[oldParameterName]
 
@@ -103,6 +106,7 @@ public class JetChangeInfo(
     fun getNonReceiverParametersCount(): Int = newParameters.size() - (if (receiverParameterInfo != null) 1 else 0)
 
     fun getNonReceiverParameters(): List<JetParameterInfo> {
+        methodDescriptor.baseDeclaration.let { if (it is JetProperty || it is JetParameter) return emptyList() }
         return receiverParameterInfo?.let { receiver -> newParameters.filter { it != receiver } } ?: newParameters
     }
 
@@ -146,7 +150,43 @@ public class JetChangeInfo(
 
     override fun getLanguage(): Language = JetLanguage.INSTANCE
 
-    public fun getNewSignature(inheritedFunction: JetFunctionDefinitionUsage<PsiElement>): String {
+    public var propagationTargetUsageInfos: List<UsageInfo> = ArrayList()
+        private set
+
+    public var primaryPropagationTargets: Collection<PsiElement> = emptyList()
+        set(value: Collection<PsiElement>) {
+            $primaryPropagationTargets = value
+
+            val result = LinkedHashSet<UsageInfo>()
+
+            fun add(element: PsiElement) {
+                element.unwrapped?.let {
+                    val usageInfo = when (it) {
+                        is JetNamedFunction, is JetConstructor<*>, is JetClassOrObject ->
+                            KotlinCallerUsage(it as JetNamedDeclaration)
+                        is PsiMethod ->
+                            CallerUsageInfo(it, true, true)
+                        else ->
+                            return
+                    }
+
+                    result.add(usageInfo)
+                }
+            }
+
+            for (caller in value) {
+                add(caller)
+                OverridingMethodsSearch.search(caller.getRepresentativeLightMethod() ?: continue).forEach { add(it) }
+            }
+
+            propagationTargetUsageInfos = result.toList()
+        }
+
+    init {
+        this.primaryPropagationTargets = primaryPropagationTargets
+    }
+
+    public fun getNewSignature(inheritedCallable: JetCallableDefinitionUsage<PsiElement>): String {
         val buffer = StringBuilder()
 
         val defaultVisibility = if (kind.isConstructor) Visibilities.PUBLIC else Visibilities.INTERNAL
@@ -174,7 +214,7 @@ public class JetChangeInfo(
             buffer.append(name)
         }
 
-        buffer.append(getNewParametersSignature(inheritedFunction))
+        buffer.append(getNewParametersSignature(inheritedCallable))
 
         if (newReturnType != null && !KotlinBuiltIns.isUnit(newReturnType) && kind == Kind.FUNCTION)
             buffer.append(": ").append(newReturnTypeText)
@@ -182,63 +222,84 @@ public class JetChangeInfo(
         return buffer.toString()
     }
 
-    public fun isRefactoringTarget(inheritedFunctionDescriptor: FunctionDescriptor?): Boolean {
-        return inheritedFunctionDescriptor != null
-               && getMethod() == DescriptorToSourceUtils.descriptorToDeclaration(inheritedFunctionDescriptor)
+    public fun isRefactoringTarget(inheritedCallableDescriptor: CallableDescriptor?): Boolean {
+        return inheritedCallableDescriptor != null
+               && getMethod() == DescriptorToSourceUtils.descriptorToDeclaration(inheritedCallableDescriptor)
     }
 
-    public fun getNewParametersSignature(inheritedFunction: JetFunctionDefinitionUsage<PsiElement>): String {
+    public fun getNewParametersSignature(inheritedCallable: JetCallableDefinitionUsage<PsiElement>): String {
         val signatureParameters = getNonReceiverParameters()
 
-        val isLambda = inheritedFunction.getDeclaration() is JetFunctionLiteral
-        if (isLambda && signatureParameters.size() == 1 && !signatureParameters.get(0).requiresExplicitType(inheritedFunction)) {
-            return signatureParameters.get(0).getDeclarationSignature(0, inheritedFunction)
+        val isLambda = inheritedCallable.getDeclaration() is JetFunctionLiteral
+        if (isLambda && signatureParameters.size() == 1 && !signatureParameters.get(0).requiresExplicitType(inheritedCallable)) {
+            return signatureParameters.get(0).getDeclarationSignature(0, inheritedCallable)
         }
 
         return signatureParameters.indices
-                .map { i -> signatureParameters[i].getDeclarationSignature(i, inheritedFunction) }
+                .map { i -> signatureParameters[i].getDeclarationSignature(i, inheritedCallable) }
                 .joinToString(prefix = "(", separator = ", ", postfix = ")")
     }
 
-    public fun renderReceiverType(inheritedFunction: JetFunctionDefinitionUsage<PsiElement>): String? {
+    public fun renderReceiverType(inheritedCallable: JetCallableDefinitionUsage<PsiElement>): String? {
         val receiverTypeText = receiverParameterInfo?.currentTypeText ?: return null
-        val typeSubstitutor = inheritedFunction.getOrCreateTypeSubstitutor() ?: return receiverTypeText
-        val currentBaseFunction = inheritedFunction.getBaseFunction().getCurrentFunctionDescriptor() ?: return receiverTypeText
+        val typeSubstitutor = inheritedCallable.getOrCreateTypeSubstitutor() ?: return receiverTypeText
+        val currentBaseFunction = inheritedCallable.getBaseFunction().getCurrentCallableDescriptor() ?: return receiverTypeText
         return currentBaseFunction.getExtensionReceiverParameter()!!.getType().renderTypeWithSubstitution(typeSubstitutor, receiverTypeText, false)
     }
 
-    public fun renderReturnType(inheritedFunction: JetFunctionDefinitionUsage<PsiElement>): String {
-        val typeSubstitutor = inheritedFunction.getOrCreateTypeSubstitutor() ?: return newReturnTypeText
-        val currentBaseFunction = inheritedFunction.getBaseFunction().getCurrentFunctionDescriptor() ?: return newReturnTypeText
-        return currentBaseFunction.getReturnType().renderTypeWithSubstitution(typeSubstitutor, newReturnTypeText, false)
+    public fun renderReturnType(inheritedCallable: JetCallableDefinitionUsage<PsiElement>): String {
+        val typeSubstitutor = inheritedCallable.getOrCreateTypeSubstitutor() ?: return newReturnTypeText
+        val currentBaseFunction = inheritedCallable.getBaseFunction().getCurrentCallableDescriptor() ?: return newReturnTypeText
+        return currentBaseFunction.getReturnType()!!.renderTypeWithSubstitution(typeSubstitutor, newReturnTypeText, false)
     }
 
     public fun primaryMethodUpdated() {
         isPrimaryMethodUpdated = true
-        javaChangeInfo = null
+        javaChangeInfos = null
     }
 
-    public fun getOrCreateJavaChangeInfo(): JavaChangeInfo? {
-        if (ProjectStructureUtil.isJsKotlinModule(getMethod().getContainingFile() as JetFile)) return null
+    public fun getOrCreateJavaChangeInfos(): List<JavaChangeInfo>? {
+        /*
+         * When primaryMethodUpdated is false, changes to the primary Kotlin declaration are already confirmed, but not yet applied.
+         * It means that originalPsiMethod has already expired, but new one can't be created until Kotlin declaration is updated
+         * (signified by primaryMethodUpdated being true). It means we can't know actual PsiType, visibility, etc.
+         * to use in JavaChangeInfo. However they are not actually used at this point since only parameter count and order matters here
+         * So we resort to this hack and pass around "default" type (void) and visibility (package-local)
+         */
 
-        if (javaChangeInfo == null) {
-            val currentPsiMethod = getCurrentPsiMethod()
-            if (originalPsiMethod == null || currentPsiMethod == null) return null
-
-            /*
-             * When primaryMethodUpdated is false, changes to the primary Kotlin declaration are already confirmed, but not yet applied.
-             * It means that originalPsiMethod has already expired, but new one can't be created until Kotlin declaration is updated
-             * (signified by primaryMethodUpdated being true). It means we can't know actual PsiType, visibility, etc.
-             * to use in JavaChangeInfo. However they are not actually used at this point since only parameter count and order matters here
-             * So we resort to this hack and pass around "default" type (void) and visibility (package-local)
-             */
-            val javaVisibility = if (isPrimaryMethodUpdated)
+        fun createJavaChangeInfo(originalPsiMethod: PsiMethod,
+                                 currentPsiMethod: PsiMethod,
+                                 newName: String,
+                                 newReturnType: PsiType?,
+                                 newParameters: Array<ParameterInfoImpl>
+        ): JavaChangeInfo? {
+            val newVisibility = if (isPrimaryMethodUpdated)
                 VisibilityUtil.getVisibilityModifier(currentPsiMethod.getModifierList())
             else
                 PsiModifier.PACKAGE_LOCAL
+            val propagationTargets = primaryPropagationTargets.asSequence()
+                    .map { it.getRepresentativeLightMethod() }
+                    .filterNotNull()
+                    .toSet()
+            val javaChangeInfo = ChangeSignatureProcessor(
+                    getMethod().getProject(),
+                    originalPsiMethod,
+                    false,
+                    newVisibility,
+                    newName,
+                    CanonicalTypes.createTypeWrapper(newReturnType ?: PsiType.VOID),
+                    newParameters,
+                    arrayOf<ThrownExceptionInfo>(),
+                    propagationTargets,
+                    emptySet()
+            ).getChangeInfo()
+            javaChangeInfo.updateMethod(currentPsiMethod)
 
-            val newParameterList = receiverParameterInfo.singletonOrEmptyList() + getNonReceiverParameters()
-            val newJavaParameters = newParameterList.withIndex().map { pair ->
+            return javaChangeInfo
+        }
+
+        fun getJavaParameterInfos(currentPsiMethod: PsiMethod, newParameterList: List<JetParameterInfo>): MutableList<ParameterInfoImpl> {
+            return newParameterList.withIndex().mapTo(ArrayList()) { pair ->
                 val (i, info) = pair
 
                 val type = if (isPrimaryMethodUpdated)
@@ -255,25 +316,66 @@ public class JetChangeInfo(
                 }
 
                 ParameterInfoImpl(javaOldIndex, info.getName(), type, info.defaultValueForCall?.getText() ?: "")
-            }.toTypedArray()
-
-            val returnType = if (isPrimaryMethodUpdated) currentPsiMethod.getReturnType() else PsiType.VOID
-
-            javaChangeInfo = ChangeSignatureProcessor(getMethod().getProject(),
-                                                      originalPsiMethod,
-                                                      false,
-                                                      javaVisibility,
-                                                      getNewName(),
-                                                      returnType,
-                                                      newJavaParameters).getChangeInfo()
-            javaChangeInfo!!.updateMethod(currentPsiMethod)
+            }
         }
 
-        return javaChangeInfo
+        fun createJavaChangeInfoForFunctionOrGetter(
+                originalPsiMethod: PsiMethod,
+                currentPsiMethod: PsiMethod,
+                isGetter: Boolean
+        ): JavaChangeInfo? {
+            val newParameterList = receiverParameterInfo.singletonOrEmptyList() + getNonReceiverParameters()
+            val newJavaParameters = getJavaParameterInfos(currentPsiMethod, newParameterList).toTypedArray()
+            val newName = if (isGetter) JvmAbi.getterName(getNewName()) else getNewName()
+            return createJavaChangeInfo(originalPsiMethod, currentPsiMethod, newName, currentPsiMethod.getReturnType(), newJavaParameters)
+        }
+
+        fun createJavaChangeInfoForSetter(originalPsiMethod: PsiMethod, currentPsiMethod: PsiMethod): JavaChangeInfo? {
+            val newJavaParameters = getJavaParameterInfos(currentPsiMethod, receiverParameterInfo.singletonOrEmptyList())
+            val oldIndex = if (methodDescriptor.receiver != null) 1 else 0
+            if (isPrimaryMethodUpdated) {
+                val newIndex = if (receiverParameterInfo != null) 1 else 0
+                val setterParameter = currentPsiMethod.getParameterList().getParameters()[newIndex]
+                newJavaParameters.add(ParameterInfoImpl(oldIndex, setterParameter.getName(), setterParameter.getType()))
+            }
+            else {
+                newJavaParameters.add(ParameterInfoImpl(oldIndex, "receiver", PsiType.VOID))
+            }
+
+            val newName = JvmAbi.setterName(getNewName())
+            return createJavaChangeInfo(originalPsiMethod, currentPsiMethod, newName, PsiType.VOID, newJavaParameters.toTypedArray())
+        }
+
+        if (ProjectStructureUtil.isJsKotlinModule(getMethod().getContainingFile() as JetFile)) return null
+
+        if (javaChangeInfos == null) {
+            val method = getMethod()
+            javaChangeInfos = (originalPsiMethods zip method.toLightMethods()).map {
+                val (originalPsiMethod, currentPsiMethod) = it
+
+                when (method) {
+                    is JetFunction, is JetClassOrObject ->
+                        createJavaChangeInfoForFunctionOrGetter(originalPsiMethod, currentPsiMethod, false)
+                    is JetProperty, is JetParameter -> {
+                        val accessorName = originalPsiMethod.getName()
+                        when {
+                            accessorName.startsWith(JvmAbi.GETTER_PREFIX) ->
+                                createJavaChangeInfoForFunctionOrGetter(originalPsiMethod, currentPsiMethod, true)
+                            accessorName.startsWith(JvmAbi.SETTER_PREFIX) ->
+                                createJavaChangeInfoForSetter(originalPsiMethod, currentPsiMethod)
+                            else -> null
+                        }
+                    }
+                    else -> null
+                }
+            }.filterNotNull()
+        }
+
+        return javaChangeInfos
     }
 }
 
-public val JetChangeInfo.originalBaseFunctionDescriptor: FunctionDescriptor
+public val JetChangeInfo.originalBaseFunctionDescriptor: CallableDescriptor
     get() = methodDescriptor.baseDescriptor
 
 public val JetChangeInfo.kind: Kind get() = methodDescriptor.kind
@@ -281,12 +383,12 @@ public val JetChangeInfo.kind: Kind get() = methodDescriptor.kind
 public val JetChangeInfo.oldName: String?
     get() = (methodDescriptor.getMethod() as? JetFunction)?.getName()
 
-public val JetChangeInfo.affectedFunctions: Collection<UsageInfo> get() = methodDescriptor.affectedFunctions
+public fun JetChangeInfo.getAffectedCallables(): Collection<UsageInfo> = methodDescriptor.affectedCallables + propagationTargetUsageInfos
 
 public fun ChangeInfo.toJetChangeInfo(originalChangeSignatureDescriptor: JetMethodDescriptor): JetChangeInfo {
     val method = getMethod() as PsiMethod
 
-    val functionDescriptor = method.getJavaMethodDescriptor()
+    val functionDescriptor = method.getJavaMethodDescriptor()!!
     val parameterDescriptors = functionDescriptor.getValueParameters()
 
     //noinspection ConstantConditions
@@ -298,19 +400,23 @@ public fun ChangeInfo.toJetChangeInfo(originalChangeSignatureDescriptor: JetMeth
         val currentType = parameterDescriptors[i].getType()
 
         val defaultValueText = info.getDefaultValue()
-        val defaultValueExpr = if (getLanguage().`is`(JavaLanguage.INSTANCE) && !defaultValueText.isNullOrEmpty()) {
-            PsiElementFactory.SERVICE.getInstance(method.getProject())
-                    .createExpressionFromText(defaultValueText!!, null)
-                    .j2k()
-        }
-        else null
+        val defaultValueExpr =
+                when {
+                    info is KotlinAwareJavaParameterInfoImpl -> info.kotlinDefaultValue
+                    getLanguage().`is`(JavaLanguage.INSTANCE) && !defaultValueText.isNullOrEmpty() -> {
+                        PsiElementFactory.SERVICE.getInstance(method.getProject())
+                                .createExpressionFromText(defaultValueText!!, null)
+                                .j2k()
+                    }
+                    else -> null
+                }
 
-        with(JetParameterInfo(functionDescriptor = functionDescriptor,
+        with(JetParameterInfo(callableDescriptor = functionDescriptor,
                               originalIndex = oldIndex,
                               name = info.getName(),
                               type = if (oldIndex >= 0) originalParameterDescriptors[oldIndex].getType() else currentType,
                               defaultValueForCall = defaultValueExpr)) {
-            currentTypeText = IdeDescriptorRenderers.SOURCE_CODE.renderType(currentType)
+            currentTypeText = IdeDescriptorRenderers.SOURCE_CODE_FOR_TYPE_ARGUMENTS.renderType(currentType)
             this
         }
     }
@@ -326,4 +432,4 @@ public fun ChangeInfo.toJetChangeInfo(originalChangeSignatureDescriptor: JetMeth
                           newParameters,
                           null,
                           method)
-}
\ No newline at end of file
+}
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/JetChangeSignature.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/JetChangeSignature.kt
index 69b1082d332..cc87043490a 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/JetChangeSignature.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/JetChangeSignature.kt
@@ -16,31 +16,43 @@
 
 package org.jetbrains.kotlin.idea.refactoring.changeSignature
 
+import com.intellij.lang.java.JavaLanguage
 import com.intellij.openapi.application.ApplicationManager
 import com.intellij.openapi.diagnostic.Logger
 import com.intellij.openapi.project.Project
+import com.intellij.openapi.ui.Messages
 import com.intellij.psi.PsiElement
-import com.intellij.refactoring.changeSignature.ChangeSignatureHandler
+import com.intellij.psi.PsiElementFactory
+import com.intellij.psi.PsiMethod
+import com.intellij.psi.PsiType
+import com.intellij.refactoring.BaseRefactoringProcessor
+import com.intellij.refactoring.changeSignature.*
+import com.intellij.refactoring.util.CanonicalTypes
+import com.intellij.testFramework.LightVirtualFile
+import com.intellij.util.VisibilityUtil
 import org.jetbrains.annotations.TestOnly
+import org.jetbrains.kotlin.asJava.getRepresentativeLightMethod
 import org.jetbrains.kotlin.descriptors.CallableDescriptor
+import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor
 import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.descriptors.ClassKind
-import org.jetbrains.kotlin.descriptors.FunctionDescriptor
+import org.jetbrains.kotlin.idea.JetFileType
 import org.jetbrains.kotlin.idea.codeInsight.DescriptorToSourceUtilsIde
+import org.jetbrains.kotlin.idea.core.refactoring.createJavaMethod
+import org.jetbrains.kotlin.idea.core.refactoring.toPsiFile
 import org.jetbrains.kotlin.idea.refactoring.CallableRefactoring
+import org.jetbrains.kotlin.idea.refactoring.changeSignature.ui.JetChangeSignatureDialog
+import org.jetbrains.kotlin.psi.*
+import org.jetbrains.kotlin.psi.psiUtil.getElementTextWithContext
 import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.OverrideResolver
 
-public trait JetChangeSignatureConfiguration {
-    fun configure(originalDescriptor: JetMethodDescriptor, bindingContext: BindingContext): JetMethodDescriptor
+public interface JetChangeSignatureConfiguration {
+    fun configure(originalDescriptor: JetMethodDescriptor, bindingContext: BindingContext): JetMethodDescriptor = originalDescriptor
+    fun performSilently(affectedFunctions: Collection<PsiElement>): Boolean = false
+    fun forcePerformForSelectedFunctionOnly(): Boolean = false
 
-    fun performSilently(affectedFunctions: Collection<PsiElement>): Boolean {
-        return false
-    }
-
-    fun forcePerformForSelectedFunctionOnly(): Boolean {
-        return false
-    }
+    object Empty: JetChangeSignatureConfiguration
 }
 
 fun JetMethodDescriptor.modify(action: (JetMutableMethodDescriptor) -> Unit): JetMethodDescriptor {
@@ -50,55 +62,137 @@ fun JetMethodDescriptor.modify(action: (JetMutableMethodDescriptor) -> Unit): Je
 }
 
 public fun runChangeSignature(project: Project,
-                              functionDescriptor: FunctionDescriptor,
+                              callableDescriptor: CallableDescriptor,
                               configuration: JetChangeSignatureConfiguration,
                               bindingContext: BindingContext,
                               defaultValueContext: PsiElement,
                               commandName: String? = null): Boolean {
-    return JetChangeSignature(project, functionDescriptor, configuration, bindingContext, defaultValueContext, commandName).run()
+    return JetChangeSignature(project, callableDescriptor, configuration, bindingContext, defaultValueContext, commandName).run()
 }
 
 public class JetChangeSignature(project: Project,
-                                functionDescriptor: FunctionDescriptor,
+                                callableDescriptor: CallableDescriptor,
                                 val configuration: JetChangeSignatureConfiguration,
                                 bindingContext: BindingContext,
                                 val defaultValueContext: PsiElement,
-                                commandName: String?): CallableRefactoring<FunctionDescriptor>(project, functionDescriptor, bindingContext, commandName) {
+                                commandName: String?): CallableRefactoring<CallableDescriptor>(project,
+                                                                                               callableDescriptor,
+                                                                                               bindingContext,
+                                                                                               commandName ?: ChangeSignatureHandler.REFACTORING_NAME) {
 
     private val LOG = Logger.getInstance(javaClass<JetChangeSignature>())
 
     override fun forcePerformForSelectedFunctionOnly() = configuration.forcePerformForSelectedFunctionOnly()
 
-    override fun performRefactoring(descriptorsForChange: Collection<CallableDescriptor>) {
-        assert (descriptorsForChange.all { it is FunctionDescriptor }) {
-            "Function descriptors expected: " + descriptorsForChange.joinToString(separator = "\n")
+    private fun runSilentRefactoring(descriptor: JetMethodDescriptor) {
+        val baseDeclaration = descriptor.baseDeclaration
+        val processor = when (baseDeclaration) {
+            is JetFunction, is JetClass -> {
+                JetChangeSignatureDialog.createRefactoringProcessorForSilentChangeSignature(project, commandName, descriptor, defaultValueContext)
+            }
+            is JetProperty, is JetParameter -> {
+                JetChangePropertySignatureDialog.createProcessorForSilentRefactoring(project, commandName, descriptor)
+            }
+            is PsiMethod -> {
+                if (baseDeclaration.getLanguage() != JavaLanguage.INSTANCE) {
+                    Messages.showErrorDialog("Can't change signature of ${baseDeclaration.getLanguage().getDisplayName()} method", commandName)
+                    return
+                }
+
+                ChangeSignatureProcessor(project, getPreviewInfoForJavaMethod(descriptor).second)
+            }
+            else -> throw AssertionError("Unexpected declaration: ${baseDeclaration.getElementTextWithContext()}")
+        }
+        processor.run()
+    }
+
+    private fun runInteractiveRefactoring(descriptor: JetMethodDescriptor) {
+        val baseDeclaration = descriptor.baseDeclaration
+        val dialog = when (baseDeclaration) {
+            is JetFunction, is JetClass -> JetChangeSignatureDialog(project, descriptor, defaultValueContext, commandName)
+            is JetProperty, is JetParameter -> JetChangePropertySignatureDialog(project, descriptor, commandName)
+            is PsiMethod -> {
+                // No changes are made from Kotlin side: just run foreign refactoring
+                if (descriptor is JetChangeSignatureData) {
+                    ChangeSignatureUtil.invokeChangeSignatureOn(baseDeclaration, project)
+                    return
+                }
+
+                if (baseDeclaration.getLanguage() != JavaLanguage.INSTANCE) {
+                    Messages.showErrorDialog("Can't change signature of ${baseDeclaration.getLanguage().getDisplayName()} method", commandName)
+                    return
+                }
+
+                val (preview, javaChangeInfo) = getPreviewInfoForJavaMethod(descriptor)
+                object: JavaChangeSignatureDialog(project, JavaMethodDescriptor(preview), false, null) {
+                    override fun createRefactoringProcessor(): BaseRefactoringProcessor? {
+                        val processor = super.createRefactoringProcessor()
+                        (processor as? ChangeSignatureProcessor)?.getChangeInfo()?.updateMethod(javaChangeInfo.getMethod())
+                        return processor
+                    }
+                }
+            }
+            else -> throw AssertionError("Unexpected declaration: ${baseDeclaration.getElementTextWithContext()}")
         }
 
-        @suppress("UNCHECKED_CAST")
-        val adjustedDescriptor = adjustDescriptor(descriptorsForChange as Collection<FunctionDescriptor>)
-        if (adjustedDescriptor == null) return
+        dialog.show()
+    }
 
-        val affectedFunctions = adjustedDescriptor.affectedFunctions.map { it.getElement() }.filterNotNull()
+    private fun getPreviewInfoForJavaMethod(descriptor: JetMethodDescriptor): Pair<PsiMethod, JavaChangeInfo> {
+        val originalMethod = descriptor.baseDeclaration as PsiMethod
+        val contextFile = defaultValueContext.getContainingFile() as JetFile
 
+        // Generate new Java method signature from the Kotlin point of view
+        val ktChangeInfo = JetChangeInfo(methodDescriptor = descriptor, context = defaultValueContext)
+        val ktSignature = ktChangeInfo.getNewSignature(descriptor.originalPrimaryCallable)
+        val dummyFileText = with(StringBuilder()) {
+            contextFile.getPackageDirective()?.let { append(it.getText()).append("\n") }
+            append("class Dummy {\n").append(ktSignature).append("{}\n}")
+            toString()
+        }
+        val dummyFile = LightVirtualFile("dummy.kt", JetFileType.INSTANCE, dummyFileText).toPsiFile(project) as JetFile
+        val dummyDeclaration = (dummyFile.getDeclarations().first() as JetClass).getBody()!!.getDeclarations().first()
+
+        // Convert to PsiMethod which can be used in Change Signature dialog
+        val containingClass = PsiElementFactory.SERVICE.getInstance(project).createClass("Dummy")
+        val preview = createJavaMethod(dummyDeclaration.getRepresentativeLightMethod()!!, containingClass)
+
+        // Create JavaChangeInfo based on new signature
+        // TODO: Support visibility change
+        val visibility = VisibilityUtil.getVisibilityModifier(originalMethod.getModifierList())
+        val returnType = CanonicalTypes.createTypeWrapper(preview.getReturnType() ?: PsiType.VOID)
+        val params = (preview.getParameterList().getParameters() zip ktChangeInfo.getNewParameters()).map {
+            val (param, paramInfo) = it
+            // Keep original default value for proper update of Kotlin usages
+            KotlinAwareJavaParameterInfoImpl(paramInfo.getOldIndex(), param.getName()!!, param.getType(), paramInfo.defaultValueForCall)
+        }.toTypedArray()
+
+        return preview to JavaChangeInfoImpl(visibility,
+                                             originalMethod,
+                                             preview.getName(),
+                                             returnType,
+                                             params,
+                                             arrayOf<ThrownExceptionInfo>(),
+                                             false,
+                                             emptySet<PsiMethod>(),
+                                             emptySet<PsiMethod>())
+    }
+
+    override fun performRefactoring(descriptorsForChange: Collection<CallableDescriptor>) {
+        val adjustedDescriptor = adjustDescriptor(descriptorsForChange) ?: return
+
+        val affectedFunctions = adjustedDescriptor.affectedCallables.map { it.getElement() }.filterNotNull()
         if (affectedFunctions.any { !checkModifiable(it) }) return
 
-        if (configuration.performSilently(affectedFunctions)
-            || ApplicationManager.getApplication()!!.isUnitTestMode()) {
-            JetChangeSignatureDialog.createRefactoringProcessorForSilentChangeSignature(
-                    project,
-                    commandName ?: ChangeSignatureHandler.REFACTORING_NAME,
-                    adjustedDescriptor,
-                    defaultValueContext
-            ).run()
+        if (configuration.performSilently(affectedFunctions) || ApplicationManager.getApplication()!!.isUnitTestMode()) {
+            runSilentRefactoring(adjustedDescriptor)
         }
         else {
-            val dialog = JetChangeSignatureDialog(project, adjustedDescriptor, defaultValueContext, commandName)
-
-            dialog.show()
+            runInteractiveRefactoring(adjustedDescriptor)
         }
     }
 
-    fun adjustDescriptor(descriptorsForSignatureChange: Collection<FunctionDescriptor>): JetMethodDescriptor? {
+    fun adjustDescriptor(descriptorsForSignatureChange: Collection<CallableDescriptor>): JetMethodDescriptor? {
         val baseDescriptor = preferContainedInClass(descriptorsForSignatureChange)
         val functionDeclaration = DescriptorToSourceUtilsIde.getAnyDeclaration(project, baseDescriptor)
         if (functionDeclaration == null) {
@@ -114,7 +208,7 @@ public class JetChangeSignature(project: Project,
         return configuration.configure(originalDescriptor, bindingContext)
     }
 
-    private fun preferContainedInClass(descriptorsForSignatureChange: Collection<FunctionDescriptor>): FunctionDescriptor {
+    private fun preferContainedInClass(descriptorsForSignatureChange: Collection<CallableDescriptor>): CallableDescriptor {
         for (descriptor in descriptorsForSignatureChange) {
             val containingDeclaration = descriptor.getContainingDeclaration()
             if (containingDeclaration is ClassDescriptor && containingDeclaration.getKind() != ClassKind.INTERFACE) {
@@ -127,15 +221,22 @@ public class JetChangeSignature(project: Project,
 }
 
 TestOnly public fun createChangeInfo(project: Project,
-                                             functionDescriptor: FunctionDescriptor,
+                                             callableDescriptor: CallableDescriptor,
                                              configuration: JetChangeSignatureConfiguration,
                                              bindingContext: BindingContext,
                                              defaultValueContext: PsiElement): JetChangeInfo? {
-    val jetChangeSignature = JetChangeSignature(project, functionDescriptor, configuration, bindingContext, defaultValueContext, null)
-    val declarations = OverrideResolver.getDeepestSuperDeclarations(functionDescriptor)
+    val jetChangeSignature = JetChangeSignature(project, callableDescriptor, configuration, bindingContext, defaultValueContext, null)
+    val declarations = if (callableDescriptor is CallableMemberDescriptor) {
+        OverrideResolver.getDeepestSuperDeclarations(callableDescriptor)
+    } else listOf(callableDescriptor)
 
     val adjustedDescriptor = jetChangeSignature.adjustDescriptor(declarations) ?: return null
 
-    val processor = JetChangeSignatureDialog.createRefactoringProcessorForSilentChangeSignature(project,  ChangeSignatureHandler.REFACTORING_NAME, adjustedDescriptor, defaultValueContext) as JetChangeSignatureProcessor
+    val processor = JetChangeSignatureDialog.createRefactoringProcessorForSilentChangeSignature(
+            project,
+            ChangeSignatureHandler.REFACTORING_NAME,
+            adjustedDescriptor,
+            defaultValueContext
+    ) as JetChangeSignatureProcessor
     return processor.getChangeInfo()
 }
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/JetChangeSignatureData.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/JetChangeSignatureData.kt
index 0788fb1eff4..0f0b43c0309 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/JetChangeSignatureData.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/JetChangeSignatureData.kt
@@ -23,6 +23,8 @@ import com.intellij.refactoring.changeSignature.OverriderUsageInfo
 import com.intellij.usageView.UsageInfo
 import org.jetbrains.kotlin.asJava.KotlinLightMethod
 import org.jetbrains.kotlin.asJava.LightClassUtil
+import org.jetbrains.kotlin.asJava.namedUnwrappedElement
+import org.jetbrains.kotlin.asJava.toLightMethods
 import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.descriptors.impl.AnonymousFunctionDescriptor
 import org.jetbrains.kotlin.idea.caches.resolve.analyze
@@ -30,10 +32,14 @@ import org.jetbrains.kotlin.idea.caches.resolve.resolveToDescriptor
 import org.jetbrains.kotlin.idea.codeInsight.DescriptorToSourceUtilsIde
 import org.jetbrains.kotlin.idea.core.CollectingNameValidator
 import org.jetbrains.kotlin.idea.core.KotlinNameSuggester
-import org.jetbrains.kotlin.idea.refactoring.changeSignature.usages.JetFunctionDefinitionUsage
+import org.jetbrains.kotlin.idea.refactoring.changeSignature.usages.JetCallableDefinitionUsage
+import org.jetbrains.kotlin.idea.search.declarationsSearch.HierarchySearchRequest
+import org.jetbrains.kotlin.idea.search.declarationsSearch.searchOverriders
 import org.jetbrains.kotlin.name.Name
+import org.jetbrains.kotlin.psi.JetCallableDeclaration
 import org.jetbrains.kotlin.psi.JetClass
 import org.jetbrains.kotlin.psi.JetFunction
+import org.jetbrains.kotlin.psi.JetNamedDeclaration
 import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.DescriptorUtils
 import java.util.Collections
@@ -41,9 +47,9 @@ import java.util.HashSet
 import kotlin.properties.Delegates
 
 public class JetChangeSignatureData(
-        override val baseDescriptor: FunctionDescriptor,
+        override val baseDescriptor: CallableDescriptor,
         override val baseDeclaration: PsiElement,
-        private val descriptorsForSignatureChange: Collection<FunctionDescriptor>
+        private val descriptorsForSignatureChange: Collection<CallableDescriptor>
 ) : JetMethodDescriptor {
     private val parameters: List<JetParameterInfo>
     override val receiver: JetParameterInfo?
@@ -60,7 +66,7 @@ public class JetChangeSignatureData(
                 .mapTo(receiver?.let{ arrayListOf(it) } ?: arrayListOf()) { parameterDescriptor ->
                     val jetParameter = valueParameters?.get(parameterDescriptor.getIndex())
                     JetParameterInfo(
-                            functionDescriptor = baseDescriptor,
+                            callableDescriptor = baseDescriptor,
                             originalIndex = parameterDescriptor.getIndex(),
                             name = parameterDescriptor.getName().asString(),
                             type = parameterDescriptor.getType(),
@@ -72,8 +78,8 @@ public class JetChangeSignatureData(
     }
 
     private fun createReceiverInfoIfNeeded(): JetParameterInfo? {
-        val function = baseDeclaration as? JetFunction ?: return null
-        val bodyScope = function.getBodyExpression()?.let { it.analyze()[BindingContext.RESOLUTION_SCOPE, it] }
+        val callable = baseDeclaration as? JetCallableDeclaration ?: return null
+        val bodyScope = (callable as? JetFunction)?.getBodyExpression()?.let { it.analyze()[BindingContext.RESOLUTION_SCOPE, it] }
         val paramNames = baseDescriptor.getValueParameters().map { it.getName().asString() }
         val validator = bodyScope?.let { bodyScope ->
             CollectingNameValidator(paramNames) {
@@ -83,34 +89,40 @@ public class JetChangeSignatureData(
         } ?: CollectingNameValidator(paramNames)
         val receiverType = baseDescriptor.getExtensionReceiverParameter()?.getType() ?: return null
         val receiverName = KotlinNameSuggester.suggestNamesByType(receiverType, validator, "receiver").first()
-        return JetParameterInfo(functionDescriptor = baseDescriptor, name = receiverName, type = receiverType)
+        return JetParameterInfo(callableDescriptor = baseDescriptor, name = receiverName, type = receiverType)
     }
 
-    override val primaryFunctions: Collection<JetFunctionDefinitionUsage<PsiElement>> by Delegates.lazy {
+    override val original: JetMethodDescriptor
+        get() = this
+
+    override val primaryCallables: Collection<JetCallableDefinitionUsage<PsiElement>> by Delegates.lazy {
         descriptorsForSignatureChange.map {
             val declaration = DescriptorToSourceUtilsIde.getAnyDeclaration(baseDeclaration.getProject(), it)
             assert(declaration != null) { "No declaration found for " + baseDescriptor }
-            JetFunctionDefinitionUsage<PsiElement>(declaration, it, null, null)
+            JetCallableDefinitionUsage<PsiElement>(declaration!!, it, null, null)
         }
     }
 
-    override val originalPrimaryFunction: JetFunctionDefinitionUsage<PsiElement> by Delegates.lazy {
-        primaryFunctions.first { it.getDeclaration() == baseDeclaration }
+    override val originalPrimaryCallable: JetCallableDefinitionUsage<PsiElement> by Delegates.lazy {
+        primaryCallables.first { it.getDeclaration() == baseDeclaration }
     }
 
-    override val affectedFunctions: Collection<UsageInfo> by Delegates.lazy {
-        primaryFunctions + primaryFunctions.flatMapTo(HashSet<UsageInfo>()) { primaryFunction ->
-            val primaryDeclaration = primaryFunction.getDeclaration() as? JetFunction
-            val lightMethod = primaryDeclaration?.let { LightClassUtil.getLightClassMethod(it) }
-            val overrides = lightMethod?.let { OverridingMethodsSearch.search(it).findAll() } ?: Collections.emptyList()
-            overrides.map { method ->
-                if (method is KotlinLightMethod) {
-                    val overridingDeclaration = method.getOrigin()
-                    val overridingDescriptor = overridingDeclaration?.resolveToDescriptor() as FunctionDescriptor
-                    JetFunctionDefinitionUsage<PsiElement>(overridingDeclaration, overridingDescriptor, primaryFunction, null)
-                }
-                else OverriderUsageInfo(method, lightMethod, true, true, true)
-            }.filterNotNullTo(HashSet<UsageInfo>())
+    override val affectedCallables: Collection<UsageInfo> by Delegates.lazy {
+        primaryCallables + primaryCallables.flatMapTo(HashSet<UsageInfo>()) { primaryFunction ->
+            val primaryDeclaration = primaryFunction.getDeclaration() as? JetCallableDeclaration
+            val lightMethods = primaryDeclaration?.toLightMethods() ?: Collections.emptyList()
+            lightMethods.flatMap { baseMethod ->
+                OverridingMethodsSearch
+                        .search(baseMethod)
+                        .map { overridingMethod ->
+                            if (overridingMethod is KotlinLightMethod) {
+                                val overridingDeclaration = overridingMethod.namedUnwrappedElement as JetNamedDeclaration
+                                val overridingDescriptor = overridingDeclaration.resolveToDescriptor() as CallableDescriptor
+                                JetCallableDefinitionUsage<PsiElement>(overridingDeclaration, overridingDescriptor, primaryFunction, null)
+                            }
+                            else OverriderUsageInfo(overridingMethod, baseMethod, true, true, true)
+                        }.filterNotNullTo(HashSet<UsageInfo>())
+            }
         }
     }
 
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/JetChangeSignatureDialog.java b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/JetChangeSignatureDialog.java
deleted file mode 100644
index b07e7ae0a73..00000000000
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/JetChangeSignatureDialog.java
+++ /dev/null
@@ -1,540 +0,0 @@
-/*
- * Copyright 2010-2015 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.kotlin.idea.refactoring.changeSignature;
-
-import com.intellij.openapi.editor.Document;
-import com.intellij.openapi.editor.colors.EditorColorsManager;
-import com.intellij.openapi.editor.colors.EditorFontType;
-import com.intellij.openapi.editor.event.DocumentAdapter;
-import com.intellij.openapi.editor.event.DocumentEvent;
-import com.intellij.openapi.fileTypes.LanguageFileType;
-import com.intellij.openapi.options.ConfigurationException;
-import com.intellij.openapi.project.Project;
-import com.intellij.openapi.ui.VerticalFlowLayout;
-import com.intellij.openapi.util.text.StringUtil;
-import com.intellij.psi.JavaPsiFacade;
-import com.intellij.psi.PsiCodeFragment;
-import com.intellij.psi.PsiDocumentManager;
-import com.intellij.psi.PsiElement;
-import com.intellij.refactoring.BaseRefactoringProcessor;
-import com.intellij.refactoring.changeSignature.CallerChooserBase;
-import com.intellij.refactoring.changeSignature.ChangeSignatureDialogBase;
-import com.intellij.refactoring.changeSignature.MethodDescriptor;
-import com.intellij.refactoring.changeSignature.ParameterTableModelItemBase;
-import com.intellij.refactoring.ui.ComboBoxVisibilityPanel;
-import com.intellij.refactoring.ui.VisibilityPanelBase;
-import com.intellij.ui.DottedBorder;
-import com.intellij.ui.EditorTextField;
-import com.intellij.ui.components.JBLabel;
-import com.intellij.ui.treeStructure.Tree;
-import com.intellij.util.Consumer;
-import com.intellij.util.Function;
-import com.intellij.util.IJSwingUtilities;
-import com.intellij.util.ui.ColumnInfo;
-import com.intellij.util.ui.UIUtil;
-import com.intellij.util.ui.table.JBTableRow;
-import com.intellij.util.ui.table.JBTableRowEditor;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.descriptors.Visibilities;
-import org.jetbrains.kotlin.descriptors.Visibility;
-import org.jetbrains.kotlin.idea.JetFileType;
-import org.jetbrains.kotlin.idea.refactoring.JetRefactoringBundle;
-import org.jetbrains.kotlin.psi.JetExpression;
-import org.jetbrains.kotlin.psi.JetExpressionCodeFragment;
-import org.jetbrains.kotlin.psi.JetTypeCodeFragment;
-import org.jetbrains.kotlin.types.JetType;
-import org.jetbrains.kotlin.idea.refactoring.changeSignature.JetMethodDescriptor.Kind;
-
-import javax.swing.*;
-import java.awt.*;
-import java.awt.event.ItemEvent;
-import java.awt.event.ItemListener;
-import java.awt.event.MouseEvent;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Set;
-
-import static org.jetbrains.kotlin.psi.PsiPackage.JetPsiFactory;
-
-public class JetChangeSignatureDialog extends ChangeSignatureDialogBase<
-        JetParameterInfo,
-        PsiElement,
-        Visibility,
-        JetMethodDescriptor,
-        ParameterTableModelItemBase<JetParameterInfo>,
-        JetCallableParameterTableModel
-        >
-{
-    private final String commandName;
-
-    public JetChangeSignatureDialog(Project project, @NotNull JetMethodDescriptor methodDescriptor, PsiElement context, String commandName) {
-        super(project, methodDescriptor, false, context);
-        this.commandName = commandName;
-    }
-
-    @Override
-    protected LanguageFileType getFileType() {
-        return JetFileType.INSTANCE;
-    }
-
-    @Override
-    protected JetCallableParameterTableModel createParametersInfoModel(JetMethodDescriptor descriptor) {
-        return createParametersInfoModel(descriptor, myDefaultValueContext);
-    }
-
-    @NotNull
-    private static JetCallableParameterTableModel createParametersInfoModel(JetMethodDescriptor descriptor, PsiElement defaultValueContext) {
-        switch (descriptor.getKind()) {
-            case FUNCTION:
-                return new JetFunctionParameterTableModel(descriptor, defaultValueContext);
-            case PRIMARY_CONSTRUCTOR:
-                return new JetPrimaryConstructorParameterTableModel(descriptor, defaultValueContext);
-            case SECONDARY_CONSTRUCTOR:
-                return new JetSecondaryConstructorParameterTableModel(descriptor, defaultValueContext);
-        }
-        throw new AssertionError("Invalid kind: " + descriptor.getKind());
-    }
-
-    @Override
-    protected PsiCodeFragment createReturnTypeCodeFragment() {
-        return createReturnTypeCodeFragment(myProject, myMethod);
-    }
-
-    @NotNull
-    private static PsiCodeFragment createReturnTypeCodeFragment(@NotNull Project project, @NotNull JetMethodDescriptor method) {
-        return JetPsiFactory(project).createTypeCodeFragment(
-                ChangeSignaturePackage.renderOriginalReturnType(method), method.getBaseDeclaration()
-        );
-    }
-
-    @Nullable
-    public JetType getReturnType() {
-        return getType((JetTypeCodeFragment) myReturnTypeCodeFragment);
-    }
-
-    private static JetType getType(JetTypeCodeFragment typeCodeFragment) {
-        return typeCodeFragment != null ? typeCodeFragment.getType() : null;
-    }
-
-    @Override
-    protected JComponent getRowPresentation(ParameterTableModelItemBase<JetParameterInfo> item, boolean selected, boolean focused) {
-        JPanel panel = new JPanel(new BorderLayout());
-        String valOrVar = "";
-
-        if (myMethod.getKind() == Kind.PRIMARY_CONSTRUCTOR) {
-            switch (item.parameter.getValOrVar()) {
-                case None:
-                    valOrVar = "    ";
-                    break;
-                case Val:
-                    valOrVar = "val ";
-                    break;
-                case Var:
-                    valOrVar = "var ";
-                    break;
-            }
-        }
-
-        String parameterName = getPresentationName(item);
-        String typeText = item.typeCodeFragment.getText();
-        String defaultValue = item.defaultValueCodeFragment.getText();
-        String separator = StringUtil.repeatSymbol(' ', getParamNamesMaxLength() - parameterName.length() + 1);
-        String text = valOrVar + parameterName + ":" + separator + typeText;
-
-        if (StringUtil.isNotEmpty(defaultValue))
-            text += " // default value = " + defaultValue;
-
-        EditorTextField field = new EditorTextField(" " + text, getProject(), getFileType()) {
-            @Override
-            protected boolean shouldHaveBorder() {
-                return false;
-            }
-        };
-
-        Font font = EditorColorsManager.getInstance().getGlobalScheme().getFont(EditorFontType.PLAIN);
-        font = new Font(font.getFontName(), font.getStyle(), 12);
-        field.setFont(font);
-
-        if (selected && focused) {
-            panel.setBackground(UIUtil.getTableSelectionBackground());
-            field.setAsRendererWithSelection(UIUtil.getTableSelectionBackground(), UIUtil.getTableSelectionForeground());
-        } else {
-            panel.setBackground(UIUtil.getTableBackground());
-            if (selected && !focused) {
-                panel.setBorder(new DottedBorder(UIUtil.getTableForeground()));
-            }
-        }
-        panel.add(field, BorderLayout.WEST);
-        return panel;
-    }
-
-    private String getPresentationName(ParameterTableModelItemBase<JetParameterInfo> item) {
-        JetParameterInfo parameter = item.parameter;
-        if (parameter == null) return null;
-        if (parameter == myParametersTableModel.getReceiver()) return "<receiver>";
-        return parameter.getName();
-    }
-
-    private int getColumnTextMaxLength(Function<ParameterTableModelItemBase<JetParameterInfo>, String> nameFunction) {
-        int len = 0;
-        for (ParameterTableModelItemBase<JetParameterInfo> item : myParametersTableModel.getItems()) {
-            String text = nameFunction.fun(item);
-            len = Math.max(len, text == null ? 0 : text.length());
-        }
-        return len;
-    }
-
-    private int getParamNamesMaxLength() {
-        return getColumnTextMaxLength(new Function<ParameterTableModelItemBase<JetParameterInfo>, String>() {
-            @Override
-            public String fun(ParameterTableModelItemBase<JetParameterInfo> item) {
-                return getPresentationName(item);
-            }
-        });
-    }
-
-    private int getTypesMaxLength() {
-        return getColumnTextMaxLength(new Function<ParameterTableModelItemBase<JetParameterInfo>, String>() {
-            @Override
-            public String fun(ParameterTableModelItemBase<JetParameterInfo> item) {
-                return item.typeCodeFragment == null ? null : item.typeCodeFragment.getText();
-            }
-        });
-    }
-
-    private int getDefaultValuesMaxLength() {
-        return getColumnTextMaxLength(new Function<ParameterTableModelItemBase<JetParameterInfo>, String>() {
-            @Override
-            public String fun(ParameterTableModelItemBase<JetParameterInfo> item) {
-                return item.defaultValueCodeFragment == null ? null : item.defaultValueCodeFragment.getText();
-            }
-        });
-    }
-
-    @Override
-    protected boolean isListTableViewSupported() {
-        return true;
-    }
-
-    @Override
-    protected boolean isEmptyRow(ParameterTableModelItemBase<JetParameterInfo> row) {
-        if (!StringUtil.isEmpty(row.parameter.getName())) return false;
-        if (!StringUtil.isEmpty(row.parameter.getTypeText())) return false;
-        return true;
-    }
-
-    @Nullable
-    @Override
-    protected CallerChooserBase<PsiElement> createCallerChooser(String title, Tree treeToReuse, Consumer<Set<PsiElement>> callback) {
-        throw new UnsupportedOperationException();
-    }
-
-    @Override
-    protected JBTableRowEditor getTableEditor(final JTable t, final ParameterTableModelItemBase<JetParameterInfo> item) {
-        return new JBTableRowEditor() {
-            private final List<JComponent> components = new ArrayList<JComponent>();
-            private final EditorTextField nameEditor = new EditorTextField(item.parameter.getName(), getProject(), getFileType());;
-
-            private void updateNameEditor() {
-                nameEditor.setEnabled(item.parameter != myParametersTableModel.getReceiver());
-            }
-
-            private boolean isDefaultColumnEnabled() {
-                return item.parameter.getIsNewParameter() && item.parameter != myMethod.getReceiver();
-            }
-
-            @Override
-            public void prepareEditor(JTable table, final int row) {
-                setLayout(new BoxLayout(this, BoxLayout.X_AXIS));
-                int column = 0;
-
-                for (ColumnInfo columnInfo : myParametersTableModel.getColumnInfos()) {
-                    JPanel panel = new JPanel(new VerticalFlowLayout(VerticalFlowLayout.TOP, 4, 2, true, false));
-                    EditorTextField editor = null;
-                    JComponent component;
-                    final int columnFinal = column;
-
-                    if (JetCallableParameterTableModel.isTypeColumn(columnInfo)) {
-                        Document document = PsiDocumentManager.getInstance(getProject()).getDocument(item.typeCodeFragment);
-                        component = editor = new EditorTextField(document, getProject(), getFileType());
-                    }
-                    else if (JetCallableParameterTableModel.isNameColumn(columnInfo)) {
-                        component = editor = nameEditor;
-                        updateNameEditor();
-                    }
-                    else if (JetCallableParameterTableModel.isDefaultValueColumn(columnInfo) && isDefaultColumnEnabled()) {
-                        Document document = PsiDocumentManager.getInstance(getProject()).getDocument(item.defaultValueCodeFragment);
-                        component = editor = new EditorTextField(document, getProject(), getFileType());
-                    }
-                    else if (JetPrimaryConstructorParameterTableModel.isValVarColumn(columnInfo)) {
-                        JComboBox comboBox = new JComboBox(JetValVar.values());
-                        comboBox.setSelectedItem(item.parameter.getValOrVar());
-                        comboBox.addItemListener(new ItemListener() {
-                            @Override
-                            public void itemStateChanged(@NotNull ItemEvent e) {
-                                myParametersTableModel.setValueAtWithoutUpdate(e.getItem(), row, columnFinal);
-                                updateSignature();
-                            }
-                        });
-                        component = comboBox;
-                    }
-                    else if (JetFunctionParameterTableModel.isReceiverColumn(columnInfo)) {
-                        JCheckBox checkBox = new JCheckBox();
-                        checkBox.setSelected(myParametersTableModel.getReceiver() == item.parameter);
-                        checkBox.addItemListener(
-                                new ItemListener() {
-                                    @Override
-                                    public void itemStateChanged(@NotNull ItemEvent e) {
-                                        ((JetFunctionParameterTableModel)myParametersTableModel).setReceiver(
-                                                e.getStateChange() == ItemEvent.SELECTED ? item.parameter : null
-                                        );
-                                        updateSignature();
-                                        updateNameEditor();
-                                    }
-                                }
-                        );
-                        component = checkBox;
-                    }
-                    else
-                        continue;
-
-                    JBLabel label = new JBLabel(columnInfo.getName(), UIUtil.ComponentStyle.SMALL);
-                    panel.add(label);
-
-                    if (editor != null) {
-                        editor.addDocumentListener(new DocumentAdapter() {
-                            @Override
-                            public void documentChanged(DocumentEvent e) {
-                                fireDocumentChanged(e, columnFinal);
-                            }
-                        });
-                        editor.setPreferredWidth(t.getWidth() / myParametersTableModel.getColumnCount());
-                    }
-
-                    components.add(component);
-                    panel.add(component);
-                    add(panel);
-                    IJSwingUtilities.adjustComponentsOnMac(label, component);
-                    column++;
-                }
-            }
-
-            @Override
-            public JBTableRow getValue() {
-                return new JBTableRow() {
-                    @Override
-                    public Object getValueAt(int column) {
-                        ColumnInfo columnInfo = myParametersTableModel.getColumnInfos()[column];
-
-                        if (JetPrimaryConstructorParameterTableModel.isValVarColumn(columnInfo))
-                            return ((JComboBox) components.get(column)).getSelectedItem();
-                        else if (JetCallableParameterTableModel.isTypeColumn(columnInfo))
-                            return item.typeCodeFragment;
-                        else if (JetCallableParameterTableModel.isNameColumn(columnInfo))
-                            return ((EditorTextField) components.get(column)).getText();
-                        else if (JetCallableParameterTableModel.isDefaultValueColumn(columnInfo))
-                            return item.defaultValueCodeFragment;
-                        else
-                            return null;
-                    }
-                };
-            }
-
-            private int getColumnWidth(int letters) {
-                Font font = EditorColorsManager.getInstance().getGlobalScheme().getFont(EditorFontType.PLAIN);
-                font = new Font(font.getFontName(), font.getStyle(), 12);
-                return letters * Toolkit.getDefaultToolkit().getFontMetrics(font).stringWidth("W");
-            }
-
-            private int getEditorIndex(int x) {
-                int[] columnLetters = isDefaultColumnEnabled() ?
-                                      new int[] { 4, getParamNamesMaxLength(), getTypesMaxLength(), getDefaultValuesMaxLength() } :
-                                      new int[] { 4, getParamNamesMaxLength(), getTypesMaxLength() };
-                int columnIndex = 0;
-
-                for (int i = myMethod.getKind() == Kind.PRIMARY_CONSTRUCTOR ? 0 : 1; i < columnLetters.length; i ++) {
-                    int width = getColumnWidth(columnLetters[i]);
-
-                    if (x <= width)
-                        return columnIndex;
-
-                    columnIndex ++;
-                    x -= width;
-                }
-
-                return columnIndex - 1;
-            }
-
-            @Override
-            public JComponent getPreferredFocusedComponent() {
-                MouseEvent me = getMouseEvent();
-                int index = me != null
-                            ? getEditorIndex((int) me.getPoint().getX())
-                            : myMethod.getKind() == Kind.PRIMARY_CONSTRUCTOR ? 1 : 0;
-                JComponent component = components.get(index);
-                return component instanceof EditorTextField ? ((EditorTextField) component).getFocusTarget() : component;
-            }
-
-            @Override
-            public JComponent[] getFocusableComponents() {
-                JComponent[] focusable = new JComponent[components.size()];
-
-                for (int i = 0; i < components.size(); i++) {
-                    focusable[i] = components.get(i);
-
-                    if (focusable[i] instanceof EditorTextField)
-                        focusable[i] = ((EditorTextField) focusable[i]).getFocusTarget();
-                }
-
-                return focusable;
-            }
-        };
-    }
-
-    @Override
-    protected String calculateSignature() {
-        JetChangeInfo changeInfo = evaluateChangeInfo(
-                myParametersTableModel,
-                myReturnTypeCodeFragment,
-                getMethodDescriptor(),
-                getVisibility(),
-                getMethodName(),
-                myDefaultValueContext
-        );
-        return changeInfo.getNewSignature(getMethodDescriptor().getOriginalPrimaryFunction());
-    }
-
-    @Override
-    protected VisibilityPanelBase<Visibility> createVisibilityControl() {
-        return new ComboBoxVisibilityPanel<Visibility>(new Visibility[]{
-                Visibilities.INTERNAL, Visibilities.PRIVATE, Visibilities.PROTECTED, Visibilities.PUBLIC }
-        );
-    }
-
-    @Override
-    protected void updateSignatureAlarmFired() {
-        super.updateSignatureAlarmFired();
-        validateButtons();
-    }
-
-    @Nullable
-    @Override
-    protected String validateAndCommitData() {
-        return null;
-    }
-
-    @Override
-    protected void canRun() throws ConfigurationException {
-        if (myNamePanel.isVisible() && myMethod.canChangeName() && !JavaPsiFacade.getInstance(myProject).getNameHelper().isIdentifier(getMethodName()))
-            throw new ConfigurationException(JetRefactoringBundle.message("function.name.is.invalid"));
-        if (myMethod.canChangeReturnType() == MethodDescriptor.ReadWriteOption.ReadWrite && getReturnType() == null)
-            throw new ConfigurationException(JetRefactoringBundle.message("return.type.is.invalid"));
-
-        List<ParameterTableModelItemBase<JetParameterInfo>> parameterInfos = myParametersTableModel.getItems();
-
-        for (ParameterTableModelItemBase<JetParameterInfo> item : parameterInfos) {
-            String parameterName = item.parameter.getName();
-
-            if (item.parameter != myParametersTableModel.getReceiver()
-                && !JavaPsiFacade.getInstance(myProject).getNameHelper().isIdentifier(parameterName))
-                throw new ConfigurationException(JetRefactoringBundle.message("parameter.name.is.invalid", parameterName));
-            if (getType((JetTypeCodeFragment) item.typeCodeFragment) == null)
-                throw new ConfigurationException(JetRefactoringBundle.message("parameter.type.is.invalid", item.typeCodeFragment.getText()));
-        }
-    }
-
-    @Override
-    @NotNull
-    protected BaseRefactoringProcessor createRefactoringProcessor() {
-        JetChangeInfo changeInfo = evaluateChangeInfo(
-                myParametersTableModel,
-                myReturnTypeCodeFragment,
-                getMethodDescriptor(),
-                getVisibility(),
-                getMethodName(),
-                myDefaultValueContext
-        );
-        return new JetChangeSignatureProcessor(myProject, changeInfo, commandName != null ? commandName : getTitle());
-    }
-
-    @NotNull
-    public static BaseRefactoringProcessor createRefactoringProcessorForSilentChangeSignature(
-            @NotNull Project project,
-            @NotNull String commandName,
-            @NotNull JetMethodDescriptor method,
-            @NotNull PsiElement defaultValueContext
-    ) {
-        JetCallableParameterTableModel parameterTableModel = createParametersInfoModel(method, defaultValueContext);
-        parameterTableModel.setParameterInfos(method.getParameters());
-        JetChangeInfo changeInfo = evaluateChangeInfo(
-                parameterTableModel,
-                createReturnTypeCodeFragment(project, method),
-                method,
-                method.getVisibility(),
-                method.getName(),
-                defaultValueContext
-        );
-        return new JetChangeSignatureProcessor(project, changeInfo, commandName);
-    }
-
-    @NotNull
-    public JetMethodDescriptor getMethodDescriptor() {
-        return myMethod;
-    }
-
-    private static JetChangeInfo evaluateChangeInfo(
-            @NotNull JetCallableParameterTableModel parametersModel,
-            @Nullable PsiCodeFragment returnTypeCodeFragment,
-            @NotNull JetMethodDescriptor methodDescriptor,
-            @Nullable Visibility visibility,
-            @NotNull String methodName,
-            @NotNull PsiElement defaultValueContext
-    ) {
-        List<JetParameterInfo> parameters = new ArrayList<JetParameterInfo>(parametersModel.getRowCount());
-
-        for (ParameterTableModelItemBase<JetParameterInfo> parameter : parametersModel.getItems()) {
-            parameter.parameter.setCurrentTypeText(parameter.typeCodeFragment.getText().trim());
-
-            parameters.add(parameter.parameter);
-
-            JetExpressionCodeFragment codeFragment = (JetExpressionCodeFragment) parameter.defaultValueCodeFragment;
-            JetExpression oldDefaultValue = parameter.parameter.getDefaultValueForCall();
-            if (!codeFragment.getText().equals(oldDefaultValue != null ? oldDefaultValue.getText() : "")) {
-                parameter.parameter.setDefaultValueForCall(codeFragment.getContentElement());
-            }
-        }
-
-        String returnTypeText = returnTypeCodeFragment != null ? returnTypeCodeFragment.getText().trim() : "";
-        JetMethodDescriptor descriptor = methodDescriptor instanceof JetMutableMethodDescriptor
-                                         ? ((JetMutableMethodDescriptor) methodDescriptor).getOriginal()
-                                         : methodDescriptor;
-        JetType returnType = getType((JetTypeCodeFragment) returnTypeCodeFragment);
-        return new JetChangeInfo(descriptor, methodName, returnType, returnTypeText,
-                                 visibility, parameters, parametersModel.getReceiver(), defaultValueContext);
-    }
-
-    @Override
-    protected int getSelectedIdx() {
-        List<JetParameterInfo> parameters = myMethod.getParameters();
-        for (int i = 0; i < parameters.size(); i++) {
-            JetParameterInfo info = parameters.get(i);
-            if (info.getIsNewParameter()) return i;
-        }
-        return super.getSelectedIdx();
-    }
-}
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/JetChangeSignatureHandler.java b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/JetChangeSignatureHandler.java
deleted file mode 100644
index beeaeea3bf5..00000000000
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/JetChangeSignatureHandler.java
+++ /dev/null
@@ -1,254 +0,0 @@
-/*
- * Copyright 2010-2015 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.kotlin.idea.refactoring.changeSignature;
-
-import com.intellij.openapi.actionSystem.CommonDataKeys;
-import com.intellij.openapi.actionSystem.DataContext;
-import com.intellij.openapi.editor.Editor;
-import com.intellij.openapi.editor.ScrollType;
-import com.intellij.openapi.project.Project;
-import com.intellij.psi.PsiElement;
-import com.intellij.psi.PsiFile;
-import com.intellij.psi.PsiMethod;
-import com.intellij.psi.util.PsiTreeUtil;
-import com.intellij.refactoring.HelpID;
-import com.intellij.refactoring.RefactoringBundle;
-import com.intellij.refactoring.changeSignature.ChangeSignatureHandler;
-import com.intellij.refactoring.changeSignature.ChangeSignatureUtil;
-import com.intellij.refactoring.util.CommonRefactoringUtil;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-import org.jetbrains.annotations.TestOnly;
-import org.jetbrains.kotlin.asJava.AsJavaPackage;
-import org.jetbrains.kotlin.descriptors.ClassDescriptor;
-import org.jetbrains.kotlin.descriptors.DeclarationDescriptor;
-import org.jetbrains.kotlin.descriptors.FunctionDescriptor;
-import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor;
-import org.jetbrains.kotlin.idea.caches.resolve.ResolvePackage;
-import org.jetbrains.kotlin.idea.codeInsight.CodeInsightUtils;
-import org.jetbrains.kotlin.idea.codeInsight.DescriptorToSourceUtilsIde;
-import org.jetbrains.kotlin.idea.refactoring.JetRefactoringBundle;
-import org.jetbrains.kotlin.load.java.descriptors.JavaCallableMemberDescriptor;
-import org.jetbrains.kotlin.psi.*;
-import org.jetbrains.kotlin.resolve.BindingContext;
-import org.jetbrains.kotlin.resolve.calls.tasks.TasksPackage;
-import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode;
-
-import java.util.Collection;
-
-import static org.jetbrains.kotlin.descriptors.CallableMemberDescriptor.Kind.SYNTHESIZED;
-import static org.jetbrains.kotlin.idea.refactoring.changeSignature.ChangeSignaturePackage.runChangeSignature;
-
-public class JetChangeSignatureHandler implements ChangeSignatureHandler {
-    @Nullable
-    public static PsiElement findTargetForRefactoring(@NotNull PsiElement element) {
-        if (PsiTreeUtil.getParentOfType(element, JetParameterList.class) != null) {
-            return PsiTreeUtil.getParentOfType(element, JetFunction.class, JetClass.class);
-        }
-
-        JetTypeParameterList typeParameterList = PsiTreeUtil.getParentOfType(element, JetTypeParameterList.class);
-        if (typeParameterList != null) {
-            return PsiTreeUtil.getParentOfType(typeParameterList, JetFunction.class, JetClass.class);
-        }
-
-        PsiElement elementParent = element.getParent();
-        if (elementParent instanceof JetNamedFunction && ((JetNamedFunction) elementParent).getNameIdentifier() == element) {
-            return elementParent;
-        }
-        if (elementParent instanceof JetClass && ((JetClass) elementParent).getNameIdentifier() == element) {
-            return elementParent;
-        }
-        if (elementParent instanceof JetSecondaryConstructor &&
-            ((JetSecondaryConstructor) elementParent).getConstructorKeyword() == element) {
-            return elementParent;
-        }
-
-        JetCallElement call = PsiTreeUtil.getParentOfType(element,
-                                                          JetCallExpression.class,
-                                                          JetDelegatorToSuperCall.class,
-                                                          JetConstructorDelegationCall.class);
-        if (call == null) return null;
-
-        JetExpression receiverExpr = call.getCalleeExpression();
-        if (receiverExpr instanceof JetConstructorCalleeExpression) {
-            receiverExpr = ((JetConstructorCalleeExpression) receiverExpr).getConstructorReferenceExpression();
-        }
-        if (receiverExpr instanceof JetSimpleNameExpression || receiverExpr instanceof JetConstructorDelegationReferenceExpression) {
-            JetElement jetElement = PsiTreeUtil.getParentOfType(element, JetElement.class);
-            if (jetElement == null) return null;
-
-            BindingContext bindingContext = ResolvePackage.analyze(jetElement, BodyResolveMode.FULL);
-            DeclarationDescriptor descriptor = bindingContext.get(BindingContext.REFERENCE_TARGET, (JetReferenceExpression) receiverExpr);
-
-            if (descriptor instanceof ClassDescriptor || descriptor instanceof FunctionDescriptor) return receiverExpr;
-        }
-
-        return null;
-    }
-
-    public static void invokeChangeSignature(
-            @NotNull JetElement element,
-            @NotNull PsiElement context,
-            @NotNull Project project,
-            @Nullable Editor editor
-    ) {
-        BindingContext bindingContext = ResolvePackage.analyze(element, BodyResolveMode.FULL);
-        
-        FunctionDescriptor functionDescriptor = findDescriptor(element, project, editor, bindingContext);
-        if (functionDescriptor == null) {
-            return;
-        }
-
-        if (functionDescriptor instanceof JavaCallableMemberDescriptor) {
-            PsiElement declaration = DescriptorToSourceUtilsIde.INSTANCE$.getAnyDeclaration(project, functionDescriptor);
-            assert declaration instanceof PsiMethod : "PsiMethod expected: " + functionDescriptor;
-            ChangeSignatureUtil.invokeChangeSignatureOn((PsiMethod) declaration, project);
-            return;
-        }
-
-        if (TasksPackage.isDynamic(functionDescriptor)) {
-            if (editor != null) {
-                CodeInsightUtils.showErrorHint(
-                        project,
-                        editor,
-                        "Change signature is not applicable to dynamically invoked functions",
-                        "Change Signature",
-                        null
-                );
-            }
-            return;
-        }
-
-        runChangeSignature(project, functionDescriptor, emptyConfiguration(), bindingContext, context, null);
-    }
-
-    @TestOnly
-    public static JetChangeSignatureConfiguration getConfiguration() {
-        return emptyConfiguration();
-    }
-
-    private static JetChangeSignatureConfiguration emptyConfiguration() {
-        return new JetChangeSignatureConfiguration() {
-            @NotNull
-            @Override
-            public JetMethodDescriptor configure(@NotNull JetMethodDescriptor originalDescriptor, @NotNull BindingContext bindingContext) {
-                //do nothing
-                return originalDescriptor;
-            }
-
-            @Override
-            public boolean performSilently(@NotNull Collection<? extends PsiElement> elements) {
-                return false;
-            }
-
-            @Override
-            public boolean forcePerformForSelectedFunctionOnly() {
-                return false;
-            }
-        };
-    }
-
-    @Nullable
-    @Override
-    public PsiElement findTargetMember(PsiFile file, Editor editor) {
-        return findTargetMember(file.findElementAt(editor.getCaretModel().getOffset()));
-    }
-
-    @Nullable
-    @Override
-    public PsiElement findTargetMember(PsiElement element) {
-        return findTargetForRefactoring(element);
-    }
-
-    @Override
-    public void invoke(@NotNull Project project, @NotNull Editor editor, @NotNull PsiFile file, DataContext dataContext) {
-        editor.getScrollingModel().scrollToCaret(ScrollType.MAKE_VISIBLE);
-        PsiElement element = findTargetMember(file, editor);
-        if (element == null) {
-            element = CommonDataKeys.PSI_ELEMENT.getData(dataContext);
-        }
-
-        PsiElement elementAtCaret = file.findElementAt(editor.getCaretModel().getOffset());
-        if (element != null && elementAtCaret != null) {
-            assert element instanceof JetElement : "This handler must be invoked for elements of JetLanguage : " + element.getText();
-
-            invokeChangeSignature((JetElement) element, elementAtCaret, project, editor);
-        }
-    }
-
-    @Override
-    public void invoke(@NotNull Project project, @NotNull PsiElement[] elements, @Nullable DataContext dataContext) {
-        if (elements.length != 1) return;
-        Editor editor = dataContext != null ? CommonDataKeys.EDITOR.getData(dataContext) : null;
-
-        PsiElement element = AsJavaPackage.getUnwrapped(elements[0]);
-        assert element instanceof JetElement : "This handler must be invoked for elements of JetLanguage : " + element.getText();
-
-        invokeChangeSignature((JetElement) element, element, project, editor);
-    }
-
-    @Nullable
-    @Override
-    public String getTargetNotFoundMessage() {
-        return JetRefactoringBundle.message("error.wrong.caret.position.function.or.constructor.name");
-    }
-
-    @Nullable
-    public static FunctionDescriptor findDescriptor(
-            @NotNull PsiElement element,
-            @NotNull Project project,
-            @Nullable Editor editor,
-            BindingContext bindingContext
-    ) {
-        if (!CommonRefactoringUtil.checkReadOnlyStatus(project, element)) return null;
-
-        DeclarationDescriptor descriptor;
-        if (element instanceof JetReferenceExpression) {
-            descriptor = bindingContext.get(BindingContext.REFERENCE_TARGET, (JetReferenceExpression) element);
-        } else {
-            descriptor = bindingContext.get(BindingContext.DECLARATION_TO_DESCRIPTOR, element);
-        }
-        if (descriptor instanceof ClassDescriptor) {
-            descriptor = ((ClassDescriptor) descriptor).getUnsubstitutedPrimaryConstructor();
-        }
-        if (descriptor instanceof FunctionDescriptor) {
-            for (ValueParameterDescriptor parameter : ((FunctionDescriptor) descriptor).getValueParameters()) {
-                if (parameter.getVarargElementType() != null) {
-                    String message = JetRefactoringBundle.message("error.cant.refactor.vararg.functions");
-                    CommonRefactoringUtil.showErrorHint(project, editor, message,
-                                                        REFACTORING_NAME,
-                                                        HelpID.CHANGE_SIGNATURE);
-                    return null;
-                }
-            }
-            if (((FunctionDescriptor) descriptor).getKind() == SYNTHESIZED) {
-                String message = JetRefactoringBundle.message("cannot.refactor.synthesized.function", descriptor.getName());
-                CommonRefactoringUtil.showErrorHint(project, editor, message, REFACTORING_NAME, HelpID.CHANGE_SIGNATURE);
-                return null;
-            }
-
-
-            return (FunctionDescriptor) descriptor;
-        }
-        else {
-            String message = RefactoringBundle.getCannotRefactorMessage(JetRefactoringBundle.message(
-                    "error.wrong.caret.position.function.or.constructor.name"));
-            CommonRefactoringUtil.showErrorHint(project, editor, message, REFACTORING_NAME, HelpID.CHANGE_SIGNATURE);
-            return null;
-        }
-    }
-}
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/JetChangeSignatureHandler.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/JetChangeSignatureHandler.kt
new file mode 100644
index 00000000000..811b31f661a
--- /dev/null
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/JetChangeSignatureHandler.kt
@@ -0,0 +1,197 @@
+/*
+ * Copyright 2010-2015 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.kotlin.idea.refactoring.changeSignature
+
+import com.intellij.openapi.actionSystem.CommonDataKeys
+import com.intellij.openapi.actionSystem.DataContext
+import com.intellij.openapi.application.ApplicationManager
+import com.intellij.openapi.editor.Editor
+import com.intellij.openapi.editor.ScrollType
+import com.intellij.openapi.project.Project
+import com.intellij.psi.PsiClass
+import com.intellij.psi.PsiElement
+import com.intellij.psi.PsiFile
+import com.intellij.psi.PsiMethod
+import com.intellij.psi.util.PsiTreeUtil
+import com.intellij.refactoring.BaseRefactoringProcessor
+import com.intellij.refactoring.HelpID
+import com.intellij.refactoring.RefactoringBundle
+import com.intellij.refactoring.changeSignature.ChangeSignatureHandler
+import com.intellij.refactoring.changeSignature.ChangeSignatureUtil
+import com.intellij.refactoring.util.CommonRefactoringUtil
+import org.jetbrains.kotlin.asJava.unwrapped
+import org.jetbrains.kotlin.descriptors.*
+import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor.Kind.SYNTHESIZED
+import org.jetbrains.kotlin.idea.caches.resolve.analyze
+import org.jetbrains.kotlin.idea.codeInsight.CodeInsightUtils
+import org.jetbrains.kotlin.idea.codeInsight.DescriptorToSourceUtilsIde
+import org.jetbrains.kotlin.idea.refactoring.JetRefactoringBundle
+import org.jetbrains.kotlin.load.java.descriptors.JavaCallableMemberDescriptor
+import org.jetbrains.kotlin.psi.*
+import org.jetbrains.kotlin.psi.psiUtil.getStrictParentOfType
+import org.jetbrains.kotlin.resolve.BindingContext
+import org.jetbrains.kotlin.resolve.calls.tasks.isDynamic
+import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode
+
+public class JetChangeSignatureHandler : ChangeSignatureHandler {
+
+    override fun findTargetMember(file: PsiFile, editor: Editor) =
+            file.findElementAt(editor.getCaretModel().getOffset())?.let { findTargetMember(it) }
+
+    override fun findTargetMember(element: PsiElement) =
+            findTargetForRefactoring(element)
+
+    override fun invoke(project: Project, editor: Editor, file: PsiFile, dataContext: DataContext) {
+        editor.getScrollingModel().scrollToCaret(ScrollType.MAKE_VISIBLE)
+
+        val element = findTargetMember(file, editor) ?: CommonDataKeys.PSI_ELEMENT.getData(dataContext) ?: return
+        val elementAtCaret = file.findElementAt(editor.getCaretModel().getOffset()) ?: return
+        if (element !is JetElement) throw AssertionError("This handler must be invoked for Kotlin elements only: ${element.getText()}")
+
+        invokeChangeSignature(element, elementAtCaret, project, editor)
+    }
+
+    override fun invoke(project: Project, elements: Array<PsiElement>, dataContext: DataContext?) {
+        val element = elements.singleOrNull()?.unwrapped ?: return
+        if (element !is JetElement) throw AssertionError("This handler must be invoked for Kotlin elements only: ${element.getText()}")
+
+        val editor = dataContext?.let { CommonDataKeys.EDITOR.getData(it) }
+        invokeChangeSignature(element, element, project, editor)
+    }
+
+    override fun getTargetNotFoundMessage() =
+            JetRefactoringBundle.message("error.wrong.caret.position.function.or.constructor.name")
+
+    companion object {
+        public fun findTargetForRefactoring(element: PsiElement): PsiElement? {
+            val elementParent = element.getParent()
+
+            if ((elementParent is JetNamedFunction || elementParent is JetClass || elementParent is JetProperty)
+                && (elementParent as JetNamedDeclaration).getNameIdentifier() === element) return elementParent
+
+            if (elementParent is JetParameter) {
+                val primaryConstructor = PsiTreeUtil.getParentOfType(elementParent, javaClass<JetPrimaryConstructor>())
+                if (elementParent.hasValOrVar()
+                    && (elementParent.getNameIdentifier() === element || elementParent.getValOrVarKeyword() === element)
+                    && primaryConstructor != null
+                    && primaryConstructor.getValueParameterList() === elementParent.getParent()) return elementParent
+            }
+
+            if (elementParent is JetSecondaryConstructor && elementParent.getConstructorKeyword() === element) return elementParent
+
+            element.getStrictParentOfType<JetParameterList>()?.let { parameterList ->
+                return PsiTreeUtil.getParentOfType(parameterList, javaClass<JetFunction>(), javaClass<JetProperty>(), javaClass<JetClass>())
+            }
+
+            element.getStrictParentOfType<JetTypeParameterList>()?.let { typeParameterList ->
+                return PsiTreeUtil.getParentOfType(typeParameterList, javaClass<JetFunction>(), javaClass<JetProperty>(), javaClass<JetClass>())
+            }
+
+            val call: JetCallElement? = PsiTreeUtil.getParentOfType(element,
+                                                                   javaClass<JetCallExpression>(),
+                                                                   javaClass<JetDelegatorToSuperCall>(),
+                                                                   javaClass<JetConstructorDelegationCall>())
+            val calleeExpr = call?.let {
+                val callee = it.getCalleeExpression()
+                (callee as? JetConstructorCalleeExpression)?.getConstructorReferenceExpression() ?: callee
+            } ?: element.getStrictParentOfType<JetSimpleNameExpression>()
+
+            if (calleeExpr is JetSimpleNameExpression || calleeExpr is JetConstructorDelegationReferenceExpression) {
+                val jetElement = element.getStrictParentOfType<JetElement>() ?: return null
+
+                val bindingContext = jetElement.analyze(BodyResolveMode.FULL)
+                val descriptor = bindingContext[BindingContext.REFERENCE_TARGET, calleeExpr as JetReferenceExpression]
+
+                if (descriptor is ClassDescriptor || descriptor is CallableDescriptor) return calleeExpr
+            }
+
+            return null
+        }
+
+        public fun invokeChangeSignature(element: JetElement, context: PsiElement, project: Project, editor: Editor?) {
+            val bindingContext = element.analyze(BodyResolveMode.FULL)
+
+            val callableDescriptor = findDescriptor(element, project, editor, bindingContext) ?: return
+
+            if (callableDescriptor is JavaCallableMemberDescriptor) {
+                val declaration = DescriptorToSourceUtilsIde.getAnyDeclaration(project, callableDescriptor)
+                if (declaration is PsiClass) {
+                    val message = RefactoringBundle.getCannotRefactorMessage(
+                            RefactoringBundle.message("error.wrong.caret.position.method.or.class.name")
+                    )
+                    CommonRefactoringUtil.showErrorHint(project,
+                                                        editor,
+                                                        message,
+                                                        ChangeSignatureHandler.REFACTORING_NAME, "refactoring.changeSignature")
+                    return
+                }
+                assert(declaration is PsiMethod) { "PsiMethod expected: $callableDescriptor" }
+                ChangeSignatureUtil.invokeChangeSignatureOn(declaration as PsiMethod, project)
+                return
+            }
+
+            if (callableDescriptor.isDynamic()) {
+                if (editor != null) {
+                    CodeInsightUtils.showErrorHint(project, editor, "Change signature is not applicable to dynamically invoked functions", "Change Signature", null)
+                }
+                return
+            }
+
+            runChangeSignature(project, callableDescriptor, JetChangeSignatureConfiguration.Empty, bindingContext, context, null)
+        }
+
+        private fun getDescriptor(bindingContext: BindingContext, element: PsiElement): DeclarationDescriptor? {
+            val descriptor = when (element) {
+                is JetReferenceExpression -> bindingContext[BindingContext.REFERENCE_TARGET, element]
+                else -> bindingContext[BindingContext.DECLARATION_TO_DESCRIPTOR, element]
+            }
+            return if (descriptor is ClassDescriptor) descriptor.getUnsubstitutedPrimaryConstructor() else descriptor
+        }
+
+        public fun findDescriptor(element: PsiElement, project: Project, editor: Editor?, bindingContext: BindingContext): CallableDescriptor? {
+            if (!CommonRefactoringUtil.checkReadOnlyStatus(project, element)) return null
+
+            var descriptor = getDescriptor(bindingContext, element)
+
+            return when (descriptor) {
+                is FunctionDescriptor -> {
+                    if (descriptor.getValueParameters().any { it.getVarargElementType() != null }) {
+                        val message = JetRefactoringBundle.message("error.cant.refactor.vararg.functions")
+                        CommonRefactoringUtil.showErrorHint(project, editor, message, ChangeSignatureHandler.REFACTORING_NAME, HelpID.CHANGE_SIGNATURE)
+                        return null
+                    }
+
+                    if (descriptor.getKind() === SYNTHESIZED) {
+                        val message = JetRefactoringBundle.message("cannot.refactor.synthesized.function", descriptor.getName())
+                        CommonRefactoringUtil.showErrorHint(project, editor, message, ChangeSignatureHandler.REFACTORING_NAME, HelpID.CHANGE_SIGNATURE)
+                        return null
+                    }
+
+                    descriptor
+                }
+
+                is PropertyDescriptor, is ValueParameterDescriptor -> descriptor as CallableDescriptor
+
+                else -> {
+                    val message = RefactoringBundle.getCannotRefactorMessage(JetRefactoringBundle.message("error.wrong.caret.position.function.or.constructor.name"))
+                    CommonRefactoringUtil.showErrorHint(project, editor, message, ChangeSignatureHandler.REFACTORING_NAME, HelpID.CHANGE_SIGNATURE)
+                    null
+                }
+            }
+        }
+    }
+}
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/JetChangeSignatureProcessor.java b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/JetChangeSignatureProcessor.java
deleted file mode 100644
index 38864e103b0..00000000000
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/JetChangeSignatureProcessor.java
+++ /dev/null
@@ -1,134 +0,0 @@
-/*
- * Copyright 2010-2015 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.kotlin.idea.refactoring.changeSignature;
-
-import com.intellij.openapi.application.ApplicationManager;
-import com.intellij.openapi.project.Project;
-import com.intellij.openapi.util.Ref;
-import com.intellij.psi.PsiElement;
-import com.intellij.refactoring.RefactoringBundle;
-import com.intellij.refactoring.changeSignature.*;
-import com.intellij.refactoring.rename.RenameUtil;
-import com.intellij.refactoring.ui.ConflictsDialog;
-import com.intellij.usageView.UsageInfo;
-import com.intellij.usageView.UsageViewDescriptor;
-import com.intellij.util.containers.HashSet;
-import com.intellij.util.containers.MultiMap;
-import kotlin.KotlinPackage;
-import kotlin.Pair;
-import kotlin.jvm.functions.Function1;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.kotlin.idea.refactoring.changeSignature.usages.JetUsageInfo;
-import org.jetbrains.kotlin.idea.refactoring.changeSignature.usages.KotlinWrapperForJavaUsageInfos;
-
-import java.util.*;
-
-public class JetChangeSignatureProcessor extends ChangeSignatureProcessorBase {
-    private final String commandName;
-
-    public JetChangeSignatureProcessor(Project project, JetChangeInfo changeInfo, String commandName) {
-        super(project, changeInfo);
-        this.commandName = commandName;
-    }
-
-    @NotNull
-    @Override
-    protected UsageViewDescriptor createUsageViewDescriptor(UsageInfo[] usages) {
-        String subject = ChangeSignaturePackage.getKind(getChangeInfo()).getIsConstructor() ? "constructor" : "function";
-        return new JetUsagesViewDescriptor(myChangeInfo.getMethod(), RefactoringBundle.message("0.to.change.signature", subject));
-    }
-
-    @Override
-    public JetChangeInfo getChangeInfo() {
-        return (JetChangeInfo) super.getChangeInfo();
-    }
-
-    @NotNull
-    @Override
-    protected UsageInfo[] findUsages() {
-        List<UsageInfo> allUsages = new ArrayList<UsageInfo>();
-
-        JavaChangeInfo javaChangeInfo = getChangeInfo().getOrCreateJavaChangeInfo();
-        if (javaChangeInfo != null) {
-            UsageInfo[] javaUsages = new JavaChangeSignatureUsageProcessor().findUsages(javaChangeInfo);
-            allUsages.add(new KotlinWrapperForJavaUsageInfos(javaUsages, getChangeInfo().getMethod()));
-        }
-        KotlinPackage.filterIsInstanceTo(super.findUsages(), allUsages, JetUsageInfo.class);
-
-        return allUsages.toArray(new UsageInfo[allUsages.size()]);
-    }
-
-    @Override
-    protected boolean preprocessUsages(Ref<UsageInfo[]> refUsages) {
-        for (ChangeSignatureUsageProcessor processor : ChangeSignatureUsageProcessor.EP_NAME.getExtensions()) {
-            if (!processor.setupDefaultValues(myChangeInfo, refUsages, myProject)) return false;
-        }
-        MultiMap<PsiElement, String> conflictDescriptions = new MultiMap<PsiElement, String>();
-        for (ChangeSignatureUsageProcessor usageProcessor : ChangeSignatureUsageProcessor.EP_NAME.getExtensions()) {
-            MultiMap<PsiElement, String> conflicts = usageProcessor.findConflicts(myChangeInfo, refUsages);
-            for (PsiElement key : conflicts.keySet()) {
-                Collection<String> collection = conflictDescriptions.get(key);
-                if (collection.size() == 0) collection = new HashSet<String>();
-                collection.addAll(conflicts.get(key));
-                conflictDescriptions.put(key, collection);
-            }
-        }
-
-        UsageInfo[] usagesIn = refUsages.get();
-        RenameUtil.addConflictDescriptions(usagesIn, conflictDescriptions);
-        Set<UsageInfo> usagesSet = new HashSet<UsageInfo>(Arrays.asList(usagesIn));
-        RenameUtil.removeConflictUsages(usagesSet);
-        if (!conflictDescriptions.isEmpty()) {
-            if (ApplicationManager.getApplication().isUnitTestMode()) {
-                throw new ConflictsInTestsException(conflictDescriptions.values());
-            }
-            if (myPrepareSuccessfulSwingThreadCallback != null) {
-                ConflictsDialog dialog = prepareConflictsDialog(conflictDescriptions, usagesIn);
-                dialog.show();
-                if (!dialog.isOK()) {
-                    if (dialog.isShowConflicts()) prepareSuccessful();
-                    return false;
-                }
-            }
-        }
-
-        UsageInfo[] array = usagesSet.toArray(new UsageInfo[usagesSet.size()]);
-        Arrays.sort(array, new Comparator<UsageInfo>() {
-            @Override
-            public int compare(@NotNull UsageInfo u1, @NotNull UsageInfo u2) {
-                PsiElement element1 = u1.getElement();
-                PsiElement element2 = u2.getElement();
-                int rank1 = element1 != null ? element1.getTextOffset() : -1;
-                int rank2 = element2 != null ? element2.getTextOffset() : -1;
-                return rank2 - rank1; // Reverse order
-            }
-        });
-        refUsages.set(array);
-        prepareSuccessful();
-        return true;
-    }
-
-    @Override
-    protected boolean isPreviewUsages(UsageInfo[] usages) {
-        return isPreviewUsages();
-    }
-
-    @Override
-    protected String getCommandName() {
-        return commandName;
-    }
-}
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/JetChangeSignatureProcessor.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/JetChangeSignatureProcessor.kt
new file mode 100644
index 00000000000..8e14ed1da06
--- /dev/null
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/JetChangeSignatureProcessor.kt
@@ -0,0 +1,110 @@
+/*
+ * Copyright 2010-2015 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.kotlin.idea.refactoring.changeSignature
+
+import com.intellij.openapi.application.ApplicationManager
+import com.intellij.openapi.project.Project
+import com.intellij.openapi.util.Ref
+import com.intellij.psi.PsiElement
+import com.intellij.refactoring.BaseRefactoringProcessor
+import com.intellij.refactoring.RefactoringBundle
+import com.intellij.refactoring.changeSignature.ChangeSignatureProcessorBase
+import com.intellij.refactoring.changeSignature.ChangeSignatureUsageProcessor
+import com.intellij.refactoring.changeSignature.JavaChangeSignatureUsageProcessor
+import com.intellij.refactoring.rename.RenameUtil
+import com.intellij.refactoring.rename.UnresolvableCollisionUsageInfo
+import com.intellij.usageView.UsageInfo
+import com.intellij.usageView.UsageViewDescriptor
+import com.intellij.util.containers.MultiMap
+import org.jetbrains.kotlin.idea.refactoring.changeSignature.usages.JetUsageInfo
+import org.jetbrains.kotlin.idea.refactoring.changeSignature.usages.KotlinWrapperForJavaUsageInfos
+import java.util.ArrayList
+import java.util.Arrays
+import java.util.LinkedHashSet
+
+public class JetChangeSignatureProcessor(project: Project,
+                                         changeInfo: JetChangeInfo,
+                                         private val commandName: String) : ChangeSignatureProcessorBase(project, changeInfo) {
+    override fun createUsageViewDescriptor(usages: Array<UsageInfo>): UsageViewDescriptor {
+        val subject = if (getChangeInfo().kind.isConstructor) "constructor" else "function"
+        return JetUsagesViewDescriptor(myChangeInfo.getMethod(), RefactoringBundle.message("0.to.change.signature", subject))
+    }
+
+    override fun getChangeInfo() = super.getChangeInfo() as JetChangeInfo
+
+    override fun findUsages(): Array<UsageInfo> {
+        val allUsages = ArrayList<UsageInfo>()
+        getChangeInfo().getOrCreateJavaChangeInfos()?.let { javaChangeInfos ->
+            val javaProcessor = JavaChangeSignatureUsageProcessor()
+            javaChangeInfos.mapTo(allUsages) {
+                KotlinWrapperForJavaUsageInfos(it, javaProcessor.findUsages(it), getChangeInfo().getMethod())
+            }
+        }
+        super.findUsages().filterTo(allUsages) { it is JetUsageInfo<*> || it is UnresolvableCollisionUsageInfo }
+
+        return allUsages.toTypedArray()
+    }
+
+    override fun preprocessUsages(refUsages: Ref<Array<UsageInfo>>): Boolean {
+        val usageProcessors = ChangeSignatureUsageProcessor.EP_NAME.getExtensions()
+
+        if (!usageProcessors.all { it.setupDefaultValues(myChangeInfo, refUsages, myProject) }) return false
+
+        val conflictDescriptions = object: MultiMap<PsiElement, String>() {
+            override fun createCollection() = LinkedHashSet<String>()
+        }
+        usageProcessors.forEach { conflictDescriptions.putAllValues(it.findConflicts(myChangeInfo, refUsages)) }
+
+        val usages = refUsages.get()
+        val usagesSet = usages.toHashSet()
+
+        RenameUtil.addConflictDescriptions(usages, conflictDescriptions)
+        RenameUtil.removeConflictUsages(usagesSet)
+        if (!conflictDescriptions.isEmpty()) {
+            if (ApplicationManager.getApplication().isUnitTestMode()) {
+                throw BaseRefactoringProcessor.ConflictsInTestsException(conflictDescriptions.values())
+            }
+
+            myPrepareSuccessfulSwingThreadCallback?.let {
+                val dialog = prepareConflictsDialog(conflictDescriptions, usages)
+                dialog.show()
+                if (!dialog.isOK()) {
+                    if (dialog.isShowConflicts()) prepareSuccessful()
+                    return false
+                }
+            }
+        }
+
+        val usageArray = usagesSet.toTypedArray()
+        Arrays.sort(usageArray) { u1, u2 ->
+            val element1 = u1.getElement()
+            val element2 = u2.getElement()
+            val rank1 = if (element1 != null) element1.getTextOffset() else -1
+            val rank2 = if (element2 != null) element2.getTextOffset() else -1
+            rank2 - rank1 // Reverse order
+        }
+        refUsages.set(usageArray)
+
+        prepareSuccessful()
+
+        return true
+    }
+
+    override fun isPreviewUsages(usages: Array<out UsageInfo>): Boolean = isPreviewUsages()
+
+    override fun getCommandName() = commandName
+}
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/JetChangeSignatureUsageProcessor.java b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/JetChangeSignatureUsageProcessor.java
index c80ab2dd743..f16e7f26062 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/JetChangeSignatureUsageProcessor.java
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/JetChangeSignatureUsageProcessor.java
@@ -21,16 +21,14 @@ import com.intellij.openapi.project.Project;
 import com.intellij.openapi.util.Ref;
 import com.intellij.psi.*;
 import com.intellij.psi.codeStyle.JavaCodeStyleManager;
-import com.intellij.psi.search.searches.OverridingMethodsSearch;
 import com.intellij.psi.search.GlobalSearchScope;
 import com.intellij.psi.search.SearchScope;
+import com.intellij.psi.search.searches.OverridingMethodsSearch;
 import com.intellij.psi.search.searches.ReferencesSearch;
 import com.intellij.psi.util.PsiTreeUtil;
-import com.intellij.refactoring.changeSignature.ChangeInfo;
-import com.intellij.refactoring.changeSignature.ChangeSignatureUsageProcessor;
-import com.intellij.refactoring.changeSignature.JavaChangeInfo;
-import com.intellij.refactoring.changeSignature.OverriderUsageInfo;
+import com.intellij.refactoring.changeSignature.*;
 import com.intellij.refactoring.rename.ResolveSnapshotProvider;
+import com.intellij.refactoring.rename.UnresolvableCollisionUsageInfo;
 import com.intellij.refactoring.util.CommonRefactoringUtil;
 import com.intellij.refactoring.util.MoveRenameUsageInfo;
 import com.intellij.refactoring.util.RefactoringUIUtil;
@@ -56,11 +54,14 @@ import org.jetbrains.kotlin.idea.codeInsight.JetFileReferencesResolver;
 import org.jetbrains.kotlin.idea.core.refactoring.RefactoringPackage;
 import org.jetbrains.kotlin.idea.refactoring.changeSignature.usages.*;
 import org.jetbrains.kotlin.idea.references.JetSimpleNameReference;
+import org.jetbrains.kotlin.idea.references.ReferencesPackage;
 import org.jetbrains.kotlin.idea.search.usagesSearch.UsagesSearchPackage;
+import org.jetbrains.kotlin.idea.util.IdeDescriptorRenderers;
 import org.jetbrains.kotlin.kdoc.psi.impl.KDocName;
 import org.jetbrains.kotlin.load.java.descriptors.JavaClassDescriptor;
 import org.jetbrains.kotlin.name.Name;
 import org.jetbrains.kotlin.psi.*;
+import org.jetbrains.kotlin.psi.psiUtil.PsiUtilPackage;
 import org.jetbrains.kotlin.psi.typeRefHelpers.TypeRefHelpersPackage;
 import org.jetbrains.kotlin.renderer.DescriptorRenderer;
 import org.jetbrains.kotlin.resolve.BindingContext;
@@ -78,14 +79,13 @@ import org.jetbrains.kotlin.resolve.scopes.receivers.ThisReceiver;
 import org.jetbrains.kotlin.types.JetType;
 import org.jetbrains.kotlin.types.TypeUtils;
 
-import java.util.Collections;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
+import java.util.*;
 
 public class JetChangeSignatureUsageProcessor implements ChangeSignatureUsageProcessor {
     @Override
     public UsageInfo[] findUsages(ChangeInfo info) {
+        originalJavaMethodDescriptor = null;
+
         Set<UsageInfo> result = new HashSet<UsageInfo>();
 
         if (info instanceof JetChangeInfo) {
@@ -95,19 +95,29 @@ public class JetChangeSignatureUsageProcessor implements ChangeSignatureUsagePro
             findSAMUsages(info, result);
             findConstructorDelegationUsages(info, result);
             findKotlinOverrides(info, result);
+            if (info instanceof JavaChangeInfo) {
+                findKotlinCallers((JavaChangeInfo) info, result);
+            }
         }
 
         return result.toArray(new UsageInfo[result.size()]);
     }
 
     private static void findAllMethodUsages(JetChangeInfo changeInfo, Set<UsageInfo> result) {
-        for (UsageInfo functionUsageInfo : ChangeSignaturePackage.getAffectedFunctions(changeInfo)) {
-            if (functionUsageInfo instanceof JetFunctionDefinitionUsage) {
-                findOneMethodUsages((JetFunctionDefinitionUsage) functionUsageInfo, changeInfo, result);
+        for (UsageInfo functionUsageInfo : ChangeSignaturePackage.getAffectedCallables(changeInfo)) {
+            if (functionUsageInfo instanceof JetCallableDefinitionUsage) {
+                findOneMethodUsages((JetCallableDefinitionUsage) functionUsageInfo, changeInfo, result);
+            }
+            else if (functionUsageInfo instanceof KotlinCallerUsage) {
+                findCallerUsages((KotlinCallerUsage) functionUsageInfo, changeInfo, result);
             }
             else {
                 result.add(functionUsageInfo);
 
+                boolean propagationTarget = functionUsageInfo instanceof CallerUsageInfo
+                                            || (functionUsageInfo instanceof OverriderUsageInfo
+                                                && !((OverriderUsageInfo) functionUsageInfo).isOriginalOverrider());
+
                 PsiElement callee = functionUsageInfo.getElement();
                 if (callee == null) continue;
 
@@ -121,15 +131,91 @@ public class JetChangeSignatureUsageProcessor implements ChangeSignatureUsagePro
                     JetCallElement callElement = PsiTreeUtil.getParentOfType(element, JetCallElement.class);
                     JetExpression calleeExpression = callElement != null ? callElement.getCalleeExpression() : null;
                     if (calleeExpression != null && PsiTreeUtil.isAncestor(calleeExpression, element, false)) {
-                        result.add(new JetFunctionCallUsage(callElement, changeInfo.getMethodDescriptor().getOriginalPrimaryFunction()));
+                        result.add(propagationTarget
+                                   ? new KotlinCallerCallUsage(callElement)
+                                   : new JetFunctionCallUsage(callElement, changeInfo.getMethodDescriptor().getOriginalPrimaryCallable()));
                     }
                 }
             }
         }
     }
 
+    private static void findCallerUsages(KotlinCallerUsage callerUsage, JetChangeInfo changeInfo, final Set<UsageInfo> result) {
+        result.add(callerUsage);
+
+        JetNamedDeclaration element = callerUsage.getElement();
+        if (element == null) return;
+
+        for (PsiReference ref : ReferencesSearch.search(element, element.getUseScope())) {
+            PsiElement refElement = ref.getElement();
+            JetCallElement callElement = PsiTreeUtil.getParentOfType(refElement, JetCallElement.class);
+            if (callElement != null && PsiTreeUtil.isAncestor(callElement.getCalleeExpression(), refElement, false)) {
+                result.add(new KotlinCallerCallUsage(callElement));
+            }
+        }
+
+        JetElement body = ChangeSignaturePackage.getDeclarationBody(element);
+        final Set<String> newParameterNames = KotlinPackage.mapTo(
+                changeInfo.getNonReceiverParameters(),
+                new HashSet<String>(),
+                new Function1<JetParameterInfo, String>() {
+                    @Override
+                    public String invoke(JetParameterInfo info) {
+                        return info.getName();
+                    }
+                }
+        );
+        if (body != null) {
+            final DeclarationDescriptor callerDescriptor = ResolvePackage.resolveToDescriptor(element);
+            final BindingContext context = ResolvePackage.analyze(body);
+            body.accept(
+                    new JetTreeVisitorVoid() {
+                        @Override
+                        public void visitSimpleNameExpression(@NotNull JetSimpleNameExpression expression) {
+                            final String currentName = expression.getReferencedName();
+                            if (!newParameterNames.contains(currentName)) return;
+
+                            ResolvedCall<? extends CallableDescriptor> resolvedCall = CallUtilPackage.getResolvedCall(expression, context);
+                            if (resolvedCall == null) return;
+
+                            if (resolvedCall.getExplicitReceiverKind() != ExplicitReceiverKind.NO_EXPLICIT_RECEIVER) return;
+
+                            CallableDescriptor resultingDescriptor = resolvedCall.getResultingDescriptor();
+                            if (!(resultingDescriptor instanceof VariableDescriptor)) return;
+
+                            // Do not report usages of duplicated parameter
+                            if (resultingDescriptor instanceof ValueParameterDescriptor
+                                && resultingDescriptor.getContainingDeclaration() == callerDescriptor) return;
+
+                            JetElement callElement = resolvedCall.getCall().getCallElement();
+
+                            ReceiverValue receiver = resolvedCall.getExtensionReceiver();
+                            if (!(receiver instanceof ThisReceiver)) {
+                                receiver = resolvedCall.getDispatchReceiver();
+                            }
+                            if (receiver instanceof ThisReceiver) {
+                                result.add(new JetImplicitThisUsage(callElement, ((ThisReceiver) receiver).getDeclarationDescriptor()));
+                            }
+                            else if (!receiver.exists()) {
+                                result.add(
+                                        new UnresolvableCollisionUsageInfo(callElement, null) {
+                                            @Override
+                                            public String getDescription() {
+                                                return "There is already a variable '" + currentName + "' in " +
+                                                       IdeDescriptorRenderers.SOURCE_CODE_SHORT_NAMES_IN_TYPES.render(callerDescriptor) +
+                                                       ". It will conflict with the new parameter.";
+                                            }
+                                        }
+                                );
+                            }
+                        }
+                    }
+            );
+        }
+    }
+
     private static void findOneMethodUsages(
-            @NotNull JetFunctionDefinitionUsage<?> functionUsageInfo,
+            @NotNull JetCallableDefinitionUsage<?> functionUsageInfo,
             final JetChangeInfo changeInfo,
             final Set<UsageInfo> result
     ) {
@@ -158,6 +244,10 @@ public class JetChangeSignatureUsageProcessor implements ChangeSignatureUsagePro
                     if (parent instanceof JetConstructorCalleeExpression && parent.getParent() instanceof JetDelegatorToSuperCall)
                         result.add(new JetFunctionCallUsage((JetDelegatorToSuperCall)parent.getParent(), functionUsageInfo));
                 }
+                else if (element instanceof JetSimpleNameExpression
+                         && (functionPsi instanceof JetProperty || functionPsi instanceof JetParameter)) {
+                    result.add(new JetPropertyCallUsage((JetSimpleNameExpression) element));
+                }
             }
         }
 
@@ -166,9 +256,7 @@ public class JetChangeSignatureUsageProcessor implements ChangeSignatureUsagePro
         if (oldName != null)
             TextOccurrencesUtil.findNonCodeUsages(functionPsi, oldName, true, true, changeInfo.getNewName(), result);
 
-        List<JetParameter> oldParameters = functionPsi instanceof JetFunction
-                                        ? ((JetFunction) functionPsi).getValueParameters()
-                                        : ((JetClass) functionPsi).getPrimaryConstructorParameters();
+        List<JetParameter> oldParameters = PsiUtilPackage.getValueParameters((JetNamedDeclaration) functionPsi);
 
         JetParameterInfo newReceiverInfo = changeInfo.getReceiverParameterInfo();
 
@@ -219,7 +307,7 @@ public class JetChangeSignatureUsageProcessor implements ChangeSignatureUsagePro
     }
 
     private static void processInternalReferences(
-            JetFunctionDefinitionUsage functionUsageInfo,
+            JetCallableDefinitionUsage functionUsageInfo,
             JetTreeVisitor<BindingContext> visitor
     ) {
         JetFunction jetFunction = (JetFunction) functionUsageInfo.getDeclaration();
@@ -236,12 +324,12 @@ public class JetChangeSignatureUsageProcessor implements ChangeSignatureUsagePro
     }
 
     private static void findOriginalReceiversUsages(
-            @NotNull final JetFunctionDefinitionUsage<?> functionUsageInfo,
+            @NotNull final JetCallableDefinitionUsage<?> functionUsageInfo,
             @NotNull final Set<UsageInfo> result,
             @NotNull final JetChangeInfo changeInfo
     ) {
         final JetParameterInfo originalReceiverInfo = changeInfo.getMethodDescriptor().getReceiver();
-        final FunctionDescriptor functionDescriptor = functionUsageInfo.getOriginalFunctionDescriptor();
+        final CallableDescriptor callableDescriptor = functionUsageInfo.getOriginalCallableDescriptor();
         processInternalReferences(
                 functionUsageInfo,
                 new JetTreeVisitor<BindingContext>() {
@@ -252,7 +340,7 @@ public class JetChangeSignatureUsageProcessor implements ChangeSignatureUsagePro
                         if (originalReceiverInfo != null && !changeInfo.hasParameter(originalReceiverInfo)) return;
                         if (!(expression.getParent() instanceof JetThisExpression)) return;
 
-                        if (receiverDescriptor == functionDescriptor.getExtensionReceiverParameter()) {
+                        if (receiverDescriptor == callableDescriptor.getExtensionReceiverParameter()) {
                             assert originalReceiverInfo != null : "No original receiver info provided: " + functionUsageInfo.getDeclaration().getText();
                             result.add(new JetParameterUsage(expression, originalReceiverInfo, functionUsageInfo));
                         }
@@ -268,12 +356,12 @@ public class JetChangeSignatureUsageProcessor implements ChangeSignatureUsagePro
                             @NotNull ThisReceiver receiverValue
                     ) {
                         DeclarationDescriptor targetDescriptor = receiverValue.getDeclarationDescriptor();
-                        if (targetDescriptor == functionDescriptor) {
+                        if (targetDescriptor == callableDescriptor) {
                             assert originalReceiverInfo != null : "No original receiver info provided: " + functionUsageInfo.getDeclaration().getText();
                             result.add(new JetImplicitThisToParameterUsage(callElement, originalReceiverInfo, functionUsageInfo));
                         }
                         else {
-                            result.add(new JetImplicitOuterThisToQualifiedThisUsage(callElement, targetDescriptor));
+                            result.add(new JetImplicitThisUsage(callElement, targetDescriptor));
                         }
                     }
 
@@ -307,6 +395,7 @@ public class JetChangeSignatureUsageProcessor implements ChangeSignatureUsagePro
         if (!RefactoringPackage.isTrueJavaMethod(method)) return;
 
         FunctionDescriptor methodDescriptor = ResolvePackage.getJavaMethodDescriptor((PsiMethod) method);
+        assert methodDescriptor != null;
 
         DeclarationDescriptor containingDescriptor = methodDescriptor.getContainingDeclaration();
         if (!(containingDescriptor instanceof JavaClassDescriptor)) return;
@@ -374,6 +463,76 @@ public class JetChangeSignatureUsageProcessor implements ChangeSignatureUsagePro
             FunctionDescriptor functionDescriptor = (FunctionDescriptor) ResolvePackage.resolveToDescriptor(function);
 
             result.add(new DeferredJavaMethodOverrideOrSAMUsage(function, functionDescriptor, null));
+
+            findDeferredUsagesOfParameters(changeInfo, result, function, functionDescriptor);
+        }
+    }
+
+    private static void findKotlinCallers(JavaChangeInfo changeInfo, Set<UsageInfo> result) {
+        PsiElement method = changeInfo.getMethod();
+        if (!RefactoringPackage.isTrueJavaMethod(method)) return;
+
+        for (PsiMethod primaryCaller : changeInfo.getMethodsToPropagateParameters()) {
+            addDeferredCallerIfPossible(result, primaryCaller);
+            for (PsiMethod overridingCaller : OverridingMethodsSearch.search(primaryCaller)) {
+                addDeferredCallerIfPossible(result, overridingCaller);
+            }
+        }
+    }
+
+    private static void addDeferredCallerIfPossible(Set<UsageInfo> result, PsiMethod overridingCaller) {
+        PsiElement unwrappedElement = AsJavaPackage.getNamedUnwrappedElement(overridingCaller);
+        if (unwrappedElement instanceof JetFunction || unwrappedElement instanceof JetClass) {
+            result.add(new DeferredJavaMethodKotlinCallerUsage((JetNamedDeclaration) unwrappedElement));
+        }
+    }
+
+    private static void findDeferredUsagesOfParameters(
+            ChangeInfo changeInfo,
+            Set<UsageInfo> result,
+            JetNamedFunction function,
+            FunctionDescriptor functionDescriptor
+    ) {
+        final JetCallableDefinitionUsage<?> functionInfoForParameters =
+                new JetCallableDefinitionUsage<PsiElement>(function, functionDescriptor, null, null);
+        List<JetParameter> oldParameters = PsiUtilPackage.getValueParameters(function);
+        ParameterInfo[] parameters = changeInfo.getNewParameters();
+        for (int i = 0; i < parameters.length; i++) {
+            final int paramIndex = i;
+            ParameterInfo parameterInfo = parameters[paramIndex];
+            if (parameterInfo.getOldIndex() >= 0 && parameterInfo.getOldIndex() < oldParameters.size()) {
+                JetParameter oldParam = oldParameters.get(parameterInfo.getOldIndex());
+                String oldParamName = oldParam.getName();
+
+                if (oldParamName != null && !oldParamName.equals(parameterInfo.getName())) {
+                    for (PsiReference reference : ReferencesSearch.search(oldParam, oldParam.getUseScope())) {
+                        final PsiElement element = reference.getElement();
+
+                        if ((element instanceof JetSimpleNameExpression || element instanceof KDocName) &&
+                            !(element.getParent() instanceof JetValueArgumentName)) // Usages in named arguments of the calls usage will be changed when the function call is changed
+                        {
+                            result.add(
+                                    new JavaMethodDeferredKotlinUsage<JetElement>((JetElement) element) {
+                                        @NotNull
+                                        @Override
+                                        public JavaMethodKotlinUsageWithDelegate<JetElement> resolve(@NotNull JetChangeInfo javaMethodChangeInfo) {
+                                            return new JavaMethodKotlinUsageWithDelegate<JetElement>((JetElement) element,
+                                                                                                     javaMethodChangeInfo) {
+                                                @NotNull
+                                                @Override
+                                                public JetUsageInfo<JetElement> getDelegateUsage() {
+                                                    return new JetParameterUsage((JetElement) element,
+                                                                                 getJavaMethodChangeInfo().getNewParameters()[paramIndex],
+                                                                                 functionInfoForParameters);
+                                                }
+                                            };
+                                        }
+                                    }
+                            );
+                        }
+                    }
+                }
+            }
         }
     }
 
@@ -381,16 +540,30 @@ public class JetChangeSignatureUsageProcessor implements ChangeSignatureUsagePro
     public MultiMap<PsiElement, String> findConflicts(ChangeInfo info, Ref<UsageInfo[]> refUsages) {
         MultiMap<PsiElement, String> result = new MultiMap<PsiElement, String>();
 
-        if (!(info instanceof JetChangeInfo)) {
-            return result;
+        // Delete OverriderUsageInfo and CallerUsageInfo for Kotlin declarations since they can't be processed correctly
+        // TODO (OverriderUsageInfo only): Drop when OverriderUsageInfo.getElement() gets deleted
+        UsageInfo[] usageInfos = refUsages.get();
+        List<UsageInfo> adjustedUsages = KotlinPackage.filterNot(
+                usageInfos,
+                new Function1<UsageInfo, Boolean>() {
+                    @Override
+                    public Boolean invoke(UsageInfo info) {
+                        return getOverriderOrCaller(info) instanceof KotlinLightMethod;
+                    }
+                }
+        );
+        if (adjustedUsages.size() < usageInfos.length) {
+            refUsages.set(adjustedUsages.toArray(new UsageInfo[adjustedUsages.size()]));
         }
 
+        if (!(info instanceof JetChangeInfo)) return result;
+
         Set<String> parameterNames = new HashSet<String>();
         JetChangeInfo changeInfo = (JetChangeInfo) info;
         PsiElement function = info.getMethod();
         PsiElement element = function != null ? function : changeInfo.getContext();
         BindingContext bindingContext = ResolvePackage.analyze((JetElement) element, BodyResolveMode.FULL);
-        FunctionDescriptor oldDescriptor = ChangeSignaturePackage.getOriginalBaseFunctionDescriptor(changeInfo);
+        CallableDescriptor oldDescriptor = ChangeSignaturePackage.getOriginalBaseFunctionDescriptor(changeInfo);
         DeclarationDescriptor containingDeclaration = oldDescriptor.getContainingDeclaration();
 
         JetScope parametersScope = null;
@@ -399,17 +572,21 @@ public class JetChangeSignatureUsageProcessor implements ChangeSignatureUsagePro
         else if (function instanceof JetFunction)
             parametersScope = org.jetbrains.kotlin.idea.refactoring.RefactoringPackage.getBodyScope((JetFunction) function, bindingContext);
 
-        JetScope functionScope = org.jetbrains.kotlin.idea.refactoring.RefactoringPackage.getContainingScope(oldDescriptor, bindingContext);
+        JetScope callableScope = org.jetbrains.kotlin.idea.refactoring.RefactoringPackage.getContainingScope(oldDescriptor, bindingContext);
 
         JetMethodDescriptor.Kind kind = ChangeSignaturePackage.getKind(changeInfo);
-        if (!kind.getIsConstructor() && functionScope != null && !info.getNewName().isEmpty()) {
-            for (FunctionDescriptor conflict : functionScope.getFunctions(Name.identifier(info.getNewName()))) {
+        if (!kind.getIsConstructor() && callableScope != null && !info.getNewName().isEmpty()) {
+            Name newName = Name.identifier(info.getNewName());
+            Collection<? extends CallableDescriptor> conflicts = oldDescriptor instanceof FunctionDescriptor
+                                                                 ? callableScope.getFunctions(newName)
+                                                                 : callableScope.getProperties(newName);
+            for (CallableDescriptor conflict : conflicts) {
                 if (conflict == oldDescriptor) continue;
 
                 PsiElement conflictElement = DescriptorToSourceUtils.descriptorToDeclaration(conflict);
                 if (conflictElement == changeInfo.getMethod()) continue;
 
-                if (getFunctionParameterTypes(conflict).equals(getFunctionParameterTypes(oldDescriptor))) {
+                if (getCallableParameterTypes(conflict).equals(getCallableParameterTypes(oldDescriptor))) {
                     result.putValue(conflictElement, "Function already exists: '" + DescriptorRenderer.SHORT_NAMES_IN_TYPES.render(conflict) + "'");
                     break;
                 }
@@ -447,15 +624,53 @@ public class JetChangeSignatureUsageProcessor implements ChangeSignatureUsagePro
 
         JetParameterInfo newReceiverInfo = changeInfo.getReceiverParameterInfo();
         JetParameterInfo originalReceiverInfo = changeInfo.getMethodDescriptor().getReceiver();
-        if (function instanceof JetNamedFunction && newReceiverInfo != originalReceiverInfo) {
+        if (function instanceof JetCallableDeclaration && newReceiverInfo != originalReceiverInfo) {
             findReceiverIntroducingConflicts(result, function, newReceiverInfo);
             findInternalExplicitReceiverConflicts(refUsages.get(), result, originalReceiverInfo);
             findThisLabelConflicts((JetChangeInfo) info, refUsages, result, changeInfo, function);
         }
 
+        for (UsageInfo usageInfo : usageInfos) {
+            if (!(usageInfo instanceof KotlinCallerUsage)) continue;
+
+            JetNamedDeclaration caller = (JetNamedDeclaration) usageInfo.getElement();
+            DeclarationDescriptor callerDescriptor = ResolvePackage.resolveToDescriptor(caller);
+
+            findParameterDuplicationInCaller(result, changeInfo, caller, callerDescriptor);
+        }
+
         return result;
     }
 
+    private static void findParameterDuplicationInCaller(
+            MultiMap<PsiElement, String> result,
+            JetChangeInfo changeInfo,
+            JetNamedDeclaration caller,
+            DeclarationDescriptor callerDescriptor
+    ) {
+        List<JetParameter> valueParameters = PsiUtilPackage.getValueParameters(caller);
+        Map<String, JetParameter> existingParameters = KotlinPackage.toMap(
+                valueParameters,
+                new Function1<JetParameter, String>() {
+                    @Override
+                    public String invoke(JetParameter parameter) {
+                        return parameter.getName();
+                    }
+                }
+        );
+        for (JetParameterInfo parameterInfo : changeInfo.getNonReceiverParameters()) {
+            if (!(parameterInfo.getIsNewParameter())) continue;
+
+            String name = parameterInfo.getName();
+            JetParameter parameter = existingParameters.get(name);
+            if (parameter != null) {
+                result.putValue(parameter, "There is already a parameter '" + name + "' in " +
+                                           IdeDescriptorRenderers.SOURCE_CODE_SHORT_NAMES_IN_TYPES.render(callerDescriptor) +
+                                           ". It will conflict with the new parameter.");
+            }
+        }
+    }
+
     private static void findThisLabelConflicts(
             JetChangeInfo info,
             Ref<UsageInfo[]> refUsages,
@@ -508,10 +723,9 @@ public class JetChangeSignatureUsageProcessor implements ChangeSignatureUsagePro
     ) {
         if (originalReceiverInfo == null) {
             for (UsageInfo usageInfo : usages) {
-                if (!(usageInfo instanceof JetFunctionCallUsage)) continue;
+                if (!(usageInfo instanceof JetFunctionCallUsage || usageInfo instanceof JetPropertyCallUsage)) continue;
 
-                JetFunctionCallUsage callUsage = (JetFunctionCallUsage) usageInfo;
-                JetElement callElement = callUsage.getElement();
+                JetElement callElement = (JetElement) usageInfo.getElement();
                 if (callElement == null) continue;
 
                 PsiElement parent = callElement.getParent();
@@ -529,7 +743,7 @@ public class JetChangeSignatureUsageProcessor implements ChangeSignatureUsagePro
             PsiElement callable,
             JetParameterInfo newReceiverInfo
     ) {
-        if (newReceiverInfo != null && ((JetNamedFunction) callable).getBodyExpression() != null) {
+        if (newReceiverInfo != null && (callable instanceof JetNamedFunction) && ((JetNamedFunction) callable).getBodyExpression() != null) {
             Map<JetReferenceExpression, BindingContext> noReceiverRefToContext = KotlinPackage.filter(
                     JetFileReferencesResolver.INSTANCE$.resolve((JetNamedFunction) callable, true, true),
                     new Function1<Map.Entry<? extends JetReferenceExpression, ? extends BindingContext>, Boolean>() {
@@ -589,7 +803,7 @@ public class JetChangeSignatureUsageProcessor implements ChangeSignatureUsagePro
         }
     }
 
-    private static List<JetType> getFunctionParameterTypes(FunctionDescriptor descriptor) {
+    private static List<JetType> getCallableParameterTypes(CallableDescriptor descriptor) {
         return ContainerUtil.map(descriptor.getValueParameters(), new Function<ValueParameterDescriptor, JetType>() {
             @Override
             public JetType fun(ValueParameterDescriptor descriptor) {
@@ -601,21 +815,24 @@ public class JetChangeSignatureUsageProcessor implements ChangeSignatureUsagePro
     private JetMethodDescriptor originalJavaMethodDescriptor;
 
     private static boolean isJavaMethodUsage(UsageInfo usageInfo) {
-        if (usageInfo instanceof JavaMethodDeferredKotlinUsage) return true;
-
         // MoveRenameUsageInfo corresponds to non-Java usage of Java method
-        return usageInfo instanceof MoveRenameUsageInfo
-               && RefactoringPackage.isTrueJavaMethod(((MoveRenameUsageInfo) usageInfo).getReferencedElement());
+        return usageInfo instanceof JavaMethodDeferredKotlinUsage || usageInfo instanceof MoveRenameUsageInfo;
     }
 
     @Nullable
-    private static UsageInfo createReplacementUsage(UsageInfo originalUsageInfo, JetChangeInfo javaMethodChangeInfo) {
+    private static UsageInfo createReplacementUsage(UsageInfo originalUsageInfo, JetChangeInfo javaMethodChangeInfo, UsageInfo[] allUsages) {
         if (originalUsageInfo instanceof JavaMethodDeferredKotlinUsage) {
             return ((JavaMethodDeferredKotlinUsage<?>) originalUsageInfo).resolve(javaMethodChangeInfo);
         }
 
         JetCallElement callElement = PsiTreeUtil.getParentOfType(originalUsageInfo.getElement(), JetCallElement.class);
-        return callElement != null ? new JavaMethodKotlinCallUsage(callElement, javaMethodChangeInfo) : null;
+        if (callElement == null) return null;
+
+        PsiReference ref = originalUsageInfo.getReference();
+        PsiElement refTarget = ref != null ? ref.resolve() : null;
+        return new JavaMethodKotlinCallUsage(callElement,
+                                             javaMethodChangeInfo,
+                                             refTarget != null && ChangeSignaturePackage.isCaller(refTarget, allUsages));
     }
 
     private static class NullabilityPropagator {
@@ -687,44 +904,86 @@ public class JetChangeSignatureUsageProcessor implements ChangeSignatureUsagePro
         }
     }
 
+    private static boolean isOverriderOrCaller(UsageInfo usage) {
+        return usage instanceof OverriderUsageInfo || usage instanceof CallerUsageInfo;
+    }
+
+    @Nullable
+    private static PsiMethod getOverriderOrCaller(UsageInfo usage) {
+        if (usage instanceof OverriderUsageInfo) return ((OverriderUsageInfo) usage).getOverridingMethod();
+        if (usage instanceof CallerUsageInfo) {
+            PsiElement element = usage.getElement();
+            return element instanceof PsiMethod ? (PsiMethod) element : null;
+        }
+        return null;
+    }
+
     @Override
     public boolean processUsage(ChangeInfo changeInfo, UsageInfo usageInfo, boolean beforeMethodChange, UsageInfo[] usages) {
         PsiElement method = changeInfo.getMethod();
         boolean isJavaMethodUsage = isJavaMethodUsage(usageInfo);
 
         if (usageInfo instanceof KotlinWrapperForJavaUsageInfos) {
-            JavaChangeInfo javaChangeInfo = ((JetChangeInfo) changeInfo).getOrCreateJavaChangeInfo();
-            assert javaChangeInfo != null : "JavaChangeInfo not found: " + method.getText();
-            UsageInfo[] javaUsageInfos = ((KotlinWrapperForJavaUsageInfos) usageInfo).getJavaUsageInfos();
+            List<JavaChangeInfo> javaChangeInfos = ((JetChangeInfo) changeInfo).getOrCreateJavaChangeInfos();
+            assert javaChangeInfos != null : "JavaChangeInfo not found: " + method.getText();
+
+            KotlinWrapperForJavaUsageInfos wrapperForJavaUsageInfos = (KotlinWrapperForJavaUsageInfos) usageInfo;
+            UsageInfo[] javaUsageInfos = wrapperForJavaUsageInfos.getJavaUsageInfos();
             ChangeSignatureUsageProcessor[] processors = ChangeSignatureUsageProcessor.EP_NAME.getExtensions();
 
-            NullabilityPropagator nullabilityPropagator = new NullabilityPropagator(javaChangeInfo.getMethod());
+            for (JavaChangeInfo javaChangeInfo : javaChangeInfos) {
+                // Match names so that getter/setter usages are not confused with each other
+                if (!javaChangeInfo.getOldName().equals(wrapperForJavaUsageInfos.getJavaChangeInfo().getOldName())) continue;
 
-            for (UsageInfo usage : javaUsageInfos) {
-                if (usage instanceof OverriderUsageInfo && beforeMethodChange) continue;
-                for (ChangeSignatureUsageProcessor processor : processors) {
-                    if (processor instanceof JetChangeSignatureUsageProcessor) continue;
-                    if (usage instanceof OverriderUsageInfo) {
-                        processor.processUsage(javaChangeInfo, usage, true, javaUsageInfos);
+                NullabilityPropagator nullabilityPropagator = new NullabilityPropagator(javaChangeInfo.getMethod());
+
+                for (UsageInfo usage : javaUsageInfos) {
+                    if (isOverriderOrCaller(usage) && beforeMethodChange) continue;
+                    for (ChangeSignatureUsageProcessor processor : processors) {
+                        if (processor instanceof JetChangeSignatureUsageProcessor) continue;
+                        if (isOverriderOrCaller(usage)) {
+                            processor.processUsage(javaChangeInfo, usage, true, javaUsageInfos);
+                        }
+                        if (processor.processUsage(javaChangeInfo, usage, beforeMethodChange, javaUsageInfos)) break;
                     }
-                    if (processor.processUsage(javaChangeInfo, usage, beforeMethodChange, javaUsageInfos)) break;
-                }
-                if (usage instanceof OverriderUsageInfo) {
-                    PsiMethod overridingMethod = ((OverriderUsageInfo)usage).getOverridingMethod();
-                    if (overridingMethod != null && !(overridingMethod instanceof KotlinLightMethod)) {
-                        nullabilityPropagator.processMethod(overridingMethod);
+                    if (usage instanceof OverriderUsageInfo && ((OverriderUsageInfo) usage).isOriginalOverrider()) {
+                        PsiMethod overridingMethod = ((OverriderUsageInfo) usage).getOverridingMethod();
+                        if (overridingMethod != null && !(overridingMethod instanceof KotlinLightMethod)) {
+                            nullabilityPropagator.processMethod(overridingMethod);
+                        }
                     }
                 }
             }
         }
 
         if (beforeMethodChange) {
-            if (isJavaMethodUsage) {
+            boolean startedFromJava = method instanceof PsiMethod;
+            if (startedFromJava && originalJavaMethodDescriptor == null) {
                 FunctionDescriptor methodDescriptor = ResolvePackage.getJavaMethodDescriptor((PsiMethod) method);
-                JetChangeSignatureData changeSignatureData =
-                        new JetChangeSignatureData(methodDescriptor, method, Collections.singletonList(methodDescriptor));
-                if (changeSignatureData != originalJavaMethodDescriptor) {
-                    originalJavaMethodDescriptor = changeSignatureData;
+                assert methodDescriptor != null;
+                originalJavaMethodDescriptor =
+                        new JetChangeSignatureData(methodDescriptor, method, Collections.singletonList(methodDescriptor));;
+
+                // This change info is used as a placeholder before primary method update
+                // It gets replaced with real change info afterwards
+                JetChangeInfo dummyChangeInfo =
+                        new JetChangeInfo(originalJavaMethodDescriptor,
+                                          "",
+                                          null,
+                                          "",
+                                          Visibilities.INTERNAL,
+                                          Collections.<JetParameterInfo>emptyList(),
+                                          null,
+                                          changeInfo.getMethod(),
+                                          Collections.<PsiElement>emptyList());
+                for (int i = 0; i < usages.length; i++) {
+                    UsageInfo oldUsageInfo = usages[i];
+                    if (!isJavaMethodUsage(oldUsageInfo)) continue;
+
+                    UsageInfo newUsageInfo = createReplacementUsage(oldUsageInfo, dummyChangeInfo, usages);
+                    if (newUsageInfo != null) {
+                        usages[i] = newUsageInfo;
+                    }
                 }
             }
 
@@ -734,31 +993,24 @@ public class JetChangeSignatureUsageProcessor implements ChangeSignatureUsagePro
         PsiElement element = usageInfo.getElement();
         if (element == null) return false;
 
-        if (isJavaMethodUsage && originalJavaMethodDescriptor != null) {
+        if (originalJavaMethodDescriptor != null) {
             JetChangeInfo javaMethodChangeInfo = ChangeSignaturePackage.toJetChangeInfo(changeInfo, originalJavaMethodDescriptor);
             originalJavaMethodDescriptor = null;
 
-            for (int i = 0; i < usages.length; i++) {
-                UsageInfo oldUsageInfo = usages[i];
-                if (!isJavaMethodUsage(oldUsageInfo)) continue;
-
-                UsageInfo newUsageInfo = createReplacementUsage(oldUsageInfo, javaMethodChangeInfo);
-                if (newUsageInfo != null) {
-                    usages[i] = newUsageInfo;
-                    if (oldUsageInfo == usageInfo) {
-                        usageInfo = newUsageInfo;
-                    }
+            for (UsageInfo info : usages) {
+                if (info instanceof JavaMethodKotlinUsageWithDelegate) {
+                    ((JavaMethodKotlinUsageWithDelegate) info).setJavaMethodChangeInfo(javaMethodChangeInfo);
                 }
             }
         }
 
         if (usageInfo instanceof JavaMethodKotlinUsageWithDelegate) {
-            return ((JavaMethodKotlinUsageWithDelegate) usageInfo).processUsage();
+            return ((JavaMethodKotlinUsageWithDelegate) usageInfo).processUsage(usages);
         }
 
         if (usageInfo instanceof MoveRenameUsageInfo && isJavaMethodUsage) {
             JetSimpleNameExpression callee = PsiTreeUtil.getParentOfType(usageInfo.getElement(), JetSimpleNameExpression.class, false);
-            PsiReference ref = callee != null ? callee.getReference() : null;
+            PsiReference ref = callee != null ? ReferencesPackage.getMainReference(callee) : null;
             if (ref instanceof JetSimpleNameReference) {
                 ((JetSimpleNameReference) ref).handleElementRename(((PsiMethod)method).getName());
                 return true;
@@ -767,7 +1019,7 @@ public class JetChangeSignatureUsageProcessor implements ChangeSignatureUsagePro
             return false;
         }
 
-        return usageInfo instanceof JetUsageInfo ? ((JetUsageInfo) usageInfo).processUsage((JetChangeInfo) changeInfo, element) : true;
+        return usageInfo instanceof JetUsageInfo ? ((JetUsageInfo) usageInfo).processUsage((JetChangeInfo) changeInfo, element, usages) : true;
     }
 
     @Override
@@ -775,8 +1027,8 @@ public class JetChangeSignatureUsageProcessor implements ChangeSignatureUsagePro
         if (!(changeInfo instanceof JetChangeInfo)) return false;
 
         JetChangeInfo jetChangeInfo = (JetChangeInfo) changeInfo;
-        for (JetFunctionDefinitionUsage primaryFunction : jetChangeInfo.getMethodDescriptor().getPrimaryFunctions()) {
-            primaryFunction.processUsage(jetChangeInfo, primaryFunction.getDeclaration());
+        for (JetCallableDefinitionUsage primaryFunction : jetChangeInfo.getMethodDescriptor().getPrimaryCallables()) {
+            primaryFunction.processUsage(jetChangeInfo, primaryFunction.getDeclaration(), UsageInfo.EMPTY_ARRAY);
         }
         jetChangeInfo.primaryMethodUpdated();
         return true;
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/JetMethodDescriptor.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/JetMethodDescriptor.kt
index b84a08d8949..7f93e37a641 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/JetMethodDescriptor.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/JetMethodDescriptor.kt
@@ -19,10 +19,10 @@ package org.jetbrains.kotlin.idea.refactoring.changeSignature
 import com.intellij.psi.PsiElement
 import com.intellij.refactoring.changeSignature.MethodDescriptor
 import com.intellij.usageView.UsageInfo
-import org.jetbrains.kotlin.descriptors.FunctionDescriptor
-import org.jetbrains.kotlin.descriptors.Visibility
-import org.jetbrains.kotlin.idea.refactoring.changeSignature.usages.JetFunctionDefinitionUsage
+import org.jetbrains.kotlin.descriptors.CallableDescriptor
 import org.jetbrains.kotlin.descriptors.ConstructorDescriptor
+import org.jetbrains.kotlin.descriptors.Visibility
+import org.jetbrains.kotlin.idea.refactoring.changeSignature.usages.JetCallableDefinitionUsage
 import org.jetbrains.kotlin.idea.util.IdeDescriptorRenderers
 
 public trait JetMethodDescriptor : MethodDescriptor<JetParameterInfo, Visibility> {
@@ -41,12 +41,14 @@ public trait JetMethodDescriptor : MethodDescriptor<JetParameterInfo, Visibility
         }
     }
 
-    val baseDeclaration: PsiElement
-    val baseDescriptor: FunctionDescriptor
+    val original: JetMethodDescriptor
 
-    val originalPrimaryFunction: JetFunctionDefinitionUsage<PsiElement>
-    val primaryFunctions: Collection<JetFunctionDefinitionUsage<PsiElement>>
-    val affectedFunctions: Collection<UsageInfo>
+    val baseDeclaration: PsiElement
+    val baseDescriptor: CallableDescriptor
+
+    val originalPrimaryCallable: JetCallableDefinitionUsage<PsiElement>
+    val primaryCallables: Collection<JetCallableDefinitionUsage<PsiElement>>
+    val affectedCallables: Collection<UsageInfo>
 
     val receiver: JetParameterInfo?
 }
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/JetMutableMethodDescriptor.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/JetMutableMethodDescriptor.kt
index 6794773a11c..032b9034536 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/JetMutableMethodDescriptor.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/JetMutableMethodDescriptor.kt
@@ -18,7 +18,7 @@ package org.jetbrains.kotlin.idea.refactoring.changeSignature
 
 import org.jetbrains.kotlin.descriptors.Visibility
 
-public class JetMutableMethodDescriptor(val original: JetMethodDescriptor): JetMethodDescriptor by original {
+public class JetMutableMethodDescriptor(override val original: JetMethodDescriptor): JetMethodDescriptor by original {
     private val parameters: MutableList<JetParameterInfo> = original.getParameters()
 
     override var receiver: JetParameterInfo? = original.receiver
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/JetParameterInfo.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/JetParameterInfo.kt
index 2130cb187c1..31270a20c12 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/JetParameterInfo.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/JetParameterInfo.kt
@@ -23,8 +23,9 @@ import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.descriptors.impl.AnonymousFunctionDescriptor
 import org.jetbrains.kotlin.idea.caches.resolve.analyze
 import org.jetbrains.kotlin.idea.core.compareDescriptors
-import org.jetbrains.kotlin.idea.refactoring.changeSignature.usages.JetFunctionDefinitionUsage
+import org.jetbrains.kotlin.idea.refactoring.changeSignature.usages.JetCallableDefinitionUsage
 import org.jetbrains.kotlin.idea.references.JetReference
+import org.jetbrains.kotlin.idea.references.mainReference
 import org.jetbrains.kotlin.idea.util.IdeDescriptorRenderers
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.resolve.BindingContext
@@ -36,7 +37,7 @@ import org.jetbrains.kotlin.types.JetType
 import java.util.LinkedHashMap
 
 public class JetParameterInfo(
-        val functionDescriptor: FunctionDescriptor,
+        val callableDescriptor: CallableDescriptor,
         val originalIndex: Int = -1,
         private var name: String,
         type: JetType? = null,
@@ -61,7 +62,7 @@ public class JetParameterInfo(
                             object : JetTreeVisitorVoid() {
                                 private fun selfParameterOrNull(parameter: DeclarationDescriptor?): ValueParameterDescriptor? {
                                     return if (parameter is ValueParameterDescriptor &&
-                                               compareDescriptors(project, parameter.getContainingDeclaration(), functionDescriptor)) {
+                                               compareDescriptors(project, parameter.getContainingDeclaration(), callableDescriptor)) {
                                         parameter
                                     } else null
                                 }
@@ -69,12 +70,12 @@ public class JetParameterInfo(
                                 private fun selfReceiverOrNull(receiverDescriptor: DeclarationDescriptor?): DeclarationDescriptor? {
                                     if (compareDescriptors(project,
                                                            receiverDescriptor,
-                                                           functionDescriptor.getExtensionReceiverParameter()?.getContainingDeclaration())) {
+                                                           callableDescriptor.getExtensionReceiverParameter()?.getContainingDeclaration())) {
                                         return receiverDescriptor
                                     }
                                     if (compareDescriptors(project,
                                                            receiverDescriptor,
-                                                           functionDescriptor.getDispatchReceiverParameter()?.getContainingDeclaration())) {
+                                                           callableDescriptor.getDispatchReceiverParameter()?.getContainingDeclaration())) {
                                         return receiverDescriptor
                                     }
                                     return null
@@ -93,7 +94,7 @@ public class JetParameterInfo(
                                     val descriptor = ref.resolveToDescriptors(context).singleOrNull()
                                     if (descriptor is ValueParameterDescriptor) return selfParameterOrNull(descriptor)
 
-                                    if (descriptor is PropertyDescriptor && functionDescriptor is ConstructorDescriptor) {
+                                    if (descriptor is PropertyDescriptor && callableDescriptor is ConstructorDescriptor) {
                                         val parameter = DescriptorToSourceUtils.getSourceFromDescriptor(descriptor) as? JetParameter
                                         return parameter?.let { selfParameterOrNull(context[BindingContext.VALUE_PARAMETER, it]) }
                                     }
@@ -110,7 +111,7 @@ public class JetParameterInfo(
                                 }
 
                                 override fun visitSimpleNameExpression(expression: JetSimpleNameExpression) {
-                                    val ref = expression.getReference() as? JetReference ?: return
+                                    val ref = expression.mainReference
                                     val descriptor = getRelevantDescriptor(expression, ref) ?: return
                                     map[ref] = descriptor
                                 }
@@ -149,20 +150,20 @@ public class JetParameterInfo(
         throw UnsupportedOperationException()
     }
 
-    public fun renderType(parameterIndex: Int, inheritedFunction: JetFunctionDefinitionUsage<*>): String {
-        val typeSubstitutor = inheritedFunction.getOrCreateTypeSubstitutor() ?: return currentTypeText
-        val currentBaseFunction = inheritedFunction.getBaseFunction().getCurrentFunctionDescriptor() ?: return currentTypeText
+    public fun renderType(parameterIndex: Int, inheritedCallable: JetCallableDefinitionUsage<*>): String {
+        val typeSubstitutor = inheritedCallable.getOrCreateTypeSubstitutor() ?: return currentTypeText
+        val currentBaseFunction = inheritedCallable.getBaseFunction().getCurrentCallableDescriptor() ?: return currentTypeText
         val parameterType = currentBaseFunction.getValueParameters().get(parameterIndex).getType()
         return parameterType.renderTypeWithSubstitution(typeSubstitutor, currentTypeText, true)
     }
 
-    public fun getInheritedName(inheritedFunction: JetFunctionDefinitionUsage<*>): String {
-        if (!inheritedFunction.isInherited()) return name
+    public fun getInheritedName(inheritedCallable: JetCallableDefinitionUsage<*>): String {
+        if (!inheritedCallable.isInherited()) return name
 
-        val baseFunction = inheritedFunction.getBaseFunction()
-        val baseFunctionDescriptor = baseFunction.getOriginalFunctionDescriptor()
+        val baseFunction = inheritedCallable.getBaseFunction()
+        val baseFunctionDescriptor = baseFunction.getOriginalCallableDescriptor()
 
-        val inheritedFunctionDescriptor = inheritedFunction.getOriginalFunctionDescriptor()
+        val inheritedFunctionDescriptor = inheritedCallable.getOriginalCallableDescriptor()
         val inheritedParameterDescriptors = inheritedFunctionDescriptor.getValueParameters()
         if (originalIndex < 0
             || originalIndex >= baseFunctionDescriptor.getValueParameters().size()
@@ -177,18 +178,18 @@ public class JetParameterInfo(
         }
     }
 
-    public fun requiresExplicitType(inheritedFunction: JetFunctionDefinitionUsage<PsiElement>): Boolean {
-        val inheritedFunctionDescriptor = inheritedFunction.getOriginalFunctionDescriptor()
+    public fun requiresExplicitType(inheritedCallable: JetCallableDefinitionUsage<PsiElement>): Boolean {
+        val inheritedFunctionDescriptor = inheritedCallable.getOriginalCallableDescriptor()
         if (inheritedFunctionDescriptor !is AnonymousFunctionDescriptor) return true
 
-        if (originalIndex < 0) return !inheritedFunction.hasExpectedType()
+        if (originalIndex < 0) return !inheritedCallable.hasExpectedType()
 
         val inheritedParameterDescriptor = inheritedFunctionDescriptor.getValueParameters().get(originalIndex)
         val parameter = DescriptorToSourceUtils.descriptorToDeclaration(inheritedParameterDescriptor) as? JetParameter ?: return false
         return parameter.getTypeReference() != null
     }
 
-    public fun getDeclarationSignature(parameterIndex: Int, inheritedFunction: JetFunctionDefinitionUsage<PsiElement>): String {
+    public fun getDeclarationSignature(parameterIndex: Int, inheritedCallable: JetCallableDefinitionUsage<PsiElement>): String {
         val buffer = StringBuilder()
 
         if (modifierList != null) {
@@ -199,13 +200,13 @@ public class JetParameterInfo(
             buffer.append(valOrVar).append(' ')
         }
 
-        buffer.append(getInheritedName(inheritedFunction))
+        buffer.append(getInheritedName(inheritedCallable))
 
-        if (requiresExplicitType(inheritedFunction)) {
-            buffer.append(": ").append(renderType(parameterIndex, inheritedFunction))
+        if (requiresExplicitType(inheritedCallable)) {
+            buffer.append(": ").append(renderType(parameterIndex, inheritedCallable))
         }
 
-        if (!inheritedFunction.isInherited()) {
+        if (!inheritedCallable.isInherited()) {
             defaultValueForParameter?.let { buffer.append(" = ").append(it.getText()) }
         }
 
diff --git a/core/builtins/src/kotlin/reflect/KTopLevelExtensionProperty.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/KotlinAwareJavaParameterInfoImpl.kt
similarity index 56%
rename from core/builtins/src/kotlin/reflect/KTopLevelExtensionProperty.kt
rename to idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/KotlinAwareJavaParameterInfoImpl.kt
index 3381b037182..7886850ec90 100644
--- a/core/builtins/src/kotlin/reflect/KTopLevelExtensionProperty.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/KotlinAwareJavaParameterInfoImpl.kt
@@ -14,14 +14,15 @@
  * limitations under the License.
  */
 
-package kotlin.reflect
+package org.jetbrains.kotlin.idea.refactoring.changeSignature
 
-/**
- * Represents an extension property declared in a package.
- */
-public interface KTopLevelExtensionProperty<E, out R> : KExtensionProperty<E, R>, KTopLevelProperty<R>
+import com.intellij.psi.PsiType
+import com.intellij.refactoring.changeSignature.ParameterInfoImpl
+import org.jetbrains.kotlin.psi.JetExpression
 
-/**
- * Represents a package extension property declared as a `var`.
- */
-public interface KMutableTopLevelExtensionProperty<E, R> : KTopLevelExtensionProperty<E, R>, KMutableExtensionProperty<E, R>, KMutableTopLevelProperty<R>
+public class KotlinAwareJavaParameterInfoImpl(
+        oldParameterIndex: Int,
+        name: String,
+        type: PsiType,
+        val kotlinDefaultValue: JetExpression?
+): ParameterInfoImpl(oldParameterIndex, name, type, kotlinDefaultValue?.getText() ?: "")
\ No newline at end of file
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/changeSignatureUtils.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/changeSignatureUtils.kt
new file mode 100644
index 00000000000..3effd19684b
--- /dev/null
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/changeSignatureUtils.kt
@@ -0,0 +1,59 @@
+/*
+ * Copyright 2010-2015 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.kotlin.idea.refactoring.changeSignature
+
+import com.intellij.psi.PsiElement
+import com.intellij.refactoring.changeSignature.CallerUsageInfo
+import com.intellij.refactoring.changeSignature.OverriderUsageInfo
+import com.intellij.usageView.UsageInfo
+import org.jetbrains.kotlin.idea.refactoring.changeSignature.usages.DeferredJavaMethodKotlinCallerUsage
+import org.jetbrains.kotlin.idea.refactoring.changeSignature.usages.JavaMethodKotlinUsageWithDelegate
+import org.jetbrains.kotlin.idea.refactoring.changeSignature.usages.KotlinCallerUsage
+import org.jetbrains.kotlin.psi.*
+import org.jetbrains.kotlin.psi.psiUtil.parentsWithSelf
+
+private fun JetNamedDeclaration.getDeclarationBody(): JetElement? {
+    return when {
+        this is JetClassOrObject -> getDelegationSpecifierList()
+        this is JetPrimaryConstructor -> getContainingClassOrObject().getDelegationSpecifierList()
+        this is JetSecondaryConstructor -> getDelegationCall()
+        this is JetNamedFunction -> getBodyExpression()
+        else -> null
+    }
+}
+
+public fun PsiElement.isCaller(allUsages: Array<out UsageInfo>): Boolean {
+    val elementToSearch = (this as? JetClass)?.getPrimaryConstructor() ?: this
+    return allUsages
+            .asSequence()
+            .filter {
+                val usage = (it as? JavaMethodKotlinUsageWithDelegate<*>)?.delegateUsage ?: it
+                usage is KotlinCallerUsage
+                || usage is DeferredJavaMethodKotlinCallerUsage
+                || usage is CallerUsageInfo
+                || (usage is OverriderUsageInfo && !usage.isOriginalOverrider())
+            }
+            .any { it.getElement() == elementToSearch }
+}
+
+public fun JetElement.isInsideOfCallerBody(allUsages: Array<out UsageInfo>): Boolean {
+    val container = parentsWithSelf.firstOrNull {
+        it is JetNamedFunction || it is JetConstructor<*> || it is JetClassOrObject
+    } as? JetNamedDeclaration ?: return false
+    val body = container.getDeclarationBody() ?: return false
+    return body.getTextRange().contains(getTextRange()) && container.isCaller(allUsages)
+}
\ No newline at end of file
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/typeUtils.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/typeUtils.kt
index 1f4a69ec17a..fca58008fe9 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/typeUtils.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/typeUtils.kt
@@ -16,18 +16,13 @@
 
 package org.jetbrains.kotlin.idea.refactoring.changeSignature
 
+import org.jetbrains.kotlin.descriptors.CallableDescriptor
 import org.jetbrains.kotlin.descriptors.ClassDescriptor
-import org.jetbrains.kotlin.types.TypeSubstitutor
-import org.jetbrains.kotlin.types.TypeConstructor
-import org.jetbrains.kotlin.types.TypeProjection
-import java.util.LinkedHashMap
-import org.jetbrains.kotlin.descriptors.FunctionDescriptor
-import org.jetbrains.kotlin.types.checker.TypeCheckingProcedure
-import org.jetbrains.kotlin.types.TypeProjectionImpl
-import org.jetbrains.kotlin.idea.refactoring.changeSignature.usages.JetFunctionDefinitionUsage
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.idea.refactoring.changeSignature.usages.JetCallableDefinitionUsage
 import org.jetbrains.kotlin.idea.util.IdeDescriptorRenderers
-import org.jetbrains.kotlin.types.Variance
+import org.jetbrains.kotlin.types.*
+import org.jetbrains.kotlin.types.checker.TypeCheckingProcedure
+import java.util.LinkedHashMap
 
 private fun getTypeSubstitution(baseType: JetType, derivedType: JetType): LinkedHashMap<TypeConstructor, TypeProjection>? {
     val substitutedType = TypeCheckingProcedure.findCorrespondingSupertype(derivedType, baseType) ?: return null
@@ -40,15 +35,15 @@ private fun getTypeSubstitution(baseType: JetType, derivedType: JetType): Linked
     return substitution
 }
 
-private fun getFunctionSubstitution(
-        baseFunction: FunctionDescriptor,
-        derivedFunction: FunctionDescriptor
+private fun getCallableSubstitution(
+        baseCallable: CallableDescriptor,
+        derivedCallable: CallableDescriptor
 ): MutableMap<TypeConstructor, TypeProjection>? {
-    val baseClass = baseFunction.getContainingDeclaration() as? ClassDescriptor ?: return null
-    val derivedClass = derivedFunction.getContainingDeclaration() as? ClassDescriptor ?: return null
+    val baseClass = baseCallable.getContainingDeclaration() as? ClassDescriptor ?: return null
+    val derivedClass = derivedCallable.getContainingDeclaration() as? ClassDescriptor ?: return null
     val substitution = getTypeSubstitution(baseClass.getDefaultType(), derivedClass.getDefaultType()) ?: return null
 
-    for ((baseParam, derivedParam) in baseFunction.getTypeParameters() zip derivedFunction.getTypeParameters()) {
+    for ((baseParam, derivedParam) in baseCallable.getTypeParameters() zip derivedCallable.getTypeParameters()) {
         substitution[baseParam.getTypeConstructor()] = TypeProjectionImpl(derivedParam.getDefaultType())
     }
 
@@ -59,15 +54,15 @@ fun getTypeSubstitutor(baseType: JetType, derivedType: JetType): TypeSubstitutor
     return getTypeSubstitution(baseType, derivedType)?.let { TypeSubstitutor.create(it) }
 }
 
-fun getFunctionSubstitutor(
-        baseFunction: JetFunctionDefinitionUsage<*>,
-        derivedFunction: JetFunctionDefinitionUsage<*>
+fun getCallableSubstitutor(
+        baseFunction: JetCallableDefinitionUsage<*>,
+        derivedCallable: JetCallableDefinitionUsage<*>
 ): TypeSubstitutor? {
-    val currentBaseFunction = baseFunction.getCurrentFunctionDescriptor()
-    val currentDerivedFunction = derivedFunction.getCurrentFunctionDescriptor()
+    val currentBaseFunction = baseFunction.getCurrentCallableDescriptor()
+    val currentDerivedFunction = derivedCallable.getCurrentCallableDescriptor()
     if (currentBaseFunction == null || currentDerivedFunction == null) return null
 
-    return getFunctionSubstitution(currentBaseFunction, currentDerivedFunction)?.let { TypeSubstitutor.create(it) }
+    return getCallableSubstitution(currentBaseFunction, currentDerivedFunction)?.let { TypeSubstitutor.create(it) }
 }
 
 fun JetType.renderTypeWithSubstitution(substitutor: TypeSubstitutor?, defaultText: String, inArgumentPosition: Boolean): String {
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/JetCallableParameterTableModel.java b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/ui/JetCallableParameterTableModel.java
similarity index 91%
rename from idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/JetCallableParameterTableModel.java
rename to idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/ui/JetCallableParameterTableModel.java
index ac8c0d280a4..96c46afb54b 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/JetCallableParameterTableModel.java
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/ui/JetCallableParameterTableModel.java
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package org.jetbrains.kotlin.idea.refactoring.changeSignature;
+package org.jetbrains.kotlin.idea.refactoring.changeSignature.ui;
 
 import com.intellij.openapi.project.Project;
 import com.intellij.psi.PsiCodeFragment;
@@ -23,6 +23,9 @@ import com.intellij.refactoring.changeSignature.ParameterTableModelBase;
 import com.intellij.refactoring.changeSignature.ParameterTableModelItemBase;
 import com.intellij.util.ui.ColumnInfo;
 import org.jetbrains.annotations.Nullable;
+import org.jetbrains.kotlin.idea.refactoring.changeSignature.JetMethodDescriptor;
+import org.jetbrains.kotlin.idea.refactoring.changeSignature.JetParameterInfo;
+import org.jetbrains.kotlin.idea.refactoring.changeSignature.JetValVar;
 import org.jetbrains.kotlin.psi.JetExpression;
 import org.jetbrains.kotlin.psi.JetPsiFactory;
 
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/ui/JetChangePropertySignatureDialog.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/ui/JetChangePropertySignatureDialog.kt
new file mode 100644
index 00000000000..02eb0db99cf
--- /dev/null
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/ui/JetChangePropertySignatureDialog.kt
@@ -0,0 +1,177 @@
+/*
+ * Copyright 2010-2015 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.kotlin.idea.refactoring.changeSignature
+
+import com.intellij.openapi.options.ConfigurationException
+import com.intellij.openapi.project.Project
+import com.intellij.psi.PsiDocumentManager
+import com.intellij.psi.PsiElement
+import com.intellij.refactoring.BaseRefactoringProcessor
+import com.intellij.refactoring.ui.ComboBoxVisibilityPanel
+import com.intellij.refactoring.ui.RefactoringDialog
+import com.intellij.ui.EditorTextField
+import com.intellij.ui.NonFocusableCheckBox
+import com.intellij.util.ui.FormBuilder
+import org.jetbrains.kotlin.descriptors.Visibilities
+import org.jetbrains.kotlin.descriptors.Visibility
+import org.jetbrains.kotlin.idea.JetFileType
+import org.jetbrains.kotlin.idea.core.refactoring.validateElement
+import org.jetbrains.kotlin.psi.JetExpression
+import org.jetbrains.kotlin.psi.JetProperty
+import org.jetbrains.kotlin.psi.JetPsiFactory
+import org.jetbrains.kotlin.psi.JetTypeCodeFragment
+import org.jetbrains.kotlin.resolve.AnalyzingUtils
+import javax.swing.JCheckBox
+import javax.swing.JComboBox
+import javax.swing.JComponent
+import javax.swing.JLabel
+import kotlin.properties.Delegates
+
+public class JetChangePropertySignatureDialog(
+        project: Project,
+        private val methodDescriptor: JetMethodDescriptor,
+        private val commandName: String?
+): RefactoringDialog(project, true) {
+    private val visibilityCombo = JComboBox(
+            arrayOf(Visibilities.INTERNAL, Visibilities.PRIVATE, Visibilities.PROTECTED, Visibilities.PUBLIC)
+    )
+    private val nameField = EditorTextField(methodDescriptor.getName())
+    private var returnTypeField: EditorTextField by Delegates.notNull()
+    private var receiverTypeCheckBox: JCheckBox? = null
+    var receiverTypeLabel: JLabel by Delegates.notNull()
+    private var receiverTypeField: EditorTextField by Delegates.notNull()
+    var receiverDefaultValueLabel: JLabel? = null
+    private var receiverDefaultValueField: EditorTextField? = null
+
+    init {
+        setTitle("Change Signature")
+        init()
+    }
+
+    override fun getPreferredFocusedComponent() = nameField
+
+    override fun createCenterPanel(): JComponent? {
+        fun updateReceiverUI() {
+            val withReceiver = receiverTypeCheckBox!!.isSelected()
+            receiverTypeLabel.setEnabled(withReceiver)
+            receiverTypeField.setEnabled(withReceiver)
+            receiverDefaultValueLabel?.setEnabled(withReceiver)
+            receiverDefaultValueField?.setEnabled(withReceiver)
+        }
+
+        val documentManager = PsiDocumentManager.getInstance(myProject)
+        val psiFactory = JetPsiFactory(myProject)
+
+        return with(FormBuilder.createFormBuilder()) {
+            val baseDeclaration = methodDescriptor.baseDeclaration
+            if (!((baseDeclaration as? JetProperty)?.isLocal() ?: false)) {
+                visibilityCombo.setSelectedItem(methodDescriptor.getVisibility())
+                addLabeledComponent("&Visibility: ", visibilityCombo)
+            }
+
+            addLabeledComponent("&Name: ", nameField)
+
+            val returnTypeCodeFragment = psiFactory.createTypeCodeFragment(methodDescriptor.renderOriginalReturnType(),
+                                                                           baseDeclaration)
+            returnTypeField = EditorTextField(documentManager.getDocument(returnTypeCodeFragment), myProject, JetFileType.INSTANCE)
+            addLabeledComponent("&Type: ", returnTypeField)
+
+            if (baseDeclaration is JetProperty) {
+                addSeparator()
+
+                val receiverTypeCheckBox = JCheckBox("Extension property: ")
+                receiverTypeCheckBox.setMnemonic('x')
+                receiverTypeCheckBox.addActionListener { updateReceiverUI() }
+                receiverTypeCheckBox.setSelected(methodDescriptor.receiver != null)
+                addComponent(receiverTypeCheckBox)
+                this@JetChangePropertySignatureDialog.receiverTypeCheckBox = receiverTypeCheckBox
+
+                val receiverTypeCodeFragment = psiFactory.createTypeCodeFragment(methodDescriptor.renderOriginalReceiverType() ?: "",
+                                                                                 methodDescriptor.baseDeclaration)
+                receiverTypeField = EditorTextField(documentManager.getDocument(receiverTypeCodeFragment), myProject, JetFileType.INSTANCE)
+                receiverTypeLabel = JLabel("Receiver type: ")
+                receiverTypeLabel.setDisplayedMnemonic('t')
+                addLabeledComponent(receiverTypeLabel, receiverTypeField)
+
+                if (methodDescriptor.receiver == null) {
+                    val receiverDefaultValueCodeFragment = psiFactory.createExpressionCodeFragment("", methodDescriptor.baseDeclaration)
+                    receiverDefaultValueField = EditorTextField(documentManager.getDocument(receiverDefaultValueCodeFragment),
+                                                                myProject,
+                                                                JetFileType.INSTANCE)
+                    receiverDefaultValueLabel = JLabel("Default receiver value: ")
+                    receiverDefaultValueLabel!!.setDisplayedMnemonic('D')
+                    addLabeledComponent(receiverDefaultValueLabel, receiverDefaultValueField!!)
+                }
+
+                updateReceiverUI()
+            }
+
+            getPanel()
+        }
+    }
+
+    private fun getDefaultReceiverValue(): JetExpression? {
+        val receiverDefaultValue = receiverDefaultValueField?.getText() ?: ""
+        return if (receiverDefaultValue.isNotEmpty()) JetPsiFactory(myProject).createExpression(receiverDefaultValue) else null
+    }
+
+    override fun canRun() {
+        val psiFactory = JetPsiFactory(myProject)
+
+        psiFactory.createSimpleName(nameField.getText()).validateElement("Invalid name")
+        psiFactory.createType(returnTypeField.getText()).validateElement("Invalid return type")
+        if (receiverTypeCheckBox?.isSelected() ?: false) {
+            psiFactory.createType(receiverTypeField.getText()).validateElement("Invalid receiver type")
+        }
+        getDefaultReceiverValue()?.validateElement("Invalid default receiver value")
+    }
+
+    override fun doAction() {
+        val originalDescriptor = methodDescriptor.original
+
+        val receiver = if (receiverTypeCheckBox?.isSelected() ?: false) {
+            originalDescriptor.receiver ?: JetParameterInfo(callableDescriptor = originalDescriptor.baseDescriptor,
+                                                            name = "receiver",
+                                                            defaultValueForCall = getDefaultReceiverValue())
+        } else null
+        receiver?.currentTypeText = receiverTypeField.getText()
+        val changeInfo = JetChangeInfo(originalDescriptor,
+                                       nameField.getText(),
+                                       null,
+                                       returnTypeField.getText(),
+                                       visibilityCombo.getSelectedItem() as Visibility,
+                                       emptyList(),
+                                       receiver,
+                                       originalDescriptor.getMethod())
+
+        invokeRefactoring(JetChangeSignatureProcessor(myProject, changeInfo, commandName ?: getTitle()))
+    }
+
+    companion object {
+        fun createProcessorForSilentRefactoring(
+                project: Project,
+                commandName: String,
+                descriptor: JetMethodDescriptor
+        ): BaseRefactoringProcessor {
+            val originalDescriptor = descriptor.original
+            val changeInfo = JetChangeInfo(methodDescriptor = originalDescriptor, context = originalDescriptor.getMethod())
+            changeInfo.setNewName(descriptor.getName())
+            changeInfo.receiverParameterInfo = descriptor.receiver
+            return JetChangeSignatureProcessor(project, changeInfo, commandName)
+        }
+    }
+}
\ No newline at end of file
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/ui/JetChangeSignatureDialog.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/ui/JetChangeSignatureDialog.kt
new file mode 100644
index 00000000000..9cb68759f8f
--- /dev/null
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/ui/JetChangeSignatureDialog.kt
@@ -0,0 +1,438 @@
+/*
+ * Copyright 2010-2015 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.kotlin.idea.refactoring.changeSignature.ui
+
+import com.intellij.openapi.editor.colors.EditorColorsManager
+import com.intellij.openapi.editor.colors.EditorFontType
+import com.intellij.openapi.editor.event.DocumentAdapter
+import com.intellij.openapi.editor.event.DocumentEvent
+import com.intellij.openapi.options.ConfigurationException
+import com.intellij.openapi.project.Project
+import com.intellij.openapi.ui.VerticalFlowLayout
+import com.intellij.openapi.util.text.StringUtil
+import com.intellij.psi.JavaPsiFacade
+import com.intellij.psi.PsiCodeFragment
+import com.intellij.psi.PsiDocumentManager
+import com.intellij.psi.PsiElement
+import com.intellij.refactoring.BaseRefactoringProcessor
+import com.intellij.refactoring.changeSignature.ChangeSignatureDialogBase
+import com.intellij.refactoring.changeSignature.MethodDescriptor
+import com.intellij.refactoring.changeSignature.ParameterTableModelItemBase
+import com.intellij.refactoring.ui.ComboBoxVisibilityPanel
+import com.intellij.ui.DottedBorder
+import com.intellij.ui.EditorTextField
+import com.intellij.ui.components.JBLabel
+import com.intellij.ui.treeStructure.Tree
+import com.intellij.util.Consumer
+import com.intellij.util.IJSwingUtilities
+import com.intellij.util.ui.UIUtil
+import com.intellij.util.ui.table.JBTableRow
+import com.intellij.util.ui.table.JBTableRowEditor
+import org.jetbrains.kotlin.descriptors.Visibilities
+import org.jetbrains.kotlin.descriptors.Visibility
+import org.jetbrains.kotlin.idea.JetFileType
+import org.jetbrains.kotlin.idea.refactoring.JetRefactoringBundle
+import org.jetbrains.kotlin.idea.refactoring.changeSignature.*
+import org.jetbrains.kotlin.idea.refactoring.changeSignature.JetMethodDescriptor.Kind
+import org.jetbrains.kotlin.psi.JetExpressionCodeFragment
+import org.jetbrains.kotlin.psi.JetPsiFactory
+import org.jetbrains.kotlin.psi.JetTypeCodeFragment
+import org.jetbrains.kotlin.types.JetType
+import java.awt.BorderLayout
+import java.awt.Font
+import java.awt.Toolkit
+import java.awt.event.ItemEvent
+import java.awt.event.ItemListener
+import java.util.ArrayList
+import javax.swing.*
+
+public class JetChangeSignatureDialog(
+        project: Project,
+        methodDescriptor: JetMethodDescriptor,
+        context: PsiElement,
+        private val commandName: String?
+) : ChangeSignatureDialogBase<
+        JetParameterInfo,
+        PsiElement,
+        Visibility,
+        JetMethodDescriptor,
+        ParameterTableModelItemBase<JetParameterInfo>,
+        JetCallableParameterTableModel>(project, methodDescriptor, false, context) {
+    override fun getFileType() = JetFileType.INSTANCE
+
+    override fun createParametersInfoModel(descriptor: JetMethodDescriptor) = createParametersInfoModel(descriptor, myDefaultValueContext)
+
+    override fun createReturnTypeCodeFragment() = createReturnTypeCodeFragment(myProject, myMethod)
+
+    public fun getReturnType(): JetType? = getType(myReturnTypeCodeFragment as JetTypeCodeFragment?)
+    
+    private val parametersTableModel: JetCallableParameterTableModel get() = super.myParametersTableModel
+    
+    override fun getRowPresentation(item: ParameterTableModelItemBase<JetParameterInfo>, selected: Boolean, focused: Boolean): JComponent? {
+        val panel = JPanel(BorderLayout())
+
+        val valOrVar: String
+        if (myMethod.kind === Kind.PRIMARY_CONSTRUCTOR) {
+            valOrVar = when (item.parameter.valOrVar) {
+                JetValVar.None -> "    "
+                JetValVar.Val -> "val "
+                JetValVar.Var -> "var "
+            }
+        }
+        else {
+            valOrVar = ""
+        }
+
+        val parameterName = getPresentationName(item)
+        val typeText = item.typeCodeFragment.getText()
+        val defaultValue = item.defaultValueCodeFragment.getText()
+        val separator = StringUtil.repeatSymbol(' ', getParamNamesMaxLength() - parameterName.length() + 1)
+        var text = "$valOrVar$parameterName:$separator$typeText"
+
+        if (StringUtil.isNotEmpty(defaultValue)) {
+            text += " // default value = $defaultValue"
+        }
+
+        val field = object : EditorTextField(" $text", getProject(), getFileType()) {
+            override fun shouldHaveBorder() = false
+        }
+
+        val plainFont  = EditorColorsManager.getInstance().getGlobalScheme().getFont(EditorFontType.PLAIN)
+        field.setFont(Font(plainFont.getFontName(), plainFont.getStyle(), 12))
+
+        if (selected && focused) {
+            panel.setBackground(UIUtil.getTableSelectionBackground())
+            field.setAsRendererWithSelection(UIUtil.getTableSelectionBackground(), UIUtil.getTableSelectionForeground())
+        }
+        else {
+            panel.setBackground(UIUtil.getTableBackground())
+            if (selected && !focused) {
+                panel.setBorder(DottedBorder(UIUtil.getTableForeground()))
+            }
+        }
+        panel.add(field, BorderLayout.WEST)
+
+        return panel
+    }
+
+    private fun getPresentationName(item: ParameterTableModelItemBase<JetParameterInfo>): String {
+        val parameter = item.parameter
+        return if (parameter == parametersTableModel.getReceiver()) "<receiver>" else parameter.getName()
+    }
+
+    private fun getColumnTextMaxLength(nameFunction: Function1<ParameterTableModelItemBase<JetParameterInfo>, String?>) =
+            parametersTableModel.getItems().map { nameFunction(it)?.length() ?: 0 }.max() ?: 0
+
+    private fun getParamNamesMaxLength() = getColumnTextMaxLength { getPresentationName(it) }
+
+    private fun getTypesMaxLength() = getColumnTextMaxLength { it.typeCodeFragment?.getText() }
+
+    private fun getDefaultValuesMaxLength() = getColumnTextMaxLength { it.defaultValueCodeFragment?.getText() }
+
+    override fun isListTableViewSupported() = true
+
+    override fun isEmptyRow(row: ParameterTableModelItemBase<JetParameterInfo>): Boolean {
+        if (!row.parameter.getName().isNullOrEmpty()) return false
+        if (!row.parameter.getTypeText().isNullOrEmpty()) return false
+        return true
+    }
+
+    override fun createCallerChooser(title: String, treeToReuse: Tree?, callback: Consumer<Set<PsiElement>>) =
+            KotlinCallerChooser(myMethod.getMethod(), myProject, title, treeToReuse, callback)
+
+    // Forbid receiver propagation
+    override fun mayPropagateParameters() =
+            getParameters().any { it.isNewParameter && it != parametersTableModel.getReceiver() }
+
+    override fun getTableEditor(table: JTable, item: ParameterTableModelItemBase<JetParameterInfo>): JBTableRowEditor? {
+        return object : JBTableRowEditor() {
+            private val components = ArrayList<JComponent>()
+            private val nameEditor = EditorTextField(item.parameter.getName(), getProject(), getFileType())
+
+            private fun updateNameEditor() {
+                nameEditor.setEnabled(item.parameter != parametersTableModel.getReceiver())
+            }
+
+            private fun isDefaultColumnEnabled() =
+                    item.parameter.isNewParameter && item.parameter != myMethod.receiver
+
+            override fun prepareEditor(table: JTable, row: Int) {
+                setLayout(BoxLayout(this, BoxLayout.X_AXIS))
+                var column = 0
+
+                for (columnInfo in parametersTableModel.getColumnInfos()) {
+                    val panel = JPanel(VerticalFlowLayout(VerticalFlowLayout.TOP, 4, 2, true, false))
+                    val editor: EditorTextField?
+                    val component: JComponent
+                    val columnFinal = column
+
+                    if (JetCallableParameterTableModel.isTypeColumn(columnInfo)) {
+                        val document = PsiDocumentManager.getInstance(getProject()).getDocument(item.typeCodeFragment)
+                        editor = EditorTextField(document, getProject(), getFileType())
+                        component = editor
+                    }
+                    else if (JetCallableParameterTableModel.isNameColumn(columnInfo)) {
+                        editor = nameEditor
+                        component = editor
+                        updateNameEditor()
+                    }
+                    else if (JetCallableParameterTableModel.isDefaultValueColumn(columnInfo) && isDefaultColumnEnabled()) {
+                        val document = PsiDocumentManager.getInstance(getProject()).getDocument(item.defaultValueCodeFragment)
+                        editor = EditorTextField(document, getProject(), getFileType())
+                        component = editor
+                    }
+                    else if (JetPrimaryConstructorParameterTableModel.isValVarColumn(columnInfo)) {
+                        val comboBox = JComboBox(JetValVar.values())
+                        comboBox.setSelectedItem(item.parameter.valOrVar)
+                        comboBox.addItemListener(object : ItemListener {
+                            override fun itemStateChanged(e: ItemEvent) {
+                                parametersTableModel.setValueAtWithoutUpdate(e.getItem(), row, columnFinal)
+                                updateSignature()
+                            }
+                        })
+                        component = comboBox
+                        editor = null
+                    }
+                    else if (JetFunctionParameterTableModel.isReceiverColumn(columnInfo)) {
+                        val checkBox = JCheckBox()
+                        checkBox.setSelected(parametersTableModel.getReceiver() == item.parameter)
+                        checkBox.addItemListener {
+                            val newReceiver = if (it.getStateChange() == ItemEvent.SELECTED) item.parameter else null
+                            (parametersTableModel as JetFunctionParameterTableModel).setReceiver(newReceiver)
+                            updateSignature()
+                            updateNameEditor()
+                        }
+                        component = checkBox
+                        editor = null
+                    }
+                    else
+                        continue
+
+                    val label = JBLabel(columnInfo.getName(), UIUtil.ComponentStyle.SMALL)
+                    panel.add(label)
+
+                    if (editor != null) {
+                        editor.addDocumentListener(
+                                object : DocumentAdapter() {
+                                    override fun documentChanged(e: DocumentEvent?) {
+                                        fireDocumentChanged(e, columnFinal)
+                                    }
+                                }
+                        )
+                        editor.setPreferredWidth(table.getWidth() / parametersTableModel.getColumnCount())
+                    }
+
+                    components.add(component)
+                    panel.add(component)
+                    add(panel)
+                    IJSwingUtilities.adjustComponentsOnMac(label, component)
+                    column++
+                }
+            }
+
+            override fun getValue(): JBTableRow {
+                return object : JBTableRow {
+                    override fun getValueAt(column: Int): Any? {
+                        val columnInfo = parametersTableModel.getColumnInfos()[column]
+
+                        if (JetPrimaryConstructorParameterTableModel.isValVarColumn(columnInfo))
+                            return (components.get(column) as @suppress("NO_TYPE_ARGUMENTS_ON_RHS") JComboBox).getSelectedItem()
+                        else if (JetCallableParameterTableModel.isTypeColumn(columnInfo))
+                            return item.typeCodeFragment
+                        else if (JetCallableParameterTableModel.isNameColumn(columnInfo))
+                            return (components.get(column) as EditorTextField).getText()
+                        else if (JetCallableParameterTableModel.isDefaultValueColumn(columnInfo))
+                            return item.defaultValueCodeFragment
+                        else
+                            return null
+                    }
+                }
+            }
+
+            private fun getColumnWidth(letters: Int): Int {
+                var font = EditorColorsManager.getInstance().getGlobalScheme().getFont(EditorFontType.PLAIN)
+                font = Font(font.getFontName(), font.getStyle(), 12)
+                return letters * Toolkit.getDefaultToolkit().getFontMetrics(font).stringWidth("W")
+            }
+
+            private fun getEditorIndex(x: Int): Int {
+                @suppress("NAME_SHADOWING") var x = x
+
+                val columnLetters = if (isDefaultColumnEnabled())
+                    intArrayOf(4, getParamNamesMaxLength(), getTypesMaxLength(), getDefaultValuesMaxLength())
+                else
+                    intArrayOf(4, getParamNamesMaxLength(), getTypesMaxLength())
+
+                var columnIndex = 0
+                for (i in (if (myMethod.kind === Kind.PRIMARY_CONSTRUCTOR) 0 else 1)..columnLetters.size() - 1) {
+                    val width = getColumnWidth(columnLetters[i])
+
+                    if (x <= width)
+                        return columnIndex
+
+                    columnIndex++
+                    x -= width
+                }
+
+                return columnIndex - 1
+            }
+
+            override fun getPreferredFocusedComponent(): JComponent {
+                val me = getMouseEvent()
+                val index = if (me != null)
+                    getEditorIndex(me.getPoint().getX().toInt())
+                else if (myMethod.kind === Kind.PRIMARY_CONSTRUCTOR) 1 else 0
+                val component = components.get(index)
+                return if (component is EditorTextField) component.getFocusTarget() else component
+            }
+
+            override fun getFocusableComponents(): Array<JComponent> {
+                return Array(components.size()) {
+                    val component = components.get(it)
+                    (component as? EditorTextField)?.getFocusTarget() ?: component
+                }
+            }
+        }
+    }
+
+    override fun calculateSignature(): String {
+        val changeInfo = evaluateChangeInfo(parametersTableModel,
+                                            myReturnTypeCodeFragment,
+                                            getMethodDescriptor(),
+                                            getVisibility(),
+                                            getMethodName(),
+                                            myDefaultValueContext)
+        return changeInfo.getNewSignature(getMethodDescriptor().originalPrimaryCallable)
+    }
+
+    override fun createVisibilityControl() = ComboBoxVisibilityPanel(
+            arrayOf(Visibilities.INTERNAL, Visibilities.PRIVATE, Visibilities.PROTECTED, Visibilities.PUBLIC)
+    )
+
+    override fun updateSignatureAlarmFired() {
+        super.updateSignatureAlarmFired()
+        validateButtons()
+    }
+
+    override fun validateAndCommitData() = null
+
+    override fun canRun() {
+        if (myNamePanel.isVisible()
+            && myMethod.canChangeName()
+            && !JavaPsiFacade.getInstance(myProject).getNameHelper().isIdentifier(getMethodName())) {
+            throw ConfigurationException(JetRefactoringBundle.message("function.name.is.invalid"))
+        }
+
+        if (myMethod.canChangeReturnType() === MethodDescriptor.ReadWriteOption.ReadWrite && getReturnType() == null) {
+            throw ConfigurationException(JetRefactoringBundle.message("return.type.is.invalid"))
+        }
+
+        val parameterInfos = parametersTableModel.getItems()
+
+        for (item in parameterInfos) {
+            val parameterName = item.parameter.getName()
+
+            if (item.parameter != parametersTableModel.getReceiver()
+                && !JavaPsiFacade.getInstance(myProject).getNameHelper().isIdentifier(parameterName)) {
+                throw ConfigurationException(JetRefactoringBundle.message("parameter.name.is.invalid", parameterName))
+            }
+
+            if (getType(item.typeCodeFragment as JetTypeCodeFragment) == null) {
+                throw ConfigurationException(JetRefactoringBundle.message("parameter.type.is.invalid", item.typeCodeFragment.getText()))
+            }
+        }
+    }
+
+    override fun createRefactoringProcessor(): BaseRefactoringProcessor {
+        val changeInfo = evaluateChangeInfo(parametersTableModel,
+                                            myReturnTypeCodeFragment,
+                                            getMethodDescriptor(),
+                                            getVisibility(),
+                                            getMethodName(),
+                                            myDefaultValueContext)
+        changeInfo.primaryPropagationTargets = myMethodsToPropagateParameters ?: emptyList();
+        return JetChangeSignatureProcessor(myProject, changeInfo, commandName ?: getTitle())
+    }
+
+    public fun getMethodDescriptor(): JetMethodDescriptor = myMethod
+
+    override fun getSelectedIdx(): Int {
+        return myMethod.getParameters().withIndex().firstOrNull { it.value.isNewParameter }?.index
+               ?: super.getSelectedIdx()
+    }
+
+    companion object {
+        private fun createParametersInfoModel(descriptor: JetMethodDescriptor, defaultValueContext: PsiElement): JetCallableParameterTableModel {
+            return when (descriptor.kind) {
+                JetMethodDescriptor.Kind.FUNCTION -> JetFunctionParameterTableModel(descriptor, defaultValueContext)
+                JetMethodDescriptor.Kind.PRIMARY_CONSTRUCTOR -> JetPrimaryConstructorParameterTableModel(descriptor, defaultValueContext)
+                JetMethodDescriptor.Kind.SECONDARY_CONSTRUCTOR -> JetSecondaryConstructorParameterTableModel(descriptor, defaultValueContext)
+            }
+        }
+
+        private fun createReturnTypeCodeFragment(project: Project, method: JetMethodDescriptor) =
+                JetPsiFactory(project).createTypeCodeFragment(method.renderOriginalReturnType(), method.baseDeclaration)
+
+        private fun getType(typeCodeFragment: JetTypeCodeFragment?) = typeCodeFragment?.getType()
+
+        public fun createRefactoringProcessorForSilentChangeSignature(project: Project,
+                                                                      commandName: String,
+                                                                      method: JetMethodDescriptor,
+                                                                      defaultValueContext: PsiElement): BaseRefactoringProcessor {
+            val parameterTableModel = createParametersInfoModel(method, defaultValueContext)
+            parameterTableModel.setParameterInfos(method.getParameters())
+            val changeInfo = evaluateChangeInfo(parameterTableModel,
+                                                createReturnTypeCodeFragment(project, method),
+                                                method,
+                                                method.getVisibility(),
+                                                method.getName(),
+                                                defaultValueContext)
+            return JetChangeSignatureProcessor(project, changeInfo, commandName)
+        }
+
+        private fun evaluateChangeInfo(parametersModel: JetCallableParameterTableModel,
+                                       returnTypeCodeFragment: PsiCodeFragment?,
+                                       methodDescriptor: JetMethodDescriptor,
+                                       visibility: Visibility?,
+                                       methodName: String,
+                                       defaultValueContext: PsiElement): JetChangeInfo {
+            val parameters = parametersModel.getItems().map { parameter ->
+                val parameterInfo = parameter.parameter
+
+                parameterInfo.currentTypeText = parameter.typeCodeFragment.getText().trim()
+                val codeFragment = parameter.defaultValueCodeFragment as JetExpressionCodeFragment
+                val oldDefaultValue = parameterInfo.defaultValueForCall
+                if (codeFragment.getText() != (if (oldDefaultValue != null) oldDefaultValue.getText() else "")) {
+                    parameterInfo.defaultValueForCall = codeFragment.getContentElement()
+                }
+
+                parameterInfo
+            }
+
+            val returnTypeText = if (returnTypeCodeFragment != null) returnTypeCodeFragment.getText().trim() else ""
+            val returnType = getType(returnTypeCodeFragment as JetTypeCodeFragment?)
+            return JetChangeInfo(methodDescriptor.original,
+                                 methodName,
+                                 returnType,
+                                 returnTypeText,
+                                 visibility ?: Visibilities.INTERNAL,
+                                 parameters,
+                                 parametersModel.getReceiver(),
+                                 defaultValueContext)
+        }
+    }
+}
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/JetFunctionParameterTableModel.java b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/ui/JetFunctionParameterTableModel.java
similarity index 94%
rename from idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/JetFunctionParameterTableModel.java
rename to idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/ui/JetFunctionParameterTableModel.java
index b3dff394552..8627ff65306 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/JetFunctionParameterTableModel.java
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/ui/JetFunctionParameterTableModel.java
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package org.jetbrains.kotlin.idea.refactoring.changeSignature;
+package org.jetbrains.kotlin.idea.refactoring.changeSignature.ui;
 
 import com.intellij.openapi.project.Project;
 import com.intellij.psi.PsiElement;
@@ -24,6 +24,8 @@ import com.intellij.ui.BooleanTableCellRenderer;
 import com.intellij.util.ui.ColumnInfo;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.idea.JetFileType;
+import org.jetbrains.kotlin.idea.refactoring.changeSignature.JetMethodDescriptor;
+import org.jetbrains.kotlin.idea.refactoring.changeSignature.JetParameterInfo;
 
 import javax.swing.table.TableCellEditor;
 import javax.swing.table.TableCellRenderer;
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/JetPrimaryConstructorParameterTableModel.java b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/ui/JetPrimaryConstructorParameterTableModel.java
similarity index 91%
rename from idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/JetPrimaryConstructorParameterTableModel.java
rename to idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/ui/JetPrimaryConstructorParameterTableModel.java
index 186b3a2fc84..82553775fe5 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/JetPrimaryConstructorParameterTableModel.java
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/ui/JetPrimaryConstructorParameterTableModel.java
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package org.jetbrains.kotlin.idea.refactoring.changeSignature;
+package org.jetbrains.kotlin.idea.refactoring.changeSignature.ui;
 
 import com.intellij.openapi.ui.ComboBoxTableRenderer;
 import com.intellij.psi.PsiElement;
@@ -23,6 +23,9 @@ import com.intellij.util.ui.ColumnInfo;
 import org.jdesktop.swingx.autocomplete.ComboBoxCellEditor;
 import org.jetbrains.kotlin.idea.JetFileType;
 import org.jetbrains.kotlin.idea.refactoring.JetRefactoringBundle;
+import org.jetbrains.kotlin.idea.refactoring.changeSignature.JetMethodDescriptor;
+import org.jetbrains.kotlin.idea.refactoring.changeSignature.JetParameterInfo;
+import org.jetbrains.kotlin.idea.refactoring.changeSignature.JetValVar;
 
 import javax.swing.*;
 import javax.swing.table.TableCellEditor;
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/JetSecondaryConstructorParameterTableModel.java b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/ui/JetSecondaryConstructorParameterTableModel.java
similarity index 85%
rename from idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/JetSecondaryConstructorParameterTableModel.java
rename to idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/ui/JetSecondaryConstructorParameterTableModel.java
index 0e7722650aa..45198b54b37 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/JetSecondaryConstructorParameterTableModel.java
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/ui/JetSecondaryConstructorParameterTableModel.java
@@ -14,11 +14,13 @@
  * limitations under the License.
  */
 
-package org.jetbrains.kotlin.idea.refactoring.changeSignature;
+package org.jetbrains.kotlin.idea.refactoring.changeSignature.ui;
 
 import com.intellij.psi.PsiElement;
 import com.intellij.refactoring.changeSignature.ParameterTableModelItemBase;
 import org.jetbrains.kotlin.idea.JetFileType;
+import org.jetbrains.kotlin.idea.refactoring.changeSignature.JetMethodDescriptor;
+import org.jetbrains.kotlin.idea.refactoring.changeSignature.JetParameterInfo;
 
 public class JetSecondaryConstructorParameterTableModel extends JetCallableParameterTableModel {
     public JetSecondaryConstructorParameterTableModel(JetMethodDescriptor methodDescriptor, PsiElement context) {
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/ui/KotlinCallerChooser.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/ui/KotlinCallerChooser.kt
new file mode 100644
index 00000000000..9ee84b4ed31
--- /dev/null
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/ui/KotlinCallerChooser.kt
@@ -0,0 +1,126 @@
+/*
+ * Copyright 2010-2015 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.kotlin.idea.refactoring.changeSignature.ui
+
+import com.intellij.openapi.project.Project
+import com.intellij.psi.PsiClassOwner
+import com.intellij.psi.PsiElement
+import com.intellij.psi.PsiMethod
+import com.intellij.psi.PsiReference
+import com.intellij.psi.search.searches.MethodReferencesSearch
+import com.intellij.psi.search.searches.ReferencesSearch
+import com.intellij.refactoring.changeSignature.CallerChooserBase
+import com.intellij.refactoring.changeSignature.MethodNodeBase
+import com.intellij.ui.ColoredTreeCellRenderer
+import com.intellij.ui.JBColor
+import com.intellij.ui.SimpleTextAttributes
+import com.intellij.ui.treeStructure.Tree
+import com.intellij.util.Consumer
+import com.intellij.util.containers
+import com.intellij.util.ui.UIUtil
+import org.jetbrains.kotlin.asJava.getRepresentativeLightMethod
+import org.jetbrains.kotlin.asJava.namedUnwrappedElement
+import org.jetbrains.kotlin.asJava.toLightMethods
+import org.jetbrains.kotlin.descriptors.ClassDescriptor
+import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
+import org.jetbrains.kotlin.descriptors.FunctionDescriptor
+import org.jetbrains.kotlin.idea.JetFileType
+import org.jetbrains.kotlin.idea.caches.resolve.getJavaMethodDescriptor
+import org.jetbrains.kotlin.idea.caches.resolve.resolveToDescriptor
+import org.jetbrains.kotlin.idea.hierarchy.calls.KotlinCallHierarchyNodeDescriptor
+import org.jetbrains.kotlin.idea.hierarchy.calls.KotlinCallerMethodsTreeStructure
+import org.jetbrains.kotlin.psi.JetClass
+import org.jetbrains.kotlin.psi.JetFunction
+import org.jetbrains.kotlin.psi.psiUtil.getElementTextWithContext
+import java.util.HashSet
+import java.util.LinkedHashSet
+
+public class KotlinCallerChooser(
+        declaration: PsiElement,
+        project: Project,
+        title: String,
+        previousTree: Tree?,
+        callback: Consumer<Set<PsiElement>>
+): CallerChooserBase<PsiElement>(declaration, project, title, previousTree, "dummy." + JetFileType.EXTENSION, callback) {
+    override fun createTreeNode(method: PsiElement?, called: containers.HashSet<PsiElement>, cancelCallback: Runnable): KotlinMethodNode {
+        return KotlinMethodNode(method, called, myProject, cancelCallback)
+    }
+
+    override fun findDeepestSuperMethods(method: PsiElement) =
+            method.toLightMethods().singleOrNull()?.findDeepestSuperMethods()
+
+    override fun getEmptyCallerText() =
+            "Caller text \nwith highlighted callee call would be shown here"
+
+    override fun getEmptyCalleeText() =
+            "Callee text would be shown here"
+}
+
+public class KotlinMethodNode(
+        method: PsiElement?,
+        called: HashSet<PsiElement>,
+        project: Project,
+        cancelCallback: Runnable
+): MethodNodeBase<PsiElement>(method?.namedUnwrappedElement ?: method, called, project, cancelCallback) {
+    override fun createNode(caller: PsiElement, called: HashSet<PsiElement>) =
+            KotlinMethodNode(caller, called, myProject, myCancelCallback)
+
+    override fun customizeRendererText(renderer: ColoredTreeCellRenderer) {
+        val descriptor = when (myMethod) {
+            is JetFunction -> myMethod.resolveToDescriptor() as FunctionDescriptor
+            is JetClass -> (myMethod.resolveToDescriptor() as ClassDescriptor).getUnsubstitutedPrimaryConstructor() ?: return
+            is PsiMethod -> myMethod.getJavaMethodDescriptor() ?: return
+            else -> throw AssertionError("Invalid declaration: ${myMethod.getElementTextWithContext()}")
+        }
+        val containerName = sequence<DeclarationDescriptor>(descriptor) { it.getContainingDeclaration() }
+                .firstOrNull { it is ClassDescriptor }
+                ?.getName()
+
+        val renderedFunction = KotlinCallHierarchyNodeDescriptor.renderNamedFunction(descriptor)
+        val renderedFunctionWithContainer =
+                containerName?.let {
+                    "${if (it.isSpecial()) "[Anonymous]" else it.asString()}.$renderedFunction"
+                } ?: renderedFunction
+
+        val attributes = if (isEnabled())
+            SimpleTextAttributes(SimpleTextAttributes.STYLE_PLAIN, UIUtil.getTreeForeground())
+        else
+            SimpleTextAttributes.EXCLUDED_ATTRIBUTES
+        renderer.append(renderedFunctionWithContainer, attributes)
+
+        val packageName = (myMethod.getContainingFile() as? PsiClassOwner)?.getPackageName() ?: ""
+        renderer.append("  ($packageName)", SimpleTextAttributes(SimpleTextAttributes.STYLE_ITALIC, JBColor.GRAY))
+    }
+
+    override fun computeCallers(): List<PsiElement> {
+        if (myMethod == null) return emptyList()
+
+        val callers = LinkedHashSet<PsiElement>()
+
+        val processor = object: KotlinCallerMethodsTreeStructure.CalleeReferenceProcessor(false) {
+            override fun onAccept(ref: PsiReference, element: PsiElement) {
+                if ((element is JetFunction || element is JetClass || element is PsiMethod) && element !in myCalled) {
+                    callers.add(element)
+                }
+            }
+        }
+        val query = myMethod.getRepresentativeLightMethod()?.let { MethodReferencesSearch.search(it, it.getUseScope(), true) }
+                    ?: ReferencesSearch.search(myMethod, myMethod.getUseScope())
+        query.forEach { processor.process(it) }
+        return callers.toList()
+    }
+}
\ No newline at end of file
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/usages/JavaMethodDeferredKotlinUsage.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/usages/JavaMethodDeferredKotlinUsage.kt
index 62d67a3afa8..8123e2d3552 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/usages/JavaMethodDeferredKotlinUsage.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/usages/JavaMethodDeferredKotlinUsage.kt
@@ -22,35 +22,41 @@ import org.jetbrains.kotlin.descriptors.FunctionDescriptor
 import org.jetbrains.kotlin.idea.refactoring.changeSignature.JetChangeInfo
 import org.jetbrains.kotlin.psi.JetConstructorDelegationCall
 import org.jetbrains.kotlin.psi.JetFunction
+import org.jetbrains.kotlin.psi.JetNamedDeclaration
 import org.jetbrains.kotlin.types.JetType
 
-public abstract class JavaMethodDeferredKotlinUsage<T: PsiElement>(element: T): UsageInfo(element) {
-        abstract fun resolve(javaMethodChangeInfo: JetChangeInfo): JavaMethodKotlinUsageWithDelegate<T>
+public abstract class JavaMethodDeferredKotlinUsage<T : PsiElement>(element: T) : UsageInfo(element) {
+    abstract fun resolve(javaMethodChangeInfo: JetChangeInfo): JavaMethodKotlinUsageWithDelegate<T>
 }
 
 public class DeferredJavaMethodOverrideOrSAMUsage(
         val function: JetFunction,
         val functionDescriptor: FunctionDescriptor,
         val samCallType: JetType?
-): JavaMethodDeferredKotlinUsage<JetFunction>(function) {
-        override fun resolve(javaMethodChangeInfo: JetChangeInfo): JavaMethodKotlinUsageWithDelegate<JetFunction> {
-                return object : JavaMethodKotlinUsageWithDelegate<JetFunction>(function, javaMethodChangeInfo) {
-                        override val delegateUsage = JetFunctionDefinitionUsage(
-                                function,
-                                functionDescriptor,
-                                javaMethodChangeInfo.methodDescriptor.originalPrimaryFunction,
-                                samCallType
-                        )
-                }
+) : JavaMethodDeferredKotlinUsage<JetFunction>(function) {
+    override fun resolve(javaMethodChangeInfo: JetChangeInfo): JavaMethodKotlinUsageWithDelegate<JetFunction> {
+        return object : JavaMethodKotlinUsageWithDelegate<JetFunction>(function, javaMethodChangeInfo) {
+            override val delegateUsage = JetCallableDefinitionUsage(function, functionDescriptor, javaMethodChangeInfo.methodDescriptor.originalPrimaryCallable, samCallType)
         }
+    }
+}
+
+public class DeferredJavaMethodKotlinCallerUsage(
+        val declaration: JetNamedDeclaration
+) : JavaMethodDeferredKotlinUsage<JetNamedDeclaration>(declaration) {
+    override fun resolve(javaMethodChangeInfo: JetChangeInfo): JavaMethodKotlinUsageWithDelegate<JetNamedDeclaration> {
+        return object : JavaMethodKotlinUsageWithDelegate<JetNamedDeclaration>(declaration, javaMethodChangeInfo) {
+            override val delegateUsage = KotlinCallerUsage(declaration)
+        }
+    }
 }
 
 public class JavaConstructorDeferredUsageInDelegationCall(
         val delegationCall: JetConstructorDelegationCall
-): JavaMethodDeferredKotlinUsage<JetConstructorDelegationCall>(delegationCall) {
-        override fun resolve(javaMethodChangeInfo: JetChangeInfo): JavaMethodKotlinUsageWithDelegate<JetConstructorDelegationCall> {
-                return object : JavaMethodKotlinUsageWithDelegate<JetConstructorDelegationCall>(delegationCall, javaMethodChangeInfo) {
-                        override val delegateUsage = JetConstructorDelegationCallUsage(delegationCall, javaMethodChangeInfo)
-                }
+) : JavaMethodDeferredKotlinUsage<JetConstructorDelegationCall>(delegationCall) {
+    override fun resolve(javaMethodChangeInfo: JetChangeInfo): JavaMethodKotlinUsageWithDelegate<JetConstructorDelegationCall> {
+        return object : JavaMethodKotlinUsageWithDelegate<JetConstructorDelegationCall>(delegationCall, javaMethodChangeInfo) {
+            override val delegateUsage = JetConstructorDelegationCallUsage(delegationCall, javaMethodChangeInfo)
         }
+    }
 }
\ No newline at end of file
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/usages/JavaMethodKotlinUsageWithDelegate.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/usages/JavaMethodKotlinUsageWithDelegate.kt
index 10c3bfc21c8..5be6bb3f743 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/usages/JavaMethodKotlinUsageWithDelegate.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/usages/JavaMethodKotlinUsageWithDelegate.kt
@@ -25,27 +25,19 @@ import org.jetbrains.kotlin.descriptors.FunctionDescriptor
 
 public abstract class JavaMethodKotlinUsageWithDelegate<T: PsiElement>(
         val psiElement: T,
-        val javaMethodChangeInfo: JetChangeInfo): UsageInfo(psiElement) {
-    protected abstract val delegateUsage: JetUsageInfo<T>
+        var javaMethodChangeInfo: JetChangeInfo): UsageInfo(psiElement) {
+    abstract val delegateUsage: JetUsageInfo<T>
 
-    fun processUsage(): Boolean = delegateUsage.processUsage(javaMethodChangeInfo, psiElement)
+    fun processUsage(allUsages: Array<UsageInfo>): Boolean = delegateUsage.processUsage(javaMethodChangeInfo, psiElement, allUsages)
 }
 
 public class JavaMethodKotlinCallUsage(
         callElement: JetCallElement,
-        javaMethodChangeInfo: JetChangeInfo): JavaMethodKotlinUsageWithDelegate<JetCallElement>(callElement, javaMethodChangeInfo) {
-    override protected val delegateUsage = JetFunctionCallUsage(psiElement, javaMethodChangeInfo.methodDescriptor.originalPrimaryFunction)
-}
-
-public class JavaMethodKotlinDerivedDefinitionUsage(
-        function: JetFunction,
-        functionDescriptor: FunctionDescriptor,
-        javaMethodChangeInfo: JetChangeInfo): JavaMethodKotlinUsageWithDelegate<JetFunction>(function, javaMethodChangeInfo) {
-    @suppress("CAST_NEVER_SUCCEEDS")
-    override protected val delegateUsage = JetFunctionDefinitionUsage(
-            psiElement,
-            functionDescriptor,
-            javaMethodChangeInfo.methodDescriptor.originalPrimaryFunction,
-            null
-    )
+        javaMethodChangeInfo: JetChangeInfo,
+        propagationCall: Boolean): JavaMethodKotlinUsageWithDelegate<JetCallElement>(callElement, javaMethodChangeInfo) {
+    override val delegateUsage = if (propagationCall) {
+        KotlinCallerCallUsage(psiElement)
+    } else {
+        JetFunctionCallUsage(psiElement, javaMethodChangeInfo.methodDescriptor.originalPrimaryCallable)
+    }
 }
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/usages/JetFunctionDefinitionUsage.java b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/usages/JetCallableDefinitionUsage.java
similarity index 73%
rename from idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/usages/JetFunctionDefinitionUsage.java
rename to idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/usages/JetCallableDefinitionUsage.java
index 0f611f11a9e..d25a1132d0b 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/usages/JetFunctionDefinitionUsage.java
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/usages/JetCallableDefinitionUsage.java
@@ -21,14 +21,15 @@ import com.intellij.psi.PsiElement;
 import com.intellij.psi.PsiMethod;
 import com.intellij.psi.PsiWhiteSpace;
 import com.intellij.psi.util.PsiTreeUtil;
+import com.intellij.usageView.UsageInfo;
 import kotlin.KotlinPackage;
 import kotlin.Pair;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
+import org.jetbrains.kotlin.descriptors.CallableDescriptor;
 import org.jetbrains.kotlin.descriptors.ClassDescriptor;
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor;
-import org.jetbrains.kotlin.descriptors.FunctionDescriptor;
 import org.jetbrains.kotlin.descriptors.impl.AnonymousFunctionDescriptor;
 import org.jetbrains.kotlin.idea.caches.resolve.ResolvePackage;
 import org.jetbrains.kotlin.idea.codeInsight.shorten.ShortenPackage;
@@ -37,10 +38,12 @@ import org.jetbrains.kotlin.idea.refactoring.changeSignature.ChangeSignaturePack
 import org.jetbrains.kotlin.idea.refactoring.changeSignature.JetChangeInfo;
 import org.jetbrains.kotlin.idea.refactoring.changeSignature.JetParameterInfo;
 import org.jetbrains.kotlin.idea.refactoring.changeSignature.JetValVar;
+import org.jetbrains.kotlin.idea.util.IdeDescriptorRenderers;
 import org.jetbrains.kotlin.idea.util.ShortenReferences;
 import org.jetbrains.kotlin.idea.util.ShortenReferences.Options;
 import org.jetbrains.kotlin.lexer.JetModifierKeywordToken;
 import org.jetbrains.kotlin.psi.*;
+import org.jetbrains.kotlin.psi.psiUtil.PsiUtilPackage;
 import org.jetbrains.kotlin.psi.typeRefHelpers.TypeRefHelpersPackage;
 import org.jetbrains.kotlin.resolve.BindingContext;
 import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils;
@@ -52,14 +55,14 @@ import java.util.List;
 
 import static org.jetbrains.kotlin.psi.PsiPackage.JetPsiFactory;
 
-public class JetFunctionDefinitionUsage<T extends PsiElement> extends JetUsageInfo<T> {
+public class JetCallableDefinitionUsage<T extends PsiElement> extends JetUsageInfo<T> {
     @NotNull
-    private final FunctionDescriptor originalFunctionDescriptor;
+    private final CallableDescriptor originalCallableDescriptor;
 
-    private FunctionDescriptor currentFunctionDescriptor;
+    private CallableDescriptor currentCallableDescriptor;
 
     @NotNull
-    private final JetFunctionDefinitionUsage<? extends PsiElement> baseFunction;
+    private final JetCallableDefinitionUsage<? extends PsiElement> baseFunction;
 
     private final boolean hasExpectedType;
 
@@ -69,24 +72,25 @@ public class JetFunctionDefinitionUsage<T extends PsiElement> extends JetUsageIn
     @Nullable
     private TypeSubstitutor typeSubstitutor;
 
-    public JetFunctionDefinitionUsage(
+    public JetCallableDefinitionUsage(
             @NotNull T function,
-            @NotNull FunctionDescriptor originalFunctionDescriptor,
-            @Nullable JetFunctionDefinitionUsage<PsiElement> baseFunction,
-            @Nullable JetType samCallType) {
+            @NotNull CallableDescriptor originalCallableDescriptor,
+            @Nullable JetCallableDefinitionUsage<PsiElement> baseFunction,
+            @Nullable JetType samCallType
+    ) {
         super(function);
-        this.originalFunctionDescriptor = originalFunctionDescriptor;
+        this.originalCallableDescriptor = originalCallableDescriptor;
         this.baseFunction = baseFunction != null ? baseFunction : this;
-        this.hasExpectedType = checkIfHasExpectedType(originalFunctionDescriptor, isInherited());
+        this.hasExpectedType = checkIfHasExpectedType(originalCallableDescriptor, isInherited());
         this.samCallType = samCallType;
     }
 
-    private static boolean checkIfHasExpectedType(@NotNull FunctionDescriptor functionDescriptor, boolean isInherited) {
-        if (!(functionDescriptor instanceof AnonymousFunctionDescriptor && isInherited)) return false;
+    private static boolean checkIfHasExpectedType(@NotNull CallableDescriptor callableDescriptor, boolean isInherited) {
+        if (!(callableDescriptor instanceof AnonymousFunctionDescriptor && isInherited)) return false;
 
         JetFunctionLiteral functionLiteral =
-                (JetFunctionLiteral) DescriptorToSourceUtils.descriptorToDeclaration(functionDescriptor);
-        assert functionLiteral != null : "No declaration found for " + functionDescriptor;
+                (JetFunctionLiteral) DescriptorToSourceUtils.descriptorToDeclaration(callableDescriptor);
+        assert functionLiteral != null : "No declaration found for " + callableDescriptor;
 
         PsiElement parent = functionLiteral.getParent();
         if (!(parent instanceof JetFunctionLiteralExpression)) return false;
@@ -96,7 +100,7 @@ public class JetFunctionDefinitionUsage<T extends PsiElement> extends JetUsageIn
     }
 
     @NotNull
-    public JetFunctionDefinitionUsage getBaseFunction() {
+    public JetCallableDefinitionUsage getBaseFunction() {
         return baseFunction;
     }
 
@@ -112,10 +116,10 @@ public class JetFunctionDefinitionUsage<T extends PsiElement> extends JetUsageIn
 
         if (typeSubstitutor == null) {
             if (samCallType == null) {
-                typeSubstitutor = ChangeSignaturePackage.getFunctionSubstitutor(baseFunction, this);
+                typeSubstitutor = ChangeSignaturePackage.getCallableSubstitutor(baseFunction, this);
             }
             else {
-                DeclarationDescriptor currentBaseDescriptor = baseFunction.getCurrentFunctionDescriptor();
+                DeclarationDescriptor currentBaseDescriptor = baseFunction.getCurrentCallableDescriptor();
                 DeclarationDescriptor classDescriptor = currentBaseDescriptor != null
                                                         ? currentBaseDescriptor.getContainingDeclaration()
                                                         : null;
@@ -140,71 +144,51 @@ public class JetFunctionDefinitionUsage<T extends PsiElement> extends JetUsageIn
     }
 
     @NotNull
-    public final FunctionDescriptor getOriginalFunctionDescriptor() {
-        return originalFunctionDescriptor;
+    public final CallableDescriptor getOriginalCallableDescriptor() {
+        return originalCallableDescriptor;
     }
 
     @Nullable
-    public final FunctionDescriptor getCurrentFunctionDescriptor() {
-        if (currentFunctionDescriptor == null) {
+    public final CallableDescriptor getCurrentCallableDescriptor() {
+        if (currentCallableDescriptor == null) {
             PsiElement element = getDeclaration();
 
-            if (element instanceof JetFunction) {
-                currentFunctionDescriptor = (FunctionDescriptor) ResolvePackage.resolveToDescriptor((JetFunction) element);
+            if (element instanceof JetFunction || element instanceof JetProperty || element instanceof JetParameter) {
+                currentCallableDescriptor = (CallableDescriptor) ResolvePackage.resolveToDescriptor((JetDeclaration) element);
             }
             else if (element instanceof JetClass) {
-                currentFunctionDescriptor = ((ClassDescriptor) ResolvePackage.resolveToDescriptor((JetClass) element)).getUnsubstitutedPrimaryConstructor();
+                currentCallableDescriptor = ((ClassDescriptor) ResolvePackage.resolveToDescriptor((JetClass) element)).getUnsubstitutedPrimaryConstructor();
             }
             else if (element instanceof PsiMethod) {
-                currentFunctionDescriptor = ResolvePackage.getJavaMethodDescriptor((PsiMethod) element);
+                currentCallableDescriptor = ResolvePackage.getJavaMethodDescriptor((PsiMethod) element);
             }
         }
-        return currentFunctionDescriptor;
+        return currentCallableDescriptor;
     }
 
     @Override
-    public boolean processUsage(JetChangeInfo changeInfo, PsiElement element) {
-        JetParameterList parameterList;
+    public boolean processUsage(@NotNull JetChangeInfo changeInfo, @NotNull PsiElement element, @NotNull UsageInfo[] allUsages) {
+        if (!(element instanceof JetNamedDeclaration)) return true;
 
         JetPsiFactory psiFactory = JetPsiFactory(element.getProject());
-        if (element instanceof JetFunction) {
-            JetFunction function = (JetFunction) element;
-            parameterList = function.getValueParameterList();
 
-            if (changeInfo.isNameChanged()) {
-                PsiElement identifier = function.getNameIdentifier();
+        if (changeInfo.isNameChanged()) {
+            PsiElement identifier = ((JetCallableDeclaration) element).getNameIdentifier();
 
-                if (identifier != null) {
-                    identifier.replace(psiFactory.createIdentifier(changeInfo.getNewName()));
-                }
-            }
-
-            boolean returnTypeIsNeeded = (changeInfo.isRefactoringTarget(originalFunctionDescriptor)
-                                         || !(function instanceof JetFunctionLiteral)
-                                         || function.getTypeReference() != null) &&
-                                         !(function instanceof JetConstructor);
-            if (changeInfo.isReturnTypeChanged() && returnTypeIsNeeded) {
-                function.setTypeReference(null);
-                String returnTypeText = changeInfo.renderReturnType((JetFunctionDefinitionUsage<PsiElement>) this);
-
-                //TODO use ChangeFunctionReturnTypeFix.invoke when JetTypeCodeFragment.getType() is ready
-                if (!KotlinBuiltIns.getInstance().getUnitType().toString().equals(returnTypeText)) {
-                    ShortenPackage.addToShorteningWaitSet(
-                            function.setTypeReference(JetPsiFactory(function).createType(returnTypeText)),
-                            Options.DEFAULT
-                    );
-                }
+            if (identifier != null) {
+                identifier.replace(psiFactory.createIdentifier(changeInfo.getNewName()));
             }
         }
-        else {
-            parameterList = ((JetClass) element).getPrimaryConstructorParameterList();
-        }
+
+        changeReturnTypeIfNeeded(changeInfo, element);
+
+        JetParameterList parameterList = PsiUtilPackage.getValueParameterList((JetNamedDeclaration) element);
 
         if (changeInfo.isParameterSetOrOrderChanged()) {
             processParameterListWithStructuralChanges(changeInfo, element, parameterList, psiFactory);
         }
         else if (parameterList != null) {
-            int paramIndex = originalFunctionDescriptor.getExtensionReceiverParameter() != null ? 1 : 0;
+            int paramIndex = originalCallableDescriptor.getExtensionReceiverParameter() != null ? 1 : 0;
 
             for (JetParameter parameter : parameterList.getParameters()) {
                 JetParameterInfo parameterInfo = changeInfo.getNewParameters()[paramIndex];
@@ -215,11 +199,11 @@ public class JetFunctionDefinitionUsage<T extends PsiElement> extends JetUsageIn
             ShortenPackage.addToShorteningWaitSet(parameterList, Options.DEFAULT);
         }
 
-        if (element instanceof JetFunction && changeInfo.isReceiverTypeChanged()) {
+        if (element instanceof JetCallableDeclaration && changeInfo.isReceiverTypeChanged()) {
             //noinspection unchecked
-            String receiverTypeText = changeInfo.renderReceiverType((JetFunctionDefinitionUsage<PsiElement>) this);
+            String receiverTypeText = changeInfo.renderReceiverType((JetCallableDefinitionUsage<PsiElement>) this);
             JetTypeReference receiverTypeRef = receiverTypeText != null ? psiFactory.createType(receiverTypeText) : null;
-            JetTypeReference newReceiverTypeRef = TypeRefHelpersPackage.setReceiverTypeReference((JetFunction) element, receiverTypeRef);
+            JetTypeReference newReceiverTypeRef = TypeRefHelpersPackage.setReceiverTypeReference((JetCallableDeclaration) element, receiverTypeRef);
             if (newReceiverTypeRef != null) {
                 ShortenPackage.addToShorteningWaitSet(newReceiverTypeRef, ShortenReferences.Options.DEFAULT);
             }
@@ -232,6 +216,36 @@ public class JetFunctionDefinitionUsage<T extends PsiElement> extends JetUsageIn
         return true;
     }
 
+    protected void changeReturnTypeIfNeeded(JetChangeInfo changeInfo, PsiElement element) {
+        if (!(element instanceof JetCallableDeclaration)) return;
+        if (element instanceof JetConstructor) return;
+
+        JetCallableDeclaration callable = (JetCallableDeclaration) element;
+
+        boolean returnTypeIsNeeded;
+        if (element instanceof JetFunction) {
+            returnTypeIsNeeded = (changeInfo.isRefactoringTarget(originalCallableDescriptor) ||
+                                  !(callable instanceof JetFunctionLiteral) ||
+                                  callable.getTypeReference() != null);
+        }
+        else {
+            returnTypeIsNeeded = element instanceof JetProperty || element instanceof JetParameter;
+        }
+
+        if (changeInfo.isReturnTypeChanged() && returnTypeIsNeeded) {
+            callable.setTypeReference(null);
+            String returnTypeText = changeInfo.renderReturnType((JetCallableDefinitionUsage<PsiElement>) this);
+
+            //TODO use ChangeFunctionReturnTypeFix.invoke when JetTypeCodeFragment.getType() is ready
+            if (!(returnTypeText.equals("Unit") || returnTypeText.equals("kotlin.Unit"))) {
+                ShortenPackage.addToShorteningWaitSet(
+                        callable.setTypeReference(JetPsiFactory(callable).createType(returnTypeText)),
+                        Options.DEFAULT
+                );
+            }
+        }
+    }
+
     private void processParameterListWithStructuralChanges(
             JetChangeInfo changeInfo,
             PsiElement element,
@@ -256,14 +270,14 @@ public class JetFunctionDefinitionUsage<T extends PsiElement> extends JetUsageIn
             }
             else {
                 newParameterList = psiFactory.createFunctionLiteralParameterList(changeInfo.getNewParametersSignature(
-                        (JetFunctionDefinitionUsage<PsiElement>) this)
+                        (JetCallableDefinitionUsage<PsiElement>) this)
                 );
                 canReplaceEntireList = true;
             }
         }
-        else {
+        else if (!(element instanceof JetProperty || element instanceof JetParameter)) {
             newParameterList = psiFactory.createParameterList(changeInfo.getNewParametersSignature(
-                    (JetFunctionDefinitionUsage<PsiElement>) this)
+                    (JetCallableDefinitionUsage<PsiElement>) this)
             );
         }
 
@@ -339,14 +353,15 @@ public class JetFunctionDefinitionUsage<T extends PsiElement> extends JetUsageIn
     private static void changeVisibility(JetChangeInfo changeInfo, PsiElement element) {
         JetModifierKeywordToken newVisibilityToken = JetRefactoringUtil.getVisibilityToken(changeInfo.getNewVisibility());
 
-        if (element instanceof JetFunction) {
-            ((JetFunction)element).addModifier(newVisibilityToken);
+        if (element instanceof JetCallableDeclaration) {
+            ((JetCallableDeclaration)element).addModifier(newVisibilityToken);
         }
-        else {
+        else if (element instanceof JetClass) {
             JetPrimaryConstructor constructor = ((JetClass) element).getPrimaryConstructor();
             assert constructor != null : "Primary constructor should be created before changing visibility";
             constructor.addModifier(newVisibilityToken);
         }
+        else throw new AssertionError("Invalid element: " + PsiUtilPackage.getElementTextWithContext(element));
     }
 
     private void changeParameter(int parameterIndex, JetParameter parameter, JetParameterInfo parameterInfo) {
@@ -365,6 +380,7 @@ public class JetFunctionDefinitionUsage<T extends PsiElement> extends JetUsageIn
         }
         else if (valOrVar != JetValVar.None) {
             PsiElement firstChild = parameter.getFirstChild();
+            //noinspection ConstantConditions
             parameter.addBefore(valOrVar.createKeyword(psiFactory), firstChild);
             parameter.addBefore(psiFactory.createWhiteSpace(), firstChild);
         }
@@ -378,7 +394,7 @@ public class JetFunctionDefinitionUsage<T extends PsiElement> extends JetUsageIn
 
         if (identifier != null) {
             //noinspection unchecked
-            String newName = parameterInfo.getInheritedName((JetFunctionDefinitionUsage<PsiElement>) this);
+            String newName = parameterInfo.getInheritedName(this);
             identifier.replace(psiFactory.createIdentifier(newName));
         }
     }
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/usages/JetConstructorDelegationCallUsage.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/usages/JetConstructorDelegationCallUsage.kt
index 5dfd37b2718..e193950b0af 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/usages/JetConstructorDelegationCallUsage.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/usages/JetConstructorDelegationCallUsage.kt
@@ -16,6 +16,7 @@
 
 package org.jetbrains.kotlin.idea.refactoring.changeSignature.usages
 
+import com.intellij.usageView.UsageInfo
 import org.jetbrains.kotlin.idea.refactoring.changeSignature.JetChangeInfo
 import org.jetbrains.kotlin.psi.JetConstructorDelegationCall
 import org.jetbrains.kotlin.psi.JetPsiFactory
@@ -25,9 +26,9 @@ public class JetConstructorDelegationCallUsage(
         call: JetConstructorDelegationCall,
         changeInfo: JetChangeInfo
 ) : JetUsageInfo<JetConstructorDelegationCall>(call) {
-    val delegate = JetFunctionCallUsage(call, changeInfo.methodDescriptor.originalPrimaryFunction)
+    val delegate = JetFunctionCallUsage(call, changeInfo.methodDescriptor.originalPrimaryCallable)
 
-    override fun processUsage(changeInfo: JetChangeInfo, element: JetConstructorDelegationCall): Boolean {
+    override fun processUsage(changeInfo: JetChangeInfo, element: JetConstructorDelegationCall, allUsages: Array<out UsageInfo>): Boolean {
         val isThisCall = element.isCallToThis()
 
         var elementToWorkWith = element
@@ -36,7 +37,7 @@ public class JetConstructorDelegationCallUsage(
             elementToWorkWith = constructor.replaceImplicitDelegationCallWithExplicit(isThisCall)
         }
 
-        val result = delegate.processUsage(changeInfo, elementToWorkWith)
+        val result = delegate.processUsage(changeInfo, elementToWorkWith, allUsages)
 
         if (changeInfo.getNewParametersCount() == 0 && !isThisCall && !elementToWorkWith.isImplicit()) {
             (elementToWorkWith.getParent() as? JetSecondaryConstructor)?.getColon()?.delete()
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/usages/JetEnumEntryWithoutSuperCallUsage.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/usages/JetEnumEntryWithoutSuperCallUsage.kt
index 24c726ab86b..d770acd3b2b 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/usages/JetEnumEntryWithoutSuperCallUsage.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/usages/JetEnumEntryWithoutSuperCallUsage.kt
@@ -16,6 +16,7 @@
 
 package org.jetbrains.kotlin.idea.refactoring.changeSignature.usages
 
+import com.intellij.usageView.UsageInfo
 import org.jetbrains.kotlin.psi.JetEnumEntry
 import org.jetbrains.kotlin.idea.refactoring.changeSignature.JetChangeInfo
 import org.jetbrains.kotlin.psi.JetPsiFactory
@@ -24,7 +25,7 @@ import org.jetbrains.kotlin.psi.JetDelegatorToSuperCall
 import org.jetbrains.kotlin.psi.psiUtil.getStrictParentOfType
 
 public class JetEnumEntryWithoutSuperCallUsage(enumEntry: JetEnumEntry) : JetUsageInfo<JetEnumEntry>(enumEntry) {
-    override fun processUsage(changeInfo: JetChangeInfo, element: JetEnumEntry): Boolean {
+    override fun processUsage(changeInfo: JetChangeInfo, element: JetEnumEntry, allUsages: Array<out UsageInfo>): Boolean {
         if (changeInfo.getNewParameters().size() > 0) {
             val psiFactory = JetPsiFactory(element)
 
@@ -35,8 +36,8 @@ public class JetEnumEntryWithoutSuperCallUsage(enumEntry: JetEnumEntry) : JetUsa
             ) as JetDelegatorToSuperCall
             element.addBefore(psiFactory.createColon(), delegatorToSuperCall)
 
-            return JetFunctionCallUsage(delegatorToSuperCall, changeInfo.methodDescriptor.originalPrimaryFunction)
-                    .processUsage(changeInfo, delegatorToSuperCall)
+            return JetFunctionCallUsage(delegatorToSuperCall, changeInfo.methodDescriptor.originalPrimaryCallable)
+                    .processUsage(changeInfo, delegatorToSuperCall, allUsages)
         }
 
         return true
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/usages/JetFunctionCallUsage.java b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/usages/JetFunctionCallUsage.java
index f88883571d3..dc53ba1645c 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/usages/JetFunctionCallUsage.java
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/usages/JetFunctionCallUsage.java
@@ -20,6 +20,7 @@ import com.intellij.openapi.util.Ref;
 import com.intellij.psi.PsiElement;
 import com.intellij.psi.PsiReference;
 import com.intellij.psi.util.PsiTreeUtil;
+import com.intellij.usageView.UsageInfo;
 import com.intellij.util.containers.ContainerUtil;
 import gnu.trove.TIntArrayList;
 import gnu.trove.TIntProcedure;
@@ -29,21 +30,24 @@ import kotlin.Unit;
 import kotlin.jvm.functions.Function1;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
+import org.jetbrains.kotlin.codegen.PropertyCodegen;
 import org.jetbrains.kotlin.descriptors.*;
 import org.jetbrains.kotlin.idea.caches.resolve.ResolvePackage;
 import org.jetbrains.kotlin.idea.codeInsight.shorten.ShortenPackage;
 import org.jetbrains.kotlin.idea.core.CorePackage;
+import org.jetbrains.kotlin.idea.refactoring.changeSignature.ChangeSignaturePackage;
 import org.jetbrains.kotlin.idea.refactoring.changeSignature.JetChangeInfo;
 import org.jetbrains.kotlin.idea.refactoring.changeSignature.JetParameterInfo;
 import org.jetbrains.kotlin.idea.refactoring.introduce.extractionEngine.ExtractionEnginePackage;
 import org.jetbrains.kotlin.idea.refactoring.introduce.introduceVariable.KotlinIntroduceVariableHandler;
 import org.jetbrains.kotlin.idea.util.ShortenReferences;
+import org.jetbrains.kotlin.load.java.JvmAbi;
+import org.jetbrains.kotlin.load.java.descriptors.JavaMethodDescriptor;
+import org.jetbrains.kotlin.name.Name;
 import org.jetbrains.kotlin.psi.*;
 import org.jetbrains.kotlin.resolve.BindingContext;
 import org.jetbrains.kotlin.resolve.calls.callUtil.CallUtilPackage;
-import org.jetbrains.kotlin.resolve.calls.model.ExpressionValueArgument;
-import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall;
-import org.jetbrains.kotlin.resolve.calls.model.ResolvedValueArgument;
+import org.jetbrains.kotlin.resolve.calls.model.*;
 import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode;
 import org.jetbrains.kotlin.resolve.scopes.receivers.ExpressionReceiver;
 import org.jetbrains.kotlin.resolve.scopes.receivers.ExtensionReceiver;
@@ -75,11 +79,11 @@ public class JetFunctionCallUsage extends JetUsageInfo<JetCallElement> {
 
     private static final ShortenReferences.Options SHORTEN_ARGUMENTS_OPTIONS = new ShortenReferences.Options(true, true);
 
-    private final JetFunctionDefinitionUsage<?> callee;
+    private final JetCallableDefinitionUsage<?> callee;
     private final BindingContext context;
     private final ResolvedCall<? extends CallableDescriptor> resolvedCall;
 
-    public JetFunctionCallUsage(@NotNull JetCallElement element, JetFunctionDefinitionUsage callee) {
+    public JetFunctionCallUsage(@NotNull JetCallElement element, JetCallableDefinitionUsage callee) {
         super(element);
         this.callee = callee;
         this.context = ResolvePackage.analyze(element, BodyResolveMode.FULL);
@@ -87,18 +91,14 @@ public class JetFunctionCallUsage extends JetUsageInfo<JetCallElement> {
     }
 
     @Override
-    public boolean processUsage(JetChangeInfo changeInfo, JetCallElement element) {
-        if (changeInfo.isNameChanged()) {
-            JetExpression callee = element.getCalleeExpression();
+    public boolean processUsage(@NotNull JetChangeInfo changeInfo, @NotNull JetCallElement element, @NotNull UsageInfo[] allUsages) {
+        if (shouldSkipUsage(element)) return true;
 
-            if (callee instanceof JetSimpleNameExpression) {
-                callee.replace(JetPsiFactory(getProject()).createSimpleName(changeInfo.getNewName()));
-            }
-        }
+        changeNameIfNeeded(changeInfo, element);
 
         if (element.getValueArgumentList() != null) {
             if (changeInfo.isParameterSetOrOrderChanged()) {
-                updateArgumentsAndReceiver(changeInfo, element);
+                updateArgumentsAndReceiver(changeInfo, element, allUsages);
             }
             else {
                 changeArgumentNames(changeInfo, element);
@@ -118,6 +118,44 @@ public class JetFunctionCallUsage extends JetUsageInfo<JetCallElement> {
         return true;
     }
 
+    private boolean shouldSkipUsage(JetCallElement element) {
+        // TODO: We probable need more clever processing of invalid calls, but for now default to Java-like behaviour
+        // TODO: Investigate why resolved call is not recorded for enum constructor call
+        if (resolvedCall == null && !(element instanceof JetDelegatorToSuperCall)) return true;
+        if (resolvedCall != null && !resolvedCall.getStatus().isSuccess()) {
+            for (ValueArgument valueArgument : resolvedCall.getCall().getValueArguments()) {
+                if (!(resolvedCall.getArgumentMapping(valueArgument) instanceof ArgumentMatch)) return true;
+            }
+            Map<ValueParameterDescriptor, ResolvedValueArgument> arguments = resolvedCall.getValueArguments();
+            for (ValueParameterDescriptor valueParameter : resolvedCall.getResultingDescriptor().getValueParameters()) {
+                if (!arguments.containsKey(valueParameter)) return true;
+            }
+        }
+        return false;
+    }
+
+    private boolean isPropertyJavaUsage() {
+        PsiElement calleeElement = this.callee.getElement();
+        return (calleeElement instanceof JetProperty || calleeElement instanceof JetParameter)
+               && resolvedCall != null && resolvedCall.getResultingDescriptor() instanceof JavaMethodDescriptor;
+    }
+
+    protected void changeNameIfNeeded(JetChangeInfo changeInfo, JetCallElement element) {
+        if (!changeInfo.isNameChanged()) return;
+
+        JetExpression callee = element.getCalleeExpression();
+        if (!(callee instanceof JetSimpleNameExpression)) return;
+
+        String newName = changeInfo.getNewName();
+        if (isPropertyJavaUsage()) {
+            String currentName = ((JetSimpleNameExpression) callee).getReferencedName();
+            if (currentName.startsWith(JvmAbi.GETTER_PREFIX)) newName = JvmAbi.getterName(newName);
+            else if (currentName.startsWith(JvmAbi.SETTER_PREFIX)) newName = JvmAbi.setterName(newName);
+        }
+
+        callee.replace(JetPsiFactory(getProject()).createSimpleName(newName));
+    }
+
     @Nullable
     private JetExpression getReceiverExpressionIfMatched(
             @NotNull ReceiverValue receiverValue,
@@ -283,11 +321,16 @@ public class JetFunctionCallUsage extends JetUsageInfo<JetCallElement> {
         return newExpression;
     }
 
-    private void updateArgumentsAndReceiver(JetChangeInfo changeInfo, JetCallElement element) {
+    private void updateArgumentsAndReceiver(JetChangeInfo changeInfo, JetCallElement element, @NotNull UsageInfo[] allUsages) {
         JetValueArgumentList arguments = element.getValueArgumentList();
         assert arguments != null : "Argument list is expected: " + element.getText();
         List<? extends ValueArgument> oldArguments = element.getValueArguments();
 
+        if (isPropertyJavaUsage()) {
+            updateJavaPropertyCall(changeInfo, element);
+            return;
+        }
+
         boolean isNamedCall = oldArguments.size() > 1 && oldArguments.get(0).isNamed();
         StringBuilder parametersBuilder = new StringBuilder("(");
         boolean isFirst = true;
@@ -306,11 +349,18 @@ public class JetFunctionCallUsage extends JetUsageInfo<JetCallElement> {
             }
 
             JetExpression defaultValueForCall = parameterInfo.getDefaultValueForCall();
-            String defaultValueText = defaultValueForCall != null
-                                      ? substituteReferences(defaultValueForCall,
-                                                             parameterInfo.getDefaultValueParameterReferences(),
-                                                             psiFactory).getText()
-                                      : "";
+
+            String defaultValueText;
+            if (ChangeSignaturePackage.isInsideOfCallerBody(element, allUsages)) {
+                defaultValueText = parameterInfo.getName();
+            }
+            else {
+                defaultValueText = defaultValueForCall != null
+                                   ? substituteReferences(defaultValueForCall,
+                                                          parameterInfo.getDefaultValueParameterReferences(),
+                                                          psiFactory).getText()
+                                   : "";
+            }
 
             if (isNamedCall) {
                 String newName = parameterInfo.getInheritedName(callee);
@@ -388,7 +438,8 @@ public class JetFunctionCallUsage extends JetUsageInfo<JetCallElement> {
 
         //TODO: this is not correct!
         JetValueArgument lastArgument = KotlinPackage.lastOrNull(newArgumentList.getArguments());
-        boolean hasTrailingLambdaInArgumentListAfter = lastArgument != null && PsiPackage.unpackFunctionLiteral(lastArgument.getArgumentExpression()) != null;
+        boolean hasTrailingLambdaInArgumentListAfter =
+                lastArgument != null && PsiPackage.unpackFunctionLiteral(lastArgument.getArgumentExpression()) != null;
 
         arguments = (JetValueArgumentList) arguments.replace(newArgumentList);
 
@@ -435,6 +486,38 @@ public class JetFunctionCallUsage extends JetUsageInfo<JetCallElement> {
         }
     }
 
+    private static void updateJavaPropertyCall(JetChangeInfo changeInfo, JetCallElement element) {
+        JetParameterInfo newReceiverInfo = changeInfo.getReceiverParameterInfo();
+        JetParameterInfo originalReceiverInfo = changeInfo.getMethodDescriptor().getReceiver();
+        if (newReceiverInfo == originalReceiverInfo) return;
+
+        JetValueArgumentList arguments = element.getValueArgumentList();
+        assert arguments != null : "Argument list is expected: " + element.getText();
+        List<? extends ValueArgument> oldArguments = element.getValueArguments();
+
+        JetPsiFactory psiFactory = new JetPsiFactory(element.getProject());
+
+        JetValueArgument firstArgument = oldArguments.isEmpty() ? null : (JetValueArgument) oldArguments.get(0);
+
+        if (newReceiverInfo == null) {
+            if (firstArgument != null) arguments.removeArgument(firstArgument);
+        }
+        else {
+            JetExpression defaultValueForCall = newReceiverInfo.getDefaultValueForCall();
+            if (defaultValueForCall == null) {
+                defaultValueForCall = psiFactory.createExpression("_");
+            }
+            JetValueArgument newReceiverArgument = psiFactory.createArgument(defaultValueForCall, null, false);
+
+            if (originalReceiverInfo != null) {
+                if (firstArgument != null) firstArgument.replace(newReceiverArgument);
+            }
+            else {
+                arguments.addArgumentAfter(newReceiverArgument, null);
+            }
+        }
+    }
+
     @Nullable
     private static JetExpression getReceiverExpression(@NotNull ReceiverValue receiver, @NotNull JetPsiFactory psiFactory) {
         if (receiver instanceof ExpressionReceiver) {
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/usages/JetImplicitThisToParameterUsage.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/usages/JetImplicitThisToParameterUsage.kt
index b67d7c1ce6e..b85e7bcec7e 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/usages/JetImplicitThisToParameterUsage.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/usages/JetImplicitThisToParameterUsage.kt
@@ -16,6 +16,7 @@
 
 package org.jetbrains.kotlin.idea.refactoring.changeSignature.usages
 
+import com.intellij.usageView.UsageInfo
 import org.jetbrains.kotlin.idea.refactoring.changeSignature.JetChangeInfo
 import org.jetbrains.kotlin.idea.refactoring.changeSignature.JetParameterInfo
 import org.jetbrains.kotlin.psi.JetPsiFactory
@@ -32,7 +33,7 @@ public abstract class JetImplicitReceiverUsage(callElement: JetElement): JetUsag
 
     }
 
-    override fun processUsage(changeInfo: JetChangeInfo, element: JetElement): Boolean {
+    override fun processUsage(changeInfo: JetChangeInfo, element: JetElement, allUsages: Array<out UsageInfo>): Boolean {
         val newQualifiedCall = JetPsiFactory(element.getProject()).createExpression(
                 "${getNewReceiverText()}.${element.getText()}"
         ) as JetQualifiedExpression
@@ -44,16 +45,16 @@ public abstract class JetImplicitReceiverUsage(callElement: JetElement): JetUsag
 public class JetImplicitThisToParameterUsage(
         callElement: JetElement,
         val parameterInfo: JetParameterInfo,
-        val containingFunction: JetFunctionDefinitionUsage<*>
+        val containingCallable: JetCallableDefinitionUsage<*>
 ): JetImplicitReceiverUsage(callElement) {
-    override fun getNewReceiverText(): String = parameterInfo.getInheritedName(containingFunction)
+    override fun getNewReceiverText(): String = parameterInfo.getInheritedName(containingCallable)
 
     override fun processReplacedElement(element: JetElement) {
         element.addToShorteningWaitSet(Options(removeThisLabels = true))
     }
 }
 
-public class JetImplicitOuterThisToQualifiedThisUsage(
+public class JetImplicitThisUsage(
         callElement: JetElement,
         val targetDescriptor: DeclarationDescriptor
 ): JetImplicitReceiverUsage(callElement) {
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/usages/JetParameterUsage.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/usages/JetParameterUsage.kt
index 5af65b9a57b..c43224b3226 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/usages/JetParameterUsage.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/usages/JetParameterUsage.kt
@@ -16,6 +16,7 @@
 
 package org.jetbrains.kotlin.idea.refactoring.changeSignature.usages
 
+import com.intellij.usageView.UsageInfo
 import org.jetbrains.kotlin.psi.JetSimpleNameExpression
 import org.jetbrains.kotlin.psi.JetPsiFactory
 import org.jetbrains.kotlin.idea.refactoring.changeSignature.JetChangeInfo
@@ -35,7 +36,7 @@ public abstract class JetExplicitReferenceUsage<T: JetElement>(element: T) : Jet
 
     }
 
-    override fun processUsage(changeInfo: JetChangeInfo, element: T): Boolean {
+    override fun processUsage(changeInfo: JetChangeInfo, element: T, allUsages: Array<out UsageInfo>): Boolean {
         val newElement = JetPsiFactory(element.getProject()).createExpression(getReplacementText(changeInfo))
         val elementToReplace = (element.getParent() as? JetThisExpression) ?: element
         processReplacedElement(elementToReplace.replace(newElement) as JetElement)
@@ -46,7 +47,7 @@ public abstract class JetExplicitReferenceUsage<T: JetElement>(element: T) : Jet
 public class JetParameterUsage(
         element: JetElement,
         private val parameterInfo: JetParameterInfo,
-        val containingFunction: JetFunctionDefinitionUsage<*>
+        val containingCallable: JetCallableDefinitionUsage<*>
 ) : JetExplicitReferenceUsage<JetElement>(element) {
     override fun processReplacedElement(element: JetElement) {
         val qualifiedExpression = element.getParent() as? JetQualifiedExpression
@@ -56,7 +57,7 @@ public class JetParameterUsage(
 
     override fun getReplacementText(changeInfo: JetChangeInfo): String =
             if (changeInfo.receiverParameterInfo != parameterInfo) {
-                parameterInfo.getInheritedName(containingFunction)
+                parameterInfo.getInheritedName(containingCallable)
             } else "this@${changeInfo.getNewName()}"
 }
 
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/usages/JetPropertyCallUsage.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/usages/JetPropertyCallUsage.kt
new file mode 100644
index 00000000000..cc55146954c
--- /dev/null
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/usages/JetPropertyCallUsage.kt
@@ -0,0 +1,66 @@
+/*
+ * Copyright 2010-2015 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.kotlin.idea.refactoring.changeSignature.usages
+
+import com.intellij.usageView.UsageInfo
+import org.jetbrains.kotlin.idea.caches.resolve.analyze
+import org.jetbrains.kotlin.idea.refactoring.changeSignature.JetChangeInfo
+import org.jetbrains.kotlin.idea.references.mainReference
+import org.jetbrains.kotlin.psi.JetPsiFactory
+import org.jetbrains.kotlin.psi.JetQualifiedExpression
+import org.jetbrains.kotlin.psi.JetSimpleNameExpression
+import org.jetbrains.kotlin.psi.createExpressionByPattern
+import org.jetbrains.kotlin.psi.psiUtil.getQualifiedExpressionForSelectorOrThis
+import org.jetbrains.kotlin.resolve.calls.callUtil.getResolvedCall
+import org.jetbrains.kotlin.resolve.scopes.receivers.ExpressionReceiver
+
+public class JetPropertyCallUsage(element: JetSimpleNameExpression): JetUsageInfo<JetSimpleNameExpression>(element) {
+    private val resolvedCall = element.getResolvedCall(element.analyze())
+
+    override fun processUsage(changeInfo: JetChangeInfo, element: JetSimpleNameExpression, allUsages: Array<out UsageInfo>): Boolean {
+        updateName(changeInfo, element)
+        updateReceiver(changeInfo, element)
+        return true
+    }
+
+    private fun updateName(changeInfo: JetChangeInfo, element: JetSimpleNameExpression) {
+        if (changeInfo.isNameChanged()) {
+            element.mainReference.handleElementRename(changeInfo.getNewName())
+        }
+    }
+
+    private fun updateReceiver(changeInfo: JetChangeInfo, element: JetSimpleNameExpression) {
+        val newReceiver = changeInfo.receiverParameterInfo
+        val oldReceiver = changeInfo.methodDescriptor.receiver
+        if (newReceiver == oldReceiver) return
+
+        val elementToReplace = element.getQualifiedExpressionForSelectorOrThis()
+
+        // Do not add extension receiver to calls with explicit dispatch receiver
+        if (newReceiver != null
+            && elementToReplace is JetQualifiedExpression
+            && resolvedCall?.getDispatchReceiver() is ExpressionReceiver) return
+
+        val replacingElement = newReceiver?.let {
+            val psiFactory = JetPsiFactory(getProject())
+            val receiver = it.defaultValueForCall ?: psiFactory.createExpression("_")
+            psiFactory.createExpressionByPattern("$0.$1", receiver, element)
+        } ?: element
+
+        elementToReplace.replace(replacingElement)
+    }
+}
\ No newline at end of file
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/usages/JetUsageInfo.java b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/usages/JetUsageInfo.kt
similarity index 52%
rename from idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/usages/JetUsageInfo.java
rename to idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/usages/JetUsageInfo.kt
index 118926c7b7a..9702a5a5e4f 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/usages/JetUsageInfo.java
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/usages/JetUsageInfo.kt
@@ -14,30 +14,19 @@
  * limitations under the License.
  */
 
-package org.jetbrains.kotlin.idea.refactoring.changeSignature.usages;
+package org.jetbrains.kotlin.idea.refactoring.changeSignature.usages
 
-import com.intellij.psi.PsiElement;
-import com.intellij.psi.PsiReference;
-import com.intellij.usageView.UsageInfo;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.idea.refactoring.changeSignature.JetChangeInfo;
+import com.intellij.psi.PsiElement
+import com.intellij.psi.PsiReference
+import com.intellij.usageView.UsageInfo
+import org.jetbrains.kotlin.idea.refactoring.changeSignature.JetChangeInfo
 
-public abstract class JetUsageInfo<T extends PsiElement> extends UsageInfo {
-    public JetUsageInfo(@NotNull T element) {
-        super(element);
-    }
+public abstract class JetUsageInfo<T : PsiElement> : UsageInfo {
+    public constructor(element: T) : super(element)
+    public constructor(reference: PsiReference) : super(reference)
 
-    public JetUsageInfo(@NotNull PsiReference reference) {
-        super(reference);
-    }
+    @suppress("UNCHECKED_CAST")
+    override fun getElement() = super.getElement() as T?
 
-    @Nullable
-    @Override
-    public T getElement() {
-        //noinspection unchecked
-        return (T) super.getElement();
-    }
-
-    public abstract boolean processUsage(JetChangeInfo changeInfo, T element);
+    public abstract fun processUsage(changeInfo: JetChangeInfo, element: T, allUsages: Array<out UsageInfo>): Boolean
 }
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/usages/KotlinCallerUsages.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/usages/KotlinCallerUsages.kt
new file mode 100644
index 00000000000..34da97664ff
--- /dev/null
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/usages/KotlinCallerUsages.kt
@@ -0,0 +1,77 @@
+/*
+ * Copyright 2010-2015 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.kotlin.idea.refactoring.changeSignature.usages
+
+import com.intellij.usageView.UsageInfo
+import org.jetbrains.kotlin.idea.codeInsight.shorten.addToShorteningWaitSet
+import org.jetbrains.kotlin.idea.refactoring.changeSignature.JetChangeInfo
+import org.jetbrains.kotlin.idea.refactoring.changeSignature.getAffectedCallables
+import org.jetbrains.kotlin.idea.refactoring.changeSignature.isInsideOfCallerBody
+import org.jetbrains.kotlin.name.Name
+import org.jetbrains.kotlin.psi.*
+import org.jetbrains.kotlin.psi.psiUtil.getValueParameterList
+
+public class KotlinCallerUsage(element: JetNamedDeclaration): JetUsageInfo<JetNamedDeclaration>(element) {
+    override fun processUsage(changeInfo: JetChangeInfo, element: JetNamedDeclaration, allUsages: Array<out UsageInfo>): Boolean {
+        // Do not process function twice
+        if (changeInfo.getAffectedCallables().any { it is JetCallableDefinitionUsage<*> && it.getElement() == element }) return true
+
+        val parameterList = when (element) {
+            is JetFunction -> element.getValueParameterList()
+            is JetClass -> element.createPrimaryConstructorParameterListIfAbsent()
+            else -> null
+        } ?: return true
+        val psiFactory = JetPsiFactory(getProject())
+        changeInfo.getNonReceiverParameters()
+                .withIndex()
+                .filter { it.value.isNewParameter }
+                .forEach {
+                    val parameterText = it.value.getDeclarationSignature(it.index, changeInfo.methodDescriptor.originalPrimaryCallable)
+                    parameterList
+                            .addParameter(psiFactory.createParameter(parameterText))
+                            .addToShorteningWaitSet()
+                }
+
+        return true
+    }
+}
+
+public class KotlinCallerCallUsage(element: JetCallElement): JetUsageInfo<JetCallElement>(element) {
+    override fun processUsage(changeInfo: JetChangeInfo, element: JetCallElement, allUsages: Array<out UsageInfo>): Boolean {
+        val argumentList = element.getValueArgumentList() ?: return true
+        val psiFactory = JetPsiFactory(getProject())
+        val isNamedCall = argumentList.getArguments().any { it.getArgumentName() != null }
+        changeInfo.getNonReceiverParameters()
+                .filter { it.isNewParameter }
+                .forEach {
+                    val parameterName = it.getName()
+                    val argumentExpression = if (element.isInsideOfCallerBody(allUsages)) {
+                        psiFactory.createExpression(parameterName)
+                    }
+                    else {
+                        it.defaultValueForCall ?: psiFactory.createExpression("_")
+                    }
+                    val argument = psiFactory.createArgument(
+                            expression = argumentExpression,
+                            name = if (isNamedCall) Name.identifier(parameterName) else null
+                    )
+                    argumentList.addArgument(argument)
+                }
+
+        return true
+    }
+}
\ No newline at end of file
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/usages/KotlinWrapperForJavaUsageInfos.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/usages/KotlinWrapperForJavaUsageInfos.kt
index 3d941aba020..f1ade8c2a92 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/usages/KotlinWrapperForJavaUsageInfos.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/usages/KotlinWrapperForJavaUsageInfos.kt
@@ -17,9 +17,19 @@
 package org.jetbrains.kotlin.idea.refactoring.changeSignature.usages
 
 import com.intellij.psi.PsiElement
+import com.intellij.refactoring.changeSignature.JavaChangeInfo
 import com.intellij.usageView.UsageInfo
 
 public class KotlinWrapperForJavaUsageInfos(
+        val javaChangeInfo: JavaChangeInfo,
         val javaUsageInfos: Array<UsageInfo>,
         val primaryMethod: PsiElement
-): UsageInfo(primaryMethod)
+): UsageInfo(primaryMethod) {
+    override fun hashCode(): Int {
+        return javaChangeInfo.getMethod().hashCode();
+    }
+
+    override fun equals(other: Any?): Boolean {
+        return other == this || (other is KotlinWrapperForJavaUsageInfos && javaChangeInfo.getMethod() == other.javaChangeInfo.getMethod())
+    }
+}
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/AbstractKotlinInplaceIntroducer.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/AbstractKotlinInplaceIntroducer.kt
index 7f79fa4e481..6027764c88b 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/AbstractKotlinInplaceIntroducer.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/AbstractKotlinInplaceIntroducer.kt
@@ -85,7 +85,7 @@ public abstract class AbstractKotlinInplaceIntroducer<D: JetNamedDeclaration>(
 
     override fun updateTitle(declaration: D?) = updateTitle(declaration, null)
 
-    override fun saveSettings(declaration: D?) {
+    override fun saveSettings(declaration: D) {
 
     }
 }
\ No newline at end of file
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/extractionEngine/ExtractableCodeDescriptor.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/extractionEngine/ExtractableCodeDescriptor.kt
index eba4e33f276..37a8a31ee16 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/extractionEngine/ExtractableCodeDescriptor.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/extractionEngine/ExtractableCodeDescriptor.kt
@@ -33,14 +33,16 @@ import org.jetbrains.kotlin.idea.refactoring.introduce.extractionEngine.OutputVa
 import org.jetbrains.kotlin.idea.refactoring.introduce.extractionEngine.OutputValue.Jump
 import org.jetbrains.kotlin.idea.references.JetSimpleNameReference
 import org.jetbrains.kotlin.idea.references.JetSimpleNameReference.ShorteningMode
+import org.jetbrains.kotlin.idea.references.mainReference
 import org.jetbrains.kotlin.idea.util.approximateFlexibleTypes
 import org.jetbrains.kotlin.idea.util.isAnnotatedNotNull
 import org.jetbrains.kotlin.idea.util.isAnnotatedNullable
-import org.jetbrains.kotlin.idea.util.isUnit
+import org.jetbrains.kotlin.types.typeUtil.isUnit
 import org.jetbrains.kotlin.idea.util.psi.patternMatching.JetPsiRange
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.getQualifiedElementSelector
+import org.jetbrains.kotlin.psi.psiUtil.getQualifiedExpressionForSelector
 import org.jetbrains.kotlin.psi.psiUtil.getQualifiedExpressionForSelectorOrThis
 import org.jetbrains.kotlin.psi.psiUtil.getStrictParentOfType
 import org.jetbrains.kotlin.resolve.BindingContext
@@ -82,7 +84,7 @@ class RenameReplacement(override val parameter: Parameter): ParameterReplacement
     override fun copy(parameter: Parameter) = RenameReplacement(parameter)
 
     override fun invoke(e: JetElement): JetElement {
-        var expressionToReplace = (e.getParent() as? JetThisExpression ?: e).getQualifiedExpressionForSelectorOrThis()
+        var expressionToReplace = (e.getParent() as? JetThisExpression ?: e).let { it.getQualifiedExpressionForSelector() ?: it }
         val parameterName = JetPsiUtil.unquoteIdentifier(parameter.nameForRef)
         val replacingName =
                 if (e.getText().startsWith('`') || !KotlinNameSuggester.isIdentifier(parameterName)) "`$parameterName`" else parameterName
@@ -117,7 +119,7 @@ class FqNameReplacement(val fqName: FqName): Replacement {
             return thisExpr.replaced(JetPsiFactory(e).createExpression(fqName.asString())).getQualifiedElementSelector()!!
         }
 
-        val newExpr = (e.getReference() as? JetSimpleNameReference)?.bindToFqName(fqName, ShorteningMode.NO_SHORTENING) as JetElement
+        val newExpr = (e as? JetSimpleNameExpression)?.mainReference?.bindToFqName(fqName, ShorteningMode.NO_SHORTENING) as JetElement
         return if (newExpr is JetQualifiedExpression) newExpr.getSelectorExpression()!! else newExpr
     }
 }
@@ -309,7 +311,7 @@ val ControlFlow.possibleReturnTypes: List<JetType>
             returnType.isAnnotatedNotNull(), returnType.isAnnotatedNullable() ->
                 listOf(approximateFlexibleTypes(returnType))
             else ->
-                returnType.getCapability(javaClass<Flexibility>()).let { listOf(it.upperBound, it.lowerBound) }
+                returnType.getCapability(javaClass<Flexibility>()).let { listOf(it!!.upperBound, it.lowerBound) }
         }
     }
 
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/extractionEngine/extractableAnalysisUtil.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/extractionEngine/extractableAnalysisUtil.kt
index 59612298acf..6304cdc897c 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/extractionEngine/extractableAnalysisUtil.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/extractionEngine/extractableAnalysisUtil.kt
@@ -59,10 +59,11 @@ import org.jetbrains.kotlin.idea.refactoring.introduce.extractionEngine.OutputVa
 import org.jetbrains.kotlin.idea.refactoring.introduce.extractionEngine.OutputValue.Jump
 import org.jetbrains.kotlin.idea.refactoring.introduce.extractionEngine.OutputValue.ParameterUpdate
 import org.jetbrains.kotlin.idea.refactoring.introduce.extractionEngine.OutputValueBoxer.AsList
+import org.jetbrains.kotlin.idea.references.mainReference
 import org.jetbrains.kotlin.idea.util.IdeDescriptorRenderers
 import org.jetbrains.kotlin.idea.util.approximateWithResolvableType
 import org.jetbrains.kotlin.idea.util.isResolvableInScope
-import org.jetbrains.kotlin.idea.util.makeNullable
+import org.jetbrains.kotlin.types.typeUtil.makeNullable
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.*
 import org.jetbrains.kotlin.resolve.BindingContext
@@ -428,7 +429,7 @@ private fun JetType.collectReferencedTypes(processTypeArguments: Boolean): List<
 fun JetTypeParameter.collectRelevantConstraints(): List<JetTypeConstraint> {
     val typeConstraints = getNonStrictParentOfType<JetTypeParameterListOwner>()?.getTypeConstraints()
     if (typeConstraints == null) return Collections.emptyList()
-    return typeConstraints.filter { it.getSubjectTypeParameterName()?.getReference()?.resolve() == this}
+    return typeConstraints.filter { it.getSubjectTypeParameterName()?.mainReference?.resolve() == this}
 }
 
 fun TypeParameter.collectReferencedTypes(bindingContext: BindingContext): List<JetType> {
@@ -520,7 +521,7 @@ private class MutableParameter(
 
     private val defaultType: JetType by Delegates.lazy {
         writable = false
-        TypeUtils.intersect(JetTypeChecker.DEFAULT, defaultTypes)
+        TypeUtils.intersect(JetTypeChecker.DEFAULT, defaultTypes)!!
     }
 
     private val parameterTypeCandidates: List<JetType> by Delegates.lazy {
@@ -530,7 +531,7 @@ private class MutableParameter(
 
         val typeList = if (defaultType.isNullabilityFlexible()) {
             val bounds = defaultType.getCapability(javaClass<Flexibility>())
-            if (typePredicate(bounds.upperBound)) arrayListOf(bounds.upperBound, bounds.lowerBound) else arrayListOf(bounds.lowerBound)
+            if (typePredicate(bounds!!.upperBound)) arrayListOf(bounds.upperBound, bounds.lowerBound) else arrayListOf(bounds.lowerBound)
         }
         else arrayListOf(defaultType)
 
@@ -780,7 +781,7 @@ private fun ExtractionData.checkDeclarationsMovingOutOfScope(
     controlFlow.jumpOutputValue?.elementToInsertAfterCall?.accept(
             object : JetTreeVisitorVoid() {
                 override fun visitSimpleNameExpression(expression: JetSimpleNameExpression) {
-                    val target = expression.getReference()?.resolve()
+                    val target = expression.mainReference.resolve()
                     if (target is JetNamedDeclaration
                         && target.isInsideOf(originalElements)
                         && target.getStrictParentOfType<JetDeclaration>() == enclosingDeclaration) {
@@ -1006,7 +1007,7 @@ fun ExtractableCodeDescriptor.validate(): ExtractableCodeDescriptorWithConflicts
             object : JetTreeVisitorVoid() {
                 override fun visitUserType(userType: JetUserType) {
                     val refExpr = userType.getReferenceExpression() ?: return
-                    val declaration = refExpr.getReference()?.resolve() as? PsiNamedElement ?: return
+                    val declaration = refExpr.mainReference.resolve() as? PsiNamedElement ?: return
                     val diagnostics = bindingContext.getDiagnostics().forElement(refExpr)
                     diagnostics.firstOrNull { it.getFactory() == Errors.INVISIBLE_REFERENCE }?.let {
                         conflicts.putValue(declaration, getDeclarationMessage(declaration, "0.will.become.invisible.after.extraction"))
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/extractionEngine/extractorUtil.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/extractionEngine/extractorUtil.kt
index 8c05f0a9ad4..245e8137df1 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/extractionEngine/extractorUtil.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/extractionEngine/extractorUtil.kt
@@ -275,7 +275,7 @@ private fun makeCall(
     val inlinableCall = controlFlow.outputValues.size() <= 1
     val unboxingExpressions =
             if (inlinableCall) {
-                controlFlow.outputValueBoxer.getUnboxingExpressions(callText)
+                controlFlow.outputValueBoxer.getUnboxingExpressions(callText!!)
             }
             else {
                 val varNameValidator = NewDeclarationNameValidator(block, anchorInBlock, NewDeclarationNameValidator.Target.VARIABLES)
@@ -293,7 +293,7 @@ private fun makeCall(
     }
 
     if (controlFlow.outputValues.isEmpty()) {
-        anchor.replace(psiFactory.createExpression(callText))
+        anchor.replace(psiFactory.createExpression(callText!!))
         return
     }
 
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/introduceParameter/KotlinInplaceParameterIntroducer.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/introduceParameter/KotlinInplaceParameterIntroducer.kt
index dda2333174d..c773e3840e5 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/introduceParameter/KotlinInplaceParameterIntroducer.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/introduceParameter/KotlinInplaceParameterIntroducer.kt
@@ -34,7 +34,7 @@ import org.jetbrains.kotlin.idea.refactoring.introduce.AbstractKotlinInplaceIntr
 import org.jetbrains.kotlin.idea.refactoring.introduce.introduceVariable.KotlinInplaceVariableIntroducer
 import org.jetbrains.kotlin.idea.util.application.runWriteAction
 import org.jetbrains.kotlin.idea.util.psi.patternMatching.toRange
-import org.jetbrains.kotlin.idea.util.supertypes
+import org.jetbrains.kotlin.types.typeUtil.supertypes
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.getElementTextWithContext
 import org.jetbrains.kotlin.psi.psiUtil.getValueParameterList
@@ -135,7 +135,7 @@ public class KotlinInplaceParameterIntroducer(
                     val parameterText = if (parameter == addedParameter){
                         val parameterName = currentName ?: parameter.getName()
                         val parameterType = currentType ?: parameter.getTypeReference()!!.getText()
-                        descriptor = descriptor.copy(newParameterName = parameterName, newParameterTypeText = parameterType)
+                        descriptor = descriptor.copy(newParameterName = parameterName!!, newParameterTypeText = parameterType)
                         val modifier = if (valVar != JetValVar.None) "${valVar.name} " else ""
                         val defaultValue = if (withDefaultValue) " = ${newArgumentValue.getText()}" else ""
 
@@ -250,7 +250,7 @@ public class KotlinInplaceParameterIntroducer(
         return descriptor.copy(
                 originalRange = originalRange,
                 occurrencesToReplace = if (replaceAll) getOccurrences().map { it.toRange() } else originalRange.singletonList(),
-                newArgumentValue = getExpr()
+                newArgumentValue = getExpr()!!
         )
     }
 
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/introduceParameter/KotlinIntroduceParameterDialog.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/introduceParameter/KotlinIntroduceParameterDialog.kt
index c5d2a50adb6..4757952c6ce 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/introduceParameter/KotlinIntroduceParameterDialog.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/introduceParameter/KotlinIntroduceParameterDialog.kt
@@ -32,6 +32,7 @@ import com.intellij.usageView.UsageInfo
 import org.jetbrains.kotlin.idea.JetFileType
 import org.jetbrains.kotlin.idea.core.refactoring.isMultiLine
 import org.jetbrains.kotlin.idea.core.refactoring.runRefactoringWithPostprocessing
+import org.jetbrains.kotlin.idea.core.refactoring.validateElement
 import org.jetbrains.kotlin.idea.refactoring.introduce.extractFunction.ui.KotlinExtractFunctionDialog
 import org.jetbrains.kotlin.idea.refactoring.introduce.extractFunction.ui.KotlinParameterTablePanel
 import org.jetbrains.kotlin.idea.refactoring.introduce.extractionEngine.*
@@ -233,18 +234,9 @@ public class KotlinIntroduceParameterDialog private constructor(
     override fun createCenterPanel() = null
 
     override fun canRun() {
-        fun validateElement(e: PsiElement, errorMessage: String) {
-            try {
-                AnalyzingUtils.checkForSyntacticErrors(e)
-            }
-            catch(e: Exception) {
-                throw ConfigurationException(errorMessage)
-            }
-        }
-
         val psiFactory = JetPsiFactory(myProject)
-        validateElement(psiFactory.createType(nameField.getEnteredName()), "Invalid parameter name")
-        validateElement(psiFactory.createType(typeField.getEnteredName()), "Invalid parameter type")
+        psiFactory.createSimpleName(nameField.getEnteredName()).validateElement("Invalid parameter name")
+        psiFactory.createType(typeField.getEnteredName()).validateElement("Invalid parameter type")
     }
 
     override fun doAction() {
@@ -331,7 +323,7 @@ public class KotlinIntroduceParameterDialog private constructor(
 
                     override fun createUsageViewDescriptor(usages: Array<out UsageInfo>) = BaseUsageViewDescriptor()
 
-                    override fun getCommandName() = commandName
+                    override fun getCommandName(): String = commandName
                 }
         )
     }
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/introduceParameter/KotlinIntroduceParameterHandler.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/introduceParameter/KotlinIntroduceParameterHandler.kt
index 5d35a857ab3..d8deb8e1b8c 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/introduceParameter/KotlinIntroduceParameterHandler.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/introduceParameter/KotlinIntroduceParameterHandler.kt
@@ -50,6 +50,7 @@ import org.jetbrains.kotlin.idea.refactoring.introduce.introduceVariable.KotlinI
 import org.jetbrains.kotlin.idea.refactoring.introduce.selectElementsWithTargetParent
 import org.jetbrains.kotlin.idea.refactoring.introduce.showErrorHint
 import org.jetbrains.kotlin.idea.refactoring.introduce.showErrorHintByKey
+import org.jetbrains.kotlin.idea.references.mainReference
 import org.jetbrains.kotlin.idea.search.usagesSearch.DefaultSearchHelper
 import org.jetbrains.kotlin.idea.search.usagesSearch.UsagesSearchTarget
 import org.jetbrains.kotlin.idea.search.usagesSearch.search
@@ -65,6 +66,9 @@ import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.calls.callUtil.getResolvedCall
 import org.jetbrains.kotlin.resolve.scopes.JetScopeUtils
 import org.jetbrains.kotlin.resolve.scopes.receivers.ThisReceiver
+import org.jetbrains.kotlin.types.typeUtil.isNothing
+import org.jetbrains.kotlin.types.typeUtil.isUnit
+import org.jetbrains.kotlin.types.typeUtil.supertypes
 import java.util.*
 import kotlin.test.fail
 
@@ -142,7 +146,7 @@ fun IntroduceParameterDescriptor.performRefactoring() {
                                 .forEach { methodDescriptor.removeParameter(it) }
                     }
 
-                    val parameterInfo = JetParameterInfo(functionDescriptor = callableDescriptor,
+                    val parameterInfo = JetParameterInfo(callableDescriptor = callableDescriptor,
                                                          name = newParameterName,
                                                          defaultValueForCall = if (withDefaultValue) null else newArgumentValue,
                                                          defaultValueForParameter = if (withDefaultValue) newArgumentValue else null,
@@ -210,7 +214,7 @@ public open class KotlinIntroduceParameterHandler(
     open fun invoke(project: Project, editor: Editor, expression: JetExpression, targetParent: JetNamedDeclaration) {
         val context = expression.analyze()
 
-        val expressionType = context.getType(expression)
+        val expressionType = context.getType(expression)!!
         if (expressionType.isUnit() || expressionType.isNothing()) {
             val message = JetRefactoringBundle.message(
                     "cannot.introduce.parameter.of.0.type",
@@ -364,7 +368,7 @@ private fun findInternalUsagesOfParametersAndReceiver(
                     override fun visitThisExpression(expression: JetThisExpression) {
                         super.visitThisExpression(expression)
 
-                        if (expression.getInstanceReference().getReference()?.resolve() == targetDescriptor) {
+                        if (expression.getInstanceReference().mainReference.resolve() == targetDescriptor) {
                             usages.putValue(receiverTypeRef, expression)
                         }
                     }
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/introduceParameter/KotlinIntroduceParameterMethodUsageProcessor.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/introduceParameter/KotlinIntroduceParameterMethodUsageProcessor.kt
index 1eb345ea27f..206873cb47f 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/introduceParameter/KotlinIntroduceParameterMethodUsageProcessor.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/introduceParameter/KotlinIntroduceParameterMethodUsageProcessor.kt
@@ -77,7 +77,7 @@ public class KotlinIntroduceParameterMethodUsageProcessor : IntroduceParameterMe
 
         // Temporarily assume that the new parameter is of Any type. Actual type is substituted during the signature update phase
         val defaultValueForCall = (data.getParameterInitializer().getExpression()!! as? PsiExpression)?.let { it.j2k() }
-        changeInfo.addParameter(JetParameterInfo(functionDescriptor = psiMethodDescriptor,
+        changeInfo.addParameter(JetParameterInfo(callableDescriptor = psiMethodDescriptor,
                                                  name = data.getParameterName(),
                                                  type = KotlinBuiltIns.getInstance().getAnyType(),
                                                  defaultValueForCall = defaultValueForCall))
@@ -89,7 +89,7 @@ public class KotlinIntroduceParameterMethodUsageProcessor : IntroduceParameterMe
 
         val changeInfo = createChangeInfo(data, element) ?: return true
         // Java method is already updated at this point
-        val addedParameterType = data.getMethodToReplaceIn().getJavaMethodDescriptor().getValueParameters().last().getType()
+        val addedParameterType = data.getMethodToReplaceIn().getJavaMethodDescriptor()!!.getValueParameters().last().getType()
         changeInfo.getNewParameters().last().currentTypeText = IdeDescriptorRenderers.SOURCE_CODE.renderType(addedParameterType)
 
         val scope = element.getUseScope().let {
@@ -100,7 +100,7 @@ public class KotlinIntroduceParameterMethodUsageProcessor : IntroduceParameterMe
                 .map { it.unwrapped }
                 .filterIsInstance<JetFunction>()
         return (kotlinFunctions + element).all {
-            JetFunctionDefinitionUsage(it, changeInfo.originalBaseFunctionDescriptor, null, null).processUsage(changeInfo, it)
+            JetCallableDefinitionUsage(it, changeInfo.originalBaseFunctionDescriptor, null, null).processUsage(changeInfo, it, usages)
         }
     }
 
@@ -114,9 +114,9 @@ public class KotlinIntroduceParameterMethodUsageProcessor : IntroduceParameterMe
             (JetConstructorDelegationCallUsage(callElement, changeInfo) as JetUsageInfo<JetCallElement>)
         }
         else {
-            JetFunctionCallUsage(callElement, changeInfo.methodDescriptor.originalPrimaryFunction)
+            JetFunctionCallUsage(callElement, changeInfo.methodDescriptor.originalPrimaryCallable)
         }
-        return delegateUsage.processUsage(changeInfo, callElement)
+        return delegateUsage.processUsage(changeInfo, callElement, usages)
     }
 
     override fun processAddSuperCall(data: IntroduceParameterData, usage: UsageInfo, usages: Array<out UsageInfo>): Boolean = true
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/introduceVariable/KotlinInplaceVariableIntroducer.java b/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/introduceVariable/KotlinInplaceVariableIntroducer.java
index c1e142904d2..ea611e0d6ea 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/introduceVariable/KotlinInplaceVariableIntroducer.java
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/introduceVariable/KotlinInplaceVariableIntroducer.java
@@ -41,6 +41,7 @@ import kotlin.jvm.functions.Function1;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.idea.intentions.SpecifyTypeExplicitlyIntention;
+import org.jetbrains.kotlin.idea.references.ReferencesPackage;
 import org.jetbrains.kotlin.idea.util.IdeDescriptorRenderers;
 import org.jetbrains.kotlin.lexer.JetTokens;
 import org.jetbrains.kotlin.psi.*;
@@ -394,7 +395,7 @@ public class KotlinInplaceVariableIntroducer<D extends JetCallableDeclaration> e
                 new Function1<JetSimpleNameExpression, PsiReference>() {
                     @Override
                     public PsiReference invoke(JetSimpleNameExpression expression) {
-                        return expression.getReference();
+                        return ReferencesPackage.getMainReference(expression);
                     }
                 }
         );
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/introduceVariable/KotlinVariableInplaceIntroducer.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/introduceVariable/KotlinVariableInplaceIntroducer.kt
index d4de5a32ae8..7df0eeb6479 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/introduceVariable/KotlinVariableInplaceIntroducer.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/introduceVariable/KotlinVariableInplaceIntroducer.kt
@@ -147,7 +147,9 @@ public class KotlinVariableInplaceIntroducer(
     override fun getComponent() = myWholePanel
 
     override fun performIntroduce() {
-        val replacement = JetPsiFactory(myProject).createExpression(addedVariable.getName() ?: return)
+        val newName = getInputName() ?: return
+        addedVariable.setName(newName)
+        val replacement = JetPsiFactory(myProject).createExpression(newName)
         getOccurrences().forEach {
             if (it.isValid()) {
                 it.replace(replacement)
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/jetRefactoringUtil.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/jetRefactoringUtil.kt
index 56f03c0a868..1f7957a6f59 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/jetRefactoringUtil.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/jetRefactoringUtil.kt
@@ -16,78 +16,70 @@
 
 package org.jetbrains.kotlin.idea.core.refactoring
 
-import com.intellij.openapi.util.Key
-import com.intellij.openapi.roots.JavaProjectRootsUtil
-import com.intellij.psi.util.PsiTreeUtil
-import com.intellij.refactoring.util.ConflictsUtil
-import com.intellij.psi.PsiFileFactory
-import org.jetbrains.kotlin.idea.core.getPackage
-import org.jetbrains.kotlin.idea.JetFileType
-import com.intellij.openapi.project.Project
-import java.io.File
-import com.intellij.openapi.vfs.LocalFileSystem
-import com.intellij.openapi.vfs.VirtualFile
-import org.jetbrains.kotlin.psi.*
-import java.util.ArrayList
-import com.intellij.openapi.application.ApplicationManager
-import com.intellij.refactoring.BaseRefactoringProcessor.ConflictsInTestsException
-import com.intellij.refactoring.ui.ConflictsDialog
-import com.intellij.util.containers.MultiMap
-import org.jetbrains.kotlin.psi.codeFragmentUtil.suppressDiagnosticsInDebugMode
-import com.intellij.ide.util.PsiElementListCellRenderer
-import com.intellij.openapi.ui.popup.JBPopup
-import com.intellij.openapi.ui.popup.PopupChooserBuilder
-import com.intellij.openapi.editor.Editor
-import com.intellij.openapi.util.TextRange
+import com.intellij.codeInsight.daemon.impl.quickfix.CreateFromUsageUtils
 import com.intellij.codeInsight.unwrap.RangeSplitter
 import com.intellij.codeInsight.unwrap.UnwrapHandler
-import com.intellij.openapi.editor.markup.TextAttributes
-import com.intellij.openapi.editor.markup.HighlighterTargetArea
-import com.intellij.openapi.editor.markup.RangeHighlighter
-import java.util.Collections
+import com.intellij.ide.util.PsiElementListCellRenderer
+import com.intellij.lang.java.JavaLanguage
+import com.intellij.openapi.application.ApplicationManager
+import com.intellij.openapi.editor.Editor
 import com.intellij.openapi.editor.colors.EditorColors
 import com.intellij.openapi.editor.colors.EditorColorsManager
-import com.intellij.ui.components.JBList
+import com.intellij.openapi.editor.markup.HighlighterTargetArea
+import com.intellij.openapi.editor.markup.RangeHighlighter
+import com.intellij.openapi.editor.markup.TextAttributes
+import com.intellij.openapi.options.ConfigurationException
+import com.intellij.openapi.project.Project
+import com.intellij.openapi.roots.JavaProjectRootsUtil
+import com.intellij.openapi.ui.popup.JBPopup
 import com.intellij.openapi.ui.popup.JBPopupAdapter
 import com.intellij.openapi.ui.popup.LightweightWindowEvent
-import org.jetbrains.kotlin.resolve.BindingContext
-import org.jetbrains.kotlin.psi.psiUtil.isAncestor
-import com.intellij.psi.PsiNamedElement
-import org.jetbrains.kotlin.descriptors.FunctionDescriptor
-import org.jetbrains.kotlin.renderer.DescriptorRenderer
+import com.intellij.openapi.ui.popup.PopupChooserBuilder
+import com.intellij.openapi.util.Key
+import com.intellij.openapi.util.TextRange
 import com.intellij.openapi.util.text.StringUtil
-import javax.swing.Icon
-import org.jetbrains.kotlin.idea.util.string.collapseSpaces
-import org.jetbrains.kotlin.asJava.KotlinLightMethod
-import org.jetbrains.kotlin.idea.caches.resolve.analyze
-import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
-import org.jetbrains.kotlin.descriptors.CallableDescriptor
-import org.jetbrains.kotlin.psi.psiUtil.getStrictParentOfType
-import com.intellij.psi.PsiPackage
-import org.jetbrains.kotlin.idea.util.ProjectRootsUtil
-import com.intellij.refactoring.util.RefactoringUIUtil
-import org.jetbrains.kotlin.idea.caches.resolve.getJavaMemberDescriptor
-import com.intellij.refactoring.changeSignature.ChangeSignatureUtil
-import org.jetbrains.kotlin.asJava.LightClassUtil
-import com.intellij.util.VisibilityUtil
-import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor
-import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor.Kind
-import org.jetbrains.kotlin.resolve.OverridingUtil
-import org.jetbrains.kotlin.idea.caches.resolve.resolveToDescriptor
-import org.jetbrains.kotlin.descriptors.ClassDescriptor
-import org.jetbrains.kotlin.descriptors.ClassKind
-import com.intellij.lang.java.JavaLanguage
-import com.intellij.codeInsight.daemon.impl.quickfix.CreateFromUsageUtils
+import com.intellij.openapi.vfs.LocalFileSystem
+import com.intellij.openapi.vfs.VirtualFile
 import com.intellij.psi.*
+import com.intellij.psi.util.PsiTreeUtil
+import com.intellij.refactoring.BaseRefactoringProcessor.ConflictsInTestsException
+import com.intellij.refactoring.changeSignature.ChangeSignatureUtil
 import com.intellij.refactoring.listeners.RefactoringEventData
 import com.intellij.refactoring.listeners.RefactoringEventListener
-import org.jetbrains.kotlin.idea.codeInsight.DescriptorToSourceUtilsIde
+import com.intellij.refactoring.ui.ConflictsDialog
+import com.intellij.refactoring.util.ConflictsUtil
+import com.intellij.refactoring.util.RefactoringUIUtil
+import com.intellij.ui.components.JBList
+import com.intellij.util.VisibilityUtil
+import com.intellij.util.containers.MultiMap
+import org.jetbrains.kotlin.asJava.KotlinLightMethod
+import org.jetbrains.kotlin.asJava.LightClassUtil
+import org.jetbrains.kotlin.builtins.KotlinBuiltIns
+import org.jetbrains.kotlin.descriptors.ClassDescriptor
+import org.jetbrains.kotlin.descriptors.ClassKind
+import org.jetbrains.kotlin.descriptors.FunctionDescriptor
+import org.jetbrains.kotlin.idea.JetFileType
+import org.jetbrains.kotlin.idea.caches.resolve.analyze
+import org.jetbrains.kotlin.idea.caches.resolve.getJavaMemberDescriptor
+import org.jetbrains.kotlin.idea.caches.resolve.resolveToDescriptor
+import org.jetbrains.kotlin.idea.core.getPackage
 import org.jetbrains.kotlin.idea.j2k.IdeaResolverForConverter
-import org.jetbrains.kotlin.idea.j2k.J2kPostProcessor
+import org.jetbrains.kotlin.idea.util.ProjectRootsUtil
+import org.jetbrains.kotlin.idea.util.string.collapseSpaces
 import org.jetbrains.kotlin.j2k.ConverterSettings
 import org.jetbrains.kotlin.j2k.IdeaReferenceSearcher
 import org.jetbrains.kotlin.j2k.JavaToKotlinConverter
+import org.jetbrains.kotlin.psi.*
+import org.jetbrains.kotlin.psi.codeFragmentUtil.suppressDiagnosticsInDebugMode
 import org.jetbrains.kotlin.psi.psiUtil.*
+import org.jetbrains.kotlin.renderer.DescriptorRenderer
+import org.jetbrains.kotlin.resolve.AnalyzingUtils
+import org.jetbrains.kotlin.resolve.BindingContext
+import java.io.File
+import java.util.ArrayList
+import java.util.Collections
+import javax.swing.Icon
+import java.lang.annotation.Retention
 
 fun <T: Any> PsiElement.getAndRemoveCopyableUserData(key: Key<T>): T? {
     val data = getCopyableUserData(key)
@@ -111,14 +103,14 @@ fun createKotlinFile(fileName: String, targetDir: PsiDirectory): JetFile {
 
 public fun File.toVirtualFile(): VirtualFile? = LocalFileSystem.getInstance().findFileByIoFile(this)
 
-public fun File.toPsiFile(project: Project): PsiFile? {
-    return toVirtualFile()?.let { vfile -> PsiManager.getInstance(project).findFile(vfile) }
-}
+public fun File.toPsiFile(project: Project): PsiFile? = toVirtualFile()?.toPsiFile(project)
 
 public fun File.toPsiDirectory(project: Project): PsiDirectory? {
     return toVirtualFile()?.let { vfile -> PsiManager.getInstance(project).findDirectory(vfile) }
 }
 
+public fun VirtualFile.toPsiFile(project: Project): PsiFile? = PsiManager.getInstance(project).findFile(this)
+
 public fun PsiElement.getUsageContext(): PsiElement {
     return when (this) {
         is JetElement -> PsiTreeUtil.getParentOfType(this, javaClass<JetNamedDeclaration>(), javaClass<JetFile>())!!
@@ -416,7 +408,11 @@ private fun copyModifierListItems(from: PsiModifierList, to: PsiModifierList, wi
         }
     }
     for (annotation in from.getAnnotations()) {
-        to.addAnnotation(annotation.getQualifiedName())
+        val annotationName = annotation.getQualifiedName()!!
+        if (KotlinBuiltIns.FQ_NAMES.annotation.asString() != annotationName
+            && javaClass<Retention>().getName() != annotationName) {
+            to.addAnnotation(annotationName)
+        }
     }
 }
 
@@ -436,7 +432,7 @@ private fun copyTypeParameters<T: PsiTypeParameterListOwner>(
         ChangeSignatureUtil.synchronizeList(
                 targetTypeParamList,
                 newTypeParams,
-                { it.getTypeParameters().toList() },
+                { it!!.getTypeParameters().toList() },
                 BooleanArray(newTypeParams.size())
         )
     }
@@ -466,8 +462,8 @@ public fun createJavaMethod(template: PsiMethod, targetClass: PsiClass): PsiMeth
 
     val targetParamList = method.getParameterList()
     val newParams = template.getParameterList().getParameters().map {
-        val param = factory.createParameter(it.getName(), it.getType())
-        copyModifierListItems(it.getModifierList(), param.getModifierList())
+        val param = factory.createParameter(it.getName()!!, it.getType())
+        copyModifierListItems(it.getModifierList()!!, param.getModifierList()!!)
         param
     }
     ChangeSignatureUtil.synchronizeList(
@@ -478,7 +474,7 @@ public fun createJavaMethod(template: PsiMethod, targetClass: PsiClass): PsiMeth
     )
 
     if (template.getModifierList().hasModifierProperty(PsiModifier.ABSTRACT) || targetClass.isInterface()) {
-        method.getBody().delete()
+        method.getBody()!!.delete()
     }
     else if (!template.isConstructor()) {
         CreateFromUsageUtils.setupMethodBody(method)
@@ -492,9 +488,9 @@ fun createJavaField(property: JetProperty, targetClass: PsiClass): PsiField {
                    ?: throw AssertionError("Can't generate light method: ${property.getElementTextWithContext()}")
 
     val factory = PsiElementFactory.SERVICE.getInstance(template.getProject())
-    val field = targetClass.add(factory.createField(property.getName(), template.getReturnType())) as PsiField
+    val field = targetClass.add(factory.createField(property.getName()!!, template.getReturnType()!!)) as PsiField
 
-    with(field.getModifierList()) {
+    with(field.getModifierList()!!) {
         val templateModifiers = template.getModifierList()
         setModifierProperty(VisibilityUtil.getVisibilityModifier(templateModifiers), true)
         if (!property.isVar() || targetClass.isInterface()) {
@@ -510,11 +506,12 @@ fun createJavaClass(klass: JetClass, targetClass: PsiClass): PsiMember {
     val kind = (klass.resolveToDescriptor() as ClassDescriptor).getKind()
 
     val factory = PsiElementFactory.SERVICE.getInstance(klass.getProject())
+    val className = klass.getName()!!
     val javaClassToAdd = when (kind) {
-        ClassKind.CLASS -> factory.createClass(klass.getName())
-        ClassKind.INTERFACE -> factory.createInterface(klass.getName())
-        ClassKind.ANNOTATION_CLASS -> factory.createAnnotationType(klass.getName())
-        ClassKind.ENUM_CLASS -> factory.createEnum(klass.getName())
+        ClassKind.CLASS -> factory.createClass(className)
+        ClassKind.INTERFACE -> factory.createInterface(className)
+        ClassKind.ANNOTATION_CLASS -> factory.createAnnotationType(className)
+        ClassKind.ENUM_CLASS -> factory.createEnum(className)
         else -> throw AssertionError("Unexpected class kind: ${klass.getElementTextWithContext()}")
     }
     val javaClass = targetClass.add(javaClassToAdd) as PsiClass
@@ -522,9 +519,9 @@ fun createJavaClass(klass: JetClass, targetClass: PsiClass): PsiMember {
     val template = LightClassUtil.getPsiClass(klass)
                    ?: throw AssertionError("Can't generate light class: ${klass.getElementTextWithContext()}")
 
-    copyModifierListItems(template.getModifierList(), javaClass.getModifierList())
+    copyModifierListItems(template.getModifierList()!!, javaClass.getModifierList()!!)
     if (template.isInterface()) {
-        javaClass.getModifierList().setModifierProperty(PsiModifier.ABSTRACT, false)
+        javaClass.getModifierList()!!.setModifierProperty(PsiModifier.ABSTRACT, false)
     }
 
     copyTypeParameters(template, javaClass) { klass, typeParameterList ->
@@ -552,7 +549,7 @@ fun createJavaClass(klass: JetClass, targetClass: PsiClass): PsiMember {
         if (method.isConstructor() && !(hasParams || needSuperCall)) continue
         with(createJavaMethod(method, javaClass)) {
             if (isConstructor() && needSuperCall) {
-                getBody().add(factory.createStatementFromText("super();", this))
+                getBody()!!.add(factory.createStatementFromText("super();", this))
             }
         }
     }
@@ -604,4 +601,14 @@ public fun (() -> Any).runRefactoringWithPostprocessing(
                              }
                          })
     this()
+}
+
+@throws(ConfigurationException::class)
+public fun JetElement.validateElement(errorMessage: String) {
+    try {
+        AnalyzingUtils.checkForSyntacticErrors(this)
+    }
+    catch(e: Exception) {
+        throw ConfigurationException(errorMessage)
+    }
 }
\ No newline at end of file
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/move/MoveJavaInnerClassKotlinUsagesHandler.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/move/MoveJavaInnerClassKotlinUsagesHandler.kt
index 12989985765..4ab4c538c94 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/move/MoveJavaInnerClassKotlinUsagesHandler.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/move/MoveJavaInnerClassKotlinUsagesHandler.kt
@@ -27,6 +27,7 @@ import java.util.ArrayList
 import org.jetbrains.kotlin.psi.JetSimpleNameExpression
 import com.intellij.psi.util.PsiTreeUtil
 import com.intellij.psi.PsiWhiteSpace
+import org.jetbrains.kotlin.idea.references.mainReference
 
 public class MoveJavaInnerClassKotlinUsagesHandler: MoveInnerClassUsagesHandler {
     override fun correctInnerClassUsage(usage: UsageInfo, outerClass: PsiClass) {
@@ -38,7 +39,7 @@ public class MoveJavaInnerClassKotlinUsagesHandler: MoveInnerClassUsagesHandler
             is JetQualifiedExpression -> receiver.getQualifiedElementSelector()
             else -> null
         } as? JetSimpleNameExpression
-        if (outerClassRef?.getReference()?.resolve() != outerClass) return
+        if (outerClassRef?.mainReference?.resolve() != outerClass) return
 
         val outerCall = outerClassRef!!.getParent() as? JetCallExpression ?: return
 
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/move/moveTopLevelDeclarations/MoveKotlinTopLevelDeclarationsProcessor.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/move/moveTopLevelDeclarations/MoveKotlinTopLevelDeclarationsProcessor.kt
index 4192974b79b..38527955601 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/move/moveTopLevelDeclarations/MoveKotlinTopLevelDeclarationsProcessor.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/move/moveTopLevelDeclarations/MoveKotlinTopLevelDeclarationsProcessor.kt
@@ -103,7 +103,7 @@ public class MoveKotlinTopLevelDeclarationsProcessor(
     private val kotlinToLightElements = elementsToMove.keysToMap { it.toLightElements() }
     private val conflicts = MultiMap<PsiElement, String>()
 
-    override fun createUsageViewDescriptor(usages: Array<out UsageInfo>?): UsageViewDescriptor {
+    override fun createUsageViewDescriptor(usages: Array<out UsageInfo>): UsageViewDescriptor {
         return MoveMultipleElementsViewDescriptor(
                 elementsToMove.toTypedArray(),
                 MoveClassesOrPackagesUtil.getPackageName(options.moveTarget.packageWrapper)
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/move/moveTopLevelDeclarations/ui/MoveFilesOrDirectoriesDialogWithKotlinOptions.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/move/moveTopLevelDeclarations/ui/MoveFilesOrDirectoriesDialogWithKotlinOptions.kt
index 2f57dcb2e67..5a15178861c 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/move/moveTopLevelDeclarations/ui/MoveFilesOrDirectoriesDialogWithKotlinOptions.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/move/moveTopLevelDeclarations/ui/MoveFilesOrDirectoriesDialogWithKotlinOptions.kt
@@ -53,7 +53,7 @@ public class MoveFilesOrDirectoriesDialogWithKotlinOptions(
         gbc.fill = GridBagConstraints.NONE
         gbc.anchor = GridBagConstraints.WEST
         gbc.insets = Insets(UIUtil.LARGE_VGAP, 0, 0, UIUtil.DEFAULT_HGAP)
-        panel.add(JLabel(), gbc)
+        panel!!.add(JLabel(), gbc)
 
         cbUpdatePackageDirective = NonFocusableCheckBox()
         gbc.gridx = 1
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/move/moveUtils.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/move/moveUtils.kt
index 509713d0e48..bcc5ac28dbb 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/move/moveUtils.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/move/moveUtils.kt
@@ -56,6 +56,7 @@ import org.jetbrains.kotlin.idea.refactoring.move.moveTopLevelDeclarations.ui.Mo
 import org.jetbrains.kotlin.idea.references.JetReference
 import org.jetbrains.kotlin.idea.references.JetSimpleNameReference
 import org.jetbrains.kotlin.idea.references.JetSimpleNameReference.ShorteningMode
+import org.jetbrains.kotlin.idea.references.mainReference
 import org.jetbrains.kotlin.idea.util.ImportInsertHelper
 import org.jetbrains.kotlin.idea.util.application.executeCommand
 import org.jetbrains.kotlin.idea.util.application.runWriteAction
@@ -119,7 +120,7 @@ public fun JetElement.getInternalReferencesToUpdateOnPackageNameChange(packageNa
             packageName == packageNameInfo.oldPackageName,
             packageName == packageNameInfo.newPackageName,
             isImported(descriptor) -> {
-                (refExpr.getReference() as? JetSimpleNameReference)?.let { createMoveUsageInfoIfPossible(it, declaration, false) }
+                refExpr.mainReference?.let { createMoveUsageInfoIfPossible(it, declaration, false) }
             }
 
             else -> null
@@ -311,7 +312,7 @@ public fun moveFilesOrDirectories(
                 }
 
                 elementsToMove.forEach {
-                    MoveFilesOrDirectoriesUtil.checkMove(it, selectedDir)
+                    MoveFilesOrDirectoriesUtil.checkMove(it, selectedDir!!)
                     if (it is JetFile && it.isInJavaSourceRoot()) {
                         it.updatePackageDirective = updatePackageDirective
                     }
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/rename/RenameKotlinPropertyProcessor.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/rename/RenameKotlinPropertyProcessor.kt
index 356272f33d3..dbbd26b2b1a 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/rename/RenameKotlinPropertyProcessor.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/rename/RenameKotlinPropertyProcessor.kt
@@ -16,32 +16,32 @@
 
 package org.jetbrains.kotlin.idea.refactoring.rename
 
-import com.intellij.refactoring.rename.RenamePsiElementProcessor
-import com.intellij.psi.PsiElement
-import org.jetbrains.kotlin.psi.JetProperty
-import com.intellij.psi.search.SearchScope
 import com.intellij.openapi.application.ApplicationManager
-import org.jetbrains.kotlin.asJava.LightClassUtil
-import com.intellij.psi.search.searches.OverridingMethodsSearch
+import com.intellij.openapi.editor.Editor
+import com.intellij.openapi.ui.Messages
+import com.intellij.psi.PsiElement
 import com.intellij.psi.PsiMethod
 import com.intellij.psi.SyntheticElement
-import com.intellij.refactoring.util.RefactoringUtil
-import com.intellij.refactoring.rename.RenameProcessor
-import org.jetbrains.kotlin.codegen.PropertyCodegen
-import org.jetbrains.kotlin.name.Name
-import com.intellij.usageView.UsageInfo
+import com.intellij.psi.search.SearchScope
+import com.intellij.psi.search.searches.OverridingMethodsSearch
 import com.intellij.refactoring.listeners.RefactoringElementListener
-import com.intellij.openapi.editor.Editor
-import org.jetbrains.kotlin.lexer.JetTokens
-import org.jetbrains.kotlin.resolve.BindingContext
-import org.jetbrains.kotlin.psi.JetClassOrObject
-import com.intellij.openapi.ui.Messages
-import org.jetbrains.kotlin.descriptors.PropertyDescriptor
+import com.intellij.refactoring.rename.RenameProcessor
+import com.intellij.refactoring.rename.RenamePsiElementProcessor
+import com.intellij.refactoring.util.RefactoringUtil
+import com.intellij.usageView.UsageInfo
+import org.jetbrains.kotlin.asJava.LightClassUtil
 import org.jetbrains.kotlin.asJava.namedUnwrappedElement
-import org.jetbrains.kotlin.resolve.OverrideResolver
-import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils
-import org.jetbrains.kotlin.idea.util.application.runReadAction
+import org.jetbrains.kotlin.descriptors.PropertyDescriptor
 import org.jetbrains.kotlin.idea.caches.resolve.analyze
+import org.jetbrains.kotlin.idea.util.application.runReadAction
+import org.jetbrains.kotlin.lexer.JetTokens
+import org.jetbrains.kotlin.load.java.JvmAbi
+import org.jetbrains.kotlin.name.Name
+import org.jetbrains.kotlin.psi.JetClassOrObject
+import org.jetbrains.kotlin.psi.JetProperty
+import org.jetbrains.kotlin.resolve.BindingContext
+import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils
+import org.jetbrains.kotlin.resolve.OverrideResolver
 
 public class RenameKotlinPropertyProcessor : RenamePsiElementProcessor() {
     override fun canProcessElement(element: PsiElement): Boolean = element.namedUnwrappedElement is JetProperty
@@ -102,8 +102,9 @@ public class RenameKotlinPropertyProcessor : RenamePsiElementProcessor() {
             return
         }
 
-        val oldGetterName = PropertyCodegen.getterName(element.getNameAsName())
-        val oldSetterName = PropertyCodegen.setterName(element.getNameAsName())
+        val name = element.getName()!!
+        val oldGetterName = JvmAbi.getterName(name)
+        val oldSetterName = JvmAbi.setterName(name)
 
         val refKindUsages = usages.toList().groupBy { usage: UsageInfo ->
             val refElement = usage.getReference()?.resolve()
@@ -119,11 +120,11 @@ public class RenameKotlinPropertyProcessor : RenamePsiElementProcessor() {
             }
         }
 
-        super.renameElement(element, PropertyCodegen.setterName(Name.identifier(newName!!)),
+        super.renameElement(element, JvmAbi.setterName(newName!!),
                             refKindUsages[UsageKind.SETTER_USAGE]?.toTypedArray() ?: arrayOf<UsageInfo>(),
                             null)
 
-        super.renameElement(element, PropertyCodegen.getterName(Name.identifier(newName)),
+        super.renameElement(element, JvmAbi.getterName(newName),
                             refKindUsages[UsageKind.GETTER_USAGE]?.toTypedArray() ?: arrayOf<UsageInfo>(),
                             null)
 
@@ -151,9 +152,7 @@ public class RenameKotlinPropertyProcessor : RenamePsiElementProcessor() {
                 if (overriderElement is PsiMethod) {
                     if (newName != null && Name.isValidIdentifier(newName)) {
                         val isGetter = overriderElement.getParameterList().getParametersCount() == 0
-                        val name = Name.identifier(newName)
-
-                        allRenames[overriderElement] = if (isGetter) PropertyCodegen.getterName(name) else PropertyCodegen.setterName(name)
+                        allRenames[overriderElement] = if (isGetter) JvmAbi.getterName(newName) else JvmAbi.setterName(newName)
                     }
                 }
                 else {
diff --git a/idea/src/org/jetbrains/kotlin/idea/run/JetJUnitConfigurationProducer.java b/idea/src/org/jetbrains/kotlin/idea/run/JetJUnitConfigurationProducer.java
deleted file mode 100644
index 480f8c8db3b..00000000000
--- a/idea/src/org/jetbrains/kotlin/idea/run/JetJUnitConfigurationProducer.java
+++ /dev/null
@@ -1,155 +0,0 @@
-/*
- * Copyright 2010-2015 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.kotlin.idea.run;
-
-import com.intellij.execution.JavaRunConfigurationExtensionManager;
-import com.intellij.execution.Location;
-import com.intellij.execution.PsiLocation;
-import com.intellij.execution.RunnerAndConfigurationSettings;
-import com.intellij.execution.actions.ConfigurationContext;
-import com.intellij.execution.junit.JUnitConfiguration;
-import com.intellij.execution.junit.JUnitConfigurationType;
-import com.intellij.execution.junit.JUnitUtil;
-import com.intellij.execution.junit.RuntimeConfigurationProducer;
-import com.intellij.openapi.module.Module;
-import com.intellij.openapi.project.DumbService;
-import com.intellij.psi.PsiClass;
-import com.intellij.psi.PsiElement;
-import com.intellij.psi.PsiMethod;
-import com.intellij.psi.util.PsiTreeUtil;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.asJava.LightClassUtil;
-import org.jetbrains.kotlin.idea.project.ProjectStructureUtil;
-import org.jetbrains.kotlin.idea.util.ProjectRootsUtil;
-import org.jetbrains.kotlin.psi.*;
-
-public class JetJUnitConfigurationProducer extends RuntimeConfigurationProducer {
-    private JetElement myElement;
-
-    public JetJUnitConfigurationProducer() {
-        super(JUnitConfigurationType.getInstance());
-    }
-
-    @Override
-    public PsiElement getSourceElement() {
-        return myElement;
-    }
-
-    @Override
-    protected RunnerAndConfigurationSettings createConfigurationByElement(Location location, ConfigurationContext context) {
-        if (DumbService.getInstance(location.getProject()).isDumb()) return null;
-
-        PsiElement leaf = location.getPsiElement();
-
-        if (!ProjectRootsUtil.isInProjectOrLibSource(leaf)) {
-            return null;
-        }
-
-        if (!(leaf.getContainingFile() instanceof JetFile)) {
-            return null;
-        }
-
-        JetFile jetFile = (JetFile) leaf.getContainingFile();
-
-        if (ProjectStructureUtil.isJsKotlinModule(jetFile)) {
-            return null;
-        }
-
-        JetNamedFunction function = PsiTreeUtil.getParentOfType(leaf, JetNamedFunction.class, false);
-        if (function != null) {
-            myElement = function;
-
-            @SuppressWarnings("unchecked")
-            JetElement owner = PsiTreeUtil.getParentOfType(function, JetFunction.class, JetClass.class);
-
-            if (owner instanceof JetClass) {
-                PsiClass delegate = LightClassUtil.getPsiClass((JetClass) owner);
-                if (delegate != null) {
-                    for (PsiMethod method : delegate.getMethods()) {
-                        if (method.getNavigationElement() == function) {
-                            Location<PsiMethod> methodLocation = PsiLocation.fromPsiElement(method);
-                            if (JUnitUtil.isTestMethod(methodLocation, false)) {
-                                RunnerAndConfigurationSettings settings = cloneTemplateConfiguration(context.getProject(), context);
-                                JUnitConfiguration configuration = (JUnitConfiguration) settings.getConfiguration();
-
-                                Module originalModule = configuration.getConfigurationModule().getModule();
-                                configuration.beMethodConfiguration(methodLocation);
-                                configuration.restoreOriginalModule(originalModule);
-                                JavaRunConfigurationExtensionManager.getInstance().extendCreatedConfiguration(configuration, location);
-
-                                return settings;
-                            }
-                            break;
-                        }
-                    }
-                }
-            }
-        }
-
-        JetClass jetClass = PsiTreeUtil.getParentOfType(leaf, JetClass.class, false);
-
-        if (jetClass == null) {
-            jetClass = getClassDeclarationInFile(jetFile);
-        }
-
-        if (jetClass != null) {
-            myElement = jetClass;
-            PsiClass delegate = LightClassUtil.getPsiClass(jetClass);
-
-            if (delegate != null && JUnitUtil.isTestClass(delegate)) {
-                RunnerAndConfigurationSettings settings = cloneTemplateConfiguration(context.getProject(), context);
-                JUnitConfiguration configuration = (JUnitConfiguration) settings.getConfiguration();
-
-                Module originalModule = configuration.getConfigurationModule().getModule();
-                configuration.beClassConfiguration(delegate);
-                configuration.restoreOriginalModule(originalModule);
-                JavaRunConfigurationExtensionManager.getInstance().extendCreatedConfiguration(configuration, location);
-
-                return settings;
-            }
-        }
-
-        return null;
-    }
-
-    @Nullable
-    static JetClass getClassDeclarationInFile(JetFile jetFile) {
-        JetClass tempSingleDeclaration = null;
-
-        for (JetDeclaration jetDeclaration : jetFile.getDeclarations()) {
-            if (jetDeclaration instanceof JetClass) {
-                JetClass declaration = (JetClass) jetDeclaration;
-
-                if (tempSingleDeclaration == null) {
-                    tempSingleDeclaration = declaration;
-                }
-                else {
-                    // There are several class declarations in file
-                    return null;
-                }
-            }
-        }
-
-        return tempSingleDeclaration;
-    }
-
-    @Override
-    public int compareTo(@NotNull Object o) {
-        return 0;
-    }
-}
diff --git a/idea/src/org/jetbrains/kotlin/idea/run/JetRunConfiguration.java b/idea/src/org/jetbrains/kotlin/idea/run/JetRunConfiguration.java
index 57a41b23f6a..bcec8cd6725 100644
--- a/idea/src/org/jetbrains/kotlin/idea/run/JetRunConfiguration.java
+++ b/idea/src/org/jetbrains/kotlin/idea/run/JetRunConfiguration.java
@@ -18,6 +18,7 @@ package org.jetbrains.kotlin.idea.run;
 
 import com.intellij.diagnostic.logging.LogConfigurationPanel;
 import com.intellij.execution.*;
+import com.intellij.execution.application.BaseJavaApplicationCommandLineState;
 import com.intellij.execution.configuration.EnvironmentVariablesComponent;
 import com.intellij.execution.configurations.*;
 import com.intellij.execution.filters.TextConsoleBuilderFactory;
@@ -34,9 +35,14 @@ import com.intellij.openapi.roots.*;
 import com.intellij.openapi.util.DefaultJDOMExternalizer;
 import com.intellij.openapi.util.InvalidDataException;
 import com.intellij.openapi.util.WriteExternalException;
+import com.intellij.openapi.util.text.StringUtil;
 import com.intellij.openapi.vfs.VirtualFile;
 import com.intellij.psi.PsiClass;
+import com.intellij.psi.PsiElement;
 import com.intellij.psi.PsiMethod;
+import com.intellij.psi.PsiPackage;
+import com.intellij.refactoring.listeners.RefactoringElementAdapter;
+import com.intellij.refactoring.listeners.RefactoringElementListener;
 import kotlin.KotlinPackage;
 import kotlin.jvm.functions.Function1;
 import org.jdom.Element;
@@ -48,9 +54,11 @@ import org.jetbrains.kotlin.asJava.KotlinLightMethod;
 import org.jetbrains.kotlin.idea.MainFunctionDetector;
 import org.jetbrains.kotlin.idea.caches.resolve.ResolvePackage;
 import org.jetbrains.kotlin.idea.stubindex.JetTopLevelFunctionFqnNameIndex;
+import org.jetbrains.kotlin.load.kotlin.PackageClassUtils;
 import org.jetbrains.kotlin.name.FqName;
 import org.jetbrains.kotlin.name.Name;
 import org.jetbrains.kotlin.psi.JetDeclaration;
+import org.jetbrains.kotlin.psi.JetDeclarationContainer;
 import org.jetbrains.kotlin.psi.JetNamedFunction;
 import org.jetbrains.kotlin.resolve.BindingContext;
 import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode;
@@ -58,7 +66,7 @@ import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode;
 import java.util.*;
 
 public class JetRunConfiguration extends ModuleBasedConfiguration<RunConfigurationModule>
-    implements CommonJavaRunConfigurationParameters {
+    implements CommonJavaRunConfigurationParameters, RefactoringListenerProvider {
 
     public String MAIN_CLASS_NAME;
     public String VM_PARAMETERS;
@@ -208,6 +216,24 @@ public class JetRunConfiguration extends ModuleBasedConfiguration<RunConfigurati
         JavaParametersUtil.checkAlternativeJRE(this);
         ProgramParametersUtil.checkWorkingDirectoryExist(this, getProject(), getConfigurationModule().getModule());
         JavaRunConfigurationExtensionManager.checkConfigurationIsValid(this);
+
+        Module module = getConfigurationModule().getModule();
+        if (module == null) {
+            throw new RuntimeConfigurationError("Module not specified");
+        }
+        if (StringUtil.isEmpty(MAIN_CLASS_NAME)) {
+            throw new RuntimeConfigurationError("No main class specified");
+        }
+        PsiClass psiClass = JavaExecutionUtil.findMainClass(module, MAIN_CLASS_NAME);
+        if (psiClass == null) {
+            throw new RuntimeConfigurationWarning("Class '" + MAIN_CLASS_NAME + "' not found in module " + getConfigurationModule().getModuleName());
+        }
+        try {
+            findMainFun(module, psiClass);
+        }
+        catch (CantRunException e) {
+            throw new RuntimeConfigurationWarning(e.getMessage());
+        }
     }
 
     @Override
@@ -218,13 +244,111 @@ public class JetRunConfiguration extends ModuleBasedConfiguration<RunConfigurati
         return state;
     }
 
-    private static class MyJavaCommandLineState extends JavaCommandLineState {
+    @Nullable
+    @Override
+    public RefactoringElementListener getRefactoringElementListener(PsiElement element) {
+        FqName fqNameBeingRenamed = null;
+        if (element instanceof JetDeclarationContainer) {
+            fqNameBeingRenamed = KotlinRunConfigurationProducer.Companion.getStartClassFqName((JetDeclarationContainer) element);
+        }
+        else if (element instanceof PsiPackage) {
+            fqNameBeingRenamed = new FqName(((PsiPackage) element).getQualifiedName());
+        }
+        FqName ourClassName = new FqName(MAIN_CLASS_NAME);
+        if (fqNameBeingRenamed != null && fqNameBeingRenamed.isAncestorOf(ourClassName)) {
+            if (element instanceof JetDeclarationContainer) {
+                return new RefactoringElementAdapter() {
+                    @Override
+                    public void undoElementMovedOrRenamed(@NotNull PsiElement newElement, @NotNull String oldQualifiedName) {
+                        updateMainClassName(newElement);
+                    }
 
-        private final JetRunConfiguration myConfiguration;
+                    @Override
+                    protected void elementRenamedOrMoved(@NotNull PsiElement newElement) {
+                        updateMainClassName(newElement);
+                    }
+                };
+            }
+            else {
+                final String nameSuffix = MAIN_CLASS_NAME.substring(fqNameBeingRenamed.toString().length());
+                return new RefactoringElementAdapter() {
+                    @Override
+                    protected void elementRenamedOrMoved(@NotNull PsiElement newElement) {
+                        updateMainClassNameWithSuffix(newElement, nameSuffix);
+                    }
 
+                    @Override
+                    public void undoElementMovedOrRenamed(@NotNull PsiElement newElement, @NotNull String oldQualifiedName) {
+                        updateMainClassNameWithSuffix(newElement, nameSuffix);
+                    }
+                };
+            }
+        }
+        return null;
+    }
+
+    private void updateMainClassName(PsiElement element) {
+        JetDeclarationContainer container = KotlinRunConfigurationProducer.Companion.getEntryPointContainer(element);
+        FqName name = KotlinRunConfigurationProducer.Companion.getStartClassFqName(container);
+        if (name != null) {
+            MAIN_CLASS_NAME = name.asString();
+        }
+    }
+
+    private void updateMainClassNameWithSuffix(PsiElement element, String suffix) {
+        if (element instanceof PsiPackage) {
+            MAIN_CLASS_NAME = ((PsiPackage) element).getQualifiedName() + suffix;
+        }
+    }
+
+    @Override
+    public String suggestedName() {
+        if (MAIN_CLASS_NAME == null) {
+            return null;
+        }
+        return StringUtil.trimEnd(MAIN_CLASS_NAME,
+                                  "." + PackageClassUtils.getPackageClassName(new FqName(MAIN_CLASS_NAME).parent()));
+    }
+
+    @NotNull
+    private static Collection<JetNamedFunction> getMainFunCandidates(@NotNull Module module, @NotNull PsiClass psiClass) {
+        if (psiClass instanceof KotlinLightClassForPackage) {
+            String qualifiedName = psiClass.getQualifiedName();
+            if (qualifiedName == null) return Collections.emptyList();
+            FqName mainFunFqName = new FqName(qualifiedName).parent().child(Name.identifier("main"));
+            return JetTopLevelFunctionFqnNameIndex.getInstance().get(
+                    mainFunFqName.asString(), module.getProject(), module.getModuleRuntimeScope(true)
+            );
+        }
+        return KotlinPackage.filterNotNull(
+                KotlinPackage.map(
+                        psiClass.findMethodsByName("main", false),
+                        new Function1<PsiMethod, JetNamedFunction>() {
+                            @Override
+                            public JetNamedFunction invoke(PsiMethod method) {
+                                if (!(method instanceof KotlinLightMethod)) return null;
+
+                                JetDeclaration declaration = ((KotlinLightMethod) method).getOrigin();
+                                return declaration instanceof JetNamedFunction ? (JetNamedFunction) declaration : null;
+                            }
+                        }
+                )
+        );
+    }
+
+    @Nullable
+    private static JetNamedFunction findMainFun(@NotNull Module module, @NotNull PsiClass psiClass) throws CantRunException {
+        for (JetNamedFunction function : getMainFunCandidates(module, psiClass)) {
+            BindingContext bindingContext = ResolvePackage.analyze(function, BodyResolveMode.FULL);
+            MainFunctionDetector mainFunctionDetector = new MainFunctionDetector(bindingContext);
+            if (mainFunctionDetector.isMain(function)) return function;
+        }
+        return null;
+    }
+
+    private static class MyJavaCommandLineState extends BaseJavaApplicationCommandLineState<JetRunConfiguration> {
         public MyJavaCommandLineState(@NotNull JetRunConfiguration configuration, ExecutionEnvironment environment) {
-            super(environment);
-            myConfiguration = configuration;
+            super(environment, configuration);
         }
 
         @Override
@@ -253,7 +377,7 @@ public class JetRunConfiguration extends ModuleBasedConfiguration<RunConfigurati
             PsiClass psiClass = JavaExecutionUtil.findMainClass(module, runClass);
             if (psiClass == null) throw CantRunException.classNotFound(runClass, module);
 
-            JetNamedFunction mainFun = findMainFun(module, psiClass);
+            JetNamedFunction mainFun = myConfiguration.findMainFun(module, psiClass);
             if (mainFun == null) throw new CantRunException(noFunctionFoundMessage(psiClass));
 
             Module classModule = ModuleUtilCore.findModuleForPsiElement(mainFun);
@@ -289,41 +413,5 @@ public class JetRunConfiguration extends ModuleBasedConfiguration<RunConfigurati
             }
             return String.format("Top-level function 'main' not found in package '%s'", classFqName.parent());
         }
-
-        @NotNull
-        private Collection<JetNamedFunction> getMainFunCandidates(@NotNull Module module, @NotNull PsiClass psiClass) {
-            if (psiClass instanceof KotlinLightClassForPackage) {
-                String qualifiedName = psiClass.getQualifiedName();
-                if (qualifiedName == null) return Collections.emptyList();
-                FqName mainFunFqName = new FqName(qualifiedName).parent().child(Name.identifier("main"));
-                return JetTopLevelFunctionFqnNameIndex.getInstance().get(
-                        mainFunFqName.asString(), module.getProject(), module.getModuleRuntimeScope(true)
-                );
-            }
-            return KotlinPackage.filterNotNull(
-                    KotlinPackage.map(
-                            psiClass.findMethodsByName("main", false),
-                            new Function1<PsiMethod, JetNamedFunction>() {
-                                @Override
-                                public JetNamedFunction invoke(PsiMethod method) {
-                                    if (!(method instanceof KotlinLightMethod)) return null;
-
-                                    JetDeclaration declaration = ((KotlinLightMethod) method).getOrigin();
-                                    return declaration instanceof JetNamedFunction ? (JetNamedFunction) declaration : null;
-                                }
-                            }
-                    )
-            );
-        }
-
-        @Nullable
-        private JetNamedFunction findMainFun(@NotNull Module module, @NotNull PsiClass psiClass) throws CantRunException {
-            for (JetNamedFunction function : getMainFunCandidates(module, psiClass)) {
-                BindingContext bindingContext = ResolvePackage.analyze(function, BodyResolveMode.FULL);
-                MainFunctionDetector mainFunctionDetector = new MainFunctionDetector(bindingContext);
-                if (mainFunctionDetector.isMain(function)) return function;
-            }
-            return null;
-        }
     }
 }
diff --git a/idea/src/org/jetbrains/kotlin/idea/run/JetRunConfigurationProducer.java b/idea/src/org/jetbrains/kotlin/idea/run/JetRunConfigurationProducer.java
deleted file mode 100644
index 7621a23fc52..00000000000
--- a/idea/src/org/jetbrains/kotlin/idea/run/JetRunConfigurationProducer.java
+++ /dev/null
@@ -1,170 +0,0 @@
-/*
- * Copyright 2010-2015 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.kotlin.idea.run;
-
-import com.intellij.execution.Location;
-import com.intellij.execution.RunnerAndConfigurationSettings;
-import com.intellij.execution.actions.ConfigurationContext;
-import com.intellij.execution.junit.RuntimeConfigurationProducer;
-import com.intellij.openapi.module.Module;
-import com.intellij.openapi.project.DumbService;
-import com.intellij.openapi.util.Comparing;
-import com.intellij.openapi.util.text.StringUtil;
-import com.intellij.psi.PsiElement;
-import com.intellij.psi.PsiFile;
-import com.intellij.psi.util.PsiTreeUtil;
-import com.intellij.util.NotNullFunction;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.descriptors.FunctionDescriptor;
-import org.jetbrains.kotlin.idea.MainFunctionDetector;
-import org.jetbrains.kotlin.idea.caches.resolve.ResolutionFacade;
-import org.jetbrains.kotlin.idea.caches.resolve.ResolvePackage;
-import org.jetbrains.kotlin.idea.project.ProjectStructureUtil;
-import org.jetbrains.kotlin.idea.util.ProjectRootsUtil;
-import org.jetbrains.kotlin.load.kotlin.PackageClassUtils;
-import org.jetbrains.kotlin.name.FqName;
-import org.jetbrains.kotlin.psi.*;
-
-import java.util.List;
-
-import static kotlin.KotlinPackage.singleOrNull;
-
-public class JetRunConfigurationProducer extends RuntimeConfigurationProducer implements Cloneable {
-    @Nullable
-    private PsiElement mySourceElement;
-
-    public JetRunConfigurationProducer() {
-        super(JetRunConfigurationType.getInstance());
-    }
-
-    @Nullable
-    @Override
-    public PsiElement getSourceElement() {
-        return mySourceElement;
-    }
-
-    @Override
-    protected RunnerAndConfigurationSettings createConfigurationByElement(@NotNull Location location, ConfigurationContext configurationContext) {
-        JetDeclarationContainer container = getEntryPointContainer(location);
-        if (container == null) return null;
-
-        mySourceElement = (PsiElement) container;
-
-        FqName startClassFQName = getStartClassFqName(container);
-        if (startClassFQName == null) return null;
-
-        Module module = location.getModule();
-        assert module != null;
-
-        return createConfigurationByQName(module, configurationContext, startClassFQName);
-    }
-
-    @Nullable
-    private static FqName getStartClassFqName(@Nullable JetDeclarationContainer container) {
-        if (container == null) return null;
-        if (container instanceof JetFile) return PackageClassUtils.getPackageClassFqName(((JetFile) container).getPackageFqName());
-        if (container instanceof JetClassOrObject) {
-            JetClassOrObject classOrObject = (JetClassOrObject) container;
-            if (classOrObject instanceof JetObjectDeclaration && ((JetObjectDeclaration) classOrObject).isCompanion()) {
-                classOrObject = PsiTreeUtil.getParentOfType(classOrObject, JetClass.class);
-            }
-            return classOrObject != null ? classOrObject.getFqName() : null;
-        }
-        throw new IllegalArgumentException("Invalid entry-point container: " + ((PsiElement) container).getText());
-    }
-
-    @Nullable
-    private static JetDeclarationContainer getEntryPointContainer(@NotNull Location location) {
-        if (DumbService.getInstance(location.getProject()).isDumb()) return null;
-
-        Module module = location.getModule();
-        if (module == null) return null;
-
-        if (ProjectStructureUtil.isJsKotlinModule(module)) return null;
-
-        PsiElement locationElement = location.getPsiElement();
-
-        PsiFile psiFile = locationElement.getContainingFile();
-        if (!(psiFile instanceof JetFile && ProjectRootsUtil.isInProjectOrLibSource(psiFile))) return null;
-
-        JetFile jetFile = (JetFile) psiFile;
-        final ResolutionFacade resolutionFacade = ResolvePackage.getResolutionFacade(jetFile);
-        MainFunctionDetector mainFunctionDetector = new MainFunctionDetector(
-                new NotNullFunction<JetNamedFunction, FunctionDescriptor>() {
-                    @NotNull
-                    @Override
-                    public FunctionDescriptor fun(JetNamedFunction function) {
-                        return (FunctionDescriptor) resolutionFacade.resolveToDescriptor(function);
-                    }
-                });
-
-        for (JetDeclarationContainer currentElement = PsiTreeUtil.getNonStrictParentOfType(locationElement, JetClassOrObject.class,
-                                                                                           JetFile.class);
-             currentElement != null;
-             currentElement = PsiTreeUtil.getParentOfType((PsiElement) currentElement, JetClassOrObject.class, JetFile.class)) {
-            JetDeclarationContainer entryPointContainer = currentElement;
-            if (entryPointContainer instanceof JetClass) {
-                entryPointContainer = singleOrNull(((JetClass) currentElement).getCompanionObjects());
-            }
-            if (entryPointContainer != null && mainFunctionDetector.hasMain(entryPointContainer.getDeclarations())) return entryPointContainer;
-        }
-
-        return null;
-    }
-
-    @NotNull
-    private RunnerAndConfigurationSettings createConfigurationByQName(
-            @NotNull Module module,
-            ConfigurationContext context,
-            @NotNull FqName fqName
-    ) {
-        RunnerAndConfigurationSettings settings = cloneTemplateConfiguration(module.getProject(), context);
-        JetRunConfiguration configuration = (JetRunConfiguration) settings.getConfiguration();
-        configuration.setModule(module);
-        configuration.setName(StringUtil.trimEnd(fqName.asString(), "." + PackageClassUtils.getPackageClassName(fqName)));
-        configuration.setRunClass(fqName.asString());
-        return settings;
-    }
-
-    @Override
-    protected RunnerAndConfigurationSettings findExistingByElement(
-            Location location,
-            @NotNull List<RunnerAndConfigurationSettings> existingConfigurations,
-            ConfigurationContext context
-    ) {
-        FqName startClassFQName = getStartClassFqName(getEntryPointContainer(location));
-        if (startClassFQName == null) return null;
-
-        for (RunnerAndConfigurationSettings existingConfiguration : existingConfigurations) {
-            if (existingConfiguration.getType() instanceof JetRunConfigurationType) {
-                JetRunConfiguration jetConfiguration = (JetRunConfiguration)existingConfiguration.getConfiguration();
-                if (Comparing.equal(jetConfiguration.getRunClass(), startClassFQName.asString())) {
-                    if (Comparing.equal(location.getModule(), jetConfiguration.getConfigurationModule().getModule())) {
-                        return existingConfiguration;
-                    }
-                }
-            }
-        }
-        return null;
-    }
-
-    @Override
-    public int compareTo(Object o) {
-        return PREFERED;
-    }
-}
diff --git a/idea/src/org/jetbrains/kotlin/idea/run/JetTestNgConfigurationProducer.java b/idea/src/org/jetbrains/kotlin/idea/run/JetTestNgConfigurationProducer.java
index 8ee7a4ec3ec..a3f73d4211e 100644
--- a/idea/src/org/jetbrains/kotlin/idea/run/JetTestNgConfigurationProducer.java
+++ b/idea/src/org/jetbrains/kotlin/idea/run/JetTestNgConfigurationProducer.java
@@ -90,7 +90,7 @@ public class JetTestNgConfigurationProducer extends TestNGConfigurationProducer
         JetClass jetClass = PsiTreeUtil.getParentOfType(leaf, JetClass.class, false);
 
         if (jetClass == null) {
-            jetClass = JetJUnitConfigurationProducer.getClassDeclarationInFile(jetFile);
+            jetClass = getClassDeclarationInFile(jetFile);
         }
 
         if (jetClass == null) {
@@ -128,4 +128,25 @@ public class JetTestNgConfigurationProducer extends TestNGConfigurationProducer
     private static boolean isTestNGClass(PsiClass psiClass) {
         return psiClass != null && PsiClassUtil.isRunnableClass(psiClass, true, false) && TestNGUtil.hasTest(psiClass);
     }
+
+    @Nullable
+    static JetClass getClassDeclarationInFile(JetFile jetFile) {
+        JetClass tempSingleDeclaration = null;
+
+        for (JetDeclaration jetDeclaration : jetFile.getDeclarations()) {
+            if (jetDeclaration instanceof JetClass) {
+                JetClass declaration = (JetClass) jetDeclaration;
+
+                if (tempSingleDeclaration == null) {
+                    tempSingleDeclaration = declaration;
+                }
+                else {
+                    // There are several class declarations in file
+                    return null;
+                }
+            }
+        }
+
+        return tempSingleDeclaration;
+    }
 }
diff --git a/idea/src/org/jetbrains/kotlin/idea/run/KotlinJUnitRunConfigurationProducer.kt b/idea/src/org/jetbrains/kotlin/idea/run/KotlinJUnitRunConfigurationProducer.kt
new file mode 100644
index 00000000000..e6e387ca2ea
--- /dev/null
+++ b/idea/src/org/jetbrains/kotlin/idea/run/KotlinJUnitRunConfigurationProducer.kt
@@ -0,0 +1,149 @@
+/*
+ * Copyright 2010-2015 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.kotlin.idea.run
+
+import com.intellij.execution.*
+import com.intellij.execution.actions.ConfigurationContext
+import com.intellij.execution.actions.RunConfigurationProducer
+import com.intellij.execution.configurations.ModuleBasedConfiguration
+import com.intellij.execution.junit.JUnitConfiguration
+import com.intellij.execution.junit.JUnitConfigurationType
+import com.intellij.execution.junit.JUnitUtil
+import com.intellij.execution.junit.PatternConfigurationProducer
+import com.intellij.openapi.project.DumbService
+import com.intellij.openapi.util.Ref
+import com.intellij.psi.PsiClass
+import com.intellij.psi.PsiElement
+import com.intellij.psi.PsiMethod
+import com.intellij.psi.util.PsiTreeUtil
+import org.jetbrains.kotlin.asJava.LightClassUtil
+import org.jetbrains.kotlin.idea.project.ProjectStructureUtil
+import org.jetbrains.kotlin.idea.util.ProjectRootsUtil
+import org.jetbrains.kotlin.psi.JetClass
+import org.jetbrains.kotlin.psi.JetFile
+import org.jetbrains.kotlin.psi.JetFunction
+import org.jetbrains.kotlin.psi.JetNamedFunction
+import org.jetbrains.kotlin.psi.psiUtil.getParentOfType
+
+public class KotlinJUnitRunConfigurationProducer : RunConfigurationProducer<JUnitConfiguration>(JUnitConfigurationType.getInstance()) {
+    override fun isConfigurationFromContext(configuration: JUnitConfiguration,
+                                            context: ConfigurationContext): Boolean {
+        if (RunConfigurationProducer.getInstance(javaClass<PatternConfigurationProducer>()).isMultipleElementsSelected(context)) {
+            return false
+        }
+
+        val leaf = context.getLocation()?.getPsiElement() ?: return false
+        val methodLocation = getTestMethodLocation(leaf)
+        val testClass = getTestClass(leaf)
+        val testObject = configuration.getTestObject()
+
+        if (!testObject.isConfiguredByElement(configuration, testClass, methodLocation?.getPsiElement(), null, null)) {
+            return false
+        }
+
+        return settingsMatchTemplate(configuration, context)
+    }
+
+    // copied from JUnitConfigurationProducer in IDEA
+    private fun settingsMatchTemplate(configuration: JUnitConfiguration, context: ConfigurationContext): Boolean {
+        val predefinedConfiguration = context.getOriginalConfiguration(JUnitConfigurationType.getInstance())
+
+        val vmParameters = (predefinedConfiguration as? CommonJavaRunConfigurationParameters)?.getVMParameters()
+        if (vmParameters != null && configuration.getVMParameters() != vmParameters) return false
+
+        val template = RunManager.getInstance(configuration.getProject()).getConfigurationTemplate(getConfigurationFactory())
+        val predefinedModule = (template.getConfiguration() as ModuleBasedConfiguration<*>).getConfigurationModule().getModule()
+        val configurationModule = configuration.getConfigurationModule().getModule()
+        return configurationModule == context.getLocation()?.getModule() || configurationModule == predefinedModule
+    }
+
+    override fun setupConfigurationFromContext(configuration: JUnitConfiguration,
+                                               context: ConfigurationContext,
+                                               sourceElement: Ref<PsiElement>): Boolean {
+        if (DumbService.getInstance(context.getProject()).isDumb()) return false
+
+        val location = context.getLocation() ?: return false
+        val leaf = location.getPsiElement()
+
+        if (!ProjectRootsUtil.isInProjectOrLibSource(leaf)) {
+            return false
+        }
+
+        if (leaf.getContainingFile() !is JetFile) {
+            return false
+        }
+
+        val jetFile = leaf.getContainingFile() as JetFile
+
+        if (ProjectStructureUtil.isJsKotlinModule(jetFile)) {
+            return false
+        }
+
+        val methodLocation = getTestMethodLocation(leaf)
+        if (methodLocation != null) {
+            val originalModule = configuration.getConfigurationModule().getModule()
+            configuration.beMethodConfiguration(methodLocation)
+            configuration.restoreOriginalModule(originalModule)
+            JavaRunConfigurationExtensionManager.getInstance().extendCreatedConfiguration(configuration, location)
+            return true
+        }
+
+        val testClass = getTestClass(leaf)
+        if (testClass != null) {
+            val originalModule = configuration.getConfigurationModule().getModule()
+            configuration.beClassConfiguration(testClass)
+            configuration.restoreOriginalModule(originalModule)
+            JavaRunConfigurationExtensionManager.getInstance().extendCreatedConfiguration(configuration, location)
+            return true
+        }
+
+        return false
+    }
+
+    private fun getTestMethodLocation(leaf: PsiElement): Location<PsiMethod>? {
+        val function = leaf.getParentOfType<JetNamedFunction>(false) ?: return null
+        val owner = PsiTreeUtil.getParentOfType(function, javaClass<JetFunction>(), javaClass<JetClass>())
+
+        if (owner is JetClass) {
+            val delegate = LightClassUtil.getPsiClass(owner) ?: return null
+            val method = delegate.getMethods().firstOrNull() { it.getNavigationElement() == function } ?: return null
+            val methodLocation = PsiLocation.fromPsiElement(method)
+            if (JUnitUtil.isTestMethod(methodLocation, false)) {
+                return methodLocation
+            }
+        }
+        return null
+    }
+
+    private fun getTestClass(leaf: PsiElement): PsiClass? {
+        val containingFile = leaf.getContainingFile() as? JetFile ?: return null
+        var jetClass = leaf.getParentOfType<JetClass>(false)
+        if (!jetClass.isJUnitTestClass()) {
+            jetClass = getTestClassInFile(containingFile)
+        }
+        if (jetClass != null) {
+            return LightClassUtil.getPsiClass(jetClass)
+        }
+        return null
+    }
+
+    private fun JetClass?.isJUnitTestClass() =
+            LightClassUtil.getPsiClass(this)?.let { JUnitUtil.isTestClass(it) } ?: false
+
+    private fun getTestClassInFile(jetFile: JetFile) =
+            jetFile.getDeclarations().filterIsInstance<JetClass>().singleOrNull { it.isJUnitTestClass() }
+}
diff --git a/idea/src/org/jetbrains/kotlin/idea/run/KotlinRunConfigurationProducer.kt b/idea/src/org/jetbrains/kotlin/idea/run/KotlinRunConfigurationProducer.kt
new file mode 100644
index 00000000000..1e19f1b5701
--- /dev/null
+++ b/idea/src/org/jetbrains/kotlin/idea/run/KotlinRunConfigurationProducer.kt
@@ -0,0 +1,128 @@
+/*
+ * Copyright 2010-2015 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.kotlin.idea.run
+
+import com.intellij.execution.Location
+import com.intellij.execution.RunnerAndConfigurationSettings
+import com.intellij.execution.actions.ConfigurationContext
+import com.intellij.execution.actions.RunConfigurationProducer
+import com.intellij.execution.junit.RuntimeConfigurationProducer
+import com.intellij.openapi.module.Module
+import com.intellij.openapi.project.DumbService
+import com.intellij.openapi.util.Comparing
+import com.intellij.openapi.util.Ref
+import com.intellij.openapi.util.text.StringUtil
+import com.intellij.psi.PsiElement
+import com.intellij.psi.util.PsiTreeUtil
+import com.intellij.util.NotNullFunction
+import org.jetbrains.kotlin.descriptors.FunctionDescriptor
+import org.jetbrains.kotlin.idea.MainFunctionDetector
+import org.jetbrains.kotlin.idea.caches.resolve.getResolutionFacade
+import org.jetbrains.kotlin.idea.project.ProjectStructureUtil
+import org.jetbrains.kotlin.idea.util.ProjectRootsUtil
+import org.jetbrains.kotlin.load.kotlin.PackageClassUtils
+import org.jetbrains.kotlin.name.FqName
+import org.jetbrains.kotlin.psi.*
+import org.jetbrains.kotlin.psi.psiUtil.getParentOfType
+
+public class KotlinRunConfigurationProducer : RunConfigurationProducer<JetRunConfiguration>(JetRunConfigurationType.getInstance()) {
+
+    override fun setupConfigurationFromContext(configuration: JetRunConfiguration,
+                                               context: ConfigurationContext,
+                                               sourceElement: Ref<PsiElement>): Boolean {
+        val location = context.getLocation() ?: return false
+        val module = location.getModule() ?: return false
+        val container = getEntryPointContainer(location)
+        val startClassFQName = getStartClassFqName(container) ?: return false
+
+        setupConfigurationByQName(module, configuration, startClassFQName)
+        return true
+    }
+
+    private fun getEntryPointContainer(location: Location<*>?): JetDeclarationContainer? {
+        if (location == null) return null
+        if (DumbService.getInstance(location.getProject()).isDumb()) return null
+
+        val module = location.getModule() ?: return null
+
+        if (ProjectStructureUtil.isJsKotlinModule(module)) return null
+
+        val locationElement = location.getPsiElement()
+
+        return getEntryPointContainer(locationElement)
+    }
+
+    private fun setupConfigurationByQName(module: Module,
+                                          configuration: JetRunConfiguration,
+                                          fqName: FqName) {
+        configuration.setModule(module)
+        configuration.setRunClass(fqName.asString())
+        configuration.setGeneratedName()
+    }
+
+    override fun isConfigurationFromContext(configuration: JetRunConfiguration, context: ConfigurationContext): Boolean {
+        val startClassFQName = getStartClassFqName(getEntryPointContainer(context.getLocation())) ?: return false
+
+        return configuration.getRunClass() == startClassFQName.asString() &&
+            context.getModule() ==  configuration.getConfigurationModule().getModule()
+    }
+
+    companion object {
+        public fun getEntryPointContainer(locationElement: PsiElement): JetDeclarationContainer? {
+            val psiFile = locationElement.getContainingFile()
+            if (!(psiFile is JetFile && ProjectRootsUtil.isInProjectOrLibSource(psiFile))) return null
+
+            val resolutionFacade = psiFile.getResolutionFacade()
+            val mainFunctionDetector = MainFunctionDetector { resolutionFacade.resolveToDescriptor(it) as FunctionDescriptor }
+
+            var currentElement = locationElement.declarationContainer(false)
+            while (currentElement != null) {
+                var entryPointContainer = currentElement
+                if (entryPointContainer is JetClass) {
+                    entryPointContainer = entryPointContainer.getCompanionObjects().singleOrNull()
+                }
+                if (entryPointContainer != null && mainFunctionDetector.hasMain(entryPointContainer.getDeclarations())) return entryPointContainer
+                currentElement = (currentElement as PsiElement).declarationContainer(true)
+            }
+
+            return null
+        }
+
+        public fun getStartClassFqName(container: JetDeclarationContainer?): FqName? = when(container) {
+            null -> null
+            is JetFile -> PackageClassUtils.getPackageClassFqName(container.getPackageFqName())
+            is JetClassOrObject -> {
+                if (container is JetObjectDeclaration && container.isCompanion()) {
+                    val containerClass = container.getParentOfType<JetClass>(true)
+                    containerClass?.getFqName()
+                } else {
+                    container.getFqName()
+                }
+            }
+            else -> throw IllegalArgumentException("Invalid entry-point container: " + (container as PsiElement).getText())
+        }
+
+        private fun PsiElement.declarationContainer(strict: Boolean): JetDeclarationContainer? {
+            val element = if (strict)
+                PsiTreeUtil.getParentOfType(this, javaClass<JetClassOrObject>(), javaClass<JetFile>())
+            else
+                PsiTreeUtil.getNonStrictParentOfType(this, javaClass<JetClassOrObject>(), javaClass<JetFile>())
+            return element as JetDeclarationContainer?
+        }
+
+    }
+}
diff --git a/idea/src/org/jetbrains/kotlin/idea/search/ideaExtensions/KotlinLightPropertyAccessorsReferenceSearcher.kt b/idea/src/org/jetbrains/kotlin/idea/search/ideaExtensions/KotlinPropertyAccessorsReferenceSearcher.kt
similarity index 58%
rename from idea/src/org/jetbrains/kotlin/idea/search/ideaExtensions/KotlinLightPropertyAccessorsReferenceSearcher.kt
rename to idea/src/org/jetbrains/kotlin/idea/search/ideaExtensions/KotlinPropertyAccessorsReferenceSearcher.kt
index 91bc4c5a187..5af77fff1c2 100644
--- a/idea/src/org/jetbrains/kotlin/idea/search/ideaExtensions/KotlinLightPropertyAccessorsReferenceSearcher.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/search/ideaExtensions/KotlinPropertyAccessorsReferenceSearcher.kt
@@ -17,27 +17,27 @@
 package org.jetbrains.kotlin.idea.search.ideaExtensions
 
 import com.intellij.openapi.application.QueryExecutorBase
+import com.intellij.psi.PsiMethod
 import com.intellij.psi.PsiReference
 import com.intellij.psi.search.GlobalSearchScope
 import com.intellij.psi.search.SearchScope
 import com.intellij.psi.search.UsageSearchContext
 import com.intellij.psi.search.searches.MethodReferencesSearch
 import com.intellij.util.Processor
-import org.jetbrains.kotlin.idea.JetFileType
 import org.jetbrains.kotlin.asJava.namedUnwrappedElement
+import org.jetbrains.kotlin.idea.JetFileType
+import org.jetbrains.kotlin.idea.caches.resolve.getJavaMethodDescriptor
 import org.jetbrains.kotlin.psi.JetProperty
+import org.jetbrains.kotlin.storage.LockBasedStorageManager
+import org.jetbrains.kotlin.synthetic.SyntheticJavaPropertyDescriptor
+import org.jetbrains.kotlin.synthetic.JavaSyntheticExtensionsScope
 
-public class KotlinLightPropertyAccessorsReferenceSearcher() : QueryExecutorBase<PsiReference, MethodReferencesSearch.SearchParameters>(true) {
+public class KotlinPropertyAccessorsReferenceSearcher() : QueryExecutorBase<PsiReference, MethodReferencesSearch.SearchParameters>(true) {
     override fun processQuery(queryParameters: MethodReferencesSearch.SearchParameters, consumer: Processor<PsiReference>) {
         val method = queryParameters.getMethod()
-        val unwrapped = method.namedUnwrappedElement
+        val propertyName = propertyName(method) ?: return
 
-        if (unwrapped !is JetProperty) return
-
-        val propertyName = unwrapped.getName()
-        if (propertyName == null) return
-
-        val onlyKotlinFiles = restrictToKotlinSources(queryParameters.getScope())
+        val onlyKotlinFiles = restrictToKotlinSources(queryParameters.getEffectiveSearchScope())
 
         queryParameters.getOptimizer()!!.searchWord(
                 propertyName,
@@ -47,10 +47,22 @@ public class KotlinLightPropertyAccessorsReferenceSearcher() : QueryExecutorBase
                 method)
     }
 
-    private fun restrictToKotlinSources(originalScope: SearchScope): SearchScope {
-        if (originalScope is GlobalSearchScope) {
-            return GlobalSearchScope.getScopeRestrictedByFileTypes(originalScope as GlobalSearchScope, JetFileType.INSTANCE)
+    private fun propertyName(method: PsiMethod): String? {
+        val unwrapped = method.namedUnwrappedElement
+        if (unwrapped is JetProperty) {
+            return unwrapped.getName()
+        }
+
+        val functionDescriptor = method.getJavaMethodDescriptor() ?: return null
+        val syntheticExtensionsScope = JavaSyntheticExtensionsScope(LockBasedStorageManager())
+        val property = SyntheticJavaPropertyDescriptor.findByGetterOrSetter(functionDescriptor, syntheticExtensionsScope) ?: return null
+        return property.getName().asString()
+    }
+
+    private fun restrictToKotlinSources(originalScope: SearchScope): SearchScope {
+        return when (originalScope) {
+            is GlobalSearchScope -> GlobalSearchScope.getScopeRestrictedByFileTypes(originalScope, JetFileType.INSTANCE)
+            else -> originalScope
         }
-        return originalScope
     }
 }
diff --git a/idea/testData/checker/AnnotationOnFile.kt b/idea/testData/checker/AnnotationOnFile.kt
index 893e1f14484..b7268c4c2c9 100644
--- a/idea/testData/checker/AnnotationOnFile.kt
+++ b/idea/testData/checker/AnnotationOnFile.kt
@@ -1,8 +1,8 @@
-@file:kotlin.deprecated("message")
+<error>@file:kotlin.deprecated("message")</error>
 @file:suppress(<error>BAR</error>)
 @file:suppress(BAZ)
 
-@<error>k</error>otlin.deprecated("message")
+<error>@<error>k</error>otlin.deprecated("message")</error>
 @<error>s</error>uppress(<error>BAR</error>)
 @<error>s</error>uppress(BAZ)
 
@@ -19,4 +19,5 @@ package boo
 val BAZ = "baz"
 val N = 0
 
+target(AnnotationTarget.FILE)
 annotation class myAnnotation(val i: Int, val s: String)
diff --git a/idea/testData/checker/codeFragments/elementAtIfWithoutBraces.kt b/idea/testData/checker/codeFragments/elementAtIfWithoutBraces.kt
new file mode 100644
index 00000000000..d178d6df57e
--- /dev/null
+++ b/idea/testData/checker/codeFragments/elementAtIfWithoutBraces.kt
@@ -0,0 +1,10 @@
+fun main(args: Array<String>) {
+    val str: String? = ""
+
+    if (str != null)
+        <caret>test(str)
+    else
+        test("")
+}
+
+fun test(s: String) = 1
\ No newline at end of file
diff --git a/idea/testData/checker/codeFragments/elementAtIfWithoutBraces.kt.fragment b/idea/testData/checker/codeFragments/elementAtIfWithoutBraces.kt.fragment
new file mode 100644
index 00000000000..fc12a393b72
--- /dev/null
+++ b/idea/testData/checker/codeFragments/elementAtIfWithoutBraces.kt.fragment
@@ -0,0 +1 @@
+test(str)
\ No newline at end of file
diff --git a/idea/testData/checker/codeFragments/elementAtWhenBranch.kt b/idea/testData/checker/codeFragments/elementAtWhenBranch.kt
new file mode 100644
index 00000000000..47389c6aac1
--- /dev/null
+++ b/idea/testData/checker/codeFragments/elementAtWhenBranch.kt
@@ -0,0 +1,10 @@
+fun main(args: Array<String>) {
+    val str: String? = ""
+
+    when(str) {
+        null -> test("")
+        else -> <caret>test(str)
+    }
+}
+
+fun test(s: String) = 1
\ No newline at end of file
diff --git a/idea/testData/checker/codeFragments/elementAtWhenBranch.kt.fragment b/idea/testData/checker/codeFragments/elementAtWhenBranch.kt.fragment
new file mode 100644
index 00000000000..fc12a393b72
--- /dev/null
+++ b/idea/testData/checker/codeFragments/elementAtWhenBranch.kt.fragment
@@ -0,0 +1 @@
+test(str)
\ No newline at end of file
diff --git a/idea/testData/checker/duplicateJvmSignature/fields/classObjectCopiedFieldObject.kt b/idea/testData/checker/duplicateJvmSignature/fields/classObjectCopiedFieldObject.kt
index 75b1c68ea7c..4505579a855 100644
--- a/idea/testData/checker/duplicateJvmSignature/fields/classObjectCopiedFieldObject.kt
+++ b/idea/testData/checker/duplicateJvmSignature/fields/classObjectCopiedFieldObject.kt
@@ -11,11 +11,3 @@ class C {
     }
 
 }
-
-class D {
-    companion <error>object A</error> {
-        <error>val `OBJECT$`</error> = this
-    }
-
-    val `OBJECT$` = D
-}
\ No newline at end of file
diff --git a/idea/testData/codeInsight/overrideImplement/propagationKJK/foo/Impl.kt.after b/idea/testData/codeInsight/overrideImplement/propagationKJK/foo/Impl.kt.after
index dc7fc6eda69..2171acf633c 100644
--- a/idea/testData/codeInsight/overrideImplement/propagationKJK/foo/Impl.kt.after
+++ b/idea/testData/codeInsight/overrideImplement/propagationKJK/foo/Impl.kt.after
@@ -1,7 +1,7 @@
 package foo
 
 class Impl : Bar() {
-    override fun f(): Any? {
+    override fun f(): Any {
         <selection><caret>return super.f()</selection>
     }
 }
diff --git a/idea/testData/copyPaste/conversion/ClassWithNoDocComment.expected.kt b/idea/testData/copyPaste/conversion/ClassWithNoDocComment.expected.kt
index 11ae5fc5a80..db736576254 100644
--- a/idea/testData/copyPaste/conversion/ClassWithNoDocComment.expected.kt
+++ b/idea/testData/copyPaste/conversion/ClassWithNoDocComment.expected.kt
@@ -2,5 +2,6 @@ package to
 
 public class JavaClass : Runnable {
     override fun run() {
+
     }
 }
diff --git a/idea/testData/copyPaste/conversion/SeveralMethodsSample.expected.kt b/idea/testData/copyPaste/conversion/SeveralMethodsSample.expected.kt
index 891dd895f64..e938d94ba9c 100644
--- a/idea/testData/copyPaste/conversion/SeveralMethodsSample.expected.kt
+++ b/idea/testData/copyPaste/conversion/SeveralMethodsSample.expected.kt
@@ -11,7 +11,10 @@ class A {
             if (declarationDescriptor is CallableMemberDescriptor) {
                 val containingDescriptor = declarationDescriptor.getContainingDeclaration()
                 if (containingDescriptor is ClassDescriptor) {
-                    return JetBundle.message("x.in.y", DescriptorRenderer.COMPACT.render(declarationDescriptor), IdeDescriptorRenderers.SOURCE_CODE_SHORT_NAMES_IN_TYPES.render(containingDescriptor))
+                    return JetBundle.message(
+                            "x.in.y",
+                            DescriptorRenderer.COMPACT.render(declarationDescriptor),
+                            IdeDescriptorRenderers.SOURCE_CODE_SHORT_NAMES_IN_TYPES.render(containingDescriptor))
                 }
             }
         }
diff --git a/idea/testData/copyPaste/imports/DependencyOnStdLib.expected.kt b/idea/testData/copyPaste/imports/DependencyOnStdLib.expected.kt
index 5f2a0f5472c..89767829ef2 100644
--- a/idea/testData/copyPaste/imports/DependencyOnStdLib.expected.kt
+++ b/idea/testData/copyPaste/imports/DependencyOnStdLib.expected.kt
@@ -1,5 +1,5 @@
 package to
 
-import kotlin.concurrent.FunctionalList
+import kotlin.properties.ObservableProperty
 
-fun f(l: FunctionalList<Int>) {}
\ No newline at end of file
+fun f(l: ObservableProperty<Int>) {}
\ No newline at end of file
diff --git a/idea/testData/copyPaste/imports/DependencyOnStdLib.expected.names b/idea/testData/copyPaste/imports/DependencyOnStdLib.expected.names
index 1e28860500b..2a89ec4170a 100644
--- a/idea/testData/copyPaste/imports/DependencyOnStdLib.expected.names
+++ b/idea/testData/copyPaste/imports/DependencyOnStdLib.expected.names
@@ -1,2 +1,2 @@
 kotlin.Int
-kotlin.concurrent.FunctionalList
+kotlin.properties.ObservableProperty
diff --git a/idea/testData/copyPaste/imports/DependencyOnStdLib.kt b/idea/testData/copyPaste/imports/DependencyOnStdLib.kt
index 4c5c5306087..73104657ebc 100644
--- a/idea/testData/copyPaste/imports/DependencyOnStdLib.kt
+++ b/idea/testData/copyPaste/imports/DependencyOnStdLib.kt
@@ -2,6 +2,6 @@
 
 package g
 
-import kotlin.concurrent.FunctionalList
+import kotlin.properties.ObservableProperty
 
-<selection>fun f(l: FunctionalList<Int>) {}</selection>
\ No newline at end of file
+<selection>fun f(l: ObservableProperty<Int>) {}</selection>
\ No newline at end of file
diff --git a/idea/testData/debugger/tinyApp/outs/frameSimple.out b/idea/testData/debugger/tinyApp/outs/frameSimple.out
index d0667b4581e..49ba752f490 100644
--- a/idea/testData/debugger/tinyApp/outs/frameSimple.out
+++ b/idea/testData/debugger/tinyApp/outs/frameSimple.out
@@ -12,18 +12,20 @@ val topVal1 = 1
 
 fun main(args: Array<String>) {
     val val1 = 1
-    val val2 = "str"
+    val val2 = MyClass()
     //Breakpoint!
     val1 + topVal1
 }
 
+class MyClass
+
 // PRINT_FRAME
 
 // EXPRESSION: val1
 // RESULT: 1: I
 
 // EXPRESSION: val2
-// RESULT: "str": Ljava/lang/String;
+// RESULT: instance of frameSimple.MyClass(id=ID): LframeSimple/MyClass;
 
 // EXPRESSION: topVal1
 // RESULT: 1: I
@@ -35,14 +37,7 @@ fun main(args: Array<String>) {
      field    = topVal1: int = 1 (sp = null)
    local    = args: java.lang.String[] = {java.lang.String[0]@uniqueID} (sp = frameSimple.kt, 5)
    local    = val1: int = 1 (sp = frameSimple.kt, 6)
-   local    = val2: java.lang.String = str (sp = frameSimple.kt, 7)
-     field    = value: char[] = {char[3]@uniqueID} (sp = String.!EXT!)
-       unknown  = [0] = 's' 115
-       unknown  = [1] = 't' 116
-       unknown  = [2] = 'r' 114
-     field    = offset: int = 0 (sp = String.!EXT!)
-     field    = count: int = 3 (sp = String.!EXT!)
-     field    = hash: int = 0 (sp = String.!EXT!)
+   local    = val2: frameSimple.MyClass = {frameSimple.MyClass@uniqueID} (sp = frameSimple.kt, 7)
 Disconnected from the target VM, address: '!HOST_NAME!:PORT_NAME!', transport: 'socket'
 
 Process finished with exit code 0
diff --git a/idea/testData/debugger/tinyApp/src/evaluate/multipleBreakpoints/exceptions.kt b/idea/testData/debugger/tinyApp/src/evaluate/multipleBreakpoints/exceptions.kt
index 3db2a8b12e6..9511fc38b80 100644
--- a/idea/testData/debugger/tinyApp/src/evaluate/multipleBreakpoints/exceptions.kt
+++ b/idea/testData/debugger/tinyApp/src/evaluate/multipleBreakpoints/exceptions.kt
@@ -37,7 +37,7 @@ fun genericClassCast() {
         val c = ArrayList<Int>()
         c.add(1)
         // EXPRESSION: c.get(0)
-        // RESULT: instance of java.lang.Integer(id=ID): Ljava/lang/Integer;
+        // RESULT: 1: I
         //Breakpoint!
         val b = 1
     }
@@ -46,7 +46,7 @@ fun genericClassCast() {
         val c = ArrayList<String>()
         c.add("a")
         // EXPRESSION: c.get(0)
-        // RESULT: java.lang.ClassCastException: java.lang.String cannot be cast to java.lang.Integer: Ljava/lang/ClassCastException;
+        // RESULT: java.lang.ClassCastException: java.lang.String cannot be cast to java.lang.Number: Ljava/lang/ClassCastException;
         //Breakpoint!
         val b = 1
     }
diff --git a/idea/testData/debugger/tinyApp/src/evaluate/singleBreakpoint/frame/frameSimple.kt b/idea/testData/debugger/tinyApp/src/evaluate/singleBreakpoint/frame/frameSimple.kt
index 3607971a065..03f25463853 100644
--- a/idea/testData/debugger/tinyApp/src/evaluate/singleBreakpoint/frame/frameSimple.kt
+++ b/idea/testData/debugger/tinyApp/src/evaluate/singleBreakpoint/frame/frameSimple.kt
@@ -4,18 +4,20 @@ val topVal1 = 1
 
 fun main(args: Array<String>) {
     val val1 = 1
-    val val2 = "str"
+    val val2 = MyClass()
     //Breakpoint!
     val1 + topVal1
 }
 
+class MyClass
+
 // PRINT_FRAME
 
 // EXPRESSION: val1
 // RESULT: 1: I
 
 // EXPRESSION: val2
-// RESULT: "str": Ljava/lang/String;
+// RESULT: instance of frameSimple.MyClass(id=ID): LframeSimple/MyClass;
 
 // EXPRESSION: topVal1
 // RESULT: 1: I
diff --git a/idea/testData/decompiler/decompiledText/Annotations/Dependency.kt b/idea/testData/decompiler/decompiledText/Annotations/Dependency.kt
index 2142cdf131e..b43d7999b16 100644
--- a/idea/testData/decompiler/decompiledText/Annotations/Dependency.kt
+++ b/idea/testData/decompiler/decompiledText/Annotations/Dependency.kt
@@ -1,5 +1,13 @@
 package dependency
 
+target(AnnotationTarget.CLASSIFIER, AnnotationTarget.FUNCTION, AnnotationTarget.PROPERTY,
+       AnnotationTarget.VALUE_PARAMETER, AnnotationTarget.TYPE)
 annotation class A(val s: String)
+
+target(AnnotationTarget.CLASSIFIER, AnnotationTarget.FUNCTION, AnnotationTarget.PROPERTY,
+       AnnotationTarget.VALUE_PARAMETER, AnnotationTarget.TYPE)
 annotation class B(val i: Int)
+
+target(AnnotationTarget.CLASSIFIER, AnnotationTarget.FUNCTION, AnnotationTarget.PROPERTY,
+       AnnotationTarget.VALUE_PARAMETER)
 annotation class C
diff --git a/idea/testData/decompiler/stubBuilder/AnnotationClass/AnnotationClass.txt b/idea/testData/decompiler/stubBuilder/AnnotationClass/AnnotationClass.txt
index fe8754994bf..f9f3011a981 100644
--- a/idea/testData/decompiler/stubBuilder/AnnotationClass/AnnotationClass.txt
+++ b/idea/testData/decompiler/stubBuilder/AnnotationClass/AnnotationClass.txt
@@ -5,7 +5,27 @@ PsiJetFileStubImpl[package=test.a]
       REFERENCE_EXPRESSION:[referencedName=a]
   IMPORT_LIST:
   CLASS:[fqName=test.a.AnnotationClass, isEnumEntry=false, isInterface=false, isLocal=false, isTopLevel=true, name=AnnotationClass, superNames=[Annotation]]
-    MODIFIER_LIST:[annotation public final]
+    MODIFIER_LIST:[public final]
+      ANNOTATION_ENTRY:[hasValueArguments=false, shortName=annotation]
+        CONSTRUCTOR_CALLEE:
+          TYPE_REFERENCE:
+            USER_TYPE:[isAbsoluteInRootPackage=false]
+              USER_TYPE:[isAbsoluteInRootPackage=false]
+                USER_TYPE:[isAbsoluteInRootPackage=false]
+                  REFERENCE_EXPRESSION:[referencedName=kotlin]
+                REFERENCE_EXPRESSION:[referencedName=annotation]
+              REFERENCE_EXPRESSION:[referencedName=annotation]
+      ANNOTATION_ENTRY:[hasValueArguments=false, shortName=Retention]
+        CONSTRUCTOR_CALLEE:
+          TYPE_REFERENCE:
+            USER_TYPE:[isAbsoluteInRootPackage=false]
+              USER_TYPE:[isAbsoluteInRootPackage=false]
+                USER_TYPE:[isAbsoluteInRootPackage=false]
+                  USER_TYPE:[isAbsoluteInRootPackage=false]
+                    REFERENCE_EXPRESSION:[referencedName=java]
+                  REFERENCE_EXPRESSION:[referencedName=lang]
+                REFERENCE_EXPRESSION:[referencedName=annotation]
+              REFERENCE_EXPRESSION:[referencedName=Retention]
     PRIMARY_CONSTRUCTOR:
       MODIFIER_LIST:[public]
       VALUE_PARAMETER_LIST:
diff --git a/idea/testData/decompiler/stubBuilder/Annotations/Annotations.kt b/idea/testData/decompiler/stubBuilder/Annotations/Annotations.kt
index 30ca8428164..6eaf41a5c51 100644
--- a/idea/testData/decompiler/stubBuilder/Annotations/Annotations.kt
+++ b/idea/testData/decompiler/stubBuilder/Annotations/Annotations.kt
@@ -25,8 +25,13 @@ a public class Annotations private @a constructor(private @a val c1: Int, @a val
     fun types(param: @a @b(E.E1) DoubleRange): @a @b(E.E2) Unit {}
 }
 
+target(AnnotationTarget.PROPERTY, AnnotationTarget.VALUE_PARAMETER, AnnotationTarget.FUNCTION,
+       AnnotationTarget.CONSTRUCTOR, AnnotationTarget.PROPERTY_GETTER, AnnotationTarget.PROPERTY_SETTER,
+       AnnotationTarget.TYPE, AnnotationTarget.CLASSIFIER)
 annotation class a
 
-annotation class b(val e: E)
+target(AnnotationTarget.PROPERTY, AnnotationTarget.FUNCTION, AnnotationTarget.CLASSIFIER,
+       AnnotationTarget.CONSTRUCTOR, AnnotationTarget.TYPE)
+annotation(repeatable = false) class b(val e: E)
 
 enum class E { E1 E2 }
\ No newline at end of file
diff --git a/idea/testData/decompiler/stubBuilder/ClassObject/ClassObject.txt b/idea/testData/decompiler/stubBuilder/ClassObject/ClassObject.txt
index 018c213880e..d9f5b894866 100644
--- a/idea/testData/decompiler/stubBuilder/ClassObject/ClassObject.txt
+++ b/idea/testData/decompiler/stubBuilder/ClassObject/ClassObject.txt
@@ -113,7 +113,27 @@ PsiJetFileStubImpl[package=test.class_object]
                                       REFERENCE_EXPRESSION:[referencedName=kotlin]
                                     REFERENCE_EXPRESSION:[referencedName=Unit]
                               CLASS:[fqName=test.class_object.ClassObject.B.Companion.C.Companion.D.Companion.Anno, isEnumEntry=false, isInterface=false, isLocal=false, isTopLevel=false, name=Anno, superNames=[Annotation]]
-                                MODIFIER_LIST:[annotation internal final]
+                                MODIFIER_LIST:[internal final]
+                                  ANNOTATION_ENTRY:[hasValueArguments=false, shortName=annotation]
+                                    CONSTRUCTOR_CALLEE:
+                                      TYPE_REFERENCE:
+                                        USER_TYPE:[isAbsoluteInRootPackage=false]
+                                          USER_TYPE:[isAbsoluteInRootPackage=false]
+                                            USER_TYPE:[isAbsoluteInRootPackage=false]
+                                              REFERENCE_EXPRESSION:[referencedName=kotlin]
+                                            REFERENCE_EXPRESSION:[referencedName=annotation]
+                                          REFERENCE_EXPRESSION:[referencedName=annotation]
+                                  ANNOTATION_ENTRY:[hasValueArguments=false, shortName=Retention]
+                                    CONSTRUCTOR_CALLEE:
+                                      TYPE_REFERENCE:
+                                        USER_TYPE:[isAbsoluteInRootPackage=false]
+                                          USER_TYPE:[isAbsoluteInRootPackage=false]
+                                            USER_TYPE:[isAbsoluteInRootPackage=false]
+                                              USER_TYPE:[isAbsoluteInRootPackage=false]
+                                                REFERENCE_EXPRESSION:[referencedName=java]
+                                              REFERENCE_EXPRESSION:[referencedName=lang]
+                                            REFERENCE_EXPRESSION:[referencedName=annotation]
+                                          REFERENCE_EXPRESSION:[referencedName=Retention]
                                 PRIMARY_CONSTRUCTOR:
                                   MODIFIER_LIST:[public]
                                   VALUE_PARAMETER_LIST:
diff --git a/idea/testData/decompiler/stubBuilder/Sealed/Sealed.kt b/idea/testData/decompiler/stubBuilder/Sealed/Sealed.kt
new file mode 100644
index 00000000000..53be5967af5
--- /dev/null
+++ b/idea/testData/decompiler/stubBuilder/Sealed/Sealed.kt
@@ -0,0 +1,6 @@
+package test
+
+sealed class Sealed {
+    class Nested: Sealed()
+    object Top: Sealed()
+}
diff --git a/idea/testData/decompiler/stubBuilder/Sealed/Sealed.txt b/idea/testData/decompiler/stubBuilder/Sealed/Sealed.txt
new file mode 100644
index 00000000000..389c3ed96da
--- /dev/null
+++ b/idea/testData/decompiler/stubBuilder/Sealed/Sealed.txt
@@ -0,0 +1,33 @@
+PsiJetFileStubImpl[package=test]
+  PACKAGE_DIRECTIVE:
+    REFERENCE_EXPRESSION:[referencedName=test]
+  IMPORT_LIST:
+  CLASS:[fqName=test.Sealed, isEnumEntry=false, isInterface=false, isLocal=false, isTopLevel=true, name=Sealed, superNames=[]]
+    MODIFIER_LIST:[internal sealed]
+    PRIMARY_CONSTRUCTOR:
+      MODIFIER_LIST:[private]
+      VALUE_PARAMETER_LIST:
+    CLASS_BODY:
+      CLASS:[fqName=test.Sealed.Nested, isEnumEntry=false, isInterface=false, isLocal=false, isTopLevel=false, name=Nested, superNames=[Sealed]]
+        MODIFIER_LIST:[internal final]
+        PRIMARY_CONSTRUCTOR:
+          MODIFIER_LIST:[public]
+          VALUE_PARAMETER_LIST:
+        DELEGATION_SPECIFIER_LIST:
+          DELEGATOR_SUPER_CLASS:
+            TYPE_REFERENCE:
+              USER_TYPE:[isAbsoluteInRootPackage=false]
+                USER_TYPE:[isAbsoluteInRootPackage=false]
+                  REFERENCE_EXPRESSION:[referencedName=test]
+                REFERENCE_EXPRESSION:[referencedName=Sealed]
+        CLASS_BODY:
+      OBJECT_DECLARATION:[fqName=test.Sealed.Top, isCompanion=false, isLocal=false, isObjectLiteral=false, isTopLevel=false, name=Top, superNames=[Sealed]]
+        MODIFIER_LIST:[internal]
+        DELEGATION_SPECIFIER_LIST:
+          DELEGATOR_SUPER_CLASS:
+            TYPE_REFERENCE:
+              USER_TYPE:[isAbsoluteInRootPackage=false]
+                USER_TYPE:[isAbsoluteInRootPackage=false]
+                  REFERENCE_EXPRESSION:[referencedName=test]
+                REFERENCE_EXPRESSION:[referencedName=Sealed]
+        CLASS_BODY:
diff --git a/idea/testData/diagnosticMessage/functionPlaceholder.kt b/idea/testData/diagnosticMessage/functionPlaceholder.kt
index f26da6266d6..6528f3994ec 100644
--- a/idea/testData/diagnosticMessage/functionPlaceholder.kt
+++ b/idea/testData/diagnosticMessage/functionPlaceholder.kt
@@ -1,5 +1,5 @@
 // !DIAGNOSTICS_NUMBER: 3
-// !DIAGNOSTICS: TYPE_INFERENCE_TYPE_CONSTRUCTOR_MISMATCH
+// !DIAGNOSTICS: TYPE_INFERENCE_PARAMETER_CONSTRAINT_ERROR
 
 class A<T, R>
 fun <T, R> foo(a: A<T, R>) = a
diff --git a/idea/testData/diagnosticMessage/numberValueTypes.kt b/idea/testData/diagnosticMessage/numberValueTypes.kt
index a5a7a2aefcf..2eaac514059 100644
--- a/idea/testData/diagnosticMessage/numberValueTypes.kt
+++ b/idea/testData/diagnosticMessage/numberValueTypes.kt
@@ -1,5 +1,5 @@
 // !DIAGNOSTICS_NUMBER: 4
-// !DIAGNOSTICS: TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH TYPE_INFERENCE_TYPE_CONSTRUCTOR_MISMATCH TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS
+// !DIAGNOSTICS: TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH TYPE_INFERENCE_PARAMETER_CONSTRAINT_ERROR TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS
 
 package a
 
diff --git a/idea/testData/findUsages/java/findJavaMethodUsages/SyntheticProperties.0.java b/idea/testData/findUsages/java/findJavaMethodUsages/SyntheticProperties.0.java
new file mode 100644
index 00000000000..763832cbb04
--- /dev/null
+++ b/idea/testData/findUsages/java/findJavaMethodUsages/SyntheticProperties.0.java
@@ -0,0 +1,6 @@
+// PSI_ELEMENT: com.intellij.psi.PsiMethod
+// OPTIONS: usages
+class JavaClass {
+    public int <caret>getSomething() { return 1; }
+    public void setSomething(int value) {}
+}
\ No newline at end of file
diff --git a/idea/testData/findUsages/java/findJavaMethodUsages/SyntheticProperties.1.kt b/idea/testData/findUsages/java/findJavaMethodUsages/SyntheticProperties.1.kt
new file mode 100644
index 00000000000..f305e8e07e3
--- /dev/null
+++ b/idea/testData/findUsages/java/findJavaMethodUsages/SyntheticProperties.1.kt
@@ -0,0 +1,5 @@
+fun foo(javaClass: JavaClass) {
+    print(javaClass.something)
+    javaClass.something = 1
+    javaClass.something++
+}
diff --git a/idea/testData/findUsages/java/findJavaMethodUsages/SyntheticProperties.results.txt b/idea/testData/findUsages/java/findJavaMethodUsages/SyntheticProperties.results.txt
new file mode 100644
index 00000000000..2be354cdc95
--- /dev/null
+++ b/idea/testData/findUsages/java/findJavaMethodUsages/SyntheticProperties.results.txt
@@ -0,0 +1,2 @@
+Value read (2: 21) print(javaClass.something)
+Value read (4: 15) javaClass.something++
diff --git a/idea/testData/findUsages/kotlin/findPropertyUsages/kotlinPrivatePropertyUsages2.0.kt b/idea/testData/findUsages/kotlin/findPropertyUsages/kotlinPrivatePropertyUsages2.0.kt
index 0043dadf521..ad25821bdad 100644
--- a/idea/testData/findUsages/kotlin/findPropertyUsages/kotlinPrivatePropertyUsages2.0.kt
+++ b/idea/testData/findUsages/kotlin/findPropertyUsages/kotlinPrivatePropertyUsages2.0.kt
@@ -6,7 +6,8 @@ public open class Server(private val <caret>foo: String = "foo") {
     open fun processRequest() = foo
 }
 
-public class ServerEx(): Server() {
-    override fun processRequest() = "foo" + foo
+public class ServerEx(): Server(foo = "!") {
+    override fun processRequest() = "foo" + foo // this reference is found as a side effect of big use scope of constructor parameter:
+                                                // if it was simple property, it wouldn't be found
 }
 
diff --git a/idea/testData/findUsages/kotlin/findPropertyUsages/kotlinPrivatePropertyUsages2.1.kt b/idea/testData/findUsages/kotlin/findPropertyUsages/kotlinPrivatePropertyUsages2.1.kt
index fc85e72876a..86c7d186022 100644
--- a/idea/testData/findUsages/kotlin/findPropertyUsages/kotlinPrivatePropertyUsages2.1.kt
+++ b/idea/testData/findUsages/kotlin/findPropertyUsages/kotlinPrivatePropertyUsages2.1.kt
@@ -2,7 +2,7 @@ import server.*;
 
 class Client {
     public fun foo() {
-        println(Server().foo)
+        println(Server(foo = "!").foo)
         ServerEx().processRequest()
     }
 }
diff --git a/idea/testData/findUsages/kotlin/findPropertyUsages/kotlinPrivatePropertyUsages2.results.txt b/idea/testData/findUsages/kotlin/findPropertyUsages/kotlinPrivatePropertyUsages2.results.txt
index 9fddae8966e..4e7b35d3730 100644
--- a/idea/testData/findUsages/kotlin/findPropertyUsages/kotlinPrivatePropertyUsages2.results.txt
+++ b/idea/testData/findUsages/kotlin/findPropertyUsages/kotlinPrivatePropertyUsages2.results.txt
@@ -1 +1,5 @@
-Value read (6: 33) open fun processRequest() = foo
+[kotlinPrivatePropertyUsages2.0.kt] Named argument (9: 33) public class ServerEx(): Server(foo = "!") {
+[kotlinPrivatePropertyUsages2.0.kt] Value read (10: 45) override fun processRequest() = "foo" + foo // this reference is found as a side effect of big use scope of constructor parameter:
+[kotlinPrivatePropertyUsages2.0.kt] Value read (6: 33) open fun processRequest() = foo
+[kotlinPrivatePropertyUsages2.1.kt] Named argument (5: 24) println(Server(foo = "!").foo)
+[kotlinPrivatePropertyUsages2.1.kt] Value read (5: 35) println(Server(foo = "!").foo)
diff --git a/idea/testData/findUsages/libraryUsages/_library/library/library.kt b/idea/testData/findUsages/libraryUsages/_library/library/library.kt
index 21ad72ec8bc..be51210073e 100644
--- a/idea/testData/findUsages/libraryUsages/_library/library/library.kt
+++ b/idea/testData/findUsages/libraryUsages/_library/library/library.kt
@@ -64,4 +64,9 @@ fun test() {
     val tt = A.T()
     t.bar(2)
     val fff = A.T::bar
+
+    class LocalClass(val localClassProperty: Int) {
+    }
+
+    LocalClass(localClassProperty = 1).localClassProperty
 }
\ No newline at end of file
diff --git a/idea/testData/hierarchy/calls/callers/kotlinPrimaryConstructorImplicitCalls/KotlinPrimaryConstructorImplicitCalls_verification.xml b/idea/testData/hierarchy/calls/callers/kotlinPrimaryConstructorImplicitCalls/KotlinPrimaryConstructorImplicitCalls_verification.xml
new file mode 100644
index 00000000000..02133749cb7
--- /dev/null
+++ b/idea/testData/hierarchy/calls/callers/kotlinPrimaryConstructorImplicitCalls/KotlinPrimaryConstructorImplicitCalls_verification.xml
@@ -0,0 +1,4 @@
+<node text="B  ()" base="true">
+    <node text="A.A(Int)  ()"/>
+    <node text="JJ.JJ()  ()"/>
+</node>
diff --git a/idea/testData/hierarchy/calls/callers/kotlinPrimaryConstructorImplicitCalls/main0.kt b/idea/testData/hierarchy/calls/callers/kotlinPrimaryConstructorImplicitCalls/main0.kt
new file mode 100644
index 00000000000..eca85407e5f
--- /dev/null
+++ b/idea/testData/hierarchy/calls/callers/kotlinPrimaryConstructorImplicitCalls/main0.kt
@@ -0,0 +1,7 @@
+open class <caret>B()
+
+open class A : B {
+    constructor(a: Int) {
+
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/hierarchy/calls/callers/kotlinPrimaryConstructorImplicitCalls/main1.java b/idea/testData/hierarchy/calls/callers/kotlinPrimaryConstructorImplicitCalls/main1.java
new file mode 100644
index 00000000000..79760d15bba
--- /dev/null
+++ b/idea/testData/hierarchy/calls/callers/kotlinPrimaryConstructorImplicitCalls/main1.java
@@ -0,0 +1,5 @@
+class JJ extends B {
+    JJ() {
+
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/hierarchy/calls/callers/kotlinSecondaryConstructorImplicitCalls/KotlinSecondaryConstructorImplicitCalls_verification.xml b/idea/testData/hierarchy/calls/callers/kotlinSecondaryConstructorImplicitCalls/KotlinSecondaryConstructorImplicitCalls_verification.xml
new file mode 100644
index 00000000000..5178b80ff8d
--- /dev/null
+++ b/idea/testData/hierarchy/calls/callers/kotlinSecondaryConstructorImplicitCalls/KotlinSecondaryConstructorImplicitCalls_verification.xml
@@ -0,0 +1,4 @@
+<node text="B.B()  ()" base="true">
+    <node text="JJ.JJ()  ()"/>
+    <node text="A.A(Int)  ()"/>
+</node>
diff --git a/idea/testData/hierarchy/calls/callers/kotlinSecondaryConstructorImplicitCalls/main0.kt b/idea/testData/hierarchy/calls/callers/kotlinSecondaryConstructorImplicitCalls/main0.kt
new file mode 100644
index 00000000000..57a5fdc0aa5
--- /dev/null
+++ b/idea/testData/hierarchy/calls/callers/kotlinSecondaryConstructorImplicitCalls/main0.kt
@@ -0,0 +1,11 @@
+open class B {
+    <caret>constructor() {
+
+    }
+}
+
+open class A : B {
+    constructor(a: Int) {
+
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/hierarchy/calls/callers/kotlinSecondaryConstructorImplicitCalls/main1.java b/idea/testData/hierarchy/calls/callers/kotlinSecondaryConstructorImplicitCalls/main1.java
new file mode 100644
index 00000000000..79760d15bba
--- /dev/null
+++ b/idea/testData/hierarchy/calls/callers/kotlinSecondaryConstructorImplicitCalls/main1.java
@@ -0,0 +1,5 @@
+class JJ extends B {
+    JJ() {
+
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/highlighter/Annotations.kt b/idea/testData/highlighter/Annotations.kt
index 466267fe97a..2f1ee3c46a2 100644
--- a/idea/testData/highlighter/Annotations.kt
+++ b/idea/testData/highlighter/Annotations.kt
@@ -1,3 +1,4 @@
+<info descr="null" textAttributesKey="KOTLIN_ANNOTATION">target</info>(<info descr="null" textAttributesKey="KOTLIN_CLASS">AnnotationTarget</info>.<info descr="null" textAttributesKey="KOTLIN_ENUM_ENTRY">CLASSIFIER</info>, <info descr="null" textAttributesKey="KOTLIN_CLASS">AnnotationTarget</info>.<info descr="null" textAttributesKey="KOTLIN_ENUM_ENTRY">EXPRESSION</info>)
 <info descr="null">annotation</info> class <info descr="null">Ann</info>
 
 <info descr="null" textAttributesKey="KOTLIN_ANNOTATION">Ann</info> class <info descr="null">A1</info>
diff --git a/idea/testData/highlighter/TypesAndAnnotations.kt b/idea/testData/highlighter/TypesAndAnnotations.kt
index 77ece2f4208..2ebdd6f3681 100644
--- a/idea/testData/highlighter/TypesAndAnnotations.kt
+++ b/idea/testData/highlighter/TypesAndAnnotations.kt
@@ -4,8 +4,8 @@ interface <info textAttributesKey="KOTLIN_TRAIT">TheTrait</info> {
 class <info textAttributesKey="KOTLIN_CLASS">TheClass</info> : <info textAttributesKey="KOTLIN_TRAIT">TheTrait</info> {
 }
 
-<info textAttributesKey="KOTLIN_BUILTIN_ANNOTATION">annotation</info> class <info textAttributesKey="KOTLIN_ANNOTATION">magnificent</info>
-<info textAttributesKey="KOTLIN_BUILTIN_ANNOTATION">annotation</info> class <info textAttributesKey="KOTLIN_ANNOTATION">deprecated</info>
+<info textAttributesKey="KOTLIN_ANNOTATION">annotation</info> class <info textAttributesKey="KOTLIN_ANNOTATION">magnificent</info>
+<info textAttributesKey="KOTLIN_ANNOTATION">annotation</info> class <info textAttributesKey="KOTLIN_ANNOTATION">deprecated</info>
 
 <info textAttributesKey="KOTLIN_ANNOTATION">@deprecated</info>
 <info textAttributesKey="KOTLIN_ANNOTATION">magnificent</info> <info textAttributesKey="KOTLIN_BUILTIN_ANNOTATION">abstract</info> class <info textAttributesKey="KOTLIN_ABSTRACT_CLASS">AbstractClass</info><<info textAttributesKey="KOTLIN_TYPE_PARAMETER">T</info>> {
diff --git a/idea/testData/inspections/reflectionNotFound/functionReference.kt b/idea/testData/inspections/reflectionNotFound/functionReference.kt
deleted file mode 100644
index 289cd4ecda9..00000000000
--- a/idea/testData/inspections/reflectionNotFound/functionReference.kt
+++ /dev/null
@@ -1,18 +0,0 @@
-package test
-
-// WITH_RUNTIME
-
-import kotlin.reflect.KFunction0
-
-fun foo() {}
-
-fun bar(f: () -> Unit) = f()
-
-// Inspection should be reported here because '::foo' may be used as a reflection object
-val p1 = ::foo                    // the type is KFunction0 by default
-val p2: KFunction0<Unit> = ::foo  // the expected type is KFunction0
-
-// But shouldn't be reported here
-val p3 = bar(::foo)               // the expected type is Function0, '::foo' is used as an ordinary function
-val p4: Any = ::foo               // the expected type is Any
-val p5: UnresolvedClass = ::foo   // an error, another warning would be useless
diff --git a/idea/testData/inspections/reflectionNotFound/inspectionData/expected.xml b/idea/testData/inspections/reflectionNotFound/inspectionData/expected.xml
deleted file mode 100644
index fed4c656629..00000000000
--- a/idea/testData/inspections/reflectionNotFound/inspectionData/expected.xml
+++ /dev/null
@@ -1,26 +0,0 @@
-<problems>
-  <problem>
-    <file>functionReference.kt</file>
-    <line>12</line>
-    <module>light_idea_test_case</module>
-    <entry_point TYPE="file" FQNAME="temp:///src/functionReference.kt" />
-    <problem_class severity="WARNING" attribute_key="WARNING_ATTRIBUTES">Reflection not found</problem_class>
-    <description>Reflection not found in the classpath</description>
-  </problem>
-  <problem>
-    <file>functionReference.kt</file>
-    <line>13</line>
-    <module>light_idea_test_case</module>
-    <entry_point TYPE="file" FQNAME="temp:///src/functionReference.kt" />
-    <problem_class severity="WARNING" attribute_key="WARNING_ATTRIBUTES">Reflection not found</problem_class>
-    <description>Reflection not found in the classpath</description>
-  </problem>
-  <problem>
-    <file>withinAnnotationEntry.kt</file>
-    <line>13</line>
-    <module>light_idea_test_case</module>
-    <entry_point TYPE="file" FQNAME="temp:///src/withinAnnotationEntry.kt" />
-    <problem_class severity="WARNING" attribute_key="WARNING_ATTRIBUTES">Reflection not found</problem_class>
-    <description>Reflection not found in the classpath</description>
-  </problem>
-</problems>
diff --git a/idea/testData/inspections/reflectionNotFound/inspectionData/inspections.test b/idea/testData/inspections/reflectionNotFound/inspectionData/inspections.test
deleted file mode 100644
index e5639d6dfe9..00000000000
--- a/idea/testData/inspections/reflectionNotFound/inspectionData/inspections.test
+++ /dev/null
@@ -1 +0,0 @@
-// INSPECTION_CLASS: org.jetbrains.kotlin.idea.inspections.ReflectionNotFoundInspection
diff --git a/idea/testData/inspections/reflectionNotFound/withinAnnotationEntry.kt b/idea/testData/inspections/reflectionNotFound/withinAnnotationEntry.kt
deleted file mode 100644
index 3e75d6bc3e8..00000000000
--- a/idea/testData/inspections/reflectionNotFound/withinAnnotationEntry.kt
+++ /dev/null
@@ -1,15 +0,0 @@
-package test
-
-// WITH_RUNTIME
-
-import kotlin.reflect.KClass
-
-annotation class A(val arg: KClass<*>, val args: Array<KClass<*>>, vararg val other: KClass<*>)
-
-A(Int::class, array(String::class), Double::class, Char::class)
-class MyClass {
-    throws(Exception::class)
-    fun foo() {
-        Exception::class
-    }
-}
diff --git a/idea/testData/intentions/convertToBlockBody/annotatedExpr.kt b/idea/testData/intentions/convertToBlockBody/annotatedExpr.kt
index 11f52949590..04d788b43ee 100644
--- a/idea/testData/intentions/convertToBlockBody/annotatedExpr.kt
+++ b/idea/testData/intentions/convertToBlockBody/annotatedExpr.kt
@@ -1,3 +1,4 @@
+target(AnnotationTarget.EXPRESSION)
 annotation class ann
 
 fun foo(): Int = <caret>@ann 1
\ No newline at end of file
diff --git a/idea/testData/intentions/convertToBlockBody/annotatedExpr.kt.after b/idea/testData/intentions/convertToBlockBody/annotatedExpr.kt.after
index ddc10faa4b3..33e6615c957 100644
--- a/idea/testData/intentions/convertToBlockBody/annotatedExpr.kt.after
+++ b/idea/testData/intentions/convertToBlockBody/annotatedExpr.kt.after
@@ -1,3 +1,4 @@
+target(AnnotationTarget.EXPRESSION)
 annotation class ann
 
 fun foo(): Int {
diff --git a/idea/testData/intentions/insertExplicitTypeArguments/insertImportForArg.kt b/idea/testData/intentions/insertExplicitTypeArguments/insertImportForArg.kt
index 10e3f0aff50..ab3c5d372c9 100644
--- a/idea/testData/intentions/insertExplicitTypeArguments/insertImportForArg.kt
+++ b/idea/testData/intentions/insertExplicitTypeArguments/insertImportForArg.kt
@@ -1,4 +1,4 @@
-fun foo(c: kotlin.support.AbstractIterator<kotlin.concurrent.FunctionalList<Int>>) {
+fun foo(c: kotlin.support.AbstractIterator<kotlin.properties.ObservableProperty<Int>>) {
     ba<caret>r(c)
 }
 
diff --git a/idea/testData/intentions/insertExplicitTypeArguments/insertImportForArg.kt.after b/idea/testData/intentions/insertExplicitTypeArguments/insertImportForArg.kt.after
index 1e09c2b3b66..2e636643e12 100644
--- a/idea/testData/intentions/insertExplicitTypeArguments/insertImportForArg.kt.after
+++ b/idea/testData/intentions/insertExplicitTypeArguments/insertImportForArg.kt.after
@@ -1,8 +1,8 @@
-import kotlin.concurrent.FunctionalList
+import kotlin.properties.ObservableProperty
 import kotlin.support.AbstractIterator
 
-fun foo(c: kotlin.support.AbstractIterator<kotlin.concurrent.FunctionalList<Int>>) {
-    bar<AbstractIterator<FunctionalList<Int>>>(c)
+fun foo(c: kotlin.support.AbstractIterator<kotlin.properties.ObservableProperty<Int>>) {
+    bar<AbstractIterator<ObservableProperty<Int>>>(c)
 }
 
 fun <T> bar(t: T): T = t
diff --git a/idea/testData/intentions/removeExplicitLambdaParameterTypes/lambdaWithLambdaAsParam.kt.after b/idea/testData/intentions/removeExplicitLambdaParameterTypes/lambdaWithLambdaAsParam.kt.after
index 42d2af38748..1f9d8c45f46 100644
--- a/idea/testData/intentions/removeExplicitLambdaParameterTypes/lambdaWithLambdaAsParam.kt.after
+++ b/idea/testData/intentions/removeExplicitLambdaParameterTypes/lambdaWithLambdaAsParam.kt.after
@@ -4,5 +4,5 @@ public class TestingUse {
 }
 
 fun main() {
-    val funcInfunc = TestingUse().test6({ f -> f(5) > 20}, {x -> x + 2})
+    val funcInfunc = TestingUse().test6({ f -> f(5) > 20}, { x -> x + 2})
 }
diff --git a/idea/testData/intentions/specifyExplicitLambdaSignature/lambdaWithLambdaAsParam.kt.after b/idea/testData/intentions/specifyExplicitLambdaSignature/lambdaWithLambdaAsParam.kt.after
index 7b53a0a3306..f829687af69 100644
--- a/idea/testData/intentions/specifyExplicitLambdaSignature/lambdaWithLambdaAsParam.kt.after
+++ b/idea/testData/intentions/specifyExplicitLambdaSignature/lambdaWithLambdaAsParam.kt.after
@@ -4,5 +4,5 @@ public class TestingUse {
 }
 
 fun main() {
-    val funcInfunc = TestingUse().test6({ f: (Int) -> Int -> f(5) > 20}, {x -> x + 2})
+    val funcInfunc = TestingUse().test6({ f: (Int) -> Int -> f(5) > 20}, { x -> x + 2})
 }
diff --git a/idea/testData/intentions/specifyTypeExplicitly/loopParameter.kt.after b/idea/testData/intentions/specifyTypeExplicitly/loopParameter.kt.after
index a0d6772e37e..32f4f937299 100644
--- a/idea/testData/intentions/specifyTypeExplicitly/loopParameter.kt.after
+++ b/idea/testData/intentions/specifyTypeExplicitly/loopParameter.kt.after
@@ -3,7 +3,7 @@
 import java.util.HashMap
 
 fun foo(map : HashMap<String, Int>) {
-    for (entry: MutableMap.MutableEntry<String, Int>?<caret> in map.entrySet()) {
+    for (entry: MutableMap.MutableEntry<String, Int><caret> in map.entrySet()) {
 
     }
 }
\ No newline at end of file
diff --git a/idea/testData/intentions/usePropertyAccessSyntax/.intention b/idea/testData/intentions/usePropertyAccessSyntax/.intention
new file mode 100644
index 00000000000..07c59e83a91
--- /dev/null
+++ b/idea/testData/intentions/usePropertyAccessSyntax/.intention
@@ -0,0 +1 @@
+org.jetbrains.kotlin.idea.intentions.UsePropertyAccessSyntaxIntention
diff --git a/idea/testData/intentions/usePropertyAccessSyntax/accessThroughKotlinClassInstance.kt b/idea/testData/intentions/usePropertyAccessSyntax/accessThroughKotlinClassInstance.kt
new file mode 100644
index 00000000000..18d4bff3b10
--- /dev/null
+++ b/idea/testData/intentions/usePropertyAccessSyntax/accessThroughKotlinClassInstance.kt
@@ -0,0 +1,8 @@
+// WITH_RUNTIME
+import java.io.File
+
+class MyFile : File("file")
+
+fun foo(file: MyFile) {
+    file.getAbsolutePath()<caret>
+}
\ No newline at end of file
diff --git a/idea/testData/intentions/usePropertyAccessSyntax/accessThroughKotlinClassInstance.kt.after b/idea/testData/intentions/usePropertyAccessSyntax/accessThroughKotlinClassInstance.kt.after
new file mode 100644
index 00000000000..1581334f1b5
--- /dev/null
+++ b/idea/testData/intentions/usePropertyAccessSyntax/accessThroughKotlinClassInstance.kt.after
@@ -0,0 +1,8 @@
+// WITH_RUNTIME
+import java.io.File
+
+class MyFile : File("file")
+
+fun foo(file: MyFile) {
+    file.absolutePath<caret>
+}
\ No newline at end of file
diff --git a/idea/testData/intentions/usePropertyAccessSyntax/accessThroughKotlinClassInstanceWithOverride.kt b/idea/testData/intentions/usePropertyAccessSyntax/accessThroughKotlinClassInstanceWithOverride.kt
new file mode 100644
index 00000000000..dcec7f3b695
--- /dev/null
+++ b/idea/testData/intentions/usePropertyAccessSyntax/accessThroughKotlinClassInstanceWithOverride.kt
@@ -0,0 +1,12 @@
+// WITH_RUNTIME
+import java.io.File
+
+class MyFile : File("file") {
+    override fun getCanonicalFile(): File {
+        return super.getCanonicalFile()
+    }
+}
+
+fun foo(file: MyFile) {
+    file.getCanonicalFile()<caret>
+}
\ No newline at end of file
diff --git a/idea/testData/intentions/usePropertyAccessSyntax/accessThroughKotlinClassInstanceWithOverride.kt.after b/idea/testData/intentions/usePropertyAccessSyntax/accessThroughKotlinClassInstanceWithOverride.kt.after
new file mode 100644
index 00000000000..89f43a93045
--- /dev/null
+++ b/idea/testData/intentions/usePropertyAccessSyntax/accessThroughKotlinClassInstanceWithOverride.kt.after
@@ -0,0 +1,12 @@
+// WITH_RUNTIME
+import java.io.File
+
+class MyFile : File("file") {
+    override fun getCanonicalFile(): File {
+        return super.getCanonicalFile()
+    }
+}
+
+fun foo(file: MyFile) {
+    file.canonicalFile<caret>
+}
\ No newline at end of file
diff --git a/idea/testData/intentions/usePropertyAccessSyntax/conflict1.kt b/idea/testData/intentions/usePropertyAccessSyntax/conflict1.kt
new file mode 100644
index 00000000000..24a31ad2bf1
--- /dev/null
+++ b/idea/testData/intentions/usePropertyAccessSyntax/conflict1.kt
@@ -0,0 +1,7 @@
+// WITH_RUNTIME
+// IS_APPLICABLE: false
+import java.io.File
+
+fun File.foo(absolutePath: String) {
+    getAbsolutePath()<caret>
+}
\ No newline at end of file
diff --git a/idea/testData/intentions/usePropertyAccessSyntax/conflict2.kt b/idea/testData/intentions/usePropertyAccessSyntax/conflict2.kt
new file mode 100644
index 00000000000..872ab35fa8f
--- /dev/null
+++ b/idea/testData/intentions/usePropertyAccessSyntax/conflict2.kt
@@ -0,0 +1,9 @@
+// WITH_RUNTIME
+// IS_APPLICABLE: false
+import java.io.File
+
+val File.absolutePath: String get() = ""
+
+fun foo(file: File) {
+    file.getAbsolutePath()<caret>
+}
\ No newline at end of file
diff --git a/idea/testData/intentions/usePropertyAccessSyntax/genericClassMethod.kt b/idea/testData/intentions/usePropertyAccessSyntax/genericClassMethod.kt
new file mode 100644
index 00000000000..7d1bf9a0f2d
--- /dev/null
+++ b/idea/testData/intentions/usePropertyAccessSyntax/genericClassMethod.kt
@@ -0,0 +1,4 @@
+// WITH_RUNTIME
+fun foo(klass: Class<*>) {
+    klass.getEnclosingClass()<caret>
+}
\ No newline at end of file
diff --git a/idea/testData/intentions/usePropertyAccessSyntax/genericClassMethod.kt.after b/idea/testData/intentions/usePropertyAccessSyntax/genericClassMethod.kt.after
new file mode 100644
index 00000000000..733e44dba2c
--- /dev/null
+++ b/idea/testData/intentions/usePropertyAccessSyntax/genericClassMethod.kt.after
@@ -0,0 +1,4 @@
+// WITH_RUNTIME
+fun foo(klass: Class<*>) {
+    klass.enclosingClass<caret>
+}
\ No newline at end of file
diff --git a/idea/testData/intentions/usePropertyAccessSyntax/get.kt b/idea/testData/intentions/usePropertyAccessSyntax/get.kt
new file mode 100644
index 00000000000..c675ee0285e
--- /dev/null
+++ b/idea/testData/intentions/usePropertyAccessSyntax/get.kt
@@ -0,0 +1,6 @@
+// WITH_RUNTIME
+import java.io.File
+
+fun foo(file: File) {
+    file.getAbsolutePath()<caret>
+}
\ No newline at end of file
diff --git a/idea/testData/intentions/usePropertyAccessSyntax/get.kt.after b/idea/testData/intentions/usePropertyAccessSyntax/get.kt.after
new file mode 100644
index 00000000000..f0bfca56602
--- /dev/null
+++ b/idea/testData/intentions/usePropertyAccessSyntax/get.kt.after
@@ -0,0 +1,6 @@
+// WITH_RUNTIME
+import java.io.File
+
+fun foo(file: File) {
+    file.absolutePath<caret>
+}
\ No newline at end of file
diff --git a/idea/testData/intentions/usePropertyAccessSyntax/getImplicitReceiver.kt b/idea/testData/intentions/usePropertyAccessSyntax/getImplicitReceiver.kt
new file mode 100644
index 00000000000..cccad1ce70e
--- /dev/null
+++ b/idea/testData/intentions/usePropertyAccessSyntax/getImplicitReceiver.kt
@@ -0,0 +1,6 @@
+// WITH_RUNTIME
+import java.io.File
+
+fun File.foo() {
+    getAbsolutePath()<caret>
+}
\ No newline at end of file
diff --git a/idea/testData/intentions/usePropertyAccessSyntax/getImplicitReceiver.kt.after b/idea/testData/intentions/usePropertyAccessSyntax/getImplicitReceiver.kt.after
new file mode 100644
index 00000000000..1dba46cb7c2
--- /dev/null
+++ b/idea/testData/intentions/usePropertyAccessSyntax/getImplicitReceiver.kt.after
@@ -0,0 +1,6 @@
+// WITH_RUNTIME
+import java.io.File
+
+fun File.foo() {
+    absolutePath<caret>
+}
\ No newline at end of file
diff --git a/idea/testData/intentions/usePropertyAccessSyntax/getSafeCall.kt b/idea/testData/intentions/usePropertyAccessSyntax/getSafeCall.kt
new file mode 100644
index 00000000000..43cb61ce3f3
--- /dev/null
+++ b/idea/testData/intentions/usePropertyAccessSyntax/getSafeCall.kt
@@ -0,0 +1,6 @@
+// WITH_RUNTIME
+import java.io.File
+
+fun foo(file: File?) {
+    file?.getAbsolutePath()<caret>
+}
\ No newline at end of file
diff --git a/idea/testData/intentions/usePropertyAccessSyntax/getSafeCall.kt.after b/idea/testData/intentions/usePropertyAccessSyntax/getSafeCall.kt.after
new file mode 100644
index 00000000000..214787cebcb
--- /dev/null
+++ b/idea/testData/intentions/usePropertyAccessSyntax/getSafeCall.kt.after
@@ -0,0 +1,6 @@
+// WITH_RUNTIME
+import java.io.File
+
+fun foo(file: File?) {
+    file?.absolutePath<caret>
+}
\ No newline at end of file
diff --git a/idea/testData/intentions/usePropertyAccessSyntax/isGet.kt b/idea/testData/intentions/usePropertyAccessSyntax/isGet.kt
new file mode 100644
index 00000000000..4226c66661d
--- /dev/null
+++ b/idea/testData/intentions/usePropertyAccessSyntax/isGet.kt
@@ -0,0 +1,4 @@
+// WITH_RUNTIME
+fun foo(thread: Thread) {
+    thread.<caret>isDaemon()
+}
\ No newline at end of file
diff --git a/idea/testData/intentions/usePropertyAccessSyntax/isGet.kt.after b/idea/testData/intentions/usePropertyAccessSyntax/isGet.kt.after
new file mode 100644
index 00000000000..2d219caa3cd
--- /dev/null
+++ b/idea/testData/intentions/usePropertyAccessSyntax/isGet.kt.after
@@ -0,0 +1,4 @@
+// WITH_RUNTIME
+fun foo(thread: Thread) {
+    thread.<caret>isDaemon
+}
\ No newline at end of file
diff --git a/idea/testData/intentions/usePropertyAccessSyntax/isSet.kt b/idea/testData/intentions/usePropertyAccessSyntax/isSet.kt
new file mode 100644
index 00000000000..d85a6bc74a5
--- /dev/null
+++ b/idea/testData/intentions/usePropertyAccessSyntax/isSet.kt
@@ -0,0 +1,4 @@
+// WITH_RUNTIME
+fun foo(thread: Thread) {
+    thread.<caret>setDaemon(true)
+}
\ No newline at end of file
diff --git a/idea/testData/intentions/usePropertyAccessSyntax/isSet.kt.after b/idea/testData/intentions/usePropertyAccessSyntax/isSet.kt.after
new file mode 100644
index 00000000000..51f85fe5da9
--- /dev/null
+++ b/idea/testData/intentions/usePropertyAccessSyntax/isSet.kt.after
@@ -0,0 +1,4 @@
+// WITH_RUNTIME
+fun foo(thread: Thread) {
+    thread.<caret>isDaemon = true
+}
\ No newline at end of file
diff --git a/idea/testData/intentions/usePropertyAccessSyntax/set.kt b/idea/testData/intentions/usePropertyAccessSyntax/set.kt
new file mode 100644
index 00000000000..1a5be1d26aa
--- /dev/null
+++ b/idea/testData/intentions/usePropertyAccessSyntax/set.kt
@@ -0,0 +1,4 @@
+// WITH_RUNTIME
+fun foo(thread: Thread) {
+    thread.setName("name")<caret>
+}
\ No newline at end of file
diff --git a/idea/testData/intentions/usePropertyAccessSyntax/set.kt.after b/idea/testData/intentions/usePropertyAccessSyntax/set.kt.after
new file mode 100644
index 00000000000..3a7238cc003
--- /dev/null
+++ b/idea/testData/intentions/usePropertyAccessSyntax/set.kt.after
@@ -0,0 +1,4 @@
+// WITH_RUNTIME
+fun foo(thread: Thread) {
+    thread.name = "name"<caret>
+}
\ No newline at end of file
diff --git a/idea/testData/intentions/usePropertyAccessSyntax/setImplicitReceiver.kt b/idea/testData/intentions/usePropertyAccessSyntax/setImplicitReceiver.kt
new file mode 100644
index 00000000000..c35a7e6f944
--- /dev/null
+++ b/idea/testData/intentions/usePropertyAccessSyntax/setImplicitReceiver.kt
@@ -0,0 +1,4 @@
+// WITH_RUNTIME
+fun Thread.foo() {
+    setName("name")<caret>
+}
\ No newline at end of file
diff --git a/idea/testData/intentions/usePropertyAccessSyntax/setImplicitReceiver.kt.after b/idea/testData/intentions/usePropertyAccessSyntax/setImplicitReceiver.kt.after
new file mode 100644
index 00000000000..a639d2fcc57
--- /dev/null
+++ b/idea/testData/intentions/usePropertyAccessSyntax/setImplicitReceiver.kt.after
@@ -0,0 +1,4 @@
+// WITH_RUNTIME
+fun Thread.foo() {
+    name = "name"<caret>
+}
\ No newline at end of file
diff --git a/idea/testData/intentions/usePropertyAccessSyntax/setSafeCall.kt b/idea/testData/intentions/usePropertyAccessSyntax/setSafeCall.kt
new file mode 100644
index 00000000000..2c44ee53f9b
--- /dev/null
+++ b/idea/testData/intentions/usePropertyAccessSyntax/setSafeCall.kt
@@ -0,0 +1,4 @@
+// WITH_RUNTIME
+fun foo(thread: Thread?) {
+    thread?.setName("name")<caret>
+}
\ No newline at end of file
diff --git a/idea/testData/intentions/usePropertyAccessSyntax/setSafeCall.kt.after b/idea/testData/intentions/usePropertyAccessSyntax/setSafeCall.kt.after
new file mode 100644
index 00000000000..15254f25621
--- /dev/null
+++ b/idea/testData/intentions/usePropertyAccessSyntax/setSafeCall.kt.after
@@ -0,0 +1,4 @@
+// WITH_RUNTIME
+fun foo(thread: Thread?) {
+    thread?.name = "name"<caret>
+}
\ No newline at end of file
diff --git a/idea/testData/intentions/usePropertyAccessSyntax/smartCast.kt b/idea/testData/intentions/usePropertyAccessSyntax/smartCast.kt
new file mode 100644
index 00000000000..e30d98f8d03
--- /dev/null
+++ b/idea/testData/intentions/usePropertyAccessSyntax/smartCast.kt
@@ -0,0 +1,8 @@
+// WITH_RUNTIME
+import java.io.File
+
+fun foo(o: Any) {
+    if (o is File) {
+        o.getAbsolutePath()<caret>
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/intentions/usePropertyAccessSyntax/smartCast.kt.after b/idea/testData/intentions/usePropertyAccessSyntax/smartCast.kt.after
new file mode 100644
index 00000000000..a69bc4b844c
--- /dev/null
+++ b/idea/testData/intentions/usePropertyAccessSyntax/smartCast.kt.after
@@ -0,0 +1,8 @@
+// WITH_RUNTIME
+import java.io.File
+
+fun foo(o: Any) {
+    if (o is File) {
+        o.absolutePath<caret>
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/intentions/usePropertyAccessSyntax/superCall.kt b/idea/testData/intentions/usePropertyAccessSyntax/superCall.kt
new file mode 100644
index 00000000000..a28fb98d88a
--- /dev/null
+++ b/idea/testData/intentions/usePropertyAccessSyntax/superCall.kt
@@ -0,0 +1,9 @@
+// WITH_RUNTIME
+// IS_APPLICABLE: false
+import java.io.File
+
+class MyFile : File("file") {
+    override fun getCanonicalFile(): File {
+        return super.getCanonicalFile()<caret>
+    }
+}
diff --git a/idea/testData/parameterInfo/functionParameterInfo/NotAccessible.kt b/idea/testData/parameterInfo/functionParameterInfo/NotAccessible.kt
new file mode 100644
index 00000000000..d479deb45d2
--- /dev/null
+++ b/idea/testData/parameterInfo/functionParameterInfo/NotAccessible.kt
@@ -0,0 +1,11 @@
+class C {
+    fun foo(){}
+    protected fun foo(p: Int){}
+}
+
+fun f(c: C) {
+    c.foo(<caret>1)
+}
+/*
+Text: (<no parameters>), Disabled: true, Strikeout: false, Green: true
+*/
\ No newline at end of file
diff --git a/idea/testData/quickfix.special/deprecatedMemberInCompiledClass.kt b/idea/testData/quickfix.special/deprecatedMemberInCompiledClass.kt
new file mode 100644
index 00000000000..110af59ade9
--- /dev/null
+++ b/idea/testData/quickfix.special/deprecatedMemberInCompiledClass.kt
@@ -0,0 +1,7 @@
+// "Replace with 'matches(input)'" "true"
+
+import kotlin.text.Regex
+
+fun foo(regex: Regex) {
+    regex.<caret>hasMatch("")
+}
\ No newline at end of file
diff --git a/idea/testData/quickfix.special/deprecatedMemberInCompiledClass.kt.after b/idea/testData/quickfix.special/deprecatedMemberInCompiledClass.kt.after
new file mode 100644
index 00000000000..14508d63305
--- /dev/null
+++ b/idea/testData/quickfix.special/deprecatedMemberInCompiledClass.kt.after
@@ -0,0 +1,7 @@
+// "Replace with 'matches(input)'" "true"
+
+import kotlin.text.Regex
+
+fun foo(regex: Regex) {
+    regex.<caret>matches("")
+}
\ No newline at end of file
diff --git a/idea/testData/quickfix/autoImports/noImportsForClassInExcludedPackage.before.Main.kt b/idea/testData/quickfix/autoImports/noImportsForClassInExcludedPackage.before.Main.kt
new file mode 100644
index 00000000000..92f2354e6c0
--- /dev/null
+++ b/idea/testData/quickfix/autoImports/noImportsForClassInExcludedPackage.before.Main.kt
@@ -0,0 +1,6 @@
+// "class com.intellij.codeInsight.daemon.impl.quickfix.ImportClassFixBase" "false"
+// ACTION: Create class 'SomeClass'
+// ACTION: Create function 'SomeClass'
+// ERROR: Unresolved reference: SomeClass
+
+val x = <caret>SomeClass()
\ No newline at end of file
diff --git a/idea/testData/quickfix/autoImports/noImportsForClassInExcludedPackage.before.data.Sample.kt b/idea/testData/quickfix/autoImports/noImportsForClassInExcludedPackage.before.data.Sample.kt
new file mode 100644
index 00000000000..00f79598da5
--- /dev/null
+++ b/idea/testData/quickfix/autoImports/noImportsForClassInExcludedPackage.before.data.Sample.kt
@@ -0,0 +1,3 @@
+package excludedPackage
+
+class SomeClass
\ No newline at end of file
diff --git a/idea/testData/quickfix/autoImports/noImportsForExcludedClass.before.Main.kt b/idea/testData/quickfix/autoImports/noImportsForExcludedClass.before.Main.kt
new file mode 100644
index 00000000000..1f3fc10ef1e
--- /dev/null
+++ b/idea/testData/quickfix/autoImports/noImportsForExcludedClass.before.Main.kt
@@ -0,0 +1,6 @@
+// "class com.intellij.codeInsight.daemon.impl.quickfix.ImportClassFixBase" "false"
+// ACTION: Create class 'ExcludedClass'
+// ACTION: Create function 'ExcludedClass'
+// ERROR: Unresolved reference: ExcludedClass
+
+val x = <caret>ExcludedClass()
\ No newline at end of file
diff --git a/idea/testData/quickfix/autoImports/noImportsForExcludedClass.before.data.Sample.kt b/idea/testData/quickfix/autoImports/noImportsForExcludedClass.before.data.Sample.kt
new file mode 100644
index 00000000000..59299eb163c
--- /dev/null
+++ b/idea/testData/quickfix/autoImports/noImportsForExcludedClass.before.data.Sample.kt
@@ -0,0 +1,3 @@
+package somePackage
+
+class ExcludedClass
\ No newline at end of file
diff --git a/idea/testData/quickfix/autoImports/noImportsForFunctionInExcludedPackage.before.Main.kt b/idea/testData/quickfix/autoImports/noImportsForFunctionInExcludedPackage.before.Main.kt
new file mode 100644
index 00000000000..081b55d7691
--- /dev/null
+++ b/idea/testData/quickfix/autoImports/noImportsForFunctionInExcludedPackage.before.Main.kt
@@ -0,0 +1,5 @@
+// "class com.intellij.codeInsight.daemon.impl.quickfix.ImportClassFixBase" "false"
+// ACTION: Create function 'someFunction'
+// ERROR: Unresolved reference: someFunction
+
+val x = <caret>someFunction()
\ No newline at end of file
diff --git a/idea/testData/quickfix/autoImports/noImportsForFunctionInExcludedPackage.before.data.Sample.kt b/idea/testData/quickfix/autoImports/noImportsForFunctionInExcludedPackage.before.data.Sample.kt
new file mode 100644
index 00000000000..c6bd1606f7f
--- /dev/null
+++ b/idea/testData/quickfix/autoImports/noImportsForFunctionInExcludedPackage.before.data.Sample.kt
@@ -0,0 +1,5 @@
+package excludedPackage
+
+fun someFunction() {
+
+}
\ No newline at end of file
diff --git a/idea/testData/quickfix/autoImports/notExcludedClass.after.kt b/idea/testData/quickfix/autoImports/notExcludedClass.after.kt
new file mode 100644
index 00000000000..b34d2bb4756
--- /dev/null
+++ b/idea/testData/quickfix/autoImports/notExcludedClass.after.kt
@@ -0,0 +1,6 @@
+import somePackage.NotExcludedClass
+
+// "Import" "true"
+// ERROR: Unresolved reference: NotExcludedClass
+
+val x = <caret>NotExcludedClass()
\ No newline at end of file
diff --git a/idea/testData/quickfix/autoImports/notExcludedClass.before.Main.kt b/idea/testData/quickfix/autoImports/notExcludedClass.before.Main.kt
new file mode 100644
index 00000000000..860bc03f0cf
--- /dev/null
+++ b/idea/testData/quickfix/autoImports/notExcludedClass.before.Main.kt
@@ -0,0 +1,4 @@
+// "Import" "true"
+// ERROR: Unresolved reference: NotExcludedClass
+
+val x = <caret>NotExcludedClass()
\ No newline at end of file
diff --git a/idea/testData/quickfix/autoImports/notExcludedClass.before.data.Sample.kt b/idea/testData/quickfix/autoImports/notExcludedClass.before.data.Sample.kt
new file mode 100644
index 00000000000..55afe2de2a1
--- /dev/null
+++ b/idea/testData/quickfix/autoImports/notExcludedClass.before.data.Sample.kt
@@ -0,0 +1,3 @@
+package somePackage
+
+class NotExcludedClass
\ No newline at end of file
diff --git a/idea/testData/quickfix/changeSignature/addConstructorParameter.kt.after b/idea/testData/quickfix/changeSignature/addConstructorParameter.kt.after
index 46e025b3162..de8e0e17339 100644
--- a/idea/testData/quickfix/changeSignature/addConstructorParameter.kt.after
+++ b/idea/testData/quickfix/changeSignature/addConstructorParameter.kt.after
@@ -2,7 +2,7 @@
 // DISABLE-ERRORS
 
 open class Base(var x: Int, d: Double) {
-    val y = Base(1, 2.5);
+    val y = Base(1, 2);
 
     fun f() {
         val base = Base(1, 2.5);
diff --git a/idea/testData/quickfix/changeSignature/addFunctionParameter.kt.after b/idea/testData/quickfix/changeSignature/addFunctionParameter.kt.after
index ea126c90485..43ecbb9773b 100644
--- a/idea/testData/quickfix/changeSignature/addFunctionParameter.kt.after
+++ b/idea/testData/quickfix/changeSignature/addFunctionParameter.kt.after
@@ -2,8 +2,8 @@
 // DISABLE-ERRORS
 
 fun foo(x: Int, i: Int) {
-    foo(, 4);
+    foo();
     foo(1, 4);
     foo(1, 4);
-    foo(2, 4);
+    foo(2, 3, sdsd);
 }
\ No newline at end of file
diff --git a/idea/testData/quickfix/changeSignature/addFunctionParameterAndChangeTypes.kt.after b/idea/testData/quickfix/changeSignature/addFunctionParameterAndChangeTypes.kt.after
index 14629bbb076..3e2ef77d39f 100644
--- a/idea/testData/quickfix/changeSignature/addFunctionParameterAndChangeTypes.kt.after
+++ b/idea/testData/quickfix/changeSignature/addFunctionParameterAndChangeTypes.kt.after
@@ -2,9 +2,9 @@
 // DISABLE-ERRORS
 
 fun foo(x: Double, i: Int, i1: Int, i2: Int) {
-    foo(,, 5, 6);
-    foo(1,, 5, 6);
+    foo();
+    foo(1);
     foo(1, 2.5, 5, 6);
     foo(1.5, 4, 5, 6);
-    foo(2, 3, 5, 6);
+    foo(2, 3, sdsd);
 }
\ No newline at end of file
diff --git a/idea/testData/quickfix/changeSignature/addJavaMethodParameter.after.Dependency.java b/idea/testData/quickfix/changeSignature/addJavaMethodParameter.after.Dependency.java
new file mode 100644
index 00000000000..724af9d6f0b
--- /dev/null
+++ b/idea/testData/quickfix/changeSignature/addJavaMethodParameter.after.Dependency.java
@@ -0,0 +1,15 @@
+class Foo {
+    static void foo(int n, int m, int i) {
+
+    }
+}
+
+class Test {
+    static void test() {
+        Foo.foo();
+        Foo.foo(1);
+        Foo.foo(1, 2, 3);
+        Foo.foo(1, 2, 3);
+        Foo.foo(4, 5, 6);
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/quickfix/changeSignature/addJavaMethodParameter.after.kt b/idea/testData/quickfix/changeSignature/addJavaMethodParameter.after.kt
new file mode 100644
index 00000000000..10a51064812
--- /dev/null
+++ b/idea/testData/quickfix/changeSignature/addJavaMethodParameter.after.kt
@@ -0,0 +1,9 @@
+// "Add parameter to function 'foo'" "true"
+// DISABLE-ERRORS
+fun test() {
+    Foo.foo()
+    Foo.foo(1)
+    Foo.foo(1, 2, 3)
+    Foo.foo(1, 2, 3<caret>)
+    Foo.foo(4, 5, 6)
+}
\ No newline at end of file
diff --git a/idea/testData/quickfix/changeSignature/addJavaMethodParameter.before.Dependency.java b/idea/testData/quickfix/changeSignature/addJavaMethodParameter.before.Dependency.java
new file mode 100644
index 00000000000..905b6820a9e
--- /dev/null
+++ b/idea/testData/quickfix/changeSignature/addJavaMethodParameter.before.Dependency.java
@@ -0,0 +1,15 @@
+class Foo {
+    static void foo(int n, int m) {
+
+    }
+}
+
+class Test {
+    static void test() {
+        Foo.foo();
+        Foo.foo(1);
+        Foo.foo(1, 2);
+        Foo.foo(1, 2, 3);
+        Foo.foo(4, 5, 6);
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/quickfix/changeSignature/addJavaMethodParameter.before.Main.kt b/idea/testData/quickfix/changeSignature/addJavaMethodParameter.before.Main.kt
new file mode 100644
index 00000000000..dd0909b5b01
--- /dev/null
+++ b/idea/testData/quickfix/changeSignature/addJavaMethodParameter.before.Main.kt
@@ -0,0 +1,9 @@
+// "Add parameter to function 'foo'" "true"
+// DISABLE-ERRORS
+fun test() {
+    Foo.foo()
+    Foo.foo(1)
+    Foo.foo(1, 2)
+    Foo.foo(1, 2, 3<caret>)
+    Foo.foo(4, 5, 6)
+}
\ No newline at end of file
diff --git a/idea/testData/quickfix/changeSignature/addParameterNotAvailableForLibrary.kt b/idea/testData/quickfix/changeSignature/addParameterNotAvailableForLibrary.kt
index 923b47d9e29..b69c7577f90 100644
--- a/idea/testData/quickfix/changeSignature/addParameterNotAvailableForLibrary.kt
+++ b/idea/testData/quickfix/changeSignature/addParameterNotAvailableForLibrary.kt
@@ -1,5 +1,5 @@
 // "class org.jetbrains.kotlin.idea.quickfix.AddFunctionParametersFix" "false"
-// ERROR: Too many arguments for public open fun equals(other: kotlin.Any!): kotlin.Boolean defined in java.lang.Object
+// ERROR: Too many arguments for public open fun equals(other: kotlin.Any?): kotlin.Boolean defined in java.lang.Object
 
 fun f(d: java.lang.Object) {
     d.equals("a", <caret>"b")
diff --git a/idea/testData/quickfix/changeSignature/removeConstructorParameter.kt.after b/idea/testData/quickfix/changeSignature/removeConstructorParameter.kt.after
index 69b96d13914..6c40ec1d8dd 100644
--- a/idea/testData/quickfix/changeSignature/removeConstructorParameter.kt.after
+++ b/idea/testData/quickfix/changeSignature/removeConstructorParameter.kt.after
@@ -5,7 +5,7 @@ open class Base() {
     val y = Base();
 
     fun f() {
-        val base = Base();
+        val base = Base(1, 2);
     }
 }
 
diff --git a/idea/testData/quickfix/changeSignature/removeFunctionFirstParameter.kt.after b/idea/testData/quickfix/changeSignature/removeFunctionFirstParameter.kt.after
index b59b76f88e3..cf636f4f4ec 100644
--- a/idea/testData/quickfix/changeSignature/removeFunctionFirstParameter.kt.after
+++ b/idea/testData/quickfix/changeSignature/removeFunctionFirstParameter.kt.after
@@ -3,7 +3,7 @@
 
 fun foo(y: Int) {
     foo();
-    foo();
+    foo(1);
     foo(2);
-    foo(3);
+    foo(2, 3, sdsd);
 }
\ No newline at end of file
diff --git a/idea/testData/quickfix/changeSignature/removeFunctionSecondParameter1.kt.after b/idea/testData/quickfix/changeSignature/removeFunctionSecondParameter1.kt.after
index baa5fc9cdab..85ceb301e66 100644
--- a/idea/testData/quickfix/changeSignature/removeFunctionSecondParameter1.kt.after
+++ b/idea/testData/quickfix/changeSignature/removeFunctionSecondParameter1.kt.after
@@ -5,5 +5,5 @@ fun foo(x: Int) {
     foo();
     foo(1);
     foo(1);
-    foo(2);
+    foo(2, 3, sdsd);
 }
\ No newline at end of file
diff --git a/idea/testData/quickfix/changeSignature/removeFunctionSecondParameter2.kt.after b/idea/testData/quickfix/changeSignature/removeFunctionSecondParameter2.kt.after
index 75434347a0f..85ceb301e66 100644
--- a/idea/testData/quickfix/changeSignature/removeFunctionSecondParameter2.kt.after
+++ b/idea/testData/quickfix/changeSignature/removeFunctionSecondParameter2.kt.after
@@ -3,7 +3,7 @@
 
 fun foo(x: Int) {
     foo();
-    foo(1<caret>);
     foo(1);
-    foo(2);
+    foo(1);
+    foo(2, 3, sdsd);
 }
\ No newline at end of file
diff --git a/idea/testData/quickfix/changeSignature/removeJavaMethodParameter.after.Dependency.java b/idea/testData/quickfix/changeSignature/removeJavaMethodParameter.after.Dependency.java
new file mode 100644
index 00000000000..702da7216d1
--- /dev/null
+++ b/idea/testData/quickfix/changeSignature/removeJavaMethodParameter.after.Dependency.java
@@ -0,0 +1,14 @@
+class Foo {
+    static void foo(int n) {
+
+    }
+}
+
+class Test {
+    static void test() {
+        Foo.foo();
+        Foo.foo(1);
+        Foo.foo(1);
+        Foo.foo(3);
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/quickfix/changeSignature/removeJavaMethodParameter.after.kt b/idea/testData/quickfix/changeSignature/removeJavaMethodParameter.after.kt
new file mode 100644
index 00000000000..4c543309c6e
--- /dev/null
+++ b/idea/testData/quickfix/changeSignature/removeJavaMethodParameter.after.kt
@@ -0,0 +1,8 @@
+// "Remove parameter 'm'" "true"
+// DISABLE-ERRORS
+fun test() {
+    Foo.foo()
+    Foo.foo(1<caret>)
+    Foo.foo(1)
+    Foo.foo(3)
+}
\ No newline at end of file
diff --git a/idea/testData/quickfix/changeSignature/removeJavaMethodParameter.before.Dependency.java b/idea/testData/quickfix/changeSignature/removeJavaMethodParameter.before.Dependency.java
new file mode 100644
index 00000000000..7ffe6cba400
--- /dev/null
+++ b/idea/testData/quickfix/changeSignature/removeJavaMethodParameter.before.Dependency.java
@@ -0,0 +1,14 @@
+class Foo {
+    static void foo(int n, int m) {
+
+    }
+}
+
+class Test {
+    static void test() {
+        Foo.foo();
+        Foo.foo(1);
+        Foo.foo(1, 2);
+        Foo.foo(3, 4);
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/quickfix/changeSignature/removeJavaMethodParameter.before.Main.kt b/idea/testData/quickfix/changeSignature/removeJavaMethodParameter.before.Main.kt
new file mode 100644
index 00000000000..dccdb733e27
--- /dev/null
+++ b/idea/testData/quickfix/changeSignature/removeJavaMethodParameter.before.Main.kt
@@ -0,0 +1,8 @@
+// "Remove parameter 'm'" "true"
+// DISABLE-ERRORS
+fun test() {
+    Foo.foo()
+    Foo.foo(1<caret>)
+    Foo.foo(1, 2)
+    Foo.foo(3, 4)
+}
\ No newline at end of file
diff --git a/idea/testData/quickfix/changeSignature/removeNamedParameter.kt.after b/idea/testData/quickfix/changeSignature/removeNamedParameter.kt.after
index a57cce2079b..52081e7d94a 100644
--- a/idea/testData/quickfix/changeSignature/removeNamedParameter.kt.after
+++ b/idea/testData/quickfix/changeSignature/removeNamedParameter.kt.after
@@ -5,5 +5,5 @@ fun foo(y: Int) {
     foo();
     foo(y = 1<caret>);
     foo(2);
-    foo(3);
+    foo(2, 3, sdsd);
 }
\ No newline at end of file
diff --git a/idea/testData/quickfix/suppress/forStatement/annotatedExpr.kt b/idea/testData/quickfix/suppress/forStatement/annotatedExpr.kt
index 2f870eee7bb..7a193109653 100644
--- a/idea/testData/quickfix/suppress/forStatement/annotatedExpr.kt
+++ b/idea/testData/quickfix/suppress/forStatement/annotatedExpr.kt
@@ -4,4 +4,5 @@ fun foo() {
     @ann ""<caret>!!
 }
 
+target(AnnotationTarget.EXPRESSION)
 annotation class ann
\ No newline at end of file
diff --git a/idea/testData/quickfix/suppress/forStatement/annotatedExpr.kt.after b/idea/testData/quickfix/suppress/forStatement/annotatedExpr.kt.after
index 9c74cb6f380..25bc15164a8 100644
--- a/idea/testData/quickfix/suppress/forStatement/annotatedExpr.kt.after
+++ b/idea/testData/quickfix/suppress/forStatement/annotatedExpr.kt.after
@@ -5,4 +5,5 @@ fun foo() {
     @ann ""<caret>!!
 }
 
+target(AnnotationTarget.EXPRESSION)
 annotation class ann
\ No newline at end of file
diff --git a/idea/testData/refactoring/changeSignature/AddPropertyReceiverAfter.1.java b/idea/testData/refactoring/changeSignature/AddPropertyReceiverAfter.1.java
new file mode 100644
index 00000000000..9af0f122297
--- /dev/null
+++ b/idea/testData/refactoring/changeSignature/AddPropertyReceiverAfter.1.java
@@ -0,0 +1,28 @@
+import java.lang.Override;
+
+class J extends A {
+    private int p;
+
+    @Override
+    public int getP(String receiver) {
+        return p;
+    }
+
+    @Override
+    public void setP(String receiver, int value) {
+        p = value;
+    }
+}
+
+class Test {
+    static void test() {
+        new A().getP("");
+        new A().setP("", 1);
+
+        new B().getP("");
+        new B().setP("", 2);
+
+        new J().getP("");
+        new J().setP("", 3);
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/refactoring/changeSignature/AddPropertyReceiverAfter.kt b/idea/testData/refactoring/changeSignature/AddPropertyReceiverAfter.kt
new file mode 100644
index 00000000000..fa1d413afa5
--- /dev/null
+++ b/idea/testData/refactoring/changeSignature/AddPropertyReceiverAfter.kt
@@ -0,0 +1,26 @@
+public inline fun <T, R> with(receiver: T, f: T.() -> R): R = receiver.f()
+
+open class A {
+    open var <caret>String.p: Int = 1
+}
+
+class B: A() {
+    override var String.p: Int = 2
+}
+
+fun test() {
+    with(A()) {
+        val t = "".p
+        "".p = 1
+    }
+
+    with(B()) {
+        val t = "".p
+        "".p = 2
+    }
+
+    with(J()) {
+        val t = getP("")
+        setP("", 3)
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/refactoring/changeSignature/AddPropertyReceiverBefore.1.java b/idea/testData/refactoring/changeSignature/AddPropertyReceiverBefore.1.java
new file mode 100644
index 00000000000..8dd79bb216b
--- /dev/null
+++ b/idea/testData/refactoring/changeSignature/AddPropertyReceiverBefore.1.java
@@ -0,0 +1,28 @@
+import java.lang.Override;
+
+class J extends A {
+    private int p;
+
+    @Override
+    public int getP() {
+        return p;
+    }
+
+    @Override
+    public void setP(int value) {
+        p = value;
+    }
+}
+
+class Test {
+    static void test() {
+        new A().getP();
+        new A().setP(1);
+
+        new B().getP();
+        new B().setP(2);
+
+        new J().getP();
+        new J().setP(3);
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/refactoring/changeSignature/AddPropertyReceiverBefore.kt b/idea/testData/refactoring/changeSignature/AddPropertyReceiverBefore.kt
new file mode 100644
index 00000000000..9e209bcf45f
--- /dev/null
+++ b/idea/testData/refactoring/changeSignature/AddPropertyReceiverBefore.kt
@@ -0,0 +1,26 @@
+public inline fun <T, R> with(receiver: T, f: T.() -> R): R = receiver.f()
+
+open class A {
+    open var <caret>p: Int = 1
+}
+
+class B: A() {
+    override var p: Int = 2
+}
+
+fun test() {
+    with(A()) {
+        val t = p
+        p = 1
+    }
+
+    with(B()) {
+        val t = p
+        p = 2
+    }
+
+    with(J()) {
+        val t = getP()
+        setP(3)
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/refactoring/changeSignature/AddPropertyReceiverConflictBefore.kt b/idea/testData/refactoring/changeSignature/AddPropertyReceiverConflictBefore.kt
new file mode 100644
index 00000000000..acdeca86b89
--- /dev/null
+++ b/idea/testData/refactoring/changeSignature/AddPropertyReceiverConflictBefore.kt
@@ -0,0 +1,8 @@
+open class A {
+    open var <caret>p: Int = 1
+}
+
+fun test() {
+    val t1 = A().p
+    A().p = 1
+}
\ No newline at end of file
diff --git a/idea/testData/refactoring/changeSignature/AddPropertyReceiverConflictMessages.txt b/idea/testData/refactoring/changeSignature/AddPropertyReceiverConflictMessages.txt
new file mode 100644
index 00000000000..65ca46ee958
--- /dev/null
+++ b/idea/testData/refactoring/changeSignature/AddPropertyReceiverConflictMessages.txt
@@ -0,0 +1,2 @@
+Explicit receiver is already present in call element: A().p
+Explicit receiver is already present in call element: A().p
\ No newline at end of file
diff --git a/idea/testData/refactoring/changeSignature/AddTopLevelPropertyReceiverAfter.1.java b/idea/testData/refactoring/changeSignature/AddTopLevelPropertyReceiverAfter.1.java
new file mode 100644
index 00000000000..efc4ff583e9
--- /dev/null
+++ b/idea/testData/refactoring/changeSignature/AddTopLevelPropertyReceiverAfter.1.java
@@ -0,0 +1,8 @@
+import test.TestPackage;
+
+class Test {
+    static void test() {
+        TestPackage.getP(A());
+        TestPackage.setP(A(), 1);
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/refactoring/changeSignature/AddTopLevelPropertyReceiverAfter.kt b/idea/testData/refactoring/changeSignature/AddTopLevelPropertyReceiverAfter.kt
new file mode 100644
index 00000000000..5a3370a1688
--- /dev/null
+++ b/idea/testData/refactoring/changeSignature/AddTopLevelPropertyReceiverAfter.kt
@@ -0,0 +1,14 @@
+package test
+
+public inline fun <T, R> with(receiver: T, f: T.() -> R): R = receiver.f()
+
+class A
+
+open var <caret>A.p: Int
+    get() = 1
+    set(value: Int) {}
+
+fun test() {
+    val t = A().p
+    A().p = 1
+}
\ No newline at end of file
diff --git a/idea/testData/refactoring/changeSignature/AddTopLevelPropertyReceiverBefore.1.java b/idea/testData/refactoring/changeSignature/AddTopLevelPropertyReceiverBefore.1.java
new file mode 100644
index 00000000000..f34461bb3f2
--- /dev/null
+++ b/idea/testData/refactoring/changeSignature/AddTopLevelPropertyReceiverBefore.1.java
@@ -0,0 +1,8 @@
+import test.TestPackage;
+
+class Test {
+    static void test() {
+        TestPackage.getP();
+        TestPackage.setP(1);
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/refactoring/changeSignature/AddTopLevelPropertyReceiverBefore.kt b/idea/testData/refactoring/changeSignature/AddTopLevelPropertyReceiverBefore.kt
new file mode 100644
index 00000000000..f6f59b884c8
--- /dev/null
+++ b/idea/testData/refactoring/changeSignature/AddTopLevelPropertyReceiverBefore.kt
@@ -0,0 +1,14 @@
+package test
+
+public inline fun <T, R> with(receiver: T, f: T.() -> R): R = receiver.f()
+
+class A
+
+open var <caret>p: Int
+    get() = 1
+    set(value: Int) {}
+
+fun test() {
+    val t = p
+    p = 1
+}
\ No newline at end of file
diff --git a/idea/testData/refactoring/changeSignature/ChangeClassParameterAfter.1.java b/idea/testData/refactoring/changeSignature/ChangeClassParameterAfter.1.java
new file mode 100644
index 00000000000..cc7c2eee483
--- /dev/null
+++ b/idea/testData/refactoring/changeSignature/ChangeClassParameterAfter.1.java
@@ -0,0 +1,38 @@
+import org.jetbrains.annotations.NotNull;
+
+import java.lang.Override;
+
+class J extends A {
+    private int p;
+
+    public J() {
+        super(0);
+    }
+
+    @NotNull
+    @Override
+    public String getS() {
+        return p;
+    }
+
+    @Override
+    public void setS(@NotNull String value) {
+        p = value;
+    }
+}
+
+class Test {
+    static void test() {
+        new A(0).getS();
+        new A(0).setS(1);
+
+        new B(0).getS();
+        new B(0).setS(2);
+
+        new C().getS();
+        new C().setS(3);
+
+        new J().getS();
+        new J().setS(4);
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/refactoring/changeSignature/ChangeClassParameterAfter.kt b/idea/testData/refactoring/changeSignature/ChangeClassParameterAfter.kt
new file mode 100644
index 00000000000..4a3e1ee1c61
--- /dev/null
+++ b/idea/testData/refactoring/changeSignature/ChangeClassParameterAfter.kt
@@ -0,0 +1,21 @@
+open class A(open var <caret>s: String)
+
+class B(override var s: String): A(s)
+
+class C: A(0) {
+    override var s: String = 1
+}
+
+fun test() {
+    val t1 = A(0).s
+    A(0).s = 1
+
+    val t2 = B(0).s
+    B(0).s = 2
+
+    val t3 = C().s
+    C().s = 3
+
+    val t4 = J().getS()
+    J().setS(4)
+}
\ No newline at end of file
diff --git a/idea/testData/refactoring/changeSignature/ChangeClassParameterBefore.1.java b/idea/testData/refactoring/changeSignature/ChangeClassParameterBefore.1.java
new file mode 100644
index 00000000000..8b02953c102
--- /dev/null
+++ b/idea/testData/refactoring/changeSignature/ChangeClassParameterBefore.1.java
@@ -0,0 +1,35 @@
+import java.lang.Override;
+
+class J extends A {
+    private int p;
+
+    public J() {
+        super(0);
+    }
+
+    @Override
+    public int getP() {
+        return p;
+    }
+
+    @Override
+    public void setP(int value) {
+        p = value;
+    }
+}
+
+class Test {
+    static void test() {
+        new A(0).getP();
+        new A(0).setP(1);
+
+        new B(0).getP();
+        new B(0).setP(2);
+
+        new C().getP();
+        new C().setP(3);
+
+        new J().getP();
+        new J().setP(4);
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/refactoring/changeSignature/ChangeClassParameterBefore.kt b/idea/testData/refactoring/changeSignature/ChangeClassParameterBefore.kt
new file mode 100644
index 00000000000..4d900d38252
--- /dev/null
+++ b/idea/testData/refactoring/changeSignature/ChangeClassParameterBefore.kt
@@ -0,0 +1,21 @@
+open class A(open var <caret>p: Int)
+
+class B(override var p: Int): A(p)
+
+class C: A(0) {
+    override var p: Int = 1
+}
+
+fun test() {
+    val t1 = A(0).p
+    A(0).p = 1
+
+    val t2 = B(0).p
+    B(0).p = 2
+
+    val t3 = C().p
+    C().p = 3
+
+    val t4 = J().getP()
+    J().setP(4)
+}
\ No newline at end of file
diff --git a/idea/testData/refactoring/changeSignature/ChangePropertyAfter.1.java b/idea/testData/refactoring/changeSignature/ChangePropertyAfter.1.java
new file mode 100644
index 00000000000..a6ea52fd86f
--- /dev/null
+++ b/idea/testData/refactoring/changeSignature/ChangePropertyAfter.1.java
@@ -0,0 +1,31 @@
+import org.jetbrains.annotations.NotNull;
+
+import java.lang.Override;
+
+class J extends A {
+    private int p;
+
+    @NotNull
+    @Override
+    public String getS() {
+        return p;
+    }
+
+    @Override
+    public void setS(@NotNull String value) {
+        p = value;
+    }
+}
+
+class Test {
+    static void test() {
+        new A().getS();
+        new A().setS(1);
+
+        new B().getS();
+        new B().setS(2);
+
+        new J().getS();
+        new J().setS(3);
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/refactoring/changeSignature/ChangePropertyAfter.kt b/idea/testData/refactoring/changeSignature/ChangePropertyAfter.kt
new file mode 100644
index 00000000000..df9f9e173de
--- /dev/null
+++ b/idea/testData/refactoring/changeSignature/ChangePropertyAfter.kt
@@ -0,0 +1,18 @@
+open class A {
+    open var <caret>s: String = 1
+}
+
+class B: A() {
+    override var s: String = 2
+}
+
+fun test() {
+    val t1 = A().s
+    A().s = 1
+
+    val t2 = B().s
+    B().s = 2
+
+    val t3 = J().getS()
+    J().setS(3)
+}
\ No newline at end of file
diff --git a/idea/testData/refactoring/changeSignature/ChangePropertyBefore.1.java b/idea/testData/refactoring/changeSignature/ChangePropertyBefore.1.java
new file mode 100644
index 00000000000..8dd79bb216b
--- /dev/null
+++ b/idea/testData/refactoring/changeSignature/ChangePropertyBefore.1.java
@@ -0,0 +1,28 @@
+import java.lang.Override;
+
+class J extends A {
+    private int p;
+
+    @Override
+    public int getP() {
+        return p;
+    }
+
+    @Override
+    public void setP(int value) {
+        p = value;
+    }
+}
+
+class Test {
+    static void test() {
+        new A().getP();
+        new A().setP(1);
+
+        new B().getP();
+        new B().setP(2);
+
+        new J().getP();
+        new J().setP(3);
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/refactoring/changeSignature/ChangePropertyBefore.kt b/idea/testData/refactoring/changeSignature/ChangePropertyBefore.kt
new file mode 100644
index 00000000000..3ff85c27509
--- /dev/null
+++ b/idea/testData/refactoring/changeSignature/ChangePropertyBefore.kt
@@ -0,0 +1,18 @@
+open class A {
+    open var <caret>p: Int = 1
+}
+
+class B: A() {
+    override var p: Int = 2
+}
+
+fun test() {
+    val t1 = A().p
+    A().p = 1
+
+    val t2 = B().p
+    B().p = 2
+
+    val t3 = J().getP()
+    J().setP(3)
+}
\ No newline at end of file
diff --git a/idea/testData/refactoring/changeSignature/ChangePropertyReceiverAfter.1.java b/idea/testData/refactoring/changeSignature/ChangePropertyReceiverAfter.1.java
new file mode 100644
index 00000000000..6953ccbb4c9
--- /dev/null
+++ b/idea/testData/refactoring/changeSignature/ChangePropertyReceiverAfter.1.java
@@ -0,0 +1,28 @@
+import java.lang.Override;
+
+class J extends A {
+    private int p;
+
+    @Override
+    public int getP(int receiver) {
+        return p;
+    }
+
+    @Override
+    public void setP(int receiver, int value) {
+        p = value;
+    }
+}
+
+class Test {
+    static void test() {
+        new A().getP("");
+        new A().setP("", 1);
+
+        new B().getP("");
+        new B().setP("", 2);
+
+        new J().getP("");
+        new J().setP("", 3);
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/refactoring/changeSignature/ChangePropertyReceiverAfter.kt b/idea/testData/refactoring/changeSignature/ChangePropertyReceiverAfter.kt
new file mode 100644
index 00000000000..430766d4d34
--- /dev/null
+++ b/idea/testData/refactoring/changeSignature/ChangePropertyReceiverAfter.kt
@@ -0,0 +1,26 @@
+public inline fun <T, R> with(receiver: T, f: T.() -> R): R = receiver.f()
+
+open class A {
+    open var Int.<caret>p: Int = 1
+}
+
+class B: A() {
+    override var Int.p: Int = 2
+}
+
+fun test() {
+    with(A()) {
+        val t = "".p
+        "".p = 1
+    }
+
+    with(B()) {
+        val t = "".p
+        "".p = 2
+    }
+
+    with(J()) {
+        val t = getP("")
+        setP("", 3)
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/refactoring/changeSignature/ChangePropertyReceiverBefore.1.java b/idea/testData/refactoring/changeSignature/ChangePropertyReceiverBefore.1.java
new file mode 100644
index 00000000000..9af0f122297
--- /dev/null
+++ b/idea/testData/refactoring/changeSignature/ChangePropertyReceiverBefore.1.java
@@ -0,0 +1,28 @@
+import java.lang.Override;
+
+class J extends A {
+    private int p;
+
+    @Override
+    public int getP(String receiver) {
+        return p;
+    }
+
+    @Override
+    public void setP(String receiver, int value) {
+        p = value;
+    }
+}
+
+class Test {
+    static void test() {
+        new A().getP("");
+        new A().setP("", 1);
+
+        new B().getP("");
+        new B().setP("", 2);
+
+        new J().getP("");
+        new J().setP("", 3);
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/refactoring/changeSignature/ChangePropertyReceiverBefore.kt b/idea/testData/refactoring/changeSignature/ChangePropertyReceiverBefore.kt
new file mode 100644
index 00000000000..8871d02caf6
--- /dev/null
+++ b/idea/testData/refactoring/changeSignature/ChangePropertyReceiverBefore.kt
@@ -0,0 +1,26 @@
+public inline fun <T, R> with(receiver: T, f: T.() -> R): R = receiver.f()
+
+open class A {
+    open var String.<caret>p: Int = 1
+}
+
+class B: A() {
+    override var String.p: Int = 2
+}
+
+fun test() {
+    with(A()) {
+        val t = "".p
+        "".p = 1
+    }
+
+    with(B()) {
+        val t = "".p
+        "".p = 2
+    }
+
+    with(J()) {
+        val t = getP("")
+        setP("", 3)
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/refactoring/changeSignature/ChangeTopLevelPropertyReceiverAfter.1.java b/idea/testData/refactoring/changeSignature/ChangeTopLevelPropertyReceiverAfter.1.java
new file mode 100644
index 00000000000..cfe96b406b8
--- /dev/null
+++ b/idea/testData/refactoring/changeSignature/ChangeTopLevelPropertyReceiverAfter.1.java
@@ -0,0 +1,8 @@
+import test.TestPackage;
+
+class Test {
+    static void test() {
+        TestPackage.getP(new A());
+        TestPackage.setP(new A(), 1);
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/refactoring/changeSignature/ChangeTopLevelPropertyReceiverAfter.kt b/idea/testData/refactoring/changeSignature/ChangeTopLevelPropertyReceiverAfter.kt
new file mode 100644
index 00000000000..05320988e3e
--- /dev/null
+++ b/idea/testData/refactoring/changeSignature/ChangeTopLevelPropertyReceiverAfter.kt
@@ -0,0 +1,19 @@
+package test
+
+public inline fun <T, R> with(receiver: T, f: T.() -> R): R = receiver.f()
+
+class A
+
+open var String.<caret>p: Int
+    get() = 1
+    set(value: Int) {}
+
+fun test() {
+    with(A()) {
+        val t = p
+        p = 1
+    }
+
+    val t1 = A().p
+    A().p = 1
+}
\ No newline at end of file
diff --git a/idea/testData/refactoring/changeSignature/ChangeTopLevelPropertyReceiverBefore.1.java b/idea/testData/refactoring/changeSignature/ChangeTopLevelPropertyReceiverBefore.1.java
new file mode 100644
index 00000000000..cfe96b406b8
--- /dev/null
+++ b/idea/testData/refactoring/changeSignature/ChangeTopLevelPropertyReceiverBefore.1.java
@@ -0,0 +1,8 @@
+import test.TestPackage;
+
+class Test {
+    static void test() {
+        TestPackage.getP(new A());
+        TestPackage.setP(new A(), 1);
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/refactoring/changeSignature/ChangeTopLevelPropertyReceiverBefore.kt b/idea/testData/refactoring/changeSignature/ChangeTopLevelPropertyReceiverBefore.kt
new file mode 100644
index 00000000000..b4e977e4dae
--- /dev/null
+++ b/idea/testData/refactoring/changeSignature/ChangeTopLevelPropertyReceiverBefore.kt
@@ -0,0 +1,19 @@
+package test
+
+public inline fun <T, R> with(receiver: T, f: T.() -> R): R = receiver.f()
+
+class A
+
+open var A.<caret>p: Int
+    get() = 1
+    set(value: Int) {}
+
+fun test() {
+    with(A()) {
+        val t = p
+        p = 1
+    }
+
+    val t1 = A().p
+    A().p = 1
+}
\ No newline at end of file
diff --git a/idea/testData/refactoring/changeSignature/ConstructorSwapArgumentsBefore.kt b/idea/testData/refactoring/changeSignature/ConstructorSwapArgumentsBefore.kt
index e66856e92e8..b66d50dc46a 100644
--- a/idea/testData/refactoring/changeSignature/ConstructorSwapArgumentsBefore.kt
+++ b/idea/testData/refactoring/changeSignature/ConstructorSwapArgumentsBefore.kt
@@ -1,4 +1,4 @@
-open class C1 protected (<caret>val x1: Int = 1, var x2: Float, x3: ((Int) -> Int)?) {
+open class C1 protected <caret>(val x1: Int = 1, var x2: Float, x3: ((Int) -> Int)?) {
     fun bar() {
         val y1 = x1;
         val y2 = x2;
diff --git a/idea/testData/refactoring/changeSignature/JavaConstructorParameterPropagationAfter.1.kt b/idea/testData/refactoring/changeSignature/JavaConstructorParameterPropagationAfter.1.kt
new file mode 100644
index 00000000000..281d5538d87
--- /dev/null
+++ b/idea/testData/refactoring/changeSignature/JavaConstructorParameterPropagationAfter.1.kt
@@ -0,0 +1,18 @@
+open class C(n: Int) : A(n) {
+
+}
+
+open class D: A {
+    constructor(n: Int): super(n)
+    constructor(b: Boolean, n: Int) : super(n)
+}
+
+fun test(n: Int) {
+    A(n)
+    A(false, n)
+    B(n)
+    B(false, n)
+    C(n)
+    D(n)
+    D(false, n)
+}
\ No newline at end of file
diff --git a/idea/testData/refactoring/changeSignature/JavaConstructorParameterPropagationAfter.java b/idea/testData/refactoring/changeSignature/JavaConstructorParameterPropagationAfter.java
new file mode 100644
index 00000000000..42e2d9eab87
--- /dev/null
+++ b/idea/testData/refactoring/changeSignature/JavaConstructorParameterPropagationAfter.java
@@ -0,0 +1,32 @@
+class A {
+    public <caret>A(int n) {
+
+    }
+
+    public A(boolean b, int n) {
+        this(n);
+    }
+}
+
+class B extends A {
+    public B(int n) {
+
+        super(n);
+    }
+
+    public B(boolean b, int n) {
+        super(n);
+    }
+}
+
+class Test {
+    void test(int n) {
+        new A(n);
+        new A(true, n);
+        new B(n);
+        new B(true, n);
+        new C(n);
+        new D(n);
+        new D(true, n);
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/refactoring/changeSignature/JavaConstructorParameterPropagationBefore.1.kt b/idea/testData/refactoring/changeSignature/JavaConstructorParameterPropagationBefore.1.kt
new file mode 100644
index 00000000000..e19235cd9de
--- /dev/null
+++ b/idea/testData/refactoring/changeSignature/JavaConstructorParameterPropagationBefore.1.kt
@@ -0,0 +1,18 @@
+open class C: A() {
+
+}
+
+open class D: A {
+    constructor(): super()
+    constructor(b: Boolean)
+}
+
+fun test() {
+    A()
+    A(false)
+    B()
+    B(false)
+    C()
+    D()
+    D(false)
+}
\ No newline at end of file
diff --git a/idea/testData/refactoring/changeSignature/JavaConstructorParameterPropagationBefore.java b/idea/testData/refactoring/changeSignature/JavaConstructorParameterPropagationBefore.java
new file mode 100644
index 00000000000..68d9991540a
--- /dev/null
+++ b/idea/testData/refactoring/changeSignature/JavaConstructorParameterPropagationBefore.java
@@ -0,0 +1,31 @@
+class A {
+    public <caret>A() {
+
+    }
+
+    public A(boolean b) {
+        this();
+    }
+}
+
+class B extends A {
+    public B() {
+
+    }
+
+    public B(boolean b) {
+        super();
+    }
+}
+
+class Test {
+    void test() {
+        new A();
+        new A(true);
+        new B();
+        new B(true);
+        new C();
+        new D();
+        new D(true);
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/refactoring/changeSignature/JavaMethodOverridesChangeParamAfter.1.kt b/idea/testData/refactoring/changeSignature/JavaMethodOverridesChangeParamAfter.1.kt
new file mode 100644
index 00000000000..260f9a89d4d
--- /dev/null
+++ b/idea/testData/refactoring/changeSignature/JavaMethodOverridesChangeParamAfter.1.kt
@@ -0,0 +1,25 @@
+open class X: A() {
+    fun foo(x: Int): String? {
+        return super.foo(x) + 1
+    }
+}
+
+open class Y: B() {
+    fun foo(x: Int): String? {
+        return x.length() * 2
+    }
+}
+
+open class Z: X() {
+    fun foo(x: Int): String? {
+        return x.length()
+    }
+}
+
+fun test() {
+    A().foo("")
+    B().foo("")
+    X().foo("")
+    Y().foo("")
+    Z().foo("")
+}
\ No newline at end of file
diff --git a/idea/testData/refactoring/changeSignature/JavaMethodOverridesChangeParamAfter.java b/idea/testData/refactoring/changeSignature/JavaMethodOverridesChangeParamAfter.java
new file mode 100644
index 00000000000..0e8c7879e76
--- /dev/null
+++ b/idea/testData/refactoring/changeSignature/JavaMethodOverridesChangeParamAfter.java
@@ -0,0 +1,25 @@
+import java.lang.Override;
+import java.lang.String;
+
+class A {
+    String <caret>foo(int x) {
+        return x.length() * 2;
+    }
+}
+
+class B extends A {
+    @Override
+    String foo(int x) {
+        return super.foo(x + "_");
+    }
+}
+
+class Test {
+    void test() {
+        new A().foo("");
+        new B().foo("");
+        new X().foo("");
+        new Y().foo("");
+        new Z().foo("");
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/refactoring/changeSignature/JavaMethodOverridesBefore.1.kt b/idea/testData/refactoring/changeSignature/JavaMethodOverridesChangeParamBefore.1.kt
similarity index 75%
rename from idea/testData/refactoring/changeSignature/JavaMethodOverridesBefore.1.kt
rename to idea/testData/refactoring/changeSignature/JavaMethodOverridesChangeParamBefore.1.kt
index ef92a4ec76d..5d5c2bde50c 100644
--- a/idea/testData/refactoring/changeSignature/JavaMethodOverridesBefore.1.kt
+++ b/idea/testData/refactoring/changeSignature/JavaMethodOverridesChangeParamBefore.1.kt
@@ -1,18 +1,18 @@
 open class X: A() {
     fun foo(s: String): Int {
-        return super.foo(s)
+        return super.foo(s) + 1
     }
 }
 
 open class Y: B() {
     fun foo(s: String): Int {
-        return 0
+        return s.length() * 2
     }
 }
 
 open class Z: X() {
     fun foo(s: String): Int {
-        return 0
+        return s.length()
     }
 }
 
diff --git a/idea/testData/refactoring/changeSignature/JavaMethodOverridesBefore.java b/idea/testData/refactoring/changeSignature/JavaMethodOverridesChangeParamBefore.java
similarity index 83%
rename from idea/testData/refactoring/changeSignature/JavaMethodOverridesBefore.java
rename to idea/testData/refactoring/changeSignature/JavaMethodOverridesChangeParamBefore.java
index 49e00cf60e8..2de8c245f90 100644
--- a/idea/testData/refactoring/changeSignature/JavaMethodOverridesBefore.java
+++ b/idea/testData/refactoring/changeSignature/JavaMethodOverridesChangeParamBefore.java
@@ -3,14 +3,14 @@ import java.lang.String;
 
 class A {
     int <caret>foo(String s) {
-        return 0;
+        return s.length() * 2;
     }
 }
 
 class B extends A {
     @Override
     int foo(String s) {
-        return super.foo(s);
+        return super.foo(s + "_");
     }
 }
 
diff --git a/idea/testData/refactoring/changeSignature/JavaMethodOverridesOmitUnitTypeAfter.1.kt b/idea/testData/refactoring/changeSignature/JavaMethodOverridesOmitUnitTypeAfter.1.kt
new file mode 100644
index 00000000000..7745d18a451
--- /dev/null
+++ b/idea/testData/refactoring/changeSignature/JavaMethodOverridesOmitUnitTypeAfter.1.kt
@@ -0,0 +1,5 @@
+open class X: A() {
+    override fun foo() {
+
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/refactoring/changeSignature/JavaMethodOverridesOmitUnitTypeAfter.java b/idea/testData/refactoring/changeSignature/JavaMethodOverridesOmitUnitTypeAfter.java
new file mode 100644
index 00000000000..3545f8c9d1a
--- /dev/null
+++ b/idea/testData/refactoring/changeSignature/JavaMethodOverridesOmitUnitTypeAfter.java
@@ -0,0 +1,5 @@
+class A {
+    void <caret>foo() {
+
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/refactoring/changeSignature/JavaMethodOverridesOmitUnitTypeBefore.1.kt b/idea/testData/refactoring/changeSignature/JavaMethodOverridesOmitUnitTypeBefore.1.kt
new file mode 100644
index 00000000000..7745d18a451
--- /dev/null
+++ b/idea/testData/refactoring/changeSignature/JavaMethodOverridesOmitUnitTypeBefore.1.kt
@@ -0,0 +1,5 @@
+open class X: A() {
+    override fun foo() {
+
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/refactoring/changeSignature/JavaMethodOverridesOmitUnitTypeBefore.java b/idea/testData/refactoring/changeSignature/JavaMethodOverridesOmitUnitTypeBefore.java
new file mode 100644
index 00000000000..3545f8c9d1a
--- /dev/null
+++ b/idea/testData/refactoring/changeSignature/JavaMethodOverridesOmitUnitTypeBefore.java
@@ -0,0 +1,5 @@
+class A {
+    void <caret>foo() {
+
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/refactoring/changeSignature/JavaMethodOverridesAfter.1.kt b/idea/testData/refactoring/changeSignature/JavaMethodOverridesReplaceParamAfter.1.kt
similarity index 75%
rename from idea/testData/refactoring/changeSignature/JavaMethodOverridesAfter.1.kt
rename to idea/testData/refactoring/changeSignature/JavaMethodOverridesReplaceParamAfter.1.kt
index 47368b2fbaa..17a9939cfcc 100644
--- a/idea/testData/refactoring/changeSignature/JavaMethodOverridesAfter.1.kt
+++ b/idea/testData/refactoring/changeSignature/JavaMethodOverridesReplaceParamAfter.1.kt
@@ -1,18 +1,18 @@
 open class X: A() {
     fun foo(x: Int): String? {
-        return super.foo(1)
+        return super.foo(1) + 1
     }
 }
 
 open class Y: B() {
     fun foo(x: Int): String? {
-        return 0
+        return s.length() * 2
     }
 }
 
 open class Z: X() {
     fun foo(x: Int): String? {
-        return 0
+        return s.length()
     }
 }
 
diff --git a/idea/testData/refactoring/changeSignature/JavaMethodOverridesAfter.java b/idea/testData/refactoring/changeSignature/JavaMethodOverridesReplaceParamAfter.java
similarity index 91%
rename from idea/testData/refactoring/changeSignature/JavaMethodOverridesAfter.java
rename to idea/testData/refactoring/changeSignature/JavaMethodOverridesReplaceParamAfter.java
index 786a267d29c..41a8939a5fa 100644
--- a/idea/testData/refactoring/changeSignature/JavaMethodOverridesAfter.java
+++ b/idea/testData/refactoring/changeSignature/JavaMethodOverridesReplaceParamAfter.java
@@ -3,7 +3,7 @@ import java.lang.String;
 
 class A {
     String foo(int x) {
-        return 0;
+        return s.length() * 2;
     }
 }
 
diff --git a/idea/testData/refactoring/changeSignature/JavaMethodOverridesReplaceParamBefore.1.kt b/idea/testData/refactoring/changeSignature/JavaMethodOverridesReplaceParamBefore.1.kt
new file mode 100644
index 00000000000..5d5c2bde50c
--- /dev/null
+++ b/idea/testData/refactoring/changeSignature/JavaMethodOverridesReplaceParamBefore.1.kt
@@ -0,0 +1,25 @@
+open class X: A() {
+    fun foo(s: String): Int {
+        return super.foo(s) + 1
+    }
+}
+
+open class Y: B() {
+    fun foo(s: String): Int {
+        return s.length() * 2
+    }
+}
+
+open class Z: X() {
+    fun foo(s: String): Int {
+        return s.length()
+    }
+}
+
+fun test() {
+    A().foo("")
+    B().foo("")
+    X().foo("")
+    Y().foo("")
+    Z().foo("")
+}
\ No newline at end of file
diff --git a/idea/testData/refactoring/changeSignature/JavaMethodOverridesReplaceParamBefore.java b/idea/testData/refactoring/changeSignature/JavaMethodOverridesReplaceParamBefore.java
new file mode 100644
index 00000000000..2de8c245f90
--- /dev/null
+++ b/idea/testData/refactoring/changeSignature/JavaMethodOverridesReplaceParamBefore.java
@@ -0,0 +1,25 @@
+import java.lang.Override;
+import java.lang.String;
+
+class A {
+    int <caret>foo(String s) {
+        return s.length() * 2;
+    }
+}
+
+class B extends A {
+    @Override
+    int foo(String s) {
+        return super.foo(s + "_");
+    }
+}
+
+class Test {
+    void test() {
+        new A().foo("");
+        new B().foo("");
+        new X().foo("");
+        new Y().foo("");
+        new Z().foo("");
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/refactoring/changeSignature/JavaParameterPropagationAfter.1.kt b/idea/testData/refactoring/changeSignature/JavaParameterPropagationAfter.1.kt
new file mode 100644
index 00000000000..26d1d3cfb9a
--- /dev/null
+++ b/idea/testData/refactoring/changeSignature/JavaParameterPropagationAfter.1.kt
@@ -0,0 +1,28 @@
+open class C: A() {
+    override fun foo(n: Int, s: String) {
+
+    }
+
+    override fun bar(b: Boolean, n: Int, s: String) {
+        foo(n, s)
+    }
+
+    override fun baz() {
+        foo(1, "abc")
+        bar(false, 1, "abc")
+    }
+}
+
+fun test(n: Int, s: String) {
+    A().foo(n, s)
+    A().bar(true, n, s)
+    A().baz()
+
+    B().foo(n, s)
+    B().bar(true, n, s)
+    B().baz()
+
+    C().foo(n, s)
+    C().bar(true, n, s)
+    C().baz()
+}
\ No newline at end of file
diff --git a/idea/testData/refactoring/changeSignature/JavaParameterPropagationAfter.java b/idea/testData/refactoring/changeSignature/JavaParameterPropagationAfter.java
new file mode 100644
index 00000000000..e3b2880e5f1
--- /dev/null
+++ b/idea/testData/refactoring/changeSignature/JavaParameterPropagationAfter.java
@@ -0,0 +1,45 @@
+class A {
+    public void foo(int n, String s) {
+
+    }
+
+    public void bar(boolean b, int n, String s) {
+        foo(n, s);
+    }
+
+    public void baz() {
+        foo(1, "abc");
+        bar(false, 1, "abc");
+    }
+}
+
+class B extends A {
+    public void foo(int n, String s) {
+
+    }
+
+    public void bar(boolean b, int n, String s) {
+        foo(n, s);
+    }
+
+    public void baz() {
+        foo(1, "abc");
+        bar(false, 1, "abc");
+    }
+}
+
+class Test {
+    void test() {
+        new A().foo(1, "abc");
+        new A().bar(true, 1, "abc");
+        new A().baz();
+
+        new B().foo(1, "abc");
+        new B().bar(true, 1, "abc");
+        new B().baz();
+
+        new C().foo(1, "abc");
+        new C().bar(true, 1, "abc");
+        new C().baz();
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/refactoring/changeSignature/JavaParameterPropagationBefore.1.kt b/idea/testData/refactoring/changeSignature/JavaParameterPropagationBefore.1.kt
new file mode 100644
index 00000000000..736e32f45ac
--- /dev/null
+++ b/idea/testData/refactoring/changeSignature/JavaParameterPropagationBefore.1.kt
@@ -0,0 +1,28 @@
+open class C: A() {
+    override fun foo() {
+
+    }
+
+    override fun bar(b: Boolean) {
+        foo()
+    }
+
+    override fun baz() {
+        foo()
+        bar(false)
+    }
+}
+
+fun test() {
+    A().foo()
+    A().bar(true)
+    A().baz()
+
+    B().foo()
+    B().bar(true)
+    B().baz()
+
+    C().foo()
+    C().bar(true)
+    C().baz()
+}
\ No newline at end of file
diff --git a/idea/testData/refactoring/changeSignature/JavaParameterPropagationBefore.java b/idea/testData/refactoring/changeSignature/JavaParameterPropagationBefore.java
new file mode 100644
index 00000000000..a9567ca9520
--- /dev/null
+++ b/idea/testData/refactoring/changeSignature/JavaParameterPropagationBefore.java
@@ -0,0 +1,45 @@
+class A {
+    public void <caret>foo() {
+
+    }
+
+    public void bar(boolean b) {
+        foo();
+    }
+
+    public void baz() {
+        foo();
+        bar(false);
+    }
+}
+
+class B extends A {
+    public void foo() {
+
+    }
+
+    public void bar(boolean b) {
+        foo();
+    }
+
+    public void baz() {
+        foo();
+        bar(false);
+    }
+}
+
+class Test {
+    void test() {
+        new A().foo();
+        new A().bar(true);
+        new A().baz();
+
+        new B().foo();
+        new B().bar(true);
+        new B().baz();
+
+        new C().foo();
+        new C().bar(true);
+        new C().baz();
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/refactoring/changeSignature/ParameterPropagationAfter.1.java b/idea/testData/refactoring/changeSignature/ParameterPropagationAfter.1.java
new file mode 100644
index 00000000000..3784b1d3122
--- /dev/null
+++ b/idea/testData/refactoring/changeSignature/ParameterPropagationAfter.1.java
@@ -0,0 +1,35 @@
+import org.jetbrains.annotations.NotNull;
+
+class J extends A {
+    @Override
+    public void foo(int n, @NotNull String s) {
+
+    }
+
+    @Override
+    public void bar(boolean b, int n, String s) {
+        foo(1, "abc"); // Propagated parameters are not passed to calles in overriding methods
+    }
+
+    @Override
+    public void baz() {
+        foo(1, "abc");
+        bar(false, 1, "abc");
+    }
+}
+
+class Test {
+    void test() {
+        new A().foo(1, "abc");
+        new A().bar(true, 1, "abc");
+        new A().baz();
+
+        new B().foo(1, "abc");
+        new B().bar(true, 1, "abc");
+        new B().baz();
+
+        new J().foo(1, "abc");
+        new J().bar(true, 1, "abc");
+        new J().baz();
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/refactoring/changeSignature/ParameterPropagationAfter.kt b/idea/testData/refactoring/changeSignature/ParameterPropagationAfter.kt
new file mode 100644
index 00000000000..07e77360641
--- /dev/null
+++ b/idea/testData/refactoring/changeSignature/ParameterPropagationAfter.kt
@@ -0,0 +1,43 @@
+open class A {
+    open fun <caret>foo(n: Int, s: String) {
+
+    }
+
+    open fun bar(b: Boolean, n: Int, s: String) {
+        foo(n, s)
+    }
+
+    open fun baz() {
+        foo(1, "abc")
+        bar(false, 1, "abc")
+    }
+}
+
+class B : A() {
+    override fun foo(n: Int, s: String) {
+
+    }
+
+    override fun bar(b: Boolean, n: Int, s: String) {
+        foo(n, s)
+    }
+
+    override fun baz() {
+        foo(1, "abc")
+        bar(false, 1, "abc")
+    }
+}
+
+fun test(n: Int, s: String) {
+    A().foo(n, s)
+    A().bar(true, n, s)
+    A().baz()
+
+    B().foo(n, s)
+    B().bar(true, n, s)
+    B().baz()
+
+    J().foo(n, s)
+    J().bar(true, n, s)
+    J().baz()
+}
\ No newline at end of file
diff --git a/idea/testData/refactoring/changeSignature/ParameterPropagationBefore.1.java b/idea/testData/refactoring/changeSignature/ParameterPropagationBefore.1.java
new file mode 100644
index 00000000000..91fd31f2f9f
--- /dev/null
+++ b/idea/testData/refactoring/changeSignature/ParameterPropagationBefore.1.java
@@ -0,0 +1,33 @@
+class J extends A {
+    @Override
+    public void foo() {
+
+    }
+
+    @Override
+    public void bar(boolean b) {
+        foo(); // Propagated parameters are not passed to calles in overriding methods
+    }
+
+    @Override
+    public void baz() {
+        foo();
+        bar(false);
+    }
+}
+
+class Test {
+    void test() {
+        new A().foo();
+        new A().bar(true);
+        new A().baz();
+
+        new B().foo();
+        new B().bar(true);
+        new B().baz();
+
+        new J().foo();
+        new J().bar(true);
+        new J().baz();
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/refactoring/changeSignature/ParameterPropagationBefore.kt b/idea/testData/refactoring/changeSignature/ParameterPropagationBefore.kt
new file mode 100644
index 00000000000..d9128170eaa
--- /dev/null
+++ b/idea/testData/refactoring/changeSignature/ParameterPropagationBefore.kt
@@ -0,0 +1,43 @@
+open class A {
+    open fun <caret>foo() {
+
+    }
+
+    open fun bar(b: Boolean) {
+        foo()
+    }
+
+    open fun baz() {
+        foo()
+        bar(false)
+    }
+}
+
+class B : A() {
+    override fun foo() {
+
+    }
+
+    override fun bar(b: Boolean) {
+        foo()
+    }
+
+    override fun baz() {
+        foo()
+        bar(false)
+    }
+}
+
+fun test() {
+    A().foo()
+    A().bar(true)
+    A().baz()
+
+    B().foo()
+    B().bar(true)
+    B().baz()
+
+    J().foo()
+    J().bar(true)
+    J().baz()
+}
\ No newline at end of file
diff --git a/idea/testData/refactoring/changeSignature/PrimaryConstructorParameterPropagationAfter.1.java b/idea/testData/refactoring/changeSignature/PrimaryConstructorParameterPropagationAfter.1.java
new file mode 100644
index 00000000000..4a5357d8bb4
--- /dev/null
+++ b/idea/testData/refactoring/changeSignature/PrimaryConstructorParameterPropagationAfter.1.java
@@ -0,0 +1,22 @@
+class J extends A {
+    public J(int n) {
+
+        super(n);
+    }
+
+    public J(boolean b, int n) {
+        super(n);
+    }
+}
+
+class Test {
+    void test(int n) {
+        new A(n);
+        new A(true, n);
+        new B(n);
+        new B(true, n);
+        new C(true, n);
+        new J(n);
+        new J(true, n);
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/refactoring/changeSignature/PrimaryConstructorParameterPropagationAfter.kt b/idea/testData/refactoring/changeSignature/PrimaryConstructorParameterPropagationAfter.kt
new file mode 100644
index 00000000000..0963b2aa7c7
--- /dev/null
+++ b/idea/testData/refactoring/changeSignature/PrimaryConstructorParameterPropagationAfter.kt
@@ -0,0 +1,21 @@
+open class <caret>A(n: Int) {
+    constructor(b: Boolean, n: Int): this(n)
+}
+
+open class B: A {
+    constructor(n: Int) : super(n)
+
+    constructor(b: Boolean, n: Int): super(n)
+}
+
+open class C(b: Boolean, n: Int): A(n)
+
+fun test(n: Int) {
+    A(n)
+    A(false, n)
+    B(n)
+    B(false, n)
+    C(false, n)
+    J(n)
+    J(false, n)
+}
\ No newline at end of file
diff --git a/idea/testData/refactoring/changeSignature/PrimaryConstructorParameterPropagationBefore.1.java b/idea/testData/refactoring/changeSignature/PrimaryConstructorParameterPropagationBefore.1.java
new file mode 100644
index 00000000000..647bfef6bee
--- /dev/null
+++ b/idea/testData/refactoring/changeSignature/PrimaryConstructorParameterPropagationBefore.1.java
@@ -0,0 +1,21 @@
+class J extends A {
+    public J() {
+
+    }
+
+    public J(boolean b) {
+        super();
+    }
+}
+
+class Test {
+    void test() {
+        new A();
+        new A(true);
+        new B();
+        new B(true);
+        new C(true);
+        new J();
+        new J(true);
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/refactoring/changeSignature/PrimaryConstructorParameterPropagationBefore.kt b/idea/testData/refactoring/changeSignature/PrimaryConstructorParameterPropagationBefore.kt
new file mode 100644
index 00000000000..b7570bd838a
--- /dev/null
+++ b/idea/testData/refactoring/changeSignature/PrimaryConstructorParameterPropagationBefore.kt
@@ -0,0 +1,20 @@
+open class <caret>A() {
+    constructor(b: Boolean): this()
+}
+
+open class B: A {
+    constructor()
+    constructor(b: Boolean): super()
+}
+
+open class C(b: Boolean): A()
+
+fun test() {
+    A()
+    A(false)
+    B()
+    B(false)
+    C(false)
+    J()
+    J(false)
+}
\ No newline at end of file
diff --git a/idea/testData/refactoring/changeSignature/PropagateWithParameterDuplicationBefore.kt b/idea/testData/refactoring/changeSignature/PropagateWithParameterDuplicationBefore.kt
new file mode 100644
index 00000000000..b73e852988b
--- /dev/null
+++ b/idea/testData/refactoring/changeSignature/PropagateWithParameterDuplicationBefore.kt
@@ -0,0 +1,5 @@
+fun <caret>foo() = 1
+
+fun bar(n: Int): Int {
+    return foo() + n
+}
\ No newline at end of file
diff --git a/idea/testData/refactoring/changeSignature/PropagateWithParameterDuplicationMessages.txt b/idea/testData/refactoring/changeSignature/PropagateWithParameterDuplicationMessages.txt
new file mode 100644
index 00000000000..a262d240b77
--- /dev/null
+++ b/idea/testData/refactoring/changeSignature/PropagateWithParameterDuplicationMessages.txt
@@ -0,0 +1 @@
+There is already a parameter 'n' in fun bar(n: Int): Int. It will conflict with the new parameter.
\ No newline at end of file
diff --git a/idea/testData/refactoring/changeSignature/PropagateWithThisQualificationInClassMemberAfter.kt b/idea/testData/refactoring/changeSignature/PropagateWithThisQualificationInClassMemberAfter.kt
new file mode 100644
index 00000000000..383e6903700
--- /dev/null
+++ b/idea/testData/refactoring/changeSignature/PropagateWithThisQualificationInClassMemberAfter.kt
@@ -0,0 +1,7 @@
+fun <caret>foo(n: Int): Int = 1
+
+class A(val n: Int) {
+    fun bar(n: Int): Int {
+        return foo(n) + this.n
+    }
+}
diff --git a/idea/testData/refactoring/changeSignature/PropagateWithThisQualificationInClassMemberBefore.kt b/idea/testData/refactoring/changeSignature/PropagateWithThisQualificationInClassMemberBefore.kt
new file mode 100644
index 00000000000..6ed7e4cef1f
--- /dev/null
+++ b/idea/testData/refactoring/changeSignature/PropagateWithThisQualificationInClassMemberBefore.kt
@@ -0,0 +1,7 @@
+fun <caret>foo(): Int = 1
+
+class A(val n: Int) {
+    fun bar(): Int {
+        return foo() + n
+    }
+}
diff --git a/idea/testData/refactoring/changeSignature/PropagateWithThisQualificationInExtensionAfter.kt b/idea/testData/refactoring/changeSignature/PropagateWithThisQualificationInExtensionAfter.kt
new file mode 100644
index 00000000000..01c6a4d0bf3
--- /dev/null
+++ b/idea/testData/refactoring/changeSignature/PropagateWithThisQualificationInExtensionAfter.kt
@@ -0,0 +1,7 @@
+fun <caret>foo(n: Int): Int = 1
+
+class A(val n: Int)
+
+fun A.bar(n: Int): Int {
+    return foo(n) + this.n
+}
diff --git a/idea/testData/refactoring/changeSignature/PropagateWithThisQualificationInExtensionBefore.kt b/idea/testData/refactoring/changeSignature/PropagateWithThisQualificationInExtensionBefore.kt
new file mode 100644
index 00000000000..978ac747033
--- /dev/null
+++ b/idea/testData/refactoring/changeSignature/PropagateWithThisQualificationInExtensionBefore.kt
@@ -0,0 +1,7 @@
+fun <caret>foo(): Int = 1
+
+class A(val n: Int)
+
+fun A.bar(): Int {
+    return foo() + n
+}
diff --git a/idea/testData/refactoring/changeSignature/PropagateWithVariableDuplicationBefore.kt b/idea/testData/refactoring/changeSignature/PropagateWithVariableDuplicationBefore.kt
new file mode 100644
index 00000000000..ce9ddaabb08
--- /dev/null
+++ b/idea/testData/refactoring/changeSignature/PropagateWithVariableDuplicationBefore.kt
@@ -0,0 +1,7 @@
+fun <caret>foo() = 1
+
+val n = 1
+
+fun bar(): Int {
+    return foo() + n
+}
\ No newline at end of file
diff --git a/idea/testData/refactoring/changeSignature/PropagateWithVariableDuplicationMessages.txt b/idea/testData/refactoring/changeSignature/PropagateWithVariableDuplicationMessages.txt
new file mode 100644
index 00000000000..86c4632a539
--- /dev/null
+++ b/idea/testData/refactoring/changeSignature/PropagateWithVariableDuplicationMessages.txt
@@ -0,0 +1 @@
+There is already a variable 'n' in fun bar(): Int. It will conflict with the new parameter.
\ No newline at end of file
diff --git a/idea/testData/refactoring/changeSignature/RemovePropertyReceiverAfter.1.java b/idea/testData/refactoring/changeSignature/RemovePropertyReceiverAfter.1.java
new file mode 100644
index 00000000000..8dd79bb216b
--- /dev/null
+++ b/idea/testData/refactoring/changeSignature/RemovePropertyReceiverAfter.1.java
@@ -0,0 +1,28 @@
+import java.lang.Override;
+
+class J extends A {
+    private int p;
+
+    @Override
+    public int getP() {
+        return p;
+    }
+
+    @Override
+    public void setP(int value) {
+        p = value;
+    }
+}
+
+class Test {
+    static void test() {
+        new A().getP();
+        new A().setP(1);
+
+        new B().getP();
+        new B().setP(2);
+
+        new J().getP();
+        new J().setP(3);
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/refactoring/changeSignature/RemovePropertyReceiverAfter.kt b/idea/testData/refactoring/changeSignature/RemovePropertyReceiverAfter.kt
new file mode 100644
index 00000000000..9e209bcf45f
--- /dev/null
+++ b/idea/testData/refactoring/changeSignature/RemovePropertyReceiverAfter.kt
@@ -0,0 +1,26 @@
+public inline fun <T, R> with(receiver: T, f: T.() -> R): R = receiver.f()
+
+open class A {
+    open var <caret>p: Int = 1
+}
+
+class B: A() {
+    override var p: Int = 2
+}
+
+fun test() {
+    with(A()) {
+        val t = p
+        p = 1
+    }
+
+    with(B()) {
+        val t = p
+        p = 2
+    }
+
+    with(J()) {
+        val t = getP()
+        setP(3)
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/refactoring/changeSignature/RemovePropertyReceiverBefore.1.java b/idea/testData/refactoring/changeSignature/RemovePropertyReceiverBefore.1.java
new file mode 100644
index 00000000000..9af0f122297
--- /dev/null
+++ b/idea/testData/refactoring/changeSignature/RemovePropertyReceiverBefore.1.java
@@ -0,0 +1,28 @@
+import java.lang.Override;
+
+class J extends A {
+    private int p;
+
+    @Override
+    public int getP(String receiver) {
+        return p;
+    }
+
+    @Override
+    public void setP(String receiver, int value) {
+        p = value;
+    }
+}
+
+class Test {
+    static void test() {
+        new A().getP("");
+        new A().setP("", 1);
+
+        new B().getP("");
+        new B().setP("", 2);
+
+        new J().getP("");
+        new J().setP("", 3);
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/refactoring/changeSignature/RemovePropertyReceiverBefore.kt b/idea/testData/refactoring/changeSignature/RemovePropertyReceiverBefore.kt
new file mode 100644
index 00000000000..8871d02caf6
--- /dev/null
+++ b/idea/testData/refactoring/changeSignature/RemovePropertyReceiverBefore.kt
@@ -0,0 +1,26 @@
+public inline fun <T, R> with(receiver: T, f: T.() -> R): R = receiver.f()
+
+open class A {
+    open var String.<caret>p: Int = 1
+}
+
+class B: A() {
+    override var String.p: Int = 2
+}
+
+fun test() {
+    with(A()) {
+        val t = "".p
+        "".p = 1
+    }
+
+    with(B()) {
+        val t = "".p
+        "".p = 2
+    }
+
+    with(J()) {
+        val t = getP("")
+        setP("", 3)
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/refactoring/changeSignature/RemoveTopLevelPropertyReceiverAfter.1.java b/idea/testData/refactoring/changeSignature/RemoveTopLevelPropertyReceiverAfter.1.java
new file mode 100644
index 00000000000..f34461bb3f2
--- /dev/null
+++ b/idea/testData/refactoring/changeSignature/RemoveTopLevelPropertyReceiverAfter.1.java
@@ -0,0 +1,8 @@
+import test.TestPackage;
+
+class Test {
+    static void test() {
+        TestPackage.getP();
+        TestPackage.setP(1);
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/refactoring/changeSignature/RemoveTopLevelPropertyReceiverAfter.kt b/idea/testData/refactoring/changeSignature/RemoveTopLevelPropertyReceiverAfter.kt
new file mode 100644
index 00000000000..09ac893e96e
--- /dev/null
+++ b/idea/testData/refactoring/changeSignature/RemoveTopLevelPropertyReceiverAfter.kt
@@ -0,0 +1,19 @@
+package test
+
+public inline fun <T, R> with(receiver: T, f: T.() -> R): R = receiver.f()
+
+class A
+
+open var <caret>p: Int
+    get() = 1
+    set(value: Int) {}
+
+fun test() {
+    with(A()) {
+        val t = p
+        p = 1
+    }
+
+    val t1 = p
+    p = 1
+}
\ No newline at end of file
diff --git a/idea/testData/refactoring/changeSignature/RemoveTopLevelPropertyReceiverBefore.1.java b/idea/testData/refactoring/changeSignature/RemoveTopLevelPropertyReceiverBefore.1.java
new file mode 100644
index 00000000000..cfe96b406b8
--- /dev/null
+++ b/idea/testData/refactoring/changeSignature/RemoveTopLevelPropertyReceiverBefore.1.java
@@ -0,0 +1,8 @@
+import test.TestPackage;
+
+class Test {
+    static void test() {
+        TestPackage.getP(new A());
+        TestPackage.setP(new A(), 1);
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/refactoring/changeSignature/RemoveTopLevelPropertyReceiverBefore.kt b/idea/testData/refactoring/changeSignature/RemoveTopLevelPropertyReceiverBefore.kt
new file mode 100644
index 00000000000..b4e977e4dae
--- /dev/null
+++ b/idea/testData/refactoring/changeSignature/RemoveTopLevelPropertyReceiverBefore.kt
@@ -0,0 +1,19 @@
+package test
+
+public inline fun <T, R> with(receiver: T, f: T.() -> R): R = receiver.f()
+
+class A
+
+open var A.<caret>p: Int
+    get() = 1
+    set(value: Int) {}
+
+fun test() {
+    with(A()) {
+        val t = p
+        p = 1
+    }
+
+    val t1 = A().p
+    A().p = 1
+}
\ No newline at end of file
diff --git a/idea/testData/refactoring/changeSignature/SecondaryConstructorParameterPropagationAfter.1.java b/idea/testData/refactoring/changeSignature/SecondaryConstructorParameterPropagationAfter.1.java
new file mode 100644
index 00000000000..4a5357d8bb4
--- /dev/null
+++ b/idea/testData/refactoring/changeSignature/SecondaryConstructorParameterPropagationAfter.1.java
@@ -0,0 +1,22 @@
+class J extends A {
+    public J(int n) {
+
+        super(n);
+    }
+
+    public J(boolean b, int n) {
+        super(n);
+    }
+}
+
+class Test {
+    void test(int n) {
+        new A(n);
+        new A(true, n);
+        new B(n);
+        new B(true, n);
+        new C(true, n);
+        new J(n);
+        new J(true, n);
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/refactoring/changeSignature/SecondaryConstructorParameterPropagationAfter.kt b/idea/testData/refactoring/changeSignature/SecondaryConstructorParameterPropagationAfter.kt
new file mode 100644
index 00000000000..e3445e7b100
--- /dev/null
+++ b/idea/testData/refactoring/changeSignature/SecondaryConstructorParameterPropagationAfter.kt
@@ -0,0 +1,21 @@
+open class A {
+    <caret>constructor(n: Int)
+    constructor(b: Boolean, n: Int): this(n)
+}
+
+open class B: A {
+    constructor(n: Int) : super(n)
+
+    constructor(b: Boolean, n: Int): super(n)
+}
+
+open class C(b: Boolean, n: Int): A(n)
+
+fun test(n: Int) {
+    A(n)
+    A(false, n)
+    B(n)
+    B(false, n)
+    C(false, n)
+    J(n)
+}
\ No newline at end of file
diff --git a/idea/testData/refactoring/changeSignature/SecondaryConstructorParameterPropagationBefore.1.java b/idea/testData/refactoring/changeSignature/SecondaryConstructorParameterPropagationBefore.1.java
new file mode 100644
index 00000000000..647bfef6bee
--- /dev/null
+++ b/idea/testData/refactoring/changeSignature/SecondaryConstructorParameterPropagationBefore.1.java
@@ -0,0 +1,21 @@
+class J extends A {
+    public J() {
+
+    }
+
+    public J(boolean b) {
+        super();
+    }
+}
+
+class Test {
+    void test() {
+        new A();
+        new A(true);
+        new B();
+        new B(true);
+        new C(true);
+        new J();
+        new J(true);
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/refactoring/changeSignature/SecondaryConstructorParameterPropagationBefore.kt b/idea/testData/refactoring/changeSignature/SecondaryConstructorParameterPropagationBefore.kt
new file mode 100644
index 00000000000..3f7a8e485d1
--- /dev/null
+++ b/idea/testData/refactoring/changeSignature/SecondaryConstructorParameterPropagationBefore.kt
@@ -0,0 +1,20 @@
+open class A {
+    <caret>constructor()
+    constructor(b: Boolean): this()
+}
+
+open class B: A {
+    constructor()
+    constructor(b: Boolean): super()
+}
+
+open class C(b: Boolean): A()
+
+fun test() {
+    A()
+    A(false)
+    B()
+    B(false)
+    C(false)
+    J()
+}
\ No newline at end of file
diff --git a/idea/testData/refactoring/extractFunction/basic/callWithPlatformTypeReceiver.kt b/idea/testData/refactoring/extractFunction/basic/callWithPlatformTypeReceiver.kt
index 514c149d396..d57a7d91694 100644
--- a/idea/testData/refactoring/extractFunction/basic/callWithPlatformTypeReceiver.kt
+++ b/idea/testData/refactoring/extractFunction/basic/callWithPlatformTypeReceiver.kt
@@ -1,7 +1,7 @@
 // WITH_RUNTIME
 // SUGGESTED_RETURN_TYPES: kotlin.Boolean?, kotlin.Boolean
-// PARAM_DESCRIPTOR: value-parameter val it: kotlin.Map.Entry<(Boolean..Boolean?), (Boolean..Boolean?)> defined in test.<anonymous>
-// PARAM_TYPES: kotlin.Map.Entry<(Boolean..Boolean?), (Boolean..Boolean?)>
+// PARAM_DESCRIPTOR: value-parameter val it: kotlin.Map.Entry<(kotlin.Boolean..kotlin.Boolean?), (kotlin.Boolean..kotlin.Boolean?)> defined in test.<anonymous>
+// PARAM_TYPES: kotlin.Map.Entry<(kotlin.Boolean..kotlin.Boolean?), (kotlin.Boolean..kotlin.Boolean?)>
 fun test() {
     J.getMap().filter { <selection>it.getKey()</selection> }
 }
\ No newline at end of file
diff --git a/idea/testData/refactoring/extractFunction/basic/callWithPlatformTypeReceiver.kt.after b/idea/testData/refactoring/extractFunction/basic/callWithPlatformTypeReceiver.kt.after
index 4146cbab390..695749d0e0f 100644
--- a/idea/testData/refactoring/extractFunction/basic/callWithPlatformTypeReceiver.kt.after
+++ b/idea/testData/refactoring/extractFunction/basic/callWithPlatformTypeReceiver.kt.after
@@ -1,7 +1,7 @@
 // WITH_RUNTIME
 // SUGGESTED_RETURN_TYPES: kotlin.Boolean?, kotlin.Boolean
-// PARAM_DESCRIPTOR: value-parameter val it: kotlin.Map.Entry<(Boolean..Boolean?), (Boolean..Boolean?)> defined in test.<anonymous>
-// PARAM_TYPES: kotlin.Map.Entry<(Boolean..Boolean?), (Boolean..Boolean?)>
+// PARAM_DESCRIPTOR: value-parameter val it: kotlin.Map.Entry<(kotlin.Boolean..kotlin.Boolean?), (kotlin.Boolean..kotlin.Boolean?)> defined in test.<anonymous>
+// PARAM_TYPES: kotlin.Map.Entry<(kotlin.Boolean..kotlin.Boolean?), (kotlin.Boolean..kotlin.Boolean?)>
 fun test() {
     J.getMap().filter { b(it) }
 }
diff --git a/idea/testData/refactoring/extractFunction/controlFlow/returnTypeCandidates/javaAnnotatedNotNull.kt.after b/idea/testData/refactoring/extractFunction/controlFlow/returnTypeCandidates/javaAnnotatedNotNull.kt.after
index c9fd0689e12..8beb976a4dc 100644
--- a/idea/testData/refactoring/extractFunction/controlFlow/returnTypeCandidates/javaAnnotatedNotNull.kt.after
+++ b/idea/testData/refactoring/extractFunction/controlFlow/returnTypeCandidates/javaAnnotatedNotNull.kt.after
@@ -4,4 +4,4 @@ fun test() {
     val s = s()
 }
 
-private fun s(): String = J.notNull()
\ No newline at end of file
+private fun s() = J.notNull()
\ No newline at end of file
diff --git a/idea/testData/refactoring/extractFunction/controlFlow/returnTypeCandidates/javaAnnotatedNullable.kt.after b/idea/testData/refactoring/extractFunction/controlFlow/returnTypeCandidates/javaAnnotatedNullable.kt.after
index e7b5d46d31b..12f66019646 100644
--- a/idea/testData/refactoring/extractFunction/controlFlow/returnTypeCandidates/javaAnnotatedNullable.kt.after
+++ b/idea/testData/refactoring/extractFunction/controlFlow/returnTypeCandidates/javaAnnotatedNullable.kt.after
@@ -3,4 +3,4 @@ fun test() {
     val s = s()
 }
 
-private fun s(): String? = J.nullable()
\ No newline at end of file
+private fun s() = J.nullable()
\ No newline at end of file
diff --git a/idea/testData/refactoring/extractFunction/parameters/candidateTypes/flexibleTypesWithNull.kt b/idea/testData/refactoring/extractFunction/parameters/candidateTypes/flexibleTypesWithNull.kt
index ae641c2ad01..99546e95cfc 100644
--- a/idea/testData/refactoring/extractFunction/parameters/candidateTypes/flexibleTypesWithNull.kt
+++ b/idea/testData/refactoring/extractFunction/parameters/candidateTypes/flexibleTypesWithNull.kt
@@ -1,7 +1,7 @@
 // WITH_RUNTIME
 // SUGGESTED_NAMES: i, getN
-// PARAM_TYPES: String?, String, kotlin.CharSequence?, CharSequence
-// PARAM_DESCRIPTOR: val property: (String..String?) defined in test
+// PARAM_TYPES: kotlin.String?, kotlin.String, kotlin.CharSequence?, CharSequence
+// PARAM_DESCRIPTOR: val property: (kotlin.String..kotlin.String?) defined in test
 fun test() {
     val property = System.getProperty("some")
     val n = <selection>property?.length()</selection>
diff --git a/idea/testData/refactoring/extractFunction/parameters/candidateTypes/flexibleTypesWithNull.kt.after b/idea/testData/refactoring/extractFunction/parameters/candidateTypes/flexibleTypesWithNull.kt.after
index a687e4b9262..50f48bb630b 100644
--- a/idea/testData/refactoring/extractFunction/parameters/candidateTypes/flexibleTypesWithNull.kt.after
+++ b/idea/testData/refactoring/extractFunction/parameters/candidateTypes/flexibleTypesWithNull.kt.after
@@ -1,10 +1,10 @@
 // WITH_RUNTIME
 // SUGGESTED_NAMES: i, getN
-// PARAM_TYPES: String?, String, kotlin.CharSequence?, CharSequence
-// PARAM_DESCRIPTOR: val property: (String..String?) defined in test
+// PARAM_TYPES: kotlin.String?, kotlin.String, kotlin.CharSequence?, CharSequence
+// PARAM_DESCRIPTOR: val property: (kotlin.String..kotlin.String?) defined in test
 fun test() {
     val property = System.getProperty("some")
     val n = i(property)
 }
 
-private fun i(property: String?) = property?.length()
+private fun i(property: String?) = property?.length()
\ No newline at end of file
diff --git a/idea/testData/refactoring/extractFunction/parameters/candidateTypes/flexibleTypesWithoutNull.kt b/idea/testData/refactoring/extractFunction/parameters/candidateTypes/flexibleTypesWithoutNull.kt
index 6130d9bf142..e3da5db7cd2 100644
--- a/idea/testData/refactoring/extractFunction/parameters/candidateTypes/flexibleTypesWithoutNull.kt
+++ b/idea/testData/refactoring/extractFunction/parameters/candidateTypes/flexibleTypesWithoutNull.kt
@@ -1,7 +1,7 @@
 // WITH_RUNTIME
 // SUGGESTED_NAMES: i, getN
-// PARAM_TYPES: String, CharSequence
-// PARAM_DESCRIPTOR: val property: (String..String?) defined in test
+// PARAM_TYPES: kotlin.String, CharSequence
+// PARAM_DESCRIPTOR: val property: (kotlin.String..kotlin.String?) defined in test
 fun test() {
     val property = System.getProperty("some")
     val n = <selection>property.length()</selection>
diff --git a/idea/testData/refactoring/extractFunction/parameters/candidateTypes/flexibleTypesWithoutNull.kt.after b/idea/testData/refactoring/extractFunction/parameters/candidateTypes/flexibleTypesWithoutNull.kt.after
index 559b5d08cf7..21d2fede2f3 100644
--- a/idea/testData/refactoring/extractFunction/parameters/candidateTypes/flexibleTypesWithoutNull.kt.after
+++ b/idea/testData/refactoring/extractFunction/parameters/candidateTypes/flexibleTypesWithoutNull.kt.after
@@ -1,7 +1,7 @@
 // WITH_RUNTIME
 // SUGGESTED_NAMES: i, getN
-// PARAM_TYPES: String, CharSequence
-// PARAM_DESCRIPTOR: val property: (String..String?) defined in test
+// PARAM_TYPES: kotlin.String, CharSequence
+// PARAM_DESCRIPTOR: val property: (kotlin.String..kotlin.String?) defined in test
 fun test() {
     val property = System.getProperty("some")
     val n = i(property)
diff --git a/idea/testData/refactoring/extractFunction/typeParameters/typeParameterNotResolvableInTargetScope.kt.after b/idea/testData/refactoring/extractFunction/typeParameters/typeParameterNotResolvableInTargetScope.kt.after
index a357e3394ad..d4af32e7b7a 100644
--- a/idea/testData/refactoring/extractFunction/typeParameters/typeParameterNotResolvableInTargetScope.kt.after
+++ b/idea/testData/refactoring/extractFunction/typeParameters/typeParameterNotResolvableInTargetScope.kt.after
@@ -15,4 +15,4 @@ class Foo<T> {
     }
 }
 
-private fun <T> Foo<T>.t(l: String): T = map[l]
\ No newline at end of file
+private fun <T> Foo<T>.t(l: String) = map[l]
\ No newline at end of file
diff --git a/idea/testData/refactoring/extractFunction/typeParameters/typeParameterResolvableInTargetScope.kt.after b/idea/testData/refactoring/extractFunction/typeParameters/typeParameterResolvableInTargetScope.kt.after
index 31579c65aca..56b4d7bb3f2 100644
--- a/idea/testData/refactoring/extractFunction/typeParameters/typeParameterResolvableInTargetScope.kt.after
+++ b/idea/testData/refactoring/extractFunction/typeParameters/typeParameterResolvableInTargetScope.kt.after
@@ -11,5 +11,5 @@ class Foo<T> {
         return t(l)
     }
 
-    private fun t(l: String): T = map[l]
+    private fun t(l: String) = map[l]
 }
\ No newline at end of file
diff --git a/idea/testData/refactoring/introduceProperty/typeParameterNotResolvableInTargetScope.kt.after b/idea/testData/refactoring/introduceProperty/typeParameterNotResolvableInTargetScope.kt.after
index bd6e251b5e4..b9961b8e82a 100644
--- a/idea/testData/refactoring/introduceProperty/typeParameterNotResolvableInTargetScope.kt.after
+++ b/idea/testData/refactoring/introduceProperty/typeParameterNotResolvableInTargetScope.kt.after
@@ -3,7 +3,7 @@
 
 import java.util.*
 
-private val <T> Foo<T>.t: T
+private val <T> Foo<T>.t: T?
     get() = map[""]
 
 // SIBLING:
diff --git a/idea/testData/refactoring/rename/syntheticPropertyUsages1/after/Usages.kt b/idea/testData/refactoring/rename/syntheticPropertyUsages1/after/Usages.kt
new file mode 100644
index 00000000000..c9635f4e917
--- /dev/null
+++ b/idea/testData/refactoring/rename/syntheticPropertyUsages1/after/Usages.kt
@@ -0,0 +1,6 @@
+import testing.JavaClass
+
+fun usages(javaClass: JavaClass) {
+    javaClass.something = javaClass.somethingNew + 1
+    javaClass.somethingNew++
+}
\ No newline at end of file
diff --git a/idea/testData/refactoring/rename/syntheticPropertyUsages1/after/testing/JavaClass.java b/idea/testData/refactoring/rename/syntheticPropertyUsages1/after/testing/JavaClass.java
new file mode 100644
index 00000000000..daec9622c18
--- /dev/null
+++ b/idea/testData/refactoring/rename/syntheticPropertyUsages1/after/testing/JavaClass.java
@@ -0,0 +1,6 @@
+package testing;
+
+public class JavaClass {
+    public int getSomethingNew() { return 1; }
+    public void setSomething(int value) {}
+}
\ No newline at end of file
diff --git a/idea/testData/refactoring/rename/syntheticPropertyUsages1/before/Usages.kt b/idea/testData/refactoring/rename/syntheticPropertyUsages1/before/Usages.kt
new file mode 100644
index 00000000000..97a3bb2eda3
--- /dev/null
+++ b/idea/testData/refactoring/rename/syntheticPropertyUsages1/before/Usages.kt
@@ -0,0 +1,6 @@
+import testing.JavaClass
+
+fun usages(javaClass: JavaClass) {
+    javaClass.something = javaClass.something + 1
+    javaClass.something++
+}
\ No newline at end of file
diff --git a/idea/testData/refactoring/rename/syntheticPropertyUsages1/before/testing/JavaClass.java b/idea/testData/refactoring/rename/syntheticPropertyUsages1/before/testing/JavaClass.java
new file mode 100644
index 00000000000..87b737c9ce3
--- /dev/null
+++ b/idea/testData/refactoring/rename/syntheticPropertyUsages1/before/testing/JavaClass.java
@@ -0,0 +1,6 @@
+package testing;
+
+public class JavaClass {
+    public int getSomething() { return 1; }
+    public void setSomething(int value) {}
+}
\ No newline at end of file
diff --git a/idea/testData/refactoring/rename/syntheticPropertyUsages1/renameGetMethod.test b/idea/testData/refactoring/rename/syntheticPropertyUsages1/renameGetMethod.test
new file mode 100644
index 00000000000..bdf2e845685
--- /dev/null
+++ b/idea/testData/refactoring/rename/syntheticPropertyUsages1/renameGetMethod.test
@@ -0,0 +1,6 @@
+{
+  "type": "JAVA_METHOD",
+  "classId": "testing/JavaClass",
+  "methodSignature": "int getSomething()",
+  "newName": "getSomethingNew"
+}
\ No newline at end of file
diff --git a/idea/testData/refactoring/rename/syntheticPropertyUsages2/after/Usages.kt b/idea/testData/refactoring/rename/syntheticPropertyUsages2/after/Usages.kt
new file mode 100644
index 00000000000..d850719ed2e
--- /dev/null
+++ b/idea/testData/refactoring/rename/syntheticPropertyUsages2/after/Usages.kt
@@ -0,0 +1,6 @@
+import testing.JavaClass
+
+fun usages(javaClass: JavaClass) {
+    javaClass.somethingNew = javaClass.something + 1
+    javaClass.somethingNew++
+}
\ No newline at end of file
diff --git a/idea/testData/refactoring/rename/syntheticPropertyUsages2/after/testing/JavaClass.java b/idea/testData/refactoring/rename/syntheticPropertyUsages2/after/testing/JavaClass.java
new file mode 100644
index 00000000000..a592c8fe126
--- /dev/null
+++ b/idea/testData/refactoring/rename/syntheticPropertyUsages2/after/testing/JavaClass.java
@@ -0,0 +1,6 @@
+package testing;
+
+public class JavaClass {
+    public int getSomething() { return 1; }
+    public void setSomethingNew(int value) {}
+}
\ No newline at end of file
diff --git a/idea/testData/refactoring/rename/syntheticPropertyUsages2/before/Usages.kt b/idea/testData/refactoring/rename/syntheticPropertyUsages2/before/Usages.kt
new file mode 100644
index 00000000000..97a3bb2eda3
--- /dev/null
+++ b/idea/testData/refactoring/rename/syntheticPropertyUsages2/before/Usages.kt
@@ -0,0 +1,6 @@
+import testing.JavaClass
+
+fun usages(javaClass: JavaClass) {
+    javaClass.something = javaClass.something + 1
+    javaClass.something++
+}
\ No newline at end of file
diff --git a/idea/testData/refactoring/rename/syntheticPropertyUsages2/before/testing/JavaClass.java b/idea/testData/refactoring/rename/syntheticPropertyUsages2/before/testing/JavaClass.java
new file mode 100644
index 00000000000..87b737c9ce3
--- /dev/null
+++ b/idea/testData/refactoring/rename/syntheticPropertyUsages2/before/testing/JavaClass.java
@@ -0,0 +1,6 @@
+package testing;
+
+public class JavaClass {
+    public int getSomething() { return 1; }
+    public void setSomething(int value) {}
+}
\ No newline at end of file
diff --git a/idea/testData/refactoring/rename/syntheticPropertyUsages2/renameSetMethod.test b/idea/testData/refactoring/rename/syntheticPropertyUsages2/renameSetMethod.test
new file mode 100644
index 00000000000..41fee1bdcf5
--- /dev/null
+++ b/idea/testData/refactoring/rename/syntheticPropertyUsages2/renameSetMethod.test
@@ -0,0 +1,6 @@
+{
+  "type": "JAVA_METHOD",
+  "classId": "testing/JavaClass",
+  "methodSignature": "void setSomething(int value)",
+  "newName": "setSomethingNew"
+}
\ No newline at end of file
diff --git a/idea/testData/refactoring/rename/syntheticPropertyUsages3/after/Usages.kt b/idea/testData/refactoring/rename/syntheticPropertyUsages3/after/Usages.kt
new file mode 100644
index 00000000000..2d1769e76d3
--- /dev/null
+++ b/idea/testData/refactoring/rename/syntheticPropertyUsages3/after/Usages.kt
@@ -0,0 +1,5 @@
+import testing.JavaClass
+
+fun usages(javaClass: JavaClass) {
+    javaClass.isSomethingNew = !javaClass.isSomething
+}
\ No newline at end of file
diff --git a/idea/testData/refactoring/rename/syntheticPropertyUsages3/after/testing/JavaClass.java b/idea/testData/refactoring/rename/syntheticPropertyUsages3/after/testing/JavaClass.java
new file mode 100644
index 00000000000..c1d68acf1af
--- /dev/null
+++ b/idea/testData/refactoring/rename/syntheticPropertyUsages3/after/testing/JavaClass.java
@@ -0,0 +1,6 @@
+package testing;
+
+public class JavaClass {
+    public boolean isSomething() { return true; }
+    public void setSomethingNew(boolean value) {}
+}
\ No newline at end of file
diff --git a/idea/testData/refactoring/rename/syntheticPropertyUsages3/before/Usages.kt b/idea/testData/refactoring/rename/syntheticPropertyUsages3/before/Usages.kt
new file mode 100644
index 00000000000..686f44b4a3e
--- /dev/null
+++ b/idea/testData/refactoring/rename/syntheticPropertyUsages3/before/Usages.kt
@@ -0,0 +1,5 @@
+import testing.JavaClass
+
+fun usages(javaClass: JavaClass) {
+    javaClass.isSomething = !javaClass.isSomething
+}
\ No newline at end of file
diff --git a/idea/testData/refactoring/rename/syntheticPropertyUsages3/before/testing/JavaClass.java b/idea/testData/refactoring/rename/syntheticPropertyUsages3/before/testing/JavaClass.java
new file mode 100644
index 00000000000..330068bb7d8
--- /dev/null
+++ b/idea/testData/refactoring/rename/syntheticPropertyUsages3/before/testing/JavaClass.java
@@ -0,0 +1,6 @@
+package testing;
+
+public class JavaClass {
+    public boolean isSomething() { return true; }
+    public void setSomething(boolean value) {}
+}
\ No newline at end of file
diff --git a/idea/testData/refactoring/rename/syntheticPropertyUsages3/renameSetMethod.test b/idea/testData/refactoring/rename/syntheticPropertyUsages3/renameSetMethod.test
new file mode 100644
index 00000000000..cfbc1f7d38a
--- /dev/null
+++ b/idea/testData/refactoring/rename/syntheticPropertyUsages3/renameSetMethod.test
@@ -0,0 +1,6 @@
+{
+  "type": "JAVA_METHOD",
+  "classId": "testing/JavaClass",
+  "methodSignature": "void setSomething(boolean value)",
+  "newName": "setSomethingNew"
+}
\ No newline at end of file
diff --git a/idea/testData/resolve/partialBodyResolve/ClassInitializerHasNoValue.dump b/idea/testData/resolve/partialBodyResolve/ClassInitializerHasNoValue.dump
new file mode 100644
index 00000000000..beeecf55bac
--- /dev/null
+++ b/idea/testData/resolve/partialBodyResolve/ClassInitializerHasNoValue.dump
@@ -0,0 +1,11 @@
+Resolve target: fun foo(): kotlin.Int
+----------------------------------------------
+class C {
+    init {
+        <caret>foo()
+        /* STATEMENT DELETED: bar() */
+    }
+}
+
+fun foo() = 1
+fun bar() = 2
diff --git a/idea/testData/resolve/partialBodyResolve/ClassInitializerHasNoValue.kt b/idea/testData/resolve/partialBodyResolve/ClassInitializerHasNoValue.kt
new file mode 100644
index 00000000000..70322619994
--- /dev/null
+++ b/idea/testData/resolve/partialBodyResolve/ClassInitializerHasNoValue.kt
@@ -0,0 +1,9 @@
+class C {
+    init {
+        <caret>foo()
+        bar()
+    }
+}
+
+fun foo() = 1
+fun bar() = 2
\ No newline at end of file
diff --git a/idea/testData/resolve/referenceInJava/DeprecatedClassObjectField.java b/idea/testData/resolve/referenceInJava/DeprecatedClassObjectField.java
deleted file mode 100644
index 0199370c25f..00000000000
--- a/idea/testData/resolve/referenceInJava/DeprecatedClassObjectField.java
+++ /dev/null
@@ -1,7 +0,0 @@
-public class ClassObjectField {
-    public static void foo() {
-        k.ClassWithClassObject.OB<caret>JECT$.f();
-    }
-}
-
-// REF: companion object of (k).ClassWithClassObject
diff --git a/idea/testData/resolve/references/SyntheticProperty.Data.java b/idea/testData/resolve/references/SyntheticProperty.Data.java
new file mode 100644
index 00000000000..a55591d9ff4
--- /dev/null
+++ b/idea/testData/resolve/references/SyntheticProperty.Data.java
@@ -0,0 +1,4 @@
+class JavaClass {
+    public int getSomething() { return 1; }
+    public void setSomething(int value) {}
+}
\ No newline at end of file
diff --git a/idea/testData/resolve/references/SyntheticProperty.kt b/idea/testData/resolve/references/SyntheticProperty.kt
new file mode 100644
index 00000000000..1a1cfa017d3
--- /dev/null
+++ b/idea/testData/resolve/references/SyntheticProperty.kt
@@ -0,0 +1,28 @@
+fun JavaClass.foo(javaClass: JavaClass) {
+    print(javaClass.<caret>something)
+    javaClass.<caret>something = 1
+    javaClass.<caret>something += 1
+    javaClass.<caret>something++
+    --javaClass.<caret>something
+
+    <caret>something++
+    (<caret>something)++
+    (<caret>something) = 1
+    (javaClass.<caret>something) = 1
+}
+
+// MULTIRESOLVE
+// REF1: (in JavaClass).getSomething()
+// REF2: (in JavaClass).setSomething(int)
+// REF3: (in JavaClass).getSomething()
+// REF3: (in JavaClass).setSomething(int)
+// REF4: (in JavaClass).getSomething()
+// REF4: (in JavaClass).setSomething(int)
+// REF5: (in JavaClass).getSomething()
+// REF5: (in JavaClass).setSomething(int)
+// REF6: (in JavaClass).getSomething()
+// REF6: (in JavaClass).setSomething(int)
+// REF7: (in JavaClass).getSomething()
+// REF7: (in JavaClass).setSomething(int)
+// REF8: (in JavaClass).setSomething(int)
+// REF9: (in JavaClass).setSomething(int)
diff --git a/idea/testData/run/UpdateOnClassRename/module/src/Foo.kt b/idea/testData/run/UpdateOnClassRename/module/src/Foo.kt
new file mode 100644
index 00000000000..80d6fcfffb5
--- /dev/null
+++ b/idea/testData/run/UpdateOnClassRename/module/src/Foo.kt
@@ -0,0 +1,8 @@
+package renameTest
+
+import kotlin.platform.platformStatic
+
+object Foo {
+    platformStatic fun main(args: Array<String>) {
+    }
+}
diff --git a/idea/testData/run/UpdateOnPackageRename/module/src/renameTest/Foo.kt b/idea/testData/run/UpdateOnPackageRename/module/src/renameTest/Foo.kt
new file mode 100644
index 00000000000..80d6fcfffb5
--- /dev/null
+++ b/idea/testData/run/UpdateOnPackageRename/module/src/renameTest/Foo.kt
@@ -0,0 +1,8 @@
+package renameTest
+
+import kotlin.platform.platformStatic
+
+object Foo {
+    platformStatic fun main(args: Array<String>) {
+    }
+}
diff --git a/idea/testData/stubs/AnnotationClass.expected b/idea/testData/stubs/AnnotationClass.expected
index 03b373d2a49..74a06f90d3c 100644
--- a/idea/testData/stubs/AnnotationClass.expected
+++ b/idea/testData/stubs/AnnotationClass.expected
@@ -2,4 +2,9 @@ PsiJetFileStubImpl[package=]
   PACKAGE_DIRECTIVE:
   IMPORT_LIST:
   CLASS:[fqName=Test, isEnumEntry=false, isInterface=false, isLocal=false, isTopLevel=true, name=Test, superNames=[]]
-    MODIFIER_LIST:[annotation]
+    MODIFIER_LIST:[]
+      ANNOTATION_ENTRY:[hasValueArguments=false, shortName=annotation]
+        CONSTRUCTOR_CALLEE:
+          TYPE_REFERENCE:
+            USER_TYPE:[isAbsoluteInRootPackage=false]
+              REFERENCE_EXPRESSION:[referencedName=annotation]
diff --git a/idea/testData/stubs/SecondaryConstructors.expected b/idea/testData/stubs/SecondaryConstructors.expected
index 278b03e45a1..080524dd1d3 100644
--- a/idea/testData/stubs/SecondaryConstructors.expected
+++ b/idea/testData/stubs/SecondaryConstructors.expected
@@ -77,4 +77,9 @@ PsiJetFileStubImpl[package=test]
             MODIFIER_LIST:[internal]
             VALUE_PARAMETER_LIST:
   CLASS:[fqName=test.anno, isEnumEntry=false, isInterface=false, isLocal=false, isTopLevel=true, name=anno, superNames=[]]
-    MODIFIER_LIST:[annotation]
+    MODIFIER_LIST:[]
+      ANNOTATION_ENTRY:[hasValueArguments=false, shortName=annotation]
+        CONSTRUCTOR_CALLEE:
+          TYPE_REFERENCE:
+            USER_TYPE:[isAbsoluteInRootPackage=false]
+              REFERENCE_EXPRESSION:[referencedName=annotation]
diff --git a/idea/testData/stubs/TypeAnnotation.expected b/idea/testData/stubs/TypeAnnotation.expected
index ecf82fcfa4f..b85e0320508 100644
--- a/idea/testData/stubs/TypeAnnotation.expected
+++ b/idea/testData/stubs/TypeAnnotation.expected
@@ -2,9 +2,19 @@ PsiJetFileStubImpl[package=]
   PACKAGE_DIRECTIVE:
   IMPORT_LIST:
   CLASS:[fqName=a, isEnumEntry=false, isInterface=false, isLocal=false, isTopLevel=true, name=a, superNames=[]]
-    MODIFIER_LIST:[annotation]
+    MODIFIER_LIST:[]
+      ANNOTATION_ENTRY:[hasValueArguments=false, shortName=annotation]
+        CONSTRUCTOR_CALLEE:
+          TYPE_REFERENCE:
+            USER_TYPE:[isAbsoluteInRootPackage=false]
+              REFERENCE_EXPRESSION:[referencedName=annotation]
   CLASS:[fqName=b, isEnumEntry=false, isInterface=false, isLocal=false, isTopLevel=true, name=b, superNames=[]]
-    MODIFIER_LIST:[annotation]
+    MODIFIER_LIST:[]
+      ANNOTATION_ENTRY:[hasValueArguments=false, shortName=annotation]
+        CONSTRUCTOR_CALLEE:
+          TYPE_REFERENCE:
+            USER_TYPE:[isAbsoluteInRootPackage=false]
+              REFERENCE_EXPRESSION:[referencedName=annotation]
     PRIMARY_CONSTRUCTOR:
       VALUE_PARAMETER_LIST:
         VALUE_PARAMETER:[fqName=b.e, hasDefaultValue=false, hasValOrVar=true, isMutable=false, name=e]
diff --git a/idea/testData/usageHighlighter/localVal.kt b/idea/testData/usageHighlighter/localVal.kt
new file mode 100644
index 00000000000..a3779680ec8
--- /dev/null
+++ b/idea/testData/usageHighlighter/localVal.kt
@@ -0,0 +1,8 @@
+fun test() {
+    val <info descr="null">a</info> = 12
+    foo(<info descr="null">~a</info>)
+}
+
+fun foo(a: Int) = a
+
+val a = 1
\ No newline at end of file
diff --git a/idea/tests/org/jetbrains/kotlin/DataFlowValueRenderingTest.kt b/idea/tests/org/jetbrains/kotlin/DataFlowValueRenderingTest.kt
index c890df62468..3143de9ebe7 100644
--- a/idea/tests/org/jetbrains/kotlin/DataFlowValueRenderingTest.kt
+++ b/idea/tests/org/jetbrains/kotlin/DataFlowValueRenderingTest.kt
@@ -44,7 +44,7 @@ public abstract class AbstractDataFlowValueRenderingTest: JetLightCodeInsightFix
         fixture.configureByFile(fileName)
 
         val jetFile = fixture.getFile() as JetFile
-        val element = jetFile.findElementAt(fixture.getCaretOffset())
+        val element = jetFile.findElementAt(fixture.getCaretOffset())!!
         val expression = element.getStrictParentOfType<JetExpression>()!!
         val info = expression.analyze().getDataFlowInfo(expression)
 
diff --git a/idea/tests/org/jetbrains/kotlin/addImport/AbstractAddImportTest.kt b/idea/tests/org/jetbrains/kotlin/addImport/AbstractAddImportTest.kt
index 42e0f72de96..1c9ac78d62f 100644
--- a/idea/tests/org/jetbrains/kotlin/addImport/AbstractAddImportTest.kt
+++ b/idea/tests/org/jetbrains/kotlin/addImport/AbstractAddImportTest.kt
@@ -50,7 +50,7 @@ public abstract class AbstractAddImportTest : AbstractImportsTest() {
             else -> {
                 val success = ImportInsertHelper.getInstance(getProject()).importDescriptor(file, descriptors.single()) != ImportInsertHelper.ImportDescriptorResult.FAIL
                 if (!success) {
-                    val document = PsiDocumentManager.getInstance(getProject()).getDocument(file)
+                    val document = PsiDocumentManager.getInstance(getProject()).getDocument(file)!!
                     document.replaceString(0, document.getTextLength(), "Failed to add import")
                     PsiDocumentManager.getInstance(getProject()).commitAllDocuments()
                 }
diff --git a/idea/tests/org/jetbrains/kotlin/asJava/LightClassesClasspathSortingTest.kt b/idea/tests/org/jetbrains/kotlin/asJava/LightClassesClasspathSortingTest.kt
index 63aeddfd2d5..80044d17d57 100644
--- a/idea/tests/org/jetbrains/kotlin/asJava/LightClassesClasspathSortingTest.kt
+++ b/idea/tests/org/jetbrains/kotlin/asJava/LightClassesClasspathSortingTest.kt
@@ -57,6 +57,7 @@ class LightClassesClasspathSortingTest : KotlinCodeInsightTestCase() {
         val psiClass = JavaPsiFacade.getInstance(getProject()).findClass(fqName, ResolveScopeManager.getElementResolveScope(getFile()))
 
         assertNotNull(psiClass, "Can't find class for $fqName")
+        psiClass!!
         assert(psiClass is KotlinLightClassForExplicitDeclaration || psiClass is KotlinLightClassForPackage,
                "Should be an explicit light class, but was $fqName ${psiClass.javaClass}")
         assert(psiClass !is KotlinLightClassForDecompiledDeclaration,
diff --git a/idea/tests/org/jetbrains/kotlin/findUsages/AbstractJetFindUsagesTest.java b/idea/tests/org/jetbrains/kotlin/findUsages/AbstractJetFindUsagesTest.java
index fb48fb6a26b..622e0d95f9d 100644
--- a/idea/tests/org/jetbrains/kotlin/findUsages/AbstractJetFindUsagesTest.java
+++ b/idea/tests/org/jetbrains/kotlin/findUsages/AbstractJetFindUsagesTest.java
@@ -358,11 +358,11 @@ public abstract class AbstractJetFindUsagesTest extends JetLightCodeInsightFixtu
     }
 
     private <T extends PsiElement> void findUsagesAndCheckResults(
-            String mainFileText,
-            String prefix,
-            String rootPath,
-            T caretElement,
-            FindUsagesOptions options
+            @NotNull String mainFileText,
+            @NotNull String prefix,
+            @NotNull String rootPath,
+            @NotNull T caretElement,
+            @Nullable FindUsagesOptions options
     ) throws ClassNotFoundException, InstantiationException, IllegalAccessException {
         Collection<UsageInfo> usageInfos = findUsages(caretElement, options);
 
@@ -419,7 +419,7 @@ public abstract class AbstractJetFindUsagesTest extends JetLightCodeInsightFixtu
         JetTestUtils.assertEqualsToFile(new File(rootPath, prefix + "results.txt"), StringUtil.join(finalUsages, "\n"));
     }
 
-    private Collection<UsageInfo> findUsages(@NotNull PsiElement targetElement, @Nullable FindUsagesOptions options) {
+    protected Collection<UsageInfo> findUsages(@NotNull PsiElement targetElement, @Nullable FindUsagesOptions options) {
         Project project = getProject();
         FindUsagesHandler handler =
                 ((FindManagerImpl) FindManager.getInstance(project)).getFindUsagesManager().getFindUsagesHandler(targetElement, false);
diff --git a/idea/tests/org/jetbrains/kotlin/findUsages/JetFindUsagesTestGenerated.java b/idea/tests/org/jetbrains/kotlin/findUsages/JetFindUsagesTestGenerated.java
index cdf5da168d4..dcbe2cdde33 100644
--- a/idea/tests/org/jetbrains/kotlin/findUsages/JetFindUsagesTestGenerated.java
+++ b/idea/tests/org/jetbrains/kotlin/findUsages/JetFindUsagesTestGenerated.java
@@ -1250,6 +1250,12 @@ public class JetFindUsagesTestGenerated extends AbstractJetFindUsagesTest {
                 String fileName = JetTestUtils.navigationMetadata("idea/testData/findUsages/java/findJavaMethodUsages/JKMethodUsages.0.java");
                 doTest(fileName);
             }
+
+            @TestMetadata("SyntheticProperties.0.java")
+            public void testSyntheticProperties() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("idea/testData/findUsages/java/findJavaMethodUsages/SyntheticProperties.0.java");
+                doTest(fileName);
+            }
         }
     }
 }
diff --git a/idea/tests/org/jetbrains/kotlin/findUsages/KotlinFindUsagesWithLibraryCustomTest.kt b/idea/tests/org/jetbrains/kotlin/findUsages/KotlinFindUsagesWithLibraryCustomTest.kt
new file mode 100644
index 00000000000..ad4646e403c
--- /dev/null
+++ b/idea/tests/org/jetbrains/kotlin/findUsages/KotlinFindUsagesWithLibraryCustomTest.kt
@@ -0,0 +1,32 @@
+/*
+ * Copyright 2010-2015 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.kotlin.findUsages
+
+import com.intellij.psi.search.FilenameIndex
+import org.jetbrains.kotlin.psi.JetParameter
+import org.jetbrains.kotlin.psi.psiUtil.getStrictParentOfType
+import kotlin.test.assertEquals
+
+public class KotlinFindUsagesWithLibraryCustomTest : AbstractKotlinFindUsagesWithLibraryTest() {
+    public fun testFindUsagesForLocalClassProperty() {
+        val libraryFile = FilenameIndex.getFilesByName(getProject(), "library.kt", myFixture.getModule().getModuleWithLibrariesScope()).first()
+        val indexOf = libraryFile.getText().indexOf("localClassProperty")
+        val jetParameter = libraryFile.findElementAt(indexOf)!!.getStrictParentOfType<JetParameter>()!!
+        val usages = findUsages(jetParameter.getOriginalElement(), null)
+        assertEquals(2, usages.size())
+    }
+}
\ No newline at end of file
diff --git a/idea/tests/org/jetbrains/kotlin/idea/ResolveElementCacheTest.kt b/idea/tests/org/jetbrains/kotlin/idea/ResolveElementCacheTest.kt
new file mode 100644
index 00000000000..3bbb9aa1bc9
--- /dev/null
+++ b/idea/tests/org/jetbrains/kotlin/idea/ResolveElementCacheTest.kt
@@ -0,0 +1,170 @@
+/*
+ * Copyright 2010-2015 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.kotlin.idea
+
+import org.jetbrains.kotlin.idea.caches.resolve.analyze
+import org.jetbrains.kotlin.idea.test.JetLightCodeInsightFixtureTestCase
+import org.jetbrains.kotlin.idea.test.JetLightProjectDescriptor
+import org.jetbrains.kotlin.idea.util.application.executeWriteCommand
+import org.jetbrains.kotlin.psi.*
+import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode
+
+public class ResolveElementCacheTest : JetLightCodeInsightFixtureTestCase() {
+    override fun getProjectDescriptor() = JetLightProjectDescriptor.INSTANCE
+
+    private val FILE_TEXT =
+"""
+class C(param1: String = "", param2: Int = 0) {
+    fun a(p: Int = 0) {
+        b(1, 2)
+        val x = c()
+        d(x)
+    }
+
+    fun b() {
+    }
+
+    fun c() {
+    }
+}
+"""
+
+    private data class Data(
+            val file: JetFile,
+            val klass: JetClass,
+            val members: List<JetDeclaration>,
+            val statements: List<JetExpression>,
+            val factory: JetPsiFactory
+    )
+
+    private fun doTest(handler: Data.() -> Unit) {
+        val file = myFixture.configureByText("Test.kt", FILE_TEXT) as JetFile
+        val klass = file.getDeclarations().single() as JetClass
+        val members = klass.getDeclarations()
+        val function = members.first() as JetNamedFunction
+        val statements = (function.getBodyExpression() as JetBlockExpression).getStatements()
+        myFixture.getProject().executeWriteCommand("") {
+            Data(file, klass, members, statements, JetPsiFactory(getProject())).handler()
+        }
+    }
+
+    public fun testResolveCaching() {
+        doTest {
+            val statement1 = statements[0]
+            val statement2 = statements[1]
+            val bindingContext1 = statement1.analyze(BodyResolveMode.FULL)
+            val bindingContext2 = statement2.analyze(BodyResolveMode.FULL)
+            assert(bindingContext1 === bindingContext2)
+
+            val bindingContext3 = statement1.analyze(BodyResolveMode.FULL)
+            assert(bindingContext3 === bindingContext1)
+
+            file.add(factory.createFunction("fun foo(){}"))
+
+            val bindingContext4 = statement1.analyze(BodyResolveMode.FULL)
+            assert(bindingContext4 !== bindingContext1)
+
+            statement1.getParent().addAfter(factory.createExpression("x()"), statement1)
+
+            val bindingContext5 = statement1.analyze(BodyResolveMode.FULL)
+            assert(bindingContext5 !== bindingContext4)
+        }
+    }
+
+    public fun testPartialResolveUsesFullResolveCached() {
+        doTest {
+            val statement1 = statements[0]
+            val statement2 = statements[1]
+            val bindingContext1 = statement1.analyze(BodyResolveMode.FULL)
+
+            val bindingContext2 = statement2.analyze(BodyResolveMode.PARTIAL)
+            assert(bindingContext2 === bindingContext1)
+
+            val bindingContext3 = statement2.analyze(BodyResolveMode.PARTIAL_FOR_COMPLETION)
+            assert(bindingContext3 === bindingContext1)
+        }
+    }
+
+    public fun testPartialResolveCaching() {
+        doTest {
+            val statement1 = statements[0]
+            val statement2 = statements[1]
+            val bindingContext1 = statement1.analyze(BodyResolveMode.PARTIAL)
+            val bindingContext2 = statement2.analyze(BodyResolveMode.PARTIAL)
+            assert(bindingContext1 !== bindingContext2)
+
+            val bindingContext3 = statement1.analyze(BodyResolveMode.PARTIAL)
+            val bindingContext4 = statement2.analyze(BodyResolveMode.PARTIAL)
+            assert(bindingContext3 === bindingContext1)
+            assert(bindingContext4 === bindingContext2)
+
+            file.add(factory.createFunction("fun foo(){}"))
+
+            val bindingContext5 = statement1.analyze(BodyResolveMode.PARTIAL)
+            assert(bindingContext5 !== bindingContext1)
+
+            statement1.getParent().addAfter(factory.createExpression("x()"), statement1)
+
+            val bindingContext6 = statement1.analyze(BodyResolveMode.PARTIAL)
+            assert(bindingContext6 !== bindingContext5)
+        }
+    }
+
+    public fun testPartialResolveCachedForWholeStatement() {
+        doTest {
+            val statement = statements[0] as JetCallExpression
+            val argument1 = statement.getValueArguments()[0]
+            val argument2 = statement.getValueArguments()[1]
+            val bindingContext1 = argument1.analyze(BodyResolveMode.PARTIAL)
+            val bindingContext2 = argument2.analyze(BodyResolveMode.PARTIAL)
+            assert(bindingContext1 === bindingContext2)
+        }
+    }
+
+    public fun testPartialResolveCachedForAllStatementsResolved() {
+        doTest {
+            val bindingContext1 = statements[2].analyze(BodyResolveMode.PARTIAL) // resolve 'd(x)'
+            val bindingContext2 = (statements[1] as JetVariableDeclaration).getInitializer()!!.analyze(BodyResolveMode.PARTIAL) // resolve initializer in 'val x = c()' - it required for resolved 'd(x)' and should be already resolved
+            assert(bindingContext1 === bindingContext2)
+
+            val bindingContext3 = statements[0].analyze(BodyResolveMode.PARTIAL)
+            assert(bindingContext3 !== bindingContext1)
+        }
+    }
+
+    public fun testPartialResolveCachedForDefaultParameterValue() {
+        doTest {
+            val defaultValue = (members[0] as JetNamedFunction).getValueParameters()[0].getDefaultValue()
+            val bindingContext1 = defaultValue!!.analyze(BodyResolveMode.PARTIAL)
+            val bindingContext2 = defaultValue.analyze(BodyResolveMode.PARTIAL)
+            assert(bindingContext1 === bindingContext2)
+
+            val bindingContext3 = statements[0].analyze(BodyResolveMode.PARTIAL)
+            assert(bindingContext3 !== bindingContext2)
+        }
+    }
+
+    public fun testFullResolvedCachedWhenPartialForConstructorInvoked() {
+        doTest {
+            val defaultValue1 = klass.getPrimaryConstructorParameters()[0].getDefaultValue()!!
+            val defaultValue2 = klass.getPrimaryConstructorParameters()[1].getDefaultValue()!!
+            val bindingContext1 = defaultValue1.analyze(BodyResolveMode.PARTIAL)
+            val bindingContext2 = defaultValue2.analyze(BodyResolveMode.FULL)
+            assert(bindingContext1 === bindingContext2)
+        }
+    }
+}
diff --git a/idea/tests/org/jetbrains/kotlin/idea/codeInsight/JetInspectionTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/codeInsight/JetInspectionTestGenerated.java
index 2ebab0d6aca..70dafa1ab80 100644
--- a/idea/tests/org/jetbrains/kotlin/idea/codeInsight/JetInspectionTestGenerated.java
+++ b/idea/tests/org/jetbrains/kotlin/idea/codeInsight/JetInspectionTestGenerated.java
@@ -88,12 +88,6 @@ public class JetInspectionTestGenerated extends AbstractJetInspectionTest {
             JetTestUtils.assertAllTestsPresentInSingleGeneratedClass(this.getClass(), new File("idea/testData/inspections"), Pattern.compile("^(inspections\\.test)$"));
         }
 
-        @TestMetadata("reflectionNotFound/inspectionData/inspections.test")
-        public void testReflectionNotFound_inspectionData_Inspections_test() throws Exception {
-            String fileName = JetTestUtils.navigationMetadata("idea/testData/inspections/reflectionNotFound/inspectionData/inspections.test");
-            doTest(fileName);
-        }
-
         @TestMetadata("spelling/inspectionData/inspections.test")
         public void testSpelling_inspectionData_Inspections_test() throws Exception {
             String fileName = JetTestUtils.navigationMetadata("idea/testData/inspections/spelling/inspectionData/inspections.test");
diff --git a/idea/tests/org/jetbrains/kotlin/idea/debugger/AbstractJetPositionManagerTest.java b/idea/tests/org/jetbrains/kotlin/idea/debugger/AbstractJetPositionManagerTest.java
index a98d0d33980..6280991c308 100644
--- a/idea/tests/org/jetbrains/kotlin/idea/debugger/AbstractJetPositionManagerTest.java
+++ b/idea/tests/org/jetbrains/kotlin/idea/debugger/AbstractJetPositionManagerTest.java
@@ -137,7 +137,9 @@ public abstract class AbstractJetPositionManagerTest extends KotlinMultiFileTest
     @Override
     public void tearDown() {
         if (debugProcess != null) {
+            debugProcess.stop(true);
             debugProcess.dispose();
+            debugProcess = null;
         }
         super.tearDown();
     }
diff --git a/idea/tests/org/jetbrains/kotlin/idea/debugger/AbstractKotlinSteppingTest.kt b/idea/tests/org/jetbrains/kotlin/idea/debugger/AbstractKotlinSteppingTest.kt
index ca491a4df8a..897163a5f8c 100644
--- a/idea/tests/org/jetbrains/kotlin/idea/debugger/AbstractKotlinSteppingTest.kt
+++ b/idea/tests/org/jetbrains/kotlin/idea/debugger/AbstractKotlinSteppingTest.kt
@@ -55,7 +55,7 @@ public abstract class AbstractKotlinSteppingTest : KotlinDebuggerTestBase() {
 
         File(path).readLines().forEach {
             when {
-                it.startsWith("// STEP_INTO") -> repeat("// STEP_INTO: ") { stepInto() }
+                it.startsWith("// STEP_INTO") -> repeat("// STEP_INTO: ") { stepInto(this) }
                 it.startsWith("// STEP_OUT") -> repeat("// STEP_OUT: ") { stepOut() }
                 it.startsWith("// SMART_STEP_INTO") -> repeat("// SMART_STEP_INTO: ") { smartStepInto() }
                 it.startsWith("// RESUME") -> repeat("// RESUME: ") { resume(this) }
@@ -75,7 +75,7 @@ public abstract class AbstractKotlinSteppingTest : KotlinDebuggerTestBase() {
         for (i in 1..(getPrefixedInt(fileText, "// $command: ") ?: 1)) {
             doOnBreakpoint {
                 when(command) {
-                    "STEP_INTO" -> stepInto()
+                    "STEP_INTO" -> stepInto(this)
                     "STEP_OUT" -> stepOut()
                     "SMART_STEP_INTO" -> smartStepInto()
                 }
diff --git a/idea/tests/org/jetbrains/kotlin/idea/debugger/KotlinDebuggerTestBase.kt b/idea/tests/org/jetbrains/kotlin/idea/debugger/KotlinDebuggerTestBase.kt
index 88eccc6dafd..168c1958f0d 100644
--- a/idea/tests/org/jetbrains/kotlin/idea/debugger/KotlinDebuggerTestBase.kt
+++ b/idea/tests/org/jetbrains/kotlin/idea/debugger/KotlinDebuggerTestBase.kt
@@ -50,13 +50,15 @@ import org.jetbrains.kotlin.idea.util.application.runWriteAction
 import org.jetbrains.kotlin.test.InTextDirectivesUtils
 import org.jetbrains.kotlin.test.InTextDirectivesUtils.findStringWithPrefixes
 import javax.swing.SwingUtilities
-import kotlin.properties.Delegates
 
 abstract class KotlinDebuggerTestBase : KotlinDebuggerTestCase() {
-    private var oldSettings: DebuggerSettings by Delegates.notNull()
-    private var oldIsFilterForStdlibAlreadyAdded: Boolean by Delegates.notNull()
-    private var oldDisableKotlinInternalClasses: Boolean by Delegates.notNull()
-    private var oldRenderDelegatedProperties: Boolean by Delegates.notNull()
+    private var oldSettings: DebuggerSettings? = null
+    private var oldIsFilterForStdlibAlreadyAdded = false
+    private var oldDisableKotlinInternalClasses = false
+    private var oldRenderDelegatedProperties = false
+
+    protected var evaluationContext: EvaluationContextImpl? = null
+    protected var debuggerContext: DebuggerContextImpl? = null
 
     override fun initApplication() {
         super.initApplication()
@@ -66,6 +68,9 @@ abstract class KotlinDebuggerTestBase : KotlinDebuggerTestCase() {
     override fun tearDown() {
         super.tearDown()
         restoreDefaultSettings()
+
+        evaluationContext = null
+        debuggerContext = null
     }
 
     protected fun configureSettings(fileText: String) {
@@ -75,11 +80,11 @@ abstract class KotlinDebuggerTestBase : KotlinDebuggerTestCase() {
         kotlinSettings.DEBUG_RENDER_DELEGATED_PROPERTIES = fileText.getValueForSetting("RENDER_DELEGATED_PROPERTIES", oldRenderDelegatedProperties)
 
         val debuggerSettings = DebuggerSettings.getInstance()!!
-        debuggerSettings.SKIP_SYNTHETIC_METHODS = fileText.getValueForSetting("SKIP_SYNTHETIC_METHODS", oldSettings.SKIP_SYNTHETIC_METHODS)
-        debuggerSettings.SKIP_CONSTRUCTORS = fileText.getValueForSetting("SKIP_CONSTRUCTORS", oldSettings.SKIP_CONSTRUCTORS)
-        debuggerSettings.SKIP_CLASSLOADERS = fileText.getValueForSetting("SKIP_CLASSLOADERS", oldSettings.SKIP_CLASSLOADERS)
-        debuggerSettings.TRACING_FILTERS_ENABLED = fileText.getValueForSetting("TRACING_FILTERS_ENABLED", oldSettings.TRACING_FILTERS_ENABLED)
-        debuggerSettings.SKIP_GETTERS = fileText.getValueForSetting("SKIP_GETTERS", oldSettings.SKIP_GETTERS)
+        debuggerSettings.SKIP_SYNTHETIC_METHODS = fileText.getValueForSetting("SKIP_SYNTHETIC_METHODS", oldSettings!!.SKIP_SYNTHETIC_METHODS)
+        debuggerSettings.SKIP_CONSTRUCTORS = fileText.getValueForSetting("SKIP_CONSTRUCTORS", oldSettings!!.SKIP_CONSTRUCTORS)
+        debuggerSettings.SKIP_CLASSLOADERS = fileText.getValueForSetting("SKIP_CLASSLOADERS", oldSettings!!.SKIP_CLASSLOADERS)
+        debuggerSettings.TRACING_FILTERS_ENABLED = fileText.getValueForSetting("TRACING_FILTERS_ENABLED", oldSettings!!.TRACING_FILTERS_ENABLED)
+        debuggerSettings.SKIP_GETTERS = fileText.getValueForSetting("SKIP_GETTERS", oldSettings!!.SKIP_GETTERS)
     }
 
     private fun String.getValueForSetting(name: String, defaultValue: Boolean): Boolean {
@@ -99,11 +104,11 @@ abstract class KotlinDebuggerTestBase : KotlinDebuggerTestCase() {
         KotlinDebuggerSettings.getInstance().DEBUG_RENDER_DELEGATED_PROPERTIES = oldRenderDelegatedProperties
 
         val debuggerSettings = DebuggerSettings.getInstance()!!
-        debuggerSettings.SKIP_SYNTHETIC_METHODS = oldSettings.SKIP_SYNTHETIC_METHODS
-        debuggerSettings.SKIP_CONSTRUCTORS = oldSettings.SKIP_CONSTRUCTORS
-        debuggerSettings.SKIP_CLASSLOADERS = oldSettings.SKIP_CLASSLOADERS
-        debuggerSettings.TRACING_FILTERS_ENABLED = oldSettings.TRACING_FILTERS_ENABLED
-        debuggerSettings.SKIP_GETTERS = oldSettings.SKIP_GETTERS
+        debuggerSettings.SKIP_SYNTHETIC_METHODS = oldSettings!!.SKIP_SYNTHETIC_METHODS
+        debuggerSettings.SKIP_CONSTRUCTORS = oldSettings!!.SKIP_CONSTRUCTORS
+        debuggerSettings.SKIP_CLASSLOADERS = oldSettings!!.SKIP_CLASSLOADERS
+        debuggerSettings.TRACING_FILTERS_ENABLED = oldSettings!!.TRACING_FILTERS_ENABLED
+        debuggerSettings.SKIP_GETTERS = oldSettings!!.SKIP_GETTERS
     }
 
     protected val dp: DebugProcessImpl
@@ -117,13 +122,6 @@ abstract class KotlinDebuggerTestBase : KotlinDebuggerTestCase() {
         }
     }
 
-    protected fun SuspendContextImpl.stepInto() {
-        this.stepInto(false, null)
-    }
-
-    protected var evaluationContext: EvaluationContextImpl by Delegates.notNull()
-    protected var debuggerContext: DebuggerContextImpl by Delegates.notNull()
-
     protected fun initContexts(suspendContext: SuspendContextImpl) {
         evaluationContext = createEvaluationContext(suspendContext)
         debuggerContext = createDebuggerContext(suspendContext)
diff --git a/idea/tests/org/jetbrains/kotlin/idea/debugger/KotlinDebuggerTestCase.java b/idea/tests/org/jetbrains/kotlin/idea/debugger/KotlinDebuggerTestCase.java
index ffba4eba0b9..a48c43c5cf4 100644
--- a/idea/tests/org/jetbrains/kotlin/idea/debugger/KotlinDebuggerTestCase.java
+++ b/idea/tests/org/jetbrains/kotlin/idea/debugger/KotlinDebuggerTestCase.java
@@ -73,8 +73,8 @@ public abstract class KotlinDebuggerTestCase extends DescriptorTestCase {
 
     @Override
     protected void setUp() throws Exception {
-        super.setUp();
         VfsRootAccess.allowRootAccess(JetTestUtils.getHomeDirectory());
+        super.setUp();
 
         UsefulTestCase.edt(new Runnable() {
             @Override
@@ -110,8 +110,8 @@ public abstract class KotlinDebuggerTestCase extends DescriptorTestCase {
 
     @Override
     protected void tearDown() throws Exception {
-        VfsRootAccess.allowRootAccess(JetTestUtils.getHomeDirectory());
         super.tearDown();
+        VfsRootAccess.allowRootAccess(JetTestUtils.getHomeDirectory());
     }
 
     @SuppressWarnings("AssignmentToStaticFieldFromInstanceMethod")
diff --git a/idea/tests/org/jetbrains/kotlin/idea/debugger/evaluate/AbstractEditorForEvaluateExpressionTest.kt b/idea/tests/org/jetbrains/kotlin/idea/debugger/evaluate/AbstractEditorForEvaluateExpressionTest.kt
index 60b1ca1e2b8..16d6b9c2c24 100644
--- a/idea/tests/org/jetbrains/kotlin/idea/debugger/evaluate/AbstractEditorForEvaluateExpressionTest.kt
+++ b/idea/tests/org/jetbrains/kotlin/idea/debugger/evaluate/AbstractEditorForEvaluateExpressionTest.kt
@@ -99,7 +99,7 @@ private fun JavaCodeInsightTestFixture.configureByCodeFragment(filePath: String)
         file.putCopyableUserData(JetCodeFragment.RUNTIME_TYPE_EVALUATOR, {
             val codeFragment = JetPsiFactory(getProject()).createBlockCodeFragment("val xxx: $typeStr" , PsiTreeUtil.getParentOfType(elementAt, javaClass<JetElement>()))
             val context = codeFragment.analyzeFully()
-            val typeReference: JetTypeReference = PsiTreeUtil.getChildOfType(codeFragment.getContentElement().getFirstChild(), javaClass())
+            val typeReference: JetTypeReference = PsiTreeUtil.getChildOfType(codeFragment.getContentElement().getFirstChild(), javaClass())!!
             context[BindingContext.TYPE, typeReference]
         })
     }
diff --git a/idea/tests/org/jetbrains/kotlin/idea/debugger/evaluate/AbstractKotlinEvaluateExpressionTest.kt b/idea/tests/org/jetbrains/kotlin/idea/debugger/evaluate/AbstractKotlinEvaluateExpressionTest.kt
index bc35fd78481..00efde1f6b5 100644
--- a/idea/tests/org/jetbrains/kotlin/idea/debugger/evaluate/AbstractKotlinEvaluateExpressionTest.kt
+++ b/idea/tests/org/jetbrains/kotlin/idea/debugger/evaluate/AbstractKotlinEvaluateExpressionTest.kt
@@ -59,13 +59,7 @@ import kotlin.test.fail
 public abstract class AbstractKotlinEvaluateExpressionTest : KotlinDebuggerTestBase() {
     private val logger = Logger.getLogger(javaClass<KotlinEvaluateExpressionCache>())!!
 
-    private val appender = object : AppenderSkeleton() {
-        override fun append(event: LoggingEvent?) {
-            println(event?.getRenderedMessage(), ProcessOutputTypes.SYSTEM)
-        }
-        override fun close() {}
-        override fun requiresLayout() = false
-    }
+    private var appender: AppenderSkeleton? = null
 
     private var oldLogLevel: Level? = null
     private var oldShowFqTypeNames = false
@@ -79,6 +73,15 @@ public abstract class AbstractKotlinEvaluateExpressionTest : KotlinDebuggerTestB
 
         oldLogLevel = logger.getLevel()
         logger.setLevel(Level.DEBUG)
+
+        appender = object : AppenderSkeleton() {
+            override fun append(event: LoggingEvent?) {
+                println(event?.getRenderedMessage(), ProcessOutputTypes.SYSTEM)
+            }
+            override fun close() {}
+            override fun requiresLayout() = false
+        }
+
         logger.addAppender(appender)
     }
 
@@ -86,6 +89,9 @@ public abstract class AbstractKotlinEvaluateExpressionTest : KotlinDebuggerTestB
         logger.setLevel(oldLogLevel)
         logger.removeAppender(appender)
 
+        appender = null
+        oldLogLevel = null
+
         NodeRendererSettings.getInstance()!!.getClassRenderer()!!.SHOW_FQ_TYPE_NAMES = oldShowFqTypeNames
 
         super.tearDown()
@@ -110,7 +116,7 @@ public abstract class AbstractKotlinEvaluateExpressionTest : KotlinDebuggerTestB
         val count = InTextDirectivesUtils.getPrefixedInt(fileText, "// STEP_INTO: ") ?: 0
         if (count > 0) {
             for (i in 1..count) {
-                doOnBreakpoint { stepInto() }
+                doOnBreakpoint { this@AbstractKotlinEvaluateExpressionTest.stepInto(this) }
             }
         }
 
@@ -195,7 +201,7 @@ public abstract class AbstractKotlinEvaluateExpressionTest : KotlinDebuggerTestB
     }
 
     fun getExtraVars(): Set<TextWithImports> {
-        return KotlinFrameExtraVariablesProvider().collectVariables(debuggerContext.getSourcePosition(), evaluationContext, hashSetOf())!!
+        return KotlinFrameExtraVariablesProvider().collectVariables(debuggerContext!!.getSourcePosition(), evaluationContext, hashSetOf())!!
     }
 
     private inner class Printer() {
@@ -223,11 +229,11 @@ public abstract class AbstractKotlinEvaluateExpressionTest : KotlinDebuggerTestB
                 is StackFrameDescriptor ->    logDescriptor(descriptor, "$curIndent frame    = $label\n")
                 is WatchItemDescriptor ->     logDescriptor(descriptor, "$curIndent extra    = ${descriptor.calcValueName()}\n")
                 is LocalVariableDescriptor -> logDescriptor(descriptor, "$curIndent local    = $label"
-                                                    + " (sp = ${render(SourcePositionProvider.getSourcePosition(descriptor, myProject, debuggerContext))})\n")
+                                                    + " (sp = ${render(SourcePositionProvider.getSourcePosition(descriptor, myProject, debuggerContext!!))})\n")
                 is StaticDescriptor ->        logDescriptor(descriptor, "$curIndent static   = $label\n")
                 is ThisDescriptorImpl ->      logDescriptor(descriptor, "$curIndent this     = $label\n")
                 is FieldDescriptor ->         logDescriptor(descriptor, "$curIndent field    = $label"
-                                                    + " (sp = ${render(SourcePositionProvider.getSourcePosition(descriptor, myProject, debuggerContext))})\n")
+                                                    + " (sp = ${render(SourcePositionProvider.getSourcePosition(descriptor, myProject, debuggerContext!!))})\n")
                 else ->                       logDescriptor(descriptor, "$curIndent unknown  = $label\n")
             }
             return false
@@ -277,7 +283,7 @@ public abstract class AbstractKotlinEvaluateExpressionTest : KotlinDebuggerTestB
 
     private fun createContextElement(context: SuspendContextImpl): PsiElement {
         val contextElement = ContextUtil.getContextElement(debuggerContext)
-        Assert.assertTrue("KotlinCodeFragmentFactory should be accepted for context element otherwise default evaluator will be called. ContextElement = ${contextElement.getText()}",
+        Assert.assertTrue("KotlinCodeFragmentFactory should be accepted for context element otherwise default evaluator will be called. ContextElement = ${contextElement?.getText() ?: "null"}",
                           KotlinCodeFragmentFactory().isContextAccepted(contextElement))
 
         if (contextElement != null) {
@@ -290,10 +296,11 @@ public abstract class AbstractKotlinEvaluateExpressionTest : KotlinDebuggerTestB
                 assert(labelParts.size() == 2) { "Wrong format for DEBUG_LABEL directive: // DEBUG_LABEL: {localVariableName} = {labelText}"}
                 val localVariableName = labelParts[0].trim()
                 val labelName = labelParts[1].trim()
-                val localVariable = context.getFrameProxy().visibleVariableByName(localVariableName)
+                val localVariable = context.getFrameProxy()!!.visibleVariableByName(localVariableName)
                 assert(localVariable != null) { "Couldn't find localVariable for label: name = $localVariableName" }
-                val localVariableValue = context.getFrameProxy().getValue(localVariable) as? ObjectReference
+                val localVariableValue = context.getFrameProxy()!!.getValue(localVariable) as? ObjectReference
                 assert(localVariableValue != null) { "Local variable $localVariableName should be an ObjectReference" }
+                localVariableValue!!
                 markupMap.put(localVariableValue, ValueMarkup(labelName, null, labelName))
             }
 
diff --git a/idea/tests/org/jetbrains/kotlin/idea/debugger/evaluate/CodeFragmentCompletionInLibraryTest.kt b/idea/tests/org/jetbrains/kotlin/idea/debugger/evaluate/CodeFragmentCompletionInLibraryTest.kt
index 5c981201fe7..55b099baf48 100644
--- a/idea/tests/org/jetbrains/kotlin/idea/debugger/evaluate/CodeFragmentCompletionInLibraryTest.kt
+++ b/idea/tests/org/jetbrains/kotlin/idea/debugger/evaluate/CodeFragmentCompletionInLibraryTest.kt
@@ -42,7 +42,7 @@ public class CodeFragmentCompletionInLibraryTest : AbstractJvmBasicCompletionTes
         override fun configureModule(module: Module, model: ModifiableRootModel, contentEntry: ContentEntry?) {
             super.configureModule(module, model, contentEntry)
 
-            val library = model.getModuleLibraryTable().getLibraryByName(JdkAndMockLibraryProjectDescriptor.LIBRARY_NAME)
+            val library = model.getModuleLibraryTable().getLibraryByName(JdkAndMockLibraryProjectDescriptor.LIBRARY_NAME)!!
             val modifiableModel = library.getModifiableModel()
 
             modifiableModel.addRoot(findLibrarySourceDir(), OrderRootType.SOURCES)
@@ -75,7 +75,7 @@ public class CodeFragmentCompletionInLibraryTest : AbstractJvmBasicCompletionTes
     }
 
     private fun setupFixtureByCodeFragment(fragmentText: String) {
-        val sourceFile = findLibrarySourceDir().findChild("customLibrary.kt")
+        val sourceFile = findLibrarySourceDir().findChild("customLibrary.kt")!!
         val jetFile = PsiManager.getInstance(getProject()).findFile(sourceFile) as JetFile
         val fooFunctionFromLibrary = jetFile.getDeclarations().first() as JetFunction
         val codeFragment = JetPsiFactory(fooFunctionFromLibrary).createExpressionCodeFragment(
diff --git a/idea/tests/org/jetbrains/kotlin/idea/debugger/evaluate/CodeFragmentCompletionTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/debugger/evaluate/CodeFragmentCompletionTestGenerated.java
index 5541f7c1e54..116c022dc08 100644
--- a/idea/tests/org/jetbrains/kotlin/idea/debugger/evaluate/CodeFragmentCompletionTestGenerated.java
+++ b/idea/tests/org/jetbrains/kotlin/idea/debugger/evaluate/CodeFragmentCompletionTestGenerated.java
@@ -47,6 +47,18 @@ public class CodeFragmentCompletionTestGenerated extends AbstractCodeFragmentCom
         doTest(fileName);
     }
 
+    @TestMetadata("elementAt.kt")
+    public void testElementAt() throws Exception {
+        String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/codeFragments/elementAt.kt");
+        doTest(fileName);
+    }
+
+    @TestMetadata("elementAtFirstInBlock.kt")
+    public void testElementAtFirstInBlock() throws Exception {
+        String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/codeFragments/elementAtFirstInBlock.kt");
+        doTest(fileName);
+    }
+
     @TestMetadata("localVal.kt")
     public void testLocalVal() throws Exception {
         String fileName = JetTestUtils.navigationMetadata("idea/idea-completion/testData/basic/codeFragments/localVal.kt");
diff --git a/idea/tests/org/jetbrains/kotlin/idea/debugger/evaluate/CodeFragmentHighlightingTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/debugger/evaluate/CodeFragmentHighlightingTestGenerated.java
index 234d00c3012..346da628466 100644
--- a/idea/tests/org/jetbrains/kotlin/idea/debugger/evaluate/CodeFragmentHighlightingTestGenerated.java
+++ b/idea/tests/org/jetbrains/kotlin/idea/debugger/evaluate/CodeFragmentHighlightingTestGenerated.java
@@ -73,6 +73,18 @@ public class CodeFragmentHighlightingTestGenerated extends AbstractCodeFragmentH
             doTest(fileName);
         }
 
+        @TestMetadata("elementAtIfWithoutBraces.kt")
+        public void testElementAtIfWithoutBraces() throws Exception {
+            String fileName = JetTestUtils.navigationMetadata("idea/testData/checker/codeFragments/elementAtIfWithoutBraces.kt");
+            doTest(fileName);
+        }
+
+        @TestMetadata("elementAtWhenBranch.kt")
+        public void testElementAtWhenBranch() throws Exception {
+            String fileName = JetTestUtils.navigationMetadata("idea/testData/checker/codeFragments/elementAtWhenBranch.kt");
+            doTest(fileName);
+        }
+
         @TestMetadata("localVariables.kt")
         public void testLocalVariables() throws Exception {
             String fileName = JetTestUtils.navigationMetadata("idea/testData/checker/codeFragments/localVariables.kt");
diff --git a/idea/tests/org/jetbrains/kotlin/idea/decompiler/navigation/AbstractNavigateToLibrarySourceTest.kt b/idea/tests/org/jetbrains/kotlin/idea/decompiler/navigation/AbstractNavigateToLibrarySourceTest.kt
index 30d3fe1fc35..01969b22337 100644
--- a/idea/tests/org/jetbrains/kotlin/idea/decompiler/navigation/AbstractNavigateToLibrarySourceTest.kt
+++ b/idea/tests/org/jetbrains/kotlin/idea/decompiler/navigation/AbstractNavigateToLibrarySourceTest.kt
@@ -18,16 +18,13 @@ package org.jetbrains.kotlin.idea.decompiler.navigation
 
 import com.intellij.openapi.roots.ProjectFileIndex
 import com.intellij.psi.PsiElement
+import com.intellij.psi.impl.source.resolve.reference.impl.PsiMultiReference
 import com.intellij.testFramework.LightProjectDescriptor
 import com.intellij.testFramework.UsefulTestCase
 import junit.framework.TestCase
-import org.jetbrains.kotlin.idea.test.JdkAndMockLibraryProjectDescriptor
-import org.jetbrains.kotlin.idea.test.KotlinCodeInsightTestCase
-import org.jetbrains.kotlin.idea.test.PluginTestCaseBase
 import org.jetbrains.kotlin.idea.navigation.NavigationTestUtils
 import org.jetbrains.kotlin.idea.references.JetReference
-import org.jetbrains.kotlin.idea.test.ModuleKind
-import org.jetbrains.kotlin.idea.test.configureAs
+import org.jetbrains.kotlin.idea.test.*
 import org.jetbrains.kotlin.test.JetTestUtils
 import java.io.File
 import java.util.LinkedHashMap
@@ -73,24 +70,30 @@ public abstract class AbstractNavigateToLibrarySourceTest : KotlinCodeInsightTes
         val referenceContainersToReferences = LinkedHashMap<PsiElement, JetReference>()
         for (offset in 0..psiFile.getTextLength() - 1) {
             val ref = psiFile.findReferenceAt(offset)
-            if (ref is JetReference && !referenceContainersToReferences.containsKey(ref.getElement())) {
-                val target = ref.resolve()
-                if (target == null) continue
-
-                val targetNavPsiFile = target.getNavigationElement().getContainingFile()
-                if (targetNavPsiFile == null) continue
-
-                val targetNavFile = targetNavPsiFile.getVirtualFile()
-                if (targetNavFile == null) continue
-
-                if (ProjectFileIndex.SERVICE.getInstance(getProject()).isInLibrarySource(targetNavFile)) {
-                    referenceContainersToReferences.put(ref.getElement(), ref)
-                }
+            val refs = when (ref) {
+                is JetReference -> listOf(ref)
+                is PsiMultiReference -> ref.getReferences().filterIsInstance<JetReference>()
+                else -> emptyList<JetReference>()
             }
+
+            refs.forEach { referenceContainersToReferences.addReference(it) }
         }
         return referenceContainersToReferences.values()
     }
 
+    private fun MutableMap<PsiElement, JetReference>.addReference(ref: JetReference) {
+        if (containsKey(ref.getElement())) return
+        val target = ref.resolve() ?: return
+
+        val targetNavPsiFile = target.getNavigationElement().getContainingFile() ?: return
+
+        val targetNavFile = targetNavPsiFile.getVirtualFile() ?: return
+
+        if (ProjectFileIndex.SERVICE.getInstance(getProject()).isInLibrarySource(targetNavFile)) {
+            put(ref.getElement(), ref)
+        }
+    }
+
     private fun collectInterestingNavigationElements() =
             collectInterestingReferences().map {
                 val target = it.resolve()
diff --git a/idea/tests/org/jetbrains/kotlin/idea/decompiler/navigation/NavigateFromLibrarySourcesTest.kt b/idea/tests/org/jetbrains/kotlin/idea/decompiler/navigation/NavigateFromLibrarySourcesTest.kt
index 936df14f82b..b4b1d85e043 100644
--- a/idea/tests/org/jetbrains/kotlin/idea/decompiler/navigation/NavigateFromLibrarySourcesTest.kt
+++ b/idea/tests/org/jetbrains/kotlin/idea/decompiler/navigation/NavigateFromLibrarySourcesTest.kt
@@ -55,7 +55,7 @@ public class NavigateFromLibrarySourcesTest: LightCodeInsightFixtureTestCase() {
         val lightClass = LightClassUtil.getPsiClass(navigationElement as JetClassOrObject)
         assertTrue(lightClass is KotlinLightClassForDecompiledDeclaration,
                    "Light classes for decompiled declaration should be provided for library source")
-        assertEquals("Foo", lightClass.getName())
+        assertEquals("Foo", lightClass!!.getName())
     }
 
     private fun checkNavigationFromLibrarySource(referenceText: String, targetFqName: String) {
diff --git a/idea/tests/org/jetbrains/kotlin/idea/decompiler/stubBuilder/AbstractClsStubBuilderTest.kt b/idea/tests/org/jetbrains/kotlin/idea/decompiler/stubBuilder/AbstractClsStubBuilderTest.kt
index 41d89651a87..89273d5637d 100644
--- a/idea/tests/org/jetbrains/kotlin/idea/decompiler/stubBuilder/AbstractClsStubBuilderTest.kt
+++ b/idea/tests/org/jetbrains/kotlin/idea/decompiler/stubBuilder/AbstractClsStubBuilderTest.kt
@@ -55,7 +55,7 @@ public abstract class AbstractClsStubBuilderTest : LightCodeInsightFixtureTestCa
     private fun getClassFileToDecompile(sourcePath: String): VirtualFile {
         val outDir = JetTestUtils.tmpDir("libForStubTest-" + sourcePath)
         MockLibraryUtil.compileKotlin(sourcePath, outDir)
-        val root = LocalFileSystem.getInstance().refreshAndFindFileByIoFile(outDir)
+        val root = LocalFileSystem.getInstance().refreshAndFindFileByIoFile(outDir)!!
         return root.findClassFileByName(lastSegment(sourcePath))
     }
 
diff --git a/idea/tests/org/jetbrains/kotlin/idea/decompiler/stubBuilder/ClsStubBuilderTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/decompiler/stubBuilder/ClsStubBuilderTestGenerated.java
index 269eb227ffb..d46059314e0 100644
--- a/idea/tests/org/jetbrains/kotlin/idea/decompiler/stubBuilder/ClsStubBuilderTestGenerated.java
+++ b/idea/tests/org/jetbrains/kotlin/idea/decompiler/stubBuilder/ClsStubBuilderTestGenerated.java
@@ -125,6 +125,12 @@ public class ClsStubBuilderTestGenerated extends AbstractClsStubBuilderTest {
         doTest(fileName);
     }
 
+    @TestMetadata("Sealed")
+    public void testSealed() throws Exception {
+        String fileName = JetTestUtils.navigationMetadata("idea/testData/decompiler/stubBuilder/Sealed/");
+        doTest(fileName);
+    }
+
     @TestMetadata("SecondaryConstructors")
     public void testSecondaryConstructors() throws Exception {
         String fileName = JetTestUtils.navigationMetadata("idea/testData/decompiler/stubBuilder/SecondaryConstructors/");
diff --git a/idea/tests/org/jetbrains/kotlin/idea/decompiler/stubBuilder/ClsStubConsistencyTest.kt b/idea/tests/org/jetbrains/kotlin/idea/decompiler/stubBuilder/ClsStubConsistencyTest.kt
index 882c9d2965f..54178930747 100644
--- a/idea/tests/org/jetbrains/kotlin/idea/decompiler/stubBuilder/ClsStubConsistencyTest.kt
+++ b/idea/tests/org/jetbrains/kotlin/idea/decompiler/stubBuilder/ClsStubConsistencyTest.kt
@@ -25,12 +25,8 @@ import org.jetbrains.kotlin.name.FqName
 import kotlin.properties.Delegates
 
 public class ClsStubConsistencyTest : StubConsistencyBaseTest() {
-
-    override val packages: List<FqName> = listOf(FqName("kotlin"))
-
-    override val virtualFileFinder: VirtualFileFinder by Delegates.lazy() {
-        JvmVirtualFileFinder.SERVICE.getInstance(getProject())
-    }
+    override fun getVirtualFileFinder(): VirtualFileFinder = JvmVirtualFileFinder.SERVICE.getInstance(getProject())
+    override fun getPackages(): List<FqName> = listOf(FqName("kotlin"))
 
     override fun createStubBuilder() = KotlinClsStubBuilder()
 
diff --git a/idea/tests/org/jetbrains/kotlin/idea/decompiler/stubBuilder/ClsStubForWrongAbiVersionTest.kt b/idea/tests/org/jetbrains/kotlin/idea/decompiler/stubBuilder/ClsStubForWrongAbiVersionTest.kt
index da40fdbf4f1..f10dc385560 100644
--- a/idea/tests/org/jetbrains/kotlin/idea/decompiler/stubBuilder/ClsStubForWrongAbiVersionTest.kt
+++ b/idea/tests/org/jetbrains/kotlin/idea/decompiler/stubBuilder/ClsStubForWrongAbiVersionTest.kt
@@ -29,7 +29,7 @@ class ClsStubBuilderForWrongAbiVersionTest : AbstractClsStubBuilderTest() {
     fun testClass() = testStubsForFileWithWrongAbiVersion("ClassWithWrongAbiVersion")
 
     private fun testStubsForFileWithWrongAbiVersion(className: String) {
-        val root = NavigateToDecompiledLibraryTest.findTestLibraryRoot(myModule!!)
+        val root = NavigateToDecompiledLibraryTest.findTestLibraryRoot(myModule!!)!!
         val result = root.findClassFileByName(className)
         testClsStubsForFile(result, null)
     }
diff --git a/idea/tests/org/jetbrains/kotlin/idea/decompiler/stubBuilder/KotlinJavaScriptStubConsistencyTest.kt b/idea/tests/org/jetbrains/kotlin/idea/decompiler/stubBuilder/KotlinJavaScriptStubConsistencyTest.kt
index 714f77616c4..b4fac01482e 100644
--- a/idea/tests/org/jetbrains/kotlin/idea/decompiler/stubBuilder/KotlinJavaScriptStubConsistencyTest.kt
+++ b/idea/tests/org/jetbrains/kotlin/idea/decompiler/stubBuilder/KotlinJavaScriptStubConsistencyTest.kt
@@ -16,6 +16,7 @@
 
 package org.jetbrains.kotlin.idea.decompiler.stubBuilder
 
+import com.intellij.openapi.Disposable
 import com.intellij.openapi.vfs.VirtualFile
 import org.jetbrains.kotlin.idea.decompiler.textBuilder.buildDecompiledTextFromJsMetadata
 import org.jetbrains.kotlin.idea.js.KotlinJavaScriptLibraryManager
@@ -26,19 +27,17 @@ import org.jetbrains.kotlin.name.FqName
 import kotlin.properties.Delegates
 
 public class KotlinJavaScriptStubConsistencyTest : StubConsistencyBaseTest() {
-
-    override val packages: List<FqName> = listOf(
-            "java.util", "jquery", "jquery.ui", "kotlin", "kotlin.browser", "kotlin.dom", "kotlin.js"
-    ).map { FqName(it) }
-
     override fun setUp() {
         super.setUp()
         KotlinJavaScriptLibraryManager.getInstance(getProject()).syncUpdateProjectLibrary()
     }
 
-    override val virtualFileFinder: VirtualFileFinder by Delegates.lazy() {
+    override fun getPackages(): List<FqName> = listOf(
+            "java.util", "jquery", "jquery.ui",
+            "kotlin", "kotlin.browser", "kotlin.dom", "kotlin.js").map { FqName(it) }
+
+    override fun getVirtualFileFinder(): VirtualFileFinder =
         JsVirtualFileFinder.SERVICE.getInstance(getProject())
-    }
 
     override fun createStubBuilder() = KotlinJavaScriptStubBuilder()
 
diff --git a/idea/tests/org/jetbrains/kotlin/idea/decompiler/stubBuilder/StubConsistencyBaseTest.kt b/idea/tests/org/jetbrains/kotlin/idea/decompiler/stubBuilder/StubConsistencyBaseTest.kt
index fef579eab6c..ce495ee3eb0 100644
--- a/idea/tests/org/jetbrains/kotlin/idea/decompiler/stubBuilder/StubConsistencyBaseTest.kt
+++ b/idea/tests/org/jetbrains/kotlin/idea/decompiler/stubBuilder/StubConsistencyBaseTest.kt
@@ -29,21 +29,20 @@ import org.junit.Assert
 
 public abstract class StubConsistencyBaseTest : JetLightCodeInsightFixtureTestCase() {
 
-    protected abstract val packages: List<FqName>
-
-    protected abstract val virtualFileFinder: VirtualFileFinder
+    protected abstract fun getPackages(): List<FqName>
+    protected abstract fun getVirtualFileFinder(): VirtualFileFinder
 
     protected abstract fun createStubBuilder(): ClsStubBuilder
 
     protected abstract fun getDecompiledText(packageFile: VirtualFile): String
 
     public fun testConsistency() {
-        packages.forEach { doTest(it) }
+        getPackages().forEach { doTest(it) }
     }
 
     private fun doTest(packageFqName: FqName) {
         val project = getProject()
-        val packageFile = virtualFileFinder.findVirtualFileWithHeader(PackageClassUtils.getPackageClassId(packageFqName))!!
+        val packageFile = getVirtualFileFinder().findVirtualFileWithHeader(PackageClassUtils.getPackageClassId(packageFqName))!!
         val decompiledText = getDecompiledText(packageFile)
         val fileWithDecompiledText = JetPsiFactory(project).createFile(decompiledText)
         val stubTreeFromDecompiledText = JetFileStubBuilder().buildStubTree(fileWithDecompiledText)
diff --git a/idea/tests/org/jetbrains/kotlin/idea/decompiler/textBuilder/DecompiledTextConsistencyTest.kt b/idea/tests/org/jetbrains/kotlin/idea/decompiler/textBuilder/DecompiledTextConsistencyTest.kt
index f8667e3ef5f..babe45bc035 100644
--- a/idea/tests/org/jetbrains/kotlin/idea/decompiler/textBuilder/DecompiledTextConsistencyTest.kt
+++ b/idea/tests/org/jetbrains/kotlin/idea/decompiler/textBuilder/DecompiledTextConsistencyTest.kt
@@ -29,13 +29,12 @@ import kotlin.properties.Delegates
 
 public class DecompiledTextConsistencyTest : TextConsistencyBaseTest() {
 
-    override val packages: List<FqName> = listOf(FqName("kotlin"))
+    override fun getPackages(): List<FqName> = listOf(FqName("kotlin"))
 
-    override val topLevelMembers: Map<String, String> = mapOf("kotlin" to "linkedListOf")
+    override fun getTopLevelMembers(): Map<String, String> = mapOf("kotlin" to "linkedListOf")
 
-    override val virtualFileFinder: VirtualFileFinder by Delegates.lazy() {
+    override fun getVirtualFileFinder(): VirtualFileFinder =
         JvmVirtualFileFinder.SERVICE.getInstance(getProject())
-    }
 
     override fun getDecompiledText(packageFile: VirtualFile, resolver: ResolverForDecompiler?): String =
             (resolver?.let { buildDecompiledText(packageFile, it) } ?: buildDecompiledText(packageFile)).text
diff --git a/idea/tests/org/jetbrains/kotlin/idea/decompiler/textBuilder/DecompiledTextForWrongAbiVersionTest.kt b/idea/tests/org/jetbrains/kotlin/idea/decompiler/textBuilder/DecompiledTextForWrongAbiVersionTest.kt
index 7c4bf7fd93f..a13d69e56aa 100644
--- a/idea/tests/org/jetbrains/kotlin/idea/decompiler/textBuilder/DecompiledTextForWrongAbiVersionTest.kt
+++ b/idea/tests/org/jetbrains/kotlin/idea/decompiler/textBuilder/DecompiledTextForWrongAbiVersionTest.kt
@@ -47,7 +47,7 @@ public class DecompiledTextForWrongAbiVersionTest : AbstractInternalCompiledClas
     fun testPackageFacadeWithWrongAbiVersion() = doTest("WrongPackage")
 
     fun doTest(name: String) {
-        val root = NavigateToDecompiledLibraryTest.findTestLibraryRoot(myModule!!)
+        val root = NavigateToDecompiledLibraryTest.findTestLibraryRoot(myModule!!)!!
         checkFileWithWrongAbiVersion(root.findClassFileByName(name))
     }
 
diff --git a/idea/tests/org/jetbrains/kotlin/idea/decompiler/textBuilder/KotlinJavaScriptDecompiledTextConsistencyTest.kt b/idea/tests/org/jetbrains/kotlin/idea/decompiler/textBuilder/KotlinJavaScriptDecompiledTextConsistencyTest.kt
index 20b3e408377..eeb1f24327a 100644
--- a/idea/tests/org/jetbrains/kotlin/idea/decompiler/textBuilder/KotlinJavaScriptDecompiledTextConsistencyTest.kt
+++ b/idea/tests/org/jetbrains/kotlin/idea/decompiler/textBuilder/KotlinJavaScriptDecompiledTextConsistencyTest.kt
@@ -30,19 +30,17 @@ import org.jetbrains.kotlin.test.JetTestUtils
 import org.jetbrains.kotlin.utils.KotlinJavascriptMetadataUtils
 import org.jetbrains.kotlin.utils.PathUtil
 import org.jetbrains.kotlin.utils.sure
+import java.util.*
 import kotlin.properties.Delegates
 
 public class KotlinJavaScriptDecompiledTextConsistencyTest : TextConsistencyBaseTest() {
-
-    override val packages: List<FqName> = listOf(
+    override fun getPackages(): List<FqName> = listOf(
             "java.util", "jquery", "jquery.ui", "kotlin", "kotlin.browser", "kotlin.dom", "kotlin.js"
     ).map { FqName(it) }
 
-    override val topLevelMembers: Map<String, String> = mapOf("kotlin" to "intArrayOf")
+    override fun getTopLevelMembers(): Map<String, String> = mapOf("kotlin" to "intArrayOf")
 
-    override val virtualFileFinder: VirtualFileFinder by Delegates.lazy() {
-        JsVirtualFileFinder.SERVICE.getInstance(getProject())
-    }
+    override fun getVirtualFileFinder(): VirtualFileFinder = JsVirtualFileFinder.SERVICE.getInstance(getProject())
 
     override fun setUp() {
         super.setUp()
diff --git a/idea/tests/org/jetbrains/kotlin/idea/decompiler/textBuilder/TextConsistencyBaseTest.kt b/idea/tests/org/jetbrains/kotlin/idea/decompiler/textBuilder/TextConsistencyBaseTest.kt
index bbffc933b16..a9f202f4dc6 100644
--- a/idea/tests/org/jetbrains/kotlin/idea/decompiler/textBuilder/TextConsistencyBaseTest.kt
+++ b/idea/tests/org/jetbrains/kotlin/idea/decompiler/textBuilder/TextConsistencyBaseTest.kt
@@ -34,27 +34,27 @@ import org.junit.Assert
 
 public abstract class TextConsistencyBaseTest : JetLightCodeInsightFixtureTestCase() {
 
-    protected abstract val packages: List<FqName>
+    protected abstract fun getPackages(): List<FqName>
 
-    protected abstract val topLevelMembers: Map<String, String>
+    protected abstract fun getTopLevelMembers(): Map<String, String>
 
-    protected abstract val virtualFileFinder: VirtualFileFinder
+    protected abstract fun getVirtualFileFinder(): VirtualFileFinder
 
     protected abstract fun getDecompiledText(packageFile: VirtualFile, resolver: ResolverForDecompiler? = null): String
 
     protected abstract fun getModuleDescriptor(): ModuleDescriptor
 
     public fun testConsistency() {
-        packages.forEach { doTest(it) }
+        getPackages().forEach { doTest(it) }
     }
 
     private fun doTest(packageFqName: FqName) {
-        val packageFile = virtualFileFinder.findVirtualFileWithHeader(PackageClassUtils.getPackageClassId(packageFqName))!!
+        val packageFile = getVirtualFileFinder().findVirtualFileWithHeader(PackageClassUtils.getPackageClassId(packageFqName))!!
         val projectBasedText = getDecompiledText(packageFile, ResolverForDecompilerImpl(getModuleDescriptor()))
         val deserializedText = getDecompiledText(packageFile)
         Assert.assertEquals(projectBasedText, deserializedText)
         // sanity checks
-        topLevelMembers[packageFqName.asString()]?.let {
+        getTopLevelMembers()[packageFqName.asString()]?.let {
             Assert.assertTrue(projectBasedText.contains(it))
         }
         Assert.assertFalse(projectBasedText.contains("ERROR"))
diff --git a/idea/tests/org/jetbrains/kotlin/idea/filters/JetExceptionFilterTest.kt b/idea/tests/org/jetbrains/kotlin/idea/filters/JetExceptionFilterTest.kt
index 69f5885a0bd..da9edf459f0 100644
--- a/idea/tests/org/jetbrains/kotlin/idea/filters/JetExceptionFilterTest.kt
+++ b/idea/tests/org/jetbrains/kotlin/idea/filters/JetExceptionFilterTest.kt
@@ -87,21 +87,26 @@ public class JetExceptionFilterTest : MultiFileTestCase() {
             VfsUtilCore.findRelativeFile(relativePath, rootDir);
         }
         TestCase.assertNotNull(expectedFile)
+        expectedFile!!
 
         val line = createStackTraceElementLine(linePrefix, relativePath, className(expectedFile), lineNumber)
         val result = filter.applyFilter(line, 0)
 
         TestCase.assertNotNull(result)
+        result!!
         val info = result.getFirstHyperlinkInfo()
         TestCase.assertNotNull(info)
         info as FileHyperlinkInfo
         val descriptor = info.getDescriptor()
         TestCase.assertNotNull(descriptor)
+        descriptor!!
 
         TestCase.assertEquals(expectedFile, descriptor.getFile())
 
         val document = FileDocumentManager.getInstance().getDocument(expectedFile)
         TestCase.assertNotNull(document)
+        document!!
+
         val expectedOffset = document.getLineStartOffset(lineNumber - 1)
         TestCase.assertEquals(expectedOffset, descriptor.getOffset())
     }
diff --git a/idea/tests/org/jetbrains/kotlin/idea/hierarchy/HierarchyTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/hierarchy/HierarchyTestGenerated.java
index 5ee8df26e60..9822367de34 100644
--- a/idea/tests/org/jetbrains/kotlin/idea/hierarchy/HierarchyTestGenerated.java
+++ b/idea/tests/org/jetbrains/kotlin/idea/hierarchy/HierarchyTestGenerated.java
@@ -358,6 +358,12 @@ public class HierarchyTestGenerated extends AbstractHierarchyTest {
             doCallerHierarchyTest(fileName);
         }
 
+        @TestMetadata("kotlinPrimaryConstructorImplicitCalls")
+        public void testKotlinPrimaryConstructorImplicitCalls() throws Exception {
+            String fileName = JetTestUtils.navigationMetadata("idea/testData/hierarchy/calls/callers/kotlinPrimaryConstructorImplicitCalls/");
+            doCallerHierarchyTest(fileName);
+        }
+
         @TestMetadata("kotlinPrivateClass")
         public void testKotlinPrivateClass() throws Exception {
             String fileName = JetTestUtils.navigationMetadata("idea/testData/hierarchy/calls/callers/kotlinPrivateClass/");
@@ -388,6 +394,12 @@ public class HierarchyTestGenerated extends AbstractHierarchyTest {
             doCallerHierarchyTest(fileName);
         }
 
+        @TestMetadata("kotlinSecondaryConstructorImplicitCalls")
+        public void testKotlinSecondaryConstructorImplicitCalls() throws Exception {
+            String fileName = JetTestUtils.navigationMetadata("idea/testData/hierarchy/calls/callers/kotlinSecondaryConstructorImplicitCalls/");
+            doCallerHierarchyTest(fileName);
+        }
+
         @TestMetadata("kotlinUnresolvedFunction")
         public void testKotlinUnresolvedFunction() throws Exception {
             String fileName = JetTestUtils.navigationMetadata("idea/testData/hierarchy/calls/callers/kotlinUnresolvedFunction/");
diff --git a/idea/tests/org/jetbrains/kotlin/idea/highlighter/AbstractUsageHighlightingTest.kt b/idea/tests/org/jetbrains/kotlin/idea/highlighter/AbstractUsageHighlightingTest.kt
new file mode 100644
index 00000000000..73a6015a33f
--- /dev/null
+++ b/idea/tests/org/jetbrains/kotlin/idea/highlighter/AbstractUsageHighlightingTest.kt
@@ -0,0 +1,68 @@
+/*
+ * Copyright 2010-2015 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.kotlin.idea.highlighter
+
+import com.intellij.codeInsight.daemon.impl.HighlightInfo
+import com.intellij.codeInsight.daemon.impl.HighlightInfoType
+import com.intellij.codeInsight.highlighting.actions.HighlightUsagesAction
+import com.intellij.openapi.command.WriteCommandAction
+import com.intellij.testFramework.ExpectedHighlightingData
+import org.jetbrains.kotlin.idea.test.JetLightCodeInsightFixtureTestCase
+import org.jetbrains.kotlin.idea.test.JetLightProjectDescriptor
+
+public abstract class AbstractUsageHighlightingTest: JetLightCodeInsightFixtureTestCase() {
+    companion object {
+        // Not standard <caret> to leave it in text after configureByFile and remove manually after collecting highlighting information
+        val CARET_TAG = "~"
+    }
+
+    protected fun doTest(filePath: String) {
+        myFixture.configureByFile(filePath)
+        val document = myFixture.getEditor().getDocument()
+        val data = ExpectedHighlightingData(document, false, false, true, false, myFixture.getFile())
+        data.init()
+
+        val caret = document.getText().indexOf(CARET_TAG)
+        assert(caret != -1, "Caret marker '$CARET_TAG' expected")
+
+        WriteCommandAction.runWriteCommandAction(myFixture.getProject()) {
+            document.deleteString(caret, caret + CARET_TAG.length())
+        }
+
+        getEditor().getCaretModel().moveToOffset(caret)
+
+        myFixture.testAction(HighlightUsagesAction())
+        val highlighters = myFixture.getEditor().getMarkupModel().getAllHighlighters()
+
+        val infos = highlighters.map { highlighter ->
+            var startOffset = highlighter.getStartOffset()
+            var endOffset = highlighter.getEndOffset()
+
+            if (startOffset > caret) startOffset += CARET_TAG.length()
+            if (endOffset > caret) endOffset += CARET_TAG.length()
+
+            HighlightInfo.newHighlightInfo(HighlightInfoType.INFORMATION).range(startOffset, endOffset).create()
+        }
+
+        data.checkResult(infos, StringBuilder(document.getText()).insert(caret, CARET_TAG).toString())
+    }
+
+
+
+    override fun getProjectDescriptor() = JetLightProjectDescriptor.INSTANCE
+    override fun getTestDataPath() = ""
+}
diff --git a/idea/tests/org/jetbrains/kotlin/idea/highlighter/UsageHighlightingTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/highlighter/UsageHighlightingTestGenerated.java
new file mode 100644
index 00000000000..ddc2363033f
--- /dev/null
+++ b/idea/tests/org/jetbrains/kotlin/idea/highlighter/UsageHighlightingTestGenerated.java
@@ -0,0 +1,43 @@
+/*
+ * Copyright 2010-2015 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.kotlin.idea.highlighter;
+
+import com.intellij.testFramework.TestDataPath;
+import org.jetbrains.kotlin.test.JUnit3RunnerWithInners;
+import org.jetbrains.kotlin.test.JetTestUtils;
+import org.jetbrains.kotlin.test.TestMetadata;
+import org.junit.runner.RunWith;
+
+import java.io.File;
+import java.util.regex.Pattern;
+
+/** This class is generated by {@link org.jetbrains.kotlin.generators.tests.TestsPackage}. DO NOT MODIFY MANUALLY */
+@SuppressWarnings("all")
+@TestMetadata("idea/testData/usageHighlighter")
+@TestDataPath("$PROJECT_ROOT")
+@RunWith(JUnit3RunnerWithInners.class)
+public class UsageHighlightingTestGenerated extends AbstractUsageHighlightingTest {
+    public void testAllFilesPresentInUsageHighlighter() throws Exception {
+        JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("idea/testData/usageHighlighter"), Pattern.compile("^(.+)\\.kt$"), true);
+    }
+
+    @TestMetadata("localVal.kt")
+    public void testLocalVal() throws Exception {
+        String fileName = JetTestUtils.navigationMetadata("idea/testData/usageHighlighter/localVal.kt");
+        doTest(fileName);
+    }
+}
diff --git a/idea/tests/org/jetbrains/kotlin/idea/intentions/IntentionTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/intentions/IntentionTestGenerated.java
index ab1120754ac..393dfac7e67 100644
--- a/idea/tests/org/jetbrains/kotlin/idea/intentions/IntentionTestGenerated.java
+++ b/idea/tests/org/jetbrains/kotlin/idea/intentions/IntentionTestGenerated.java
@@ -7496,4 +7496,103 @@ public class IntentionTestGenerated extends AbstractIntentionTest {
             doTest(fileName);
         }
     }
+
+    @TestMetadata("idea/testData/intentions/usePropertyAccessSyntax")
+    @TestDataPath("$PROJECT_ROOT")
+    @RunWith(JUnit3RunnerWithInners.class)
+    public static class UsePropertyAccessSyntax extends AbstractIntentionTest {
+        @TestMetadata("accessThroughKotlinClassInstance.kt")
+        public void testAccessThroughKotlinClassInstance() throws Exception {
+            String fileName = JetTestUtils.navigationMetadata("idea/testData/intentions/usePropertyAccessSyntax/accessThroughKotlinClassInstance.kt");
+            doTest(fileName);
+        }
+
+        @TestMetadata("accessThroughKotlinClassInstanceWithOverride.kt")
+        public void testAccessThroughKotlinClassInstanceWithOverride() throws Exception {
+            String fileName = JetTestUtils.navigationMetadata("idea/testData/intentions/usePropertyAccessSyntax/accessThroughKotlinClassInstanceWithOverride.kt");
+            doTest(fileName);
+        }
+
+        public void testAllFilesPresentInUsePropertyAccessSyntax() throws Exception {
+            JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("idea/testData/intentions/usePropertyAccessSyntax"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), true);
+        }
+
+        @TestMetadata("conflict1.kt")
+        public void testConflict1() throws Exception {
+            String fileName = JetTestUtils.navigationMetadata("idea/testData/intentions/usePropertyAccessSyntax/conflict1.kt");
+            doTest(fileName);
+        }
+
+        @TestMetadata("conflict2.kt")
+        public void testConflict2() throws Exception {
+            String fileName = JetTestUtils.navigationMetadata("idea/testData/intentions/usePropertyAccessSyntax/conflict2.kt");
+            doTest(fileName);
+        }
+
+        @TestMetadata("genericClassMethod.kt")
+        public void testGenericClassMethod() throws Exception {
+            String fileName = JetTestUtils.navigationMetadata("idea/testData/intentions/usePropertyAccessSyntax/genericClassMethod.kt");
+            doTest(fileName);
+        }
+
+        @TestMetadata("get.kt")
+        public void testGet() throws Exception {
+            String fileName = JetTestUtils.navigationMetadata("idea/testData/intentions/usePropertyAccessSyntax/get.kt");
+            doTest(fileName);
+        }
+
+        @TestMetadata("getImplicitReceiver.kt")
+        public void testGetImplicitReceiver() throws Exception {
+            String fileName = JetTestUtils.navigationMetadata("idea/testData/intentions/usePropertyAccessSyntax/getImplicitReceiver.kt");
+            doTest(fileName);
+        }
+
+        @TestMetadata("getSafeCall.kt")
+        public void testGetSafeCall() throws Exception {
+            String fileName = JetTestUtils.navigationMetadata("idea/testData/intentions/usePropertyAccessSyntax/getSafeCall.kt");
+            doTest(fileName);
+        }
+
+        @TestMetadata("isGet.kt")
+        public void testIsGet() throws Exception {
+            String fileName = JetTestUtils.navigationMetadata("idea/testData/intentions/usePropertyAccessSyntax/isGet.kt");
+            doTest(fileName);
+        }
+
+        @TestMetadata("isSet.kt")
+        public void testIsSet() throws Exception {
+            String fileName = JetTestUtils.navigationMetadata("idea/testData/intentions/usePropertyAccessSyntax/isSet.kt");
+            doTest(fileName);
+        }
+
+        @TestMetadata("set.kt")
+        public void testSet() throws Exception {
+            String fileName = JetTestUtils.navigationMetadata("idea/testData/intentions/usePropertyAccessSyntax/set.kt");
+            doTest(fileName);
+        }
+
+        @TestMetadata("setImplicitReceiver.kt")
+        public void testSetImplicitReceiver() throws Exception {
+            String fileName = JetTestUtils.navigationMetadata("idea/testData/intentions/usePropertyAccessSyntax/setImplicitReceiver.kt");
+            doTest(fileName);
+        }
+
+        @TestMetadata("setSafeCall.kt")
+        public void testSetSafeCall() throws Exception {
+            String fileName = JetTestUtils.navigationMetadata("idea/testData/intentions/usePropertyAccessSyntax/setSafeCall.kt");
+            doTest(fileName);
+        }
+
+        @TestMetadata("smartCast.kt")
+        public void testSmartCast() throws Exception {
+            String fileName = JetTestUtils.navigationMetadata("idea/testData/intentions/usePropertyAccessSyntax/smartCast.kt");
+            doTest(fileName);
+        }
+
+        @TestMetadata("superCall.kt")
+        public void testSuperCall() throws Exception {
+            String fileName = JetTestUtils.navigationMetadata("idea/testData/intentions/usePropertyAccessSyntax/superCall.kt");
+            doTest(fileName);
+        }
+    }
 }
diff --git a/idea/tests/org/jetbrains/kotlin/idea/javaFacade/JetJavaFacadeTest.java b/idea/tests/org/jetbrains/kotlin/idea/javaFacade/JetJavaFacadeTest.java
index 9d51a2cdad4..f41d01efdbd 100644
--- a/idea/tests/org/jetbrains/kotlin/idea/javaFacade/JetJavaFacadeTest.java
+++ b/idea/tests/org/jetbrains/kotlin/idea/javaFacade/JetJavaFacadeTest.java
@@ -27,7 +27,6 @@ import org.jetbrains.kotlin.asJava.LightClassUtil;
 import org.jetbrains.kotlin.idea.test.JetLightCodeInsightFixtureTestCase;
 import org.jetbrains.kotlin.idea.test.JetLightProjectDescriptor;
 import org.jetbrains.kotlin.idea.test.PluginTestCaseBase;
-import org.jetbrains.kotlin.load.java.JvmAbi;
 import org.jetbrains.kotlin.name.SpecialNames;
 import org.jetbrains.kotlin.psi.*;
 
@@ -199,14 +198,6 @@ public class JetJavaFacadeTest extends JetLightCodeInsightFixtureTestCase {
         assertTrue(instance.hasModifierProperty(PsiModifier.STATIC));
         assertTrue(instance.hasModifierProperty(PsiModifier.FINAL));
 
-        PsiField deprecatedAccessor = theClass.findFieldByName(JvmAbi.DEPRECATED_COMPANION_OBJECT_FIELD, false);
-        assertNotNull(deprecatedAccessor);
-        assertEquals("foo.TheClass." + defaultCompanionObjectName, deprecatedAccessor.getType().getCanonicalText());
-        assertTrue(deprecatedAccessor.hasModifierProperty(PsiModifier.PUBLIC));
-        assertTrue(deprecatedAccessor.hasModifierProperty(PsiModifier.STATIC));
-        assertTrue(deprecatedAccessor.hasModifierProperty(PsiModifier.FINAL));
-        assertTrue(deprecatedAccessor.isDeprecated());
-
         PsiMethod[] methods = classObjectClass.findMethodsByName("getOut", false);
 
         assertEquals("java.io.PrintStream", methods[0].getReturnType().getCanonicalText());
diff --git a/idea/tests/org/jetbrains/kotlin/idea/kdoc/KDocFinderTest.kt b/idea/tests/org/jetbrains/kotlin/idea/kdoc/KDocFinderTest.kt
index 33daa939643..df96bdc109d 100644
--- a/idea/tests/org/jetbrains/kotlin/idea/kdoc/KDocFinderTest.kt
+++ b/idea/tests/org/jetbrains/kotlin/idea/kdoc/KDocFinderTest.kt
@@ -33,7 +33,7 @@ public class KDocFinderTest() : LightPlatformCodeInsightFixtureTestCase() {
         myFixture.configureByFile(getTestName(false) + ".kt")
         val declaration = (myFixture.getFile() as JetFile).getDeclarations()[0]
         val descriptor = declaration.resolveToDescriptor() as ClassDescriptor
-        val constructorDescriptor = descriptor.getUnsubstitutedPrimaryConstructor()
+        val constructorDescriptor = descriptor.getUnsubstitutedPrimaryConstructor()!!
         val doc = KDocFinder.findKDoc(constructorDescriptor)
         Assert.assertEquals("Doc for constructor of class C.", doc!!.getContent())
     }
diff --git a/idea/tests/org/jetbrains/kotlin/idea/parameterInfo/FunctionParameterInfoTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/parameterInfo/FunctionParameterInfoTestGenerated.java
index e23191fe321..4df942d70a3 100644
--- a/idea/tests/org/jetbrains/kotlin/idea/parameterInfo/FunctionParameterInfoTestGenerated.java
+++ b/idea/tests/org/jetbrains/kotlin/idea/parameterInfo/FunctionParameterInfoTestGenerated.java
@@ -77,6 +77,12 @@ public class FunctionParameterInfoTestGenerated extends AbstractFunctionParamete
         doTest(fileName);
     }
 
+    @TestMetadata("NotAccessible.kt")
+    public void testNotAccessible() throws Exception {
+        String fileName = JetTestUtils.navigationMetadata("idea/testData/parameterInfo/functionParameterInfo/NotAccessible.kt");
+        doTest(fileName);
+    }
+
     @TestMetadata("NotGreen.kt")
     public void testNotGreen() throws Exception {
         String fileName = JetTestUtils.navigationMetadata("idea/testData/parameterInfo/functionParameterInfo/NotGreen.kt");
diff --git a/idea/tests/org/jetbrains/kotlin/idea/quickfix/AbstractQuickFixMultiFileTest.java b/idea/tests/org/jetbrains/kotlin/idea/quickfix/AbstractQuickFixMultiFileTest.java
index 694977bce05..ca35d7439d4 100644
--- a/idea/tests/org/jetbrains/kotlin/idea/quickfix/AbstractQuickFixMultiFileTest.java
+++ b/idea/tests/org/jetbrains/kotlin/idea/quickfix/AbstractQuickFixMultiFileTest.java
@@ -16,6 +16,7 @@
 
 package org.jetbrains.kotlin.idea.quickfix;
 
+import com.intellij.codeInsight.CodeInsightSettings;
 import com.intellij.codeInsight.daemon.impl.HighlightInfo;
 import com.intellij.codeInsight.daemon.quickFix.LightQuickFixTestCase;
 import com.intellij.codeInsight.intention.IntentionAction;
@@ -67,6 +68,18 @@ public abstract class AbstractQuickFixMultiFileTest extends KotlinDaemonAnalyzer
         doTest(beforeFileName, true);
     }
 
+    @Override
+    protected void setUp() throws Exception {
+        super.setUp();
+        CodeInsightSettings.getInstance().EXCLUDED_PACKAGES = new String[]{"excludedPackage", "somePackage.ExcludedClass"};
+    }
+
+    @Override
+    protected void tearDown() throws Exception {
+        CodeInsightSettings.getInstance().EXCLUDED_PACKAGES = ArrayUtil.EMPTY_STRING_ARRAY;
+        super.tearDown();
+    }
+
     private void doTest(final String beforeFileName, boolean withExtraFile) throws Exception {
         String testDataPath = getTestDataPath();
         File mainFile = new File(testDataPath + beforeFileName);
diff --git a/idea/tests/org/jetbrains/kotlin/idea/quickfix/DeprecatedInCompiledClassTest.kt b/idea/tests/org/jetbrains/kotlin/idea/quickfix/DeprecatedInCompiledClassTest.kt
new file mode 100644
index 00000000000..d6272ee856f
--- /dev/null
+++ b/idea/tests/org/jetbrains/kotlin/idea/quickfix/DeprecatedInCompiledClassTest.kt
@@ -0,0 +1,54 @@
+/*
+ * Copyright 2010-2015 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.kotlin.idea.quickfix;
+
+import com.intellij.testFramework.LightProjectDescriptor
+import com.intellij.testFramework.TestDataPath
+import org.jetbrains.kotlin.idea.test.JetLightCodeInsightFixtureTestCase
+import org.jetbrains.kotlin.idea.test.JetWithJdkAndRuntimeLightProjectDescriptor
+import org.jetbrains.kotlin.idea.util.application.executeWriteCommand
+import org.jetbrains.kotlin.idea.util.application.runWriteAction
+import org.jetbrains.kotlin.psi.JetSimpleNameExpression
+import org.jetbrains.kotlin.psi.psiUtil.parents
+import org.jetbrains.kotlin.test.JUnit3RunnerWithInners
+import org.jetbrains.kotlin.test.JetTestUtils
+import org.jetbrains.kotlin.test.TestMetadata
+import org.jetbrains.kotlin.utils.addToStdlib.firstIsInstance
+import org.junit.runner.RunWith
+
+TestMetadata("idea/testData/quickfix.special")
+TestDataPath("\$PROJECT_ROOT")
+RunWith(JUnit3RunnerWithInners::class)
+public class QuickFixSpecialTest : JetLightCodeInsightFixtureTestCase() {
+    override fun getTestDataPath() = JetTestUtils.getHomeDirectory()
+    override fun getProjectDescriptor() = JetWithJdkAndRuntimeLightProjectDescriptor.INSTANCE
+
+    TestMetadata("deprecatedMemberInCompiledClass.kt")
+    public fun testDeprecatedMemberInCompiledClass() {
+        val testPath = JetTestUtils.navigationMetadata("idea/testData/quickfix.special/deprecatedMemberInCompiledClass.kt")
+        myFixture.configureByFile(testPath)
+
+        val offset = getEditor().getCaretModel().getOffset()
+        val element = getFile().findElementAt(offset)
+        val nameExpression = element!!.parents.firstIsInstance<JetSimpleNameExpression>()
+        getProject().executeWriteCommand("") {
+            DeprecatedSymbolUsageFix(nameExpression, ReplaceWith("matches(input)")).invoke(getProject(), getEditor(), getFile())
+        }
+
+        myFixture.checkResultByFile("$testPath.after")
+    }
+}
diff --git a/idea/tests/org/jetbrains/kotlin/idea/quickfix/QuickFixMultiFileTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/quickfix/QuickFixMultiFileTestGenerated.java
index e69b13eae81..638f8cd5a74 100644
--- a/idea/tests/org/jetbrains/kotlin/idea/quickfix/QuickFixMultiFileTestGenerated.java
+++ b/idea/tests/org/jetbrains/kotlin/idea/quickfix/QuickFixMultiFileTestGenerated.java
@@ -185,6 +185,30 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes
             doTestWithExtraFile(fileName);
         }
 
+        @TestMetadata("noImportsForClassInExcludedPackage.before.Main.kt")
+        public void testNoImportsForClassInExcludedPackage() throws Exception {
+            String fileName = JetTestUtils.navigationMetadata("idea/testData/quickfix/autoImports/noImportsForClassInExcludedPackage.before.Main.kt");
+            doTestWithExtraFile(fileName);
+        }
+
+        @TestMetadata("noImportsForExcludedClass.before.Main.kt")
+        public void testNoImportsForExcludedClass() throws Exception {
+            String fileName = JetTestUtils.navigationMetadata("idea/testData/quickfix/autoImports/noImportsForExcludedClass.before.Main.kt");
+            doTestWithExtraFile(fileName);
+        }
+
+        @TestMetadata("noImportsForFunctionInExcludedPackage.before.Main.kt")
+        public void testNoImportsForFunctionInExcludedPackage() throws Exception {
+            String fileName = JetTestUtils.navigationMetadata("idea/testData/quickfix/autoImports/noImportsForFunctionInExcludedPackage.before.Main.kt");
+            doTestWithExtraFile(fileName);
+        }
+
+        @TestMetadata("notExcludedClass.before.Main.kt")
+        public void testNotExcludedClass() throws Exception {
+            String fileName = JetTestUtils.navigationMetadata("idea/testData/quickfix/autoImports/notExcludedClass.before.Main.kt");
+            doTestWithExtraFile(fileName);
+        }
+
         @TestMetadata("objectImport.before.Main.kt")
         public void testObjectImport() throws Exception {
             String fileName = JetTestUtils.navigationMetadata("idea/testData/quickfix/autoImports/objectImport.before.Main.kt");
@@ -250,6 +274,12 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
     public static class ChangeSignature extends AbstractQuickFixMultiFileTest {
+        @TestMetadata("addJavaMethodParameter.before.Main.kt")
+        public void testAddJavaMethodParameter() throws Exception {
+            String fileName = JetTestUtils.navigationMetadata("idea/testData/quickfix/changeSignature/addJavaMethodParameter.before.Main.kt");
+            doTestWithExtraFile(fileName);
+        }
+
         @TestMetadata("addParameterWithImport.before.Main.kt")
         public void testAddParameterWithImport() throws Exception {
             String fileName = JetTestUtils.navigationMetadata("idea/testData/quickfix/changeSignature/addParameterWithImport.before.Main.kt");
@@ -265,6 +295,12 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes
             String fileName = JetTestUtils.navigationMetadata("idea/testData/quickfix/changeSignature/matchFunctionLiteralWithSAMType.before.Main.kt");
             doTestWithExtraFile(fileName);
         }
+
+        @TestMetadata("removeJavaMethodParameter.before.Main.kt")
+        public void testRemoveJavaMethodParameter() throws Exception {
+            String fileName = JetTestUtils.navigationMetadata("idea/testData/quickfix/changeSignature/removeJavaMethodParameter.before.Main.kt");
+            doTestWithExtraFile(fileName);
+        }
     }
 
     @TestMetadata("idea/testData/quickfix/createFromUsage")
diff --git a/idea/tests/org/jetbrains/kotlin/idea/refactoring/changeSignature/JetChangeSignatureTest.java b/idea/tests/org/jetbrains/kotlin/idea/refactoring/changeSignature/JetChangeSignatureTest.java
index ee46b50d103..40f168a756c 100644
--- a/idea/tests/org/jetbrains/kotlin/idea/refactoring/changeSignature/JetChangeSignatureTest.java
+++ b/idea/tests/org/jetbrains/kotlin/idea/refactoring/changeSignature/JetChangeSignatureTest.java
@@ -22,27 +22,32 @@ import com.intellij.openapi.project.Project;
 import com.intellij.openapi.projectRoots.Sdk;
 import com.intellij.openapi.util.text.StringUtil;
 import com.intellij.psi.*;
+import com.intellij.psi.impl.java.stubs.index.JavaFullClassNameIndex;
 import com.intellij.psi.search.GlobalSearchScope;
 import com.intellij.refactoring.BaseRefactoringProcessor;
 import com.intellij.refactoring.changeSignature.ChangeSignatureProcessor;
 import com.intellij.refactoring.changeSignature.ParameterInfoImpl;
 import com.intellij.refactoring.changeSignature.ThrownExceptionInfo;
+import com.intellij.refactoring.util.CanonicalTypes;
 import com.intellij.refactoring.util.CommonRefactoringUtil;
 import com.intellij.util.ArrayUtil;
 import com.intellij.util.VisibilityUtil;
+import kotlin.KotlinPackage;
+import kotlin.jvm.functions.Function1;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
+import org.jetbrains.kotlin.asJava.AsJavaPackage;
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
-import org.jetbrains.kotlin.descriptors.FunctionDescriptor;
+import org.jetbrains.kotlin.descriptors.CallableDescriptor;
 import org.jetbrains.kotlin.descriptors.Visibilities;
 import org.jetbrains.kotlin.idea.caches.resolve.ResolvePackage;
 import org.jetbrains.kotlin.idea.refactoring.JetRefactoringBundle;
+import org.jetbrains.kotlin.idea.refactoring.changeSignature.ui.KotlinMethodNode;
+import org.jetbrains.kotlin.idea.stubindex.JetFullClassNameIndex;
+import org.jetbrains.kotlin.idea.stubindex.JetTopLevelFunctionFqnNameIndex;
 import org.jetbrains.kotlin.idea.test.DirectiveBasedActionUtils;
 import org.jetbrains.kotlin.idea.test.KotlinCodeInsightTestCase;
 import org.jetbrains.kotlin.idea.test.PluginTestCaseBase;
-import org.jetbrains.kotlin.psi.JetElement;
-import org.jetbrains.kotlin.psi.JetFile;
-import org.jetbrains.kotlin.psi.JetPsiFactory;
+import org.jetbrains.kotlin.psi.*;
 import org.jetbrains.kotlin.resolve.BindingContext;
 import org.jetbrains.kotlin.resolve.dataClassUtils.DataClassUtilsPackage;
 import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode;
@@ -544,7 +549,7 @@ public class JetChangeSignatureTest extends KotlinCodeInsightTestCase {
     public void testSAMChangeMethodReturnType() throws Exception {
         doJavaTest(
                 new JavaRefactoringProvider() {
-                    @Nullable
+                    @NotNull
                     @Override
                     PsiType getNewReturnType(@NotNull PsiMethod method) {
                         return PsiType.getJavaLangObject(getPsiManager(), GlobalSearchScope.allScope(getProject()));
@@ -567,7 +572,7 @@ public class JetChangeSignatureTest extends KotlinCodeInsightTestCase {
                         return newParameters;
                     }
 
-                    @Nullable
+                    @NotNull
                     @Override
                     PsiType getNewReturnType(@NotNull PsiMethod method) {
                         return factory.createTypeFromText("X<java.util.List<A>>", method);
@@ -975,10 +980,10 @@ public class JetChangeSignatureTest extends KotlinCodeInsightTestCase {
         doTest(changeInfo);
     }
 
-    public void testJavaMethodOverrides() throws Exception {
+    public void testJavaMethodOverridesReplaceParam() throws Exception {
         doJavaTest(
                 new JavaRefactoringProvider() {
-                    @Nullable
+                    @NotNull
                     @Override
                     PsiType getNewReturnType(@NotNull PsiMethod method) {
                         return PsiType.getJavaLangString(getPsiManager(), GlobalSearchScope.allScope(getProject()));
@@ -995,16 +1000,349 @@ public class JetChangeSignatureTest extends KotlinCodeInsightTestCase {
         );
     }
 
+    public void testJavaMethodOverridesChangeParam() throws Exception {
+        doJavaTest(
+                new JavaRefactoringProvider() {
+                    @NotNull
+                    @Override
+                    PsiType getNewReturnType(@NotNull PsiMethod method) {
+                        return PsiType.getJavaLangString(getPsiManager(), GlobalSearchScope.allScope(getProject()));
+                    }
+
+                    @NotNull
+                    @Override
+                    ParameterInfoImpl[] getNewParameters(@NotNull PsiMethod method) {
+                        ParameterInfoImpl[] newParameters = super.getNewParameters(method);
+                        newParameters[0].setName("x");
+                        newParameters[0].setType(PsiType.INT);
+                        return newParameters;
+                    }
+                }
+        );
+    }
+
+    public void testChangeProperty() throws Exception {
+        JetChangeInfo changeInfo = getChangeInfo();
+        changeInfo.setNewName("s");
+        changeInfo.setNewReturnTypeText("String");
+        doTest(changeInfo);
+    }
+
+    public void testAddPropertyReceiverConflict() throws Exception {
+        JetChangeInfo changeInfo = getChangeInfo();
+        JetParameterInfo newParameter = new JetParameterInfo(changeInfo.getMethodDescriptor().getBaseDescriptor(),
+                                                             -1, "receiver", KotlinBuiltIns.getInstance().getStringType(), null,
+                                                             new JetPsiFactory(getProject()).createExpression("\"\""), JetValVar.None, null);
+        changeInfo.setReceiverParameterInfo(newParameter);
+        doTestConflict(changeInfo);
+    }
+
+    public void testAddPropertyReceiver() throws Exception {
+        JetChangeInfo changeInfo = getChangeInfo();
+        JetParameterInfo newParameter = new JetParameterInfo(changeInfo.getMethodDescriptor().getBaseDescriptor(),
+                                                             -1, "receiver", KotlinBuiltIns.getInstance().getStringType(), null,
+                                                             new JetPsiFactory(getProject()).createExpression("\"\""), JetValVar.None, null);
+        changeInfo.setReceiverParameterInfo(newParameter);
+        doTest(changeInfo);
+    }
+
+    public void testChangePropertyReceiver() throws Exception {
+        JetChangeInfo changeInfo = getChangeInfo();
+        //noinspection ConstantConditions
+        changeInfo.getReceiverParameterInfo().setCurrentTypeText("Int");
+        doTest(changeInfo);
+    }
+
+    public void testRemovePropertyReceiver() throws Exception {
+        JetChangeInfo changeInfo = getChangeInfo();
+        changeInfo.setReceiverParameterInfo(null);
+        doTest(changeInfo);
+    }
+
+    public void testAddTopLevelPropertyReceiver() throws Exception {
+        JetChangeInfo changeInfo = getChangeInfo();
+        JetParameterInfo newParameter = new JetParameterInfo(changeInfo.getMethodDescriptor().getBaseDescriptor(),
+                                                             -1, "receiver", null, null,
+                                                             new JetPsiFactory(getProject()).createExpression("A()"), JetValVar.None, null);
+        newParameter.setCurrentTypeText("test.A");
+        changeInfo.setReceiverParameterInfo(newParameter);
+        doTest(changeInfo);
+    }
+
+    public void testChangeTopLevelPropertyReceiver() throws Exception {
+        JetChangeInfo changeInfo = getChangeInfo();
+        //noinspection ConstantConditions
+        changeInfo.getReceiverParameterInfo().setCurrentTypeText("String");
+        doTest(changeInfo);
+    }
+
+    public void testRemoveTopLevelPropertyReceiver() throws Exception {
+        JetChangeInfo changeInfo = getChangeInfo();
+        changeInfo.setReceiverParameterInfo(null);
+        doTest(changeInfo);
+    }
+
+    public void testChangeClassParameter() throws Exception {
+        JetChangeInfo changeInfo = getChangeInfo();
+        changeInfo.setNewName("s");
+        changeInfo.setNewReturnTypeText("String");
+        doTest(changeInfo);
+    }
+
+    public void testParameterPropagation() throws Exception {
+        JetChangeInfo changeInfo = getChangeInfo();
+
+        JetParameterInfo newParameter1 = new JetParameterInfo(changeInfo.getMethodDescriptor().getBaseDescriptor(),
+                                                             -1, "n", null, null,
+                                                             new JetPsiFactory(getProject()).createExpression("1"), JetValVar.None, null);
+        newParameter1.setCurrentTypeText("kotlin.Int");
+        changeInfo.addParameter(newParameter1);
+
+        JetParameterInfo newParameter2 = new JetParameterInfo(changeInfo.getMethodDescriptor().getBaseDescriptor(),
+                                                              -1, "s", null, null,
+                                                              new JetPsiFactory(getProject()).createExpression("\"abc\""), JetValVar.None, null);
+        newParameter2.setCurrentTypeText("kotlin.String");
+        changeInfo.addParameter(newParameter2);
+
+        JetClassOrObject classA =
+                JetFullClassNameIndex.getInstance().get("A", getProject(), GlobalSearchScope.allScope(getProject()))
+                        .iterator().next();
+        JetDeclaration functionBar = KotlinPackage.first(
+                classA.getDeclarations(),
+                new Function1<JetDeclaration, Boolean>() {
+                    @Override
+                    public Boolean invoke(JetDeclaration declaration) {
+                        return declaration instanceof JetNamedFunction && "bar".equals(declaration.getName());
+                    }
+                }
+        );
+        JetNamedFunction functionTest =
+                JetTopLevelFunctionFqnNameIndex.getInstance().get("test", getProject(), GlobalSearchScope.allScope(getProject()))
+                        .iterator().next();
+
+        changeInfo.setPrimaryPropagationTargets(Arrays.asList(functionBar, functionTest));
+
+        doTest(changeInfo);
+    }
+
+    public void testJavaParameterPropagation() throws Exception {
+        doJavaTest(
+                new JavaRefactoringProvider() {
+                    @NotNull
+                    @Override
+                    ParameterInfoImpl[] getNewParameters(@NotNull PsiMethod method) {
+                        return new ParameterInfoImpl[] {
+                                new ParameterInfoImpl(-1, "n", PsiType.INT, "1"),
+                                new ParameterInfoImpl(-1,
+                                                      "s",
+                                                      PsiType.getJavaLangString(getPsiManager(), GlobalSearchScope.allScope(getProject())),
+                                                      "\"abc\"")
+                        };
+                    }
+
+                    @NotNull
+                    @Override
+                    Set<PsiMethod> getParameterPropagationTargets(@NotNull PsiMethod method) {
+                        PsiClass classA = KotlinPackage.first(
+                                JavaFullClassNameIndex.getInstance()
+                                        .get("A".hashCode(), getProject(), GlobalSearchScope.allScope(getProject())),
+                                new Function1<PsiClass, Boolean>() {
+                                    @Override
+                                    public Boolean invoke(PsiClass aClass) {
+                                        return "A".equals(aClass.getName());
+                                    }
+                                }
+                        );
+                        PsiMethod methodBar = KotlinPackage.first(
+                                classA.getMethods(),
+                                new Function1<PsiMethod, Boolean>() {
+                                    @Override
+                                    public Boolean invoke(PsiMethod method) {
+                                        return "bar".equals(method.getName());
+                                    }
+                                }
+                        );
+                        JetNamedFunction functionTest =
+                                JetTopLevelFunctionFqnNameIndex.getInstance().get("test", getProject(), GlobalSearchScope.allScope(getProject()))
+                                        .iterator().next();
+
+                        return KotlinPackage.setOf(methodBar, AsJavaPackage.getRepresentativeLightMethod(functionTest));
+                    }
+                }
+        );
+    }
+
+    public void testPropagateWithParameterDuplication() throws Exception {
+        JetChangeInfo changeInfo = getChangeInfo();
+
+        JetParameterInfo newParameter = new JetParameterInfo(changeInfo.getMethodDescriptor().getBaseDescriptor(),
+                                                             -1, "n", KotlinBuiltIns.getInstance().getIntType(), null,
+                                                             new JetPsiFactory(getProject()).createExpression("1"), JetValVar.None, null);
+        changeInfo.addParameter(newParameter);
+
+        JetNamedFunction functionBar =
+                JetTopLevelFunctionFqnNameIndex.getInstance().get("bar", getProject(), GlobalSearchScope.allScope(getProject()))
+                        .iterator().next();
+
+        changeInfo.setPrimaryPropagationTargets(Collections.singletonList(functionBar));
+
+        doTestConflict(changeInfo);
+    }
+
+    public void testPropagateWithVariableDuplication() throws Exception {
+        JetChangeInfo changeInfo = getChangeInfo();
+
+        JetParameterInfo newParameter = new JetParameterInfo(changeInfo.getMethodDescriptor().getBaseDescriptor(),
+                                                             -1, "n", KotlinBuiltIns.getInstance().getIntType(), null,
+                                                             new JetPsiFactory(getProject()).createExpression("1"), JetValVar.None, null);
+        changeInfo.addParameter(newParameter);
+
+        JetNamedFunction functionBar =
+                JetTopLevelFunctionFqnNameIndex.getInstance().get("bar", getProject(), GlobalSearchScope.allScope(getProject()))
+                        .iterator().next();
+
+        changeInfo.setPrimaryPropagationTargets(Collections.singletonList(functionBar));
+
+        doTestConflict(changeInfo);
+    }
+
+    public void testPropagateWithThisQualificationInClassMember() throws Exception {
+        JetChangeInfo changeInfo = getChangeInfo();
+
+        JetParameterInfo newParameter = new JetParameterInfo(changeInfo.getMethodDescriptor().getBaseDescriptor(),
+                                                             -1, "n", KotlinBuiltIns.getInstance().getIntType(), null,
+                                                             new JetPsiFactory(getProject()).createExpression("1"), JetValVar.None, null);
+        changeInfo.addParameter(newParameter);
+
+        JetClassOrObject classA =
+                JetFullClassNameIndex.getInstance().get("A", getProject(), GlobalSearchScope.allScope(getProject()))
+                        .iterator().next();
+        JetDeclaration functionBar = KotlinPackage.first(
+                classA.getDeclarations(),
+                new Function1<JetDeclaration, Boolean>() {
+                    @Override
+                    public Boolean invoke(JetDeclaration declaration) {
+                        return declaration instanceof JetNamedFunction && "bar".equals(declaration.getName());
+                    }
+                }
+        );
+        changeInfo.setPrimaryPropagationTargets(Collections.singletonList(functionBar));
+
+        doTest(changeInfo);
+    }
+
+    public void testPropagateWithThisQualificationInExtension() throws Exception {
+        JetChangeInfo changeInfo = getChangeInfo();
+
+        JetParameterInfo newParameter = new JetParameterInfo(changeInfo.getMethodDescriptor().getBaseDescriptor(),
+                                                             -1, "n", KotlinBuiltIns.getInstance().getIntType(), null,
+                                                             new JetPsiFactory(getProject()).createExpression("1"), JetValVar.None, null);
+        changeInfo.addParameter(newParameter);
+
+        JetNamedFunction functionBar =
+                JetTopLevelFunctionFqnNameIndex.getInstance().get("bar", getProject(), GlobalSearchScope.allScope(getProject()))
+                        .iterator().next();
+
+        changeInfo.setPrimaryPropagationTargets(Collections.singletonList(functionBar));
+
+        doTest(changeInfo);
+    }
+
+    public void testJavaConstructorParameterPropagation() throws Exception {
+        doJavaTest(
+                new JavaRefactoringProvider() {
+                    @NotNull
+                    @Override
+                    ParameterInfoImpl[] getNewParameters(@NotNull PsiMethod method) {
+                        return new ParameterInfoImpl[] { new ParameterInfoImpl(-1, "n", PsiType.INT, "1") };
+                    }
+
+                    @NotNull
+                    @Override
+                    Set<PsiMethod> getParameterPropagationTargets(@NotNull PsiMethod method) {
+                        return findCallers(method);
+                    }
+                }
+        );
+    }
+
+    public void testPrimaryConstructorParameterPropagation() throws Exception {
+        JetChangeInfo changeInfo = getChangeInfo();
+
+        JetParameterInfo newParameter = new JetParameterInfo(changeInfo.getMethodDescriptor().getBaseDescriptor(),
+                                                             -1, "n", KotlinBuiltIns.getInstance().getIntType(), null,
+                                                             new JetPsiFactory(getProject()).createExpression("1"), JetValVar.None, null);
+        changeInfo.addParameter(newParameter);
+
+        PsiMethod constructor = AsJavaPackage.getRepresentativeLightMethod(changeInfo.getMethod());
+        assert constructor != null;
+        changeInfo.setPrimaryPropagationTargets(findCallers(constructor));
+
+        doTest(changeInfo);
+    }
+
+    public void testSecondaryConstructorParameterPropagation() throws Exception {
+        JetChangeInfo changeInfo = getChangeInfo();
+
+        JetParameterInfo newParameter = new JetParameterInfo(changeInfo.getMethodDescriptor().getBaseDescriptor(),
+                                                             -1, "n", KotlinBuiltIns.getInstance().getIntType(), null,
+                                                             new JetPsiFactory(getProject()).createExpression("1"), JetValVar.None, null);
+        changeInfo.addParameter(newParameter);
+
+        PsiMethod constructor = AsJavaPackage.getRepresentativeLightMethod(changeInfo.getMethod());
+        assert constructor != null;
+        changeInfo.setPrimaryPropagationTargets(findCallers(constructor));
+
+        doTest(changeInfo);
+    }
+
+    public void testJavaMethodOverridesOmitUnitType() throws Exception {
+        doJavaTest(new JavaRefactoringProvider());
+    }
+
+    private List<Editor> editors = null;
+
+    private static final String[] EXTENSIONS = {".kt", ".java"};
+
+    @Override
+    protected void setUp() throws Exception {
+        super.setUp();
+        editors = new ArrayList<Editor>();
+    }
+
+    @Override
+    protected void tearDown() throws Exception {
+        super.tearDown();
+        editors.clear();
+        editors = null;
+    }
+
+    @NotNull
+    private LinkedHashSet<PsiMethod> findCallers(@NotNull PsiMethod method) {
+        KotlinMethodNode rootNode =
+                new KotlinMethodNode(method,
+                                     new HashSet<PsiElement>(),
+                                     getProject(),
+                                     new Runnable() {
+                                         @Override
+                                         public void run() {
+
+                                         }
+                                     });
+        LinkedHashSet<PsiMethod> callers = new LinkedHashSet<PsiMethod>();
+        for (int i = 0; i < rootNode.getChildCount(); i++) {
+            PsiElement element = ((KotlinMethodNode) rootNode.getChildAt(i)).getMethod();
+            callers.addAll(AsJavaPackage.toLightMethods(element));
+        }
+        return callers;
+    }
+
     @NotNull
     @Override
     protected String getTestDataPath() {
         return new File(PluginTestCaseBase.getTestDataPathBase(), "/refactoring/changeSignature").getPath() + File.separator;
     }
 
-    private final List<Editor> editors = new ArrayList<Editor>();
-
-    private static final String[] EXTENSIONS = {".kt", ".java"};
-
     private void configureFiles() throws Exception {
         editors.clear();
 
@@ -1039,11 +1377,12 @@ public class JetChangeSignatureTest extends KotlinCodeInsightTestCase {
         PsiElement context = file.findElementAt(editor.getCaretModel().getOffset());
         assertNotNull(context);
 
-        FunctionDescriptor functionDescriptor = JetChangeSignatureHandler.findDescriptor(element, project, editor, bindingContext);
-        assertNotNull(functionDescriptor);
+        CallableDescriptor callableDescriptor = JetChangeSignatureHandler.Companion.findDescriptor(element, project, editor, bindingContext);
+        assertNotNull(callableDescriptor);
 
         return ChangeSignaturePackage.createChangeInfo(
-                project, functionDescriptor, JetChangeSignatureHandler.getConfiguration(), bindingContext, context);
+                project, callableDescriptor, JetChangeSignatureConfiguration.Empty.INSTANCE$, bindingContext, context
+        );
     }
 
     private class JavaRefactoringProvider {
@@ -1052,9 +1391,10 @@ public class JetChangeSignatureTest extends KotlinCodeInsightTestCase {
             return method.getName();
         }
 
-        @Nullable
+        @NotNull
         PsiType getNewReturnType(@NotNull PsiMethod method) {
-            return method.getReturnType();
+            PsiType type = method.getReturnType();
+            return type != null ? type : PsiType.VOID;
         }
 
         @NotNull
@@ -1068,6 +1408,11 @@ public class JetChangeSignatureTest extends KotlinCodeInsightTestCase {
             return parameterInfos;
         }
 
+        @NotNull
+        Set<PsiMethod> getParameterPropagationTargets(@NotNull PsiMethod method) {
+            return Collections.emptySet();
+        }
+
         @NotNull
         final ChangeSignatureProcessor getProcessor(@NotNull PsiMethod method) {
             return new ChangeSignatureProcessor(
@@ -1076,9 +1421,11 @@ public class JetChangeSignatureTest extends KotlinCodeInsightTestCase {
                     false,
                     VisibilityUtil.getVisibilityModifier(method.getModifierList()),
                     getNewName(method),
-                    getNewReturnType(method),
+                    CanonicalTypes.createTypeWrapper(getNewReturnType(method)),
                     getNewParameters(method),
-                    new ThrownExceptionInfo[0]);
+                    new ThrownExceptionInfo[0],
+                    getParameterPropagationTargets(method),
+                    Collections.<PsiMethod>emptySet());
         }
     }
 
diff --git a/idea/tests/org/jetbrains/kotlin/idea/refactoring/nameSuggester/JetNameSuggesterTest.kt b/idea/tests/org/jetbrains/kotlin/idea/refactoring/nameSuggester/JetNameSuggesterTest.kt
index af58246171e..b393f3bf470 100644
--- a/idea/tests/org/jetbrains/kotlin/idea/refactoring/nameSuggester/JetNameSuggesterTest.kt
+++ b/idea/tests/org/jetbrains/kotlin/idea/refactoring/nameSuggester/JetNameSuggesterTest.kt
@@ -68,8 +68,8 @@ public class JetNameSuggesterTest : LightCodeInsightFixtureTestCase() {
         val expectedResultText = JetTestUtils.getLastCommentInFile(file)
         try {
             JetRefactoringUtil.selectExpression(myFixture.getEditor(), file, object : JetRefactoringUtil.SelectExpressionCallback {
-                override fun run(expression: JetExpression) {
-                    val names = KotlinNameSuggester.suggestNamesByExpressionAndType(expression, expression.analyze(BodyResolveMode.PARTIAL), { true }, "value").sort()
+                override fun run(expression: JetExpression?) {
+                    val names = KotlinNameSuggester.suggestNamesByExpressionAndType(expression!!, expression.analyze(BodyResolveMode.PARTIAL), { true }, "value").sort()
                     val result = StringUtil.join(names, "\n").trim()
                     assertEquals(expectedResultText, result)
                 }
diff --git a/idea/tests/org/jetbrains/kotlin/idea/refactoring/rename/AbstractRenameTest.kt b/idea/tests/org/jetbrains/kotlin/idea/refactoring/rename/AbstractRenameTest.kt
index 0622cd4efc3..0dd94677975 100644
--- a/idea/tests/org/jetbrains/kotlin/idea/refactoring/rename/AbstractRenameTest.kt
+++ b/idea/tests/org/jetbrains/kotlin/idea/refactoring/rename/AbstractRenameTest.kt
@@ -42,6 +42,7 @@ import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 import org.jetbrains.kotlin.idea.caches.resolve.analyzeFullyAndGetResult
 import org.jetbrains.kotlin.idea.jsonUtils.getNullableString
 import org.jetbrains.kotlin.idea.jsonUtils.getString
+import org.jetbrains.kotlin.idea.references.mainReference
 import org.jetbrains.kotlin.idea.search.allScope
 import org.jetbrains.kotlin.idea.test.DirectiveBasedActionUtils
 import org.jetbrains.kotlin.idea.test.KotlinMultiFileTestCase
@@ -215,7 +216,7 @@ public abstract class AbstractRenameTest : KotlinMultiFileTestCase() {
             Assert.assertTrue("File '${mainFilePath}' should have package containing ${fqn}", fileFqn.isSubpackageOf(fqn))
 
             val packageSegment = jetFile.getPackageDirective()!!.getPackageNames()[fqn.pathSegments().size() - 1]
-            val segmentReference = packageSegment.getReference()!!
+            val segmentReference = packageSegment.mainReference
 
             val psiElement = segmentReference.resolve()!!
 
@@ -299,11 +300,7 @@ public abstract class AbstractRenameTest : KotlinMultiFileTestCase() {
 
 
 private  fun String.toClassId(): ClassId {
-    val lastSlash = lastIndexOf("/")
-    if (lastSlash == -1) {
-        throw IllegalArgumentException("Class id should contain slash: $this")
-    }
-    val relativeClassName = FqName(substring(lastSlash + 1))
-    val packageFqName = FqName(substring(0, lastSlash).replace('/', '.'))
+    val relativeClassName = FqName(substringAfterLast('/'))
+    val packageFqName = FqName(substringBeforeLast('/', "").replace('/', '.'))
     return ClassId(packageFqName, relativeClassName, false)
 }
diff --git a/idea/tests/org/jetbrains/kotlin/idea/refactoring/rename/RenameTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/refactoring/rename/RenameTestGenerated.java
index 536fce18bfd..05d62c0d780 100644
--- a/idea/tests/org/jetbrains/kotlin/idea/refactoring/rename/RenameTestGenerated.java
+++ b/idea/tests/org/jetbrains/kotlin/idea/refactoring/rename/RenameTestGenerated.java
@@ -370,4 +370,22 @@ public class RenameTestGenerated extends AbstractRenameTest {
         String fileName = JetTestUtils.navigationMetadata("idea/testData/refactoring/rename/renameUnaryMinus/unaryMinus.test");
         doTest(fileName);
     }
+
+    @TestMetadata("syntheticPropertyUsages1/renameGetMethod.test")
+    public void testSyntheticPropertyUsages1_RenameGetMethod() throws Exception {
+        String fileName = JetTestUtils.navigationMetadata("idea/testData/refactoring/rename/syntheticPropertyUsages1/renameGetMethod.test");
+        doTest(fileName);
+    }
+
+    @TestMetadata("syntheticPropertyUsages2/renameSetMethod.test")
+    public void testSyntheticPropertyUsages2_RenameSetMethod() throws Exception {
+        String fileName = JetTestUtils.navigationMetadata("idea/testData/refactoring/rename/syntheticPropertyUsages2/renameSetMethod.test");
+        doTest(fileName);
+    }
+
+    @TestMetadata("syntheticPropertyUsages3/renameSetMethod.test")
+    public void testSyntheticPropertyUsages3_RenameSetMethod() throws Exception {
+        String fileName = JetTestUtils.navigationMetadata("idea/testData/refactoring/rename/syntheticPropertyUsages3/renameSetMethod.test");
+        doTest(fileName);
+    }
 }
diff --git a/idea/tests/org/jetbrains/kotlin/idea/references/BuiltInsReferenceResolverTest.java b/idea/tests/org/jetbrains/kotlin/idea/references/BuiltInsReferenceResolverTest.java
index b660dc5e81f..7ad145cae5f 100644
--- a/idea/tests/org/jetbrains/kotlin/idea/references/BuiltInsReferenceResolverTest.java
+++ b/idea/tests/org/jetbrains/kotlin/idea/references/BuiltInsReferenceResolverTest.java
@@ -116,7 +116,7 @@ public class BuiltInsReferenceResolverTest extends ResolveTestCase {
     }
 
     private void doTest() throws Exception {
-        JetReference reference = (JetReference) configureByFile(getTestName(true) + ".kt");
+        PsiPolyVariantReference reference = (PsiPolyVariantReference) configureByFile(getTestName(true) + ".kt");
         PsiElement resolved = reference.resolve();
         assertNotNull(resolved);
         assertEquals(1, reference.multiResolve(false).length);
diff --git a/idea/tests/org/jetbrains/kotlin/idea/resolve/AbstractPartialBodyResolveTest.kt b/idea/tests/org/jetbrains/kotlin/idea/resolve/AbstractPartialBodyResolveTest.kt
index 58fb76b35b7..722ca5c1351 100644
--- a/idea/tests/org/jetbrains/kotlin/idea/resolve/AbstractPartialBodyResolveTest.kt
+++ b/idea/tests/org/jetbrains/kotlin/idea/resolve/AbstractPartialBodyResolveTest.kt
@@ -77,7 +77,7 @@ public abstract class AbstractPartialBodyResolveTest : JetLightCodeInsightFixtur
         }
         else {
             val offset = editor.getCaretModel().getOffset()
-            val element = file.findElementAt(offset)
+            val element = file.findElementAt(offset)!!
             element.getNonStrictParentOfType<JetSimpleNameExpression>() ?: error("No JetSimpleNameExpression at caret")
         }
 
diff --git a/idea/tests/org/jetbrains/kotlin/idea/resolve/AbstractReferenceResolveInLibrarySourcesTest.kt b/idea/tests/org/jetbrains/kotlin/idea/resolve/AbstractReferenceResolveInLibrarySourcesTest.kt
index a9becbfd00f..a4d38ec7450 100644
--- a/idea/tests/org/jetbrains/kotlin/idea/resolve/AbstractReferenceResolveInLibrarySourcesTest.kt
+++ b/idea/tests/org/jetbrains/kotlin/idea/resolve/AbstractReferenceResolveInLibrarySourcesTest.kt
@@ -34,7 +34,7 @@ public abstract class AbstractReferenceResolveInLibrarySourcesTest : JetLightCod
 
         fixture.configureByFile(path)
 
-        val expectedResolveData = AbstractReferenceResolveTest.readResolveData(fixture.getFile()!!.getText())
+        val expectedResolveData = AbstractReferenceResolveTest.readResolveData(fixture.getFile()!!.getText(), 0)
 
         val gotoData = NavigationTestUtils.invokeGotoImplementations(fixture.getEditor(), fixture.getFile())!!
         Assert.assertEquals("Single target expected for origianl file", 1, gotoData.targets.size())
diff --git a/idea/tests/org/jetbrains/kotlin/idea/resolve/AbstractReferenceResolveTest.java b/idea/tests/org/jetbrains/kotlin/idea/resolve/AbstractReferenceResolveTest.java
deleted file mode 100644
index 811a2fd490a..00000000000
--- a/idea/tests/org/jetbrains/kotlin/idea/resolve/AbstractReferenceResolveTest.java
+++ /dev/null
@@ -1,164 +0,0 @@
-/*
- * Copyright 2010-2015 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.kotlin.idea.resolve;
-
-import com.google.common.collect.Lists;
-import com.google.common.collect.Ordering;
-import com.intellij.psi.PsiElement;
-import com.intellij.psi.PsiPolyVariantReference;
-import com.intellij.psi.PsiReference;
-import com.intellij.psi.ResolveResult;
-import com.intellij.testFramework.LightProjectDescriptor;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.idea.test.JetWithJdkAndRuntimeLightProjectDescriptor;
-import org.jetbrains.kotlin.idea.test.KotlinLightPlatformCodeInsightFixtureTestCase;
-import org.jetbrains.kotlin.test.InTextDirectivesUtils;
-import org.jetbrains.kotlin.test.ReferenceUtils;
-import org.jetbrains.kotlin.test.util.UtilPackage;
-import org.junit.Assert;
-
-import java.util.List;
-
-public abstract class AbstractReferenceResolveTest extends KotlinLightPlatformCodeInsightFixtureTestCase {
-    public static class ExpectedResolveData {
-        private final Boolean shouldBeUnresolved;
-        private final String referenceToString;
-
-        public ExpectedResolveData(Boolean shouldBeUnresolved, String referenceToString) {
-            this.shouldBeUnresolved = shouldBeUnresolved;
-            this.referenceToString = referenceToString;
-        }
-
-        public boolean shouldBeUnresolved() {
-            return shouldBeUnresolved;
-        }
-
-        public String getReferenceString() {
-            return referenceToString;
-        }
-    }
-
-    public static final String MULTIRESOLVE = "MULTIRESOLVE";
-    public static final String REF_EMPTY = "REF_EMPTY";
-
-    protected void doTest(@NotNull String path) {
-        assert path.endsWith(".kt") : path;
-        UtilPackage.configureWithExtraFile(myFixture, path, ".Data");
-        performChecks();
-    }
-
-    protected void performChecks() {
-        if (InTextDirectivesUtils.isDirectiveDefined(myFixture.getFile().getText(), MULTIRESOLVE)) {
-            doMultiResolveTest();
-        }
-        else {
-            doSingleResolveTest();
-        }
-    }
-
-    protected void doSingleResolveTest() {
-        ExpectedResolveData expectedResolveData = readResolveData(myFixture.getFile().getText());
-
-        int offset = myFixture.getEditor().getCaretModel().getOffset();
-        PsiReference psiReference = myFixture.getFile().findReferenceAt(offset);
-
-        checkReferenceResolve(expectedResolveData, offset, psiReference);
-    }
-
-    protected void doMultiResolveTest() {
-        List<String> expectedReferences = ReferenceUtils.getExpectedReferences(myFixture.getFile().getText());
-
-        PsiReference psiReference = myFixture.getFile().findReferenceAt(myFixture.getEditor().getCaretModel().getOffset());
-
-        assertTrue(psiReference instanceof PsiPolyVariantReference);
-
-        PsiPolyVariantReference variantReference = (PsiPolyVariantReference) psiReference;
-
-        ResolveResult[] results = variantReference.multiResolve(true);
-
-        List<String> actualResolvedTo = Lists.newArrayList();
-        for (ResolveResult result : results) {
-            PsiElement resolvedToElement = result.getElement();
-            assertNotNull(resolvedToElement);
-
-            actualResolvedTo.add(ReferenceUtils.renderAsGotoImplementation(resolvedToElement));
-        }
-
-        assertOrderedEquals(Ordering.natural().sortedCopy(actualResolvedTo), Ordering.natural().sortedCopy(expectedReferences));
-    }
-
-    @NotNull
-    public static ExpectedResolveData readResolveData(String fileText) {
-        boolean shouldBeUnresolved = InTextDirectivesUtils.isDirectiveDefined(fileText, REF_EMPTY);
-        List<String> refs = ReferenceUtils.getExpectedReferences(fileText);
-
-        String referenceToString;
-        if (shouldBeUnresolved) {
-            Assert.assertTrue("REF: directives will be ignored for " + REF_EMPTY + " test: " + refs, refs.isEmpty());
-            referenceToString = "<empty>";
-        }
-        else {
-            assertTrue("Must be a single ref: " + refs + ".\n" +
-                       "Use " + MULTIRESOLVE + " if you need multiple refs\n" +
-                       "Use "+ REF_EMPTY + " for an unresolved reference",
-                       refs.size() == 1);
-            referenceToString = refs.get(0);
-            Assert.assertNotNull("Test data wasn't found, use \"// REF: \" directive", referenceToString);
-        }
-
-        return new ExpectedResolveData(shouldBeUnresolved, referenceToString);
-    }
-
-    public static void checkReferenceResolve(ExpectedResolveData expectedResolveData, int offset, PsiReference psiReference) {
-        if (psiReference != null) {
-            PsiElement resolvedTo = psiReference.resolve();
-            if (resolvedTo != null) {
-                String resolvedToElementStr = ReferenceUtils.renderAsGotoImplementation(resolvedTo);
-                String notEqualMessage = String.format("Found reference to '%s', but '%s' was expected",
-                                                       resolvedToElementStr, expectedResolveData.getReferenceString());
-                assertEquals(notEqualMessage, expectedResolveData.getReferenceString(), resolvedToElementStr);
-            }
-            else {
-                if (!expectedResolveData.shouldBeUnresolved()) {
-                    Assert.assertNull(
-                            String.format("Element %s wasn't resolved to anything, but %s was expected",
-                                          psiReference, expectedResolveData.getReferenceString()),
-                            expectedResolveData.getReferenceString());
-                }
-            }
-        }
-        else {
-            Assert.assertNull(
-                    String.format("No reference found at offset: %s, but one resolved to %s was expected",
-                                  offset, expectedResolveData.getReferenceString()),
-                    expectedResolveData.getReferenceString());
-        }
-    }
-
-    @Nullable
-    @Override
-    protected LightProjectDescriptor getProjectDescriptor() {
-        return JetWithJdkAndRuntimeLightProjectDescriptor.INSTANCE;
-    }
-
-    @NotNull
-    @Override
-    protected String getTestDataPath() {
-        return "./";
-    }
-}
diff --git a/idea/tests/org/jetbrains/kotlin/idea/resolve/AbstractReferenceResolveTest.kt b/idea/tests/org/jetbrains/kotlin/idea/resolve/AbstractReferenceResolveTest.kt
new file mode 100644
index 00000000000..6211bc78dcc
--- /dev/null
+++ b/idea/tests/org/jetbrains/kotlin/idea/resolve/AbstractReferenceResolveTest.kt
@@ -0,0 +1,151 @@
+/*
+ * Copyright 2010-2015 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.kotlin.idea.resolve
+
+import com.google.common.collect.Lists
+import com.google.common.collect.Ordering
+import com.intellij.psi.PsiPolyVariantReference
+import com.intellij.psi.PsiReference
+import com.intellij.testFramework.LightProjectDescriptor
+import com.intellij.testFramework.UsefulTestCase
+import com.intellij.util.PathUtil
+import org.jetbrains.kotlin.idea.test.JetWithJdkAndRuntimeLightProjectDescriptor
+import org.jetbrains.kotlin.idea.test.KotlinLightPlatformCodeInsightFixtureTestCase
+import org.jetbrains.kotlin.idea.test.PluginTestCaseBase
+import org.jetbrains.kotlin.test.InTextDirectivesUtils
+import org.jetbrains.kotlin.test.ReferenceUtils
+import org.jetbrains.kotlin.test.util.configureWithExtraFile
+import org.junit.Assert
+import kotlin.test.assertEquals
+import kotlin.test.assertNotNull
+import kotlin.test.assertNull
+import kotlin.test.assertTrue
+
+public abstract class AbstractReferenceResolveTest : KotlinLightPlatformCodeInsightFixtureTestCase() {
+    public class ExpectedResolveData(private val shouldBeUnresolved: Boolean?, public val referenceString: String) {
+
+        public fun shouldBeUnresolved(): Boolean {
+            return shouldBeUnresolved!!
+        }
+    }
+
+    protected open fun doTest(path: String) {
+        assert(path.endsWith(".kt")) { path }
+        myFixture.configureWithExtraFile(path, ".Data")
+        performChecks()
+    }
+
+    protected fun performChecks() {
+        if (InTextDirectivesUtils.isDirectiveDefined(myFixture.getFile().getText(), MULTIRESOLVE)) {
+            doMultiResolveTest()
+        }
+        else {
+            doSingleResolveTest()
+        }
+    }
+
+    protected fun doSingleResolveTest() {
+        forEachCaret { index, offset ->
+            val expectedResolveData = readResolveData(myFixture.getFile().getText(), index)
+            val psiReference = myFixture.getFile().findReferenceAt(offset)
+            checkReferenceResolve(expectedResolveData, offset, psiReference)
+        }
+    }
+
+    protected fun doMultiResolveTest() {
+        forEachCaret { index, offset ->
+            val expectedReferences = getExpectedReferences(myFixture.getFile().getText(), index)
+
+            val psiReference = myFixture.getFile().findReferenceAt(offset)
+            assertTrue(psiReference is PsiPolyVariantReference)
+            psiReference as PsiPolyVariantReference
+
+            val results = psiReference.multiResolve(true)
+
+            val actualResolvedTo = Lists.newArrayList<String>()
+            for (result in results) {
+                actualResolvedTo.add(ReferenceUtils.renderAsGotoImplementation(result.getElement()!!))
+            }
+
+            UsefulTestCase.assertOrderedEquals("Not matching for reference #$index", actualResolvedTo.sort(), expectedReferences.sort())
+        }
+    }
+
+    private fun forEachCaret(action: (index: Int, offset: Int) -> Unit) {
+        val offsets = myFixture.getEditor().getCaretModel().getAllCarets().map { it.getOffset() }
+        val singleCaret = offsets.size() == 1
+        for ((index, offset) in offsets.withIndex()) {
+            action(if (singleCaret) -1 else index + 1, offset)
+        }
+    }
+
+    override fun getProjectDescriptor(): LightProjectDescriptor? = JetWithJdkAndRuntimeLightProjectDescriptor.INSTANCE
+
+    override fun getTestDataPath() = "./"
+
+    companion object {
+        public val MULTIRESOLVE: String = "MULTIRESOLVE"
+        public val REF_EMPTY: String = "REF_EMPTY"
+
+        public fun readResolveData(fileText: String, index: Int): ExpectedResolveData {
+            val shouldBeUnresolved = InTextDirectivesUtils.isDirectiveDefined(fileText, REF_EMPTY)
+            val refs = getExpectedReferences(fileText, index)
+
+            val referenceToString: String
+            if (shouldBeUnresolved) {
+                Assert.assertTrue("REF: directives will be ignored for $REF_EMPTY test: $refs", refs.isEmpty())
+                referenceToString = "<empty>"
+            }
+            else {
+                assertTrue(refs.size() == 1, "Must be a single ref: $refs.\nUse $MULTIRESOLVE if you need multiple refs\nUse $REF_EMPTY for an unresolved reference")
+                referenceToString = refs.get(0)
+                Assert.assertNotNull("Test data wasn't found, use \"// REF: \" directive", referenceToString)
+            }
+
+            return ExpectedResolveData(shouldBeUnresolved, referenceToString)
+        }
+
+        // purpose of this helper is to deal with the case when navigation element is a file
+        // see ReferenceResolveInJavaTestGenerated.testPackageFacade()
+        private fun getExpectedReferences(text: String, index: Int): List<String> {
+            val prefix = if (index > 0) "// REF$index:" else "// REF:"
+            val prefixes = InTextDirectivesUtils.findLinesWithPrefixesRemoved(text, prefix)
+            return prefixes.map {
+                val replaced = it.replace("<test dir>", PluginTestCaseBase.getTestDataPathBase())
+                PathUtil.toSystemDependentName(replaced).replace("//", "/") //happens on Unix
+            }
+        }
+
+        public fun checkReferenceResolve(expectedResolveData: ExpectedResolveData, offset: Int, psiReference: PsiReference?) {
+            if (psiReference != null) {
+                val resolvedTo = psiReference.resolve()
+                if (resolvedTo != null) {
+                    val resolvedToElementStr = ReferenceUtils.renderAsGotoImplementation(resolvedTo)
+                    assertEquals(expectedResolveData.referenceString, resolvedToElementStr, "Found reference to '$resolvedToElementStr', but '${expectedResolveData.referenceString}' was expected")
+                }
+                else {
+                    if (!expectedResolveData.shouldBeUnresolved()) {
+                        assertNull(expectedResolveData.referenceString, "Element $psiReference wasn't resolved to anything, but ${expectedResolveData.referenceString} was expected")
+                    }
+                }
+            }
+            else {
+                assertNull(expectedResolveData.referenceString, "No reference found at offset: $offset, but one resolved to ${expectedResolveData.referenceString} was expected")
+            }
+        }
+    }
+}
diff --git a/idea/tests/org/jetbrains/kotlin/idea/resolve/PartialBodyResolveTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/resolve/PartialBodyResolveTestGenerated.java
index cb3f15221fb..a0a08e82022 100644
--- a/idea/tests/org/jetbrains/kotlin/idea/resolve/PartialBodyResolveTestGenerated.java
+++ b/idea/tests/org/jetbrains/kotlin/idea/resolve/PartialBodyResolveTestGenerated.java
@@ -65,6 +65,12 @@ public class PartialBodyResolveTestGenerated extends AbstractPartialBodyResolveT
         doTest(fileName);
     }
 
+    @TestMetadata("ClassInitializerHasNoValue.kt")
+    public void testClassInitializerHasNoValue() throws Exception {
+        String fileName = JetTestUtils.navigationMetadata("idea/testData/resolve/partialBodyResolve/ClassInitializerHasNoValue.kt");
+        doTest(fileName);
+    }
+
     @TestMetadata("DeclarationsBefore.kt")
     public void testDeclarationsBefore() throws Exception {
         String fileName = JetTestUtils.navigationMetadata("idea/testData/resolve/partialBodyResolve/DeclarationsBefore.kt");
diff --git a/idea/tests/org/jetbrains/kotlin/idea/resolve/ReferenceResolveInJavaTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/resolve/ReferenceResolveInJavaTestGenerated.java
index 2f28ae5f55d..4cf14ac99e5 100644
--- a/idea/tests/org/jetbrains/kotlin/idea/resolve/ReferenceResolveInJavaTestGenerated.java
+++ b/idea/tests/org/jetbrains/kotlin/idea/resolve/ReferenceResolveInJavaTestGenerated.java
@@ -77,12 +77,6 @@ public class ReferenceResolveInJavaTestGenerated extends AbstractReferenceResolv
         doTest(fileName);
     }
 
-    @TestMetadata("DeprecatedClassObjectField.java")
-    public void testDeprecatedClassObjectField() throws Exception {
-        String fileName = JetTestUtils.navigationMetadata("idea/testData/resolve/referenceInJava/DeprecatedClassObjectField.java");
-        doTest(fileName);
-    }
-
     @TestMetadata("EnumEntry.java")
     public void testEnumEntry() throws Exception {
         String fileName = JetTestUtils.navigationMetadata("idea/testData/resolve/referenceInJava/EnumEntry.java");
diff --git a/idea/tests/org/jetbrains/kotlin/idea/resolve/ReferenceResolveTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/resolve/ReferenceResolveTestGenerated.java
index 5c38f574575..afaea8b1dc3 100644
--- a/idea/tests/org/jetbrains/kotlin/idea/resolve/ReferenceResolveTestGenerated.java
+++ b/idea/tests/org/jetbrains/kotlin/idea/resolve/ReferenceResolveTestGenerated.java
@@ -347,6 +347,12 @@ public class ReferenceResolveTestGenerated extends AbstractReferenceResolveTest
         doTest(fileName);
     }
 
+    @TestMetadata("SyntheticProperty.kt")
+    public void testSyntheticProperty() throws Exception {
+        String fileName = JetTestUtils.navigationMetadata("idea/testData/resolve/references/SyntheticProperty.kt");
+        doTest(fileName);
+    }
+
     @TestMetadata("TypeParameterInAnonymousObject.kt")
     public void testTypeParameterInAnonymousObject() throws Exception {
         String fileName = JetTestUtils.navigationMetadata("idea/testData/resolve/references/TypeParameterInAnonymousObject.kt");
diff --git a/idea/tests/org/jetbrains/kotlin/idea/run/RunConfigurationTest.kt b/idea/tests/org/jetbrains/kotlin/idea/run/RunConfigurationTest.kt
index a56fa702f2c..506285369f9 100644
--- a/idea/tests/org/jetbrains/kotlin/idea/run/RunConfigurationTest.kt
+++ b/idea/tests/org/jetbrains/kotlin/idea/run/RunConfigurationTest.kt
@@ -20,6 +20,7 @@ import com.intellij.codeInsight.CodeInsightTestCase
 import com.intellij.execution.Executor
 import com.intellij.execution.Location
 import com.intellij.execution.PsiLocation
+import com.intellij.execution.RunManagerEx
 import com.intellij.execution.actions.ConfigurationContext
 import com.intellij.execution.configurations.JavaCommandLine
 import com.intellij.execution.configurations.JavaParameters
@@ -32,19 +33,20 @@ import com.intellij.openapi.module.Module
 import com.intellij.openapi.projectRoots.Sdk
 import com.intellij.openapi.roots.ModuleRootModificationUtil
 import com.intellij.openapi.vfs.VirtualFile
-import com.intellij.psi.PsiComment
-import com.intellij.psi.PsiDocumentManager
-import com.intellij.psi.PsiManager
+import com.intellij.psi.*
+import com.intellij.refactoring.RefactoringFactory
 import com.intellij.testFramework.MapDataContext
 import com.intellij.testFramework.PlatformTestCase
 import com.intellij.testFramework.PsiTestUtil
 import org.jetbrains.kotlin.idea.search.allScope
+import org.jetbrains.kotlin.idea.stubindex.JetFullClassNameIndex
 import org.jetbrains.kotlin.idea.stubindex.JetTopLevelFunctionFqnNameIndex
 import org.jetbrains.kotlin.idea.test.ConfigLibraryUtil
 import org.jetbrains.kotlin.idea.test.ConfigLibraryUtil.configureKotlinJsRuntimeAndSdk
 import org.jetbrains.kotlin.idea.test.ConfigLibraryUtil.configureKotlinRuntimeAndSdk
 import org.jetbrains.kotlin.idea.test.PluginTestCaseBase
 import org.jetbrains.kotlin.idea.util.application.runWriteAction
+import org.jetbrains.kotlin.psi.JetFunction
 import org.jetbrains.kotlin.psi.JetNamedDeclaration
 import org.jetbrains.kotlin.psi.JetTreeVisitorVoid
 import org.jetbrains.kotlin.psi.psiUtil.getStrictParentOfType
@@ -98,6 +100,32 @@ class RunConfigurationTest: CodeInsightTestCase() {
         doTest(ConfigLibraryUtil::configureKotlinJsRuntimeAndSdk)
     }
 
+    fun testUpdateOnClassRename() {
+        val createModuleResult = configureModule(moduleDirPath("module"), getTestProject().getBaseDir()!!)
+        ConfigLibraryUtil.configureKotlinRuntimeAndSdk(createModuleResult.module, PluginTestCaseBase.mockJdk())
+
+        val runConfiguration = createConfigurationFromObject("renameTest.Foo", save = true)
+
+        val obj = JetFullClassNameIndex.getInstance().get("renameTest.Foo", getTestProject(), getTestProject().allScope()).single()
+        val rename = RefactoringFactory.getInstance(getTestProject()).createRename(obj, "Bar")
+        rename.run()
+
+        Assert.assertEquals("renameTest.Bar", runConfiguration.MAIN_CLASS_NAME)
+    }
+
+    fun testUpdateOnPackageRename() {
+        val createModuleResult = configureModule(moduleDirPath("module"), getTestProject().getBaseDir()!!)
+        ConfigLibraryUtil.configureKotlinRuntimeAndSdk(createModuleResult.module, PluginTestCaseBase.mockJdk())
+
+        val runConfiguration = createConfigurationFromObject("renameTest.Foo", save = true)
+
+        val pkg = JavaPsiFacade.getInstance(getTestProject()).findPackage("renameTest")
+        val rename = RefactoringFactory.getInstance(getTestProject()).createRename(pkg, "afterRenameTest")
+        rename.run()
+
+        Assert.assertEquals("afterRenameTest.Foo", runConfiguration.MAIN_CLASS_NAME)
+    }
+
     private fun doTest(configureRuntime: (Module, Sdk) -> Unit) {
         val baseDir = getTestProject().getBaseDir()!!
         val createModuleResult = configureModule(moduleDirPath("module"), baseDir)
@@ -140,10 +168,24 @@ class RunConfigurationTest: CodeInsightTestCase() {
     private fun createConfigurationFromMain(mainFqn: String): JetRunConfiguration {
         val mainFunction = JetTopLevelFunctionFqnNameIndex.getInstance().get(mainFqn, getTestProject(), getTestProject().allScope()).first()
 
-        val dataContext = MapDataContext()
-        dataContext.put(Location.DATA_KEY, PsiLocation(getTestProject(), mainFunction))
+        return createConfigurationFromElement(mainFunction)
+    }
 
-        return ConfigurationContext.getFromContext(dataContext)!!.getConfiguration()!!.getConfiguration() as JetRunConfiguration
+    private fun createConfigurationFromObject(objectFqn: String, save: Boolean = false): JetRunConfiguration {
+        val obj = JetFullClassNameIndex.getInstance().get(objectFqn, getTestProject(), getTestProject().allScope()).single()
+        val mainFunction = obj.getDeclarations().single { it is JetFunction && it.getName() == "main" }
+        return createConfigurationFromElement(mainFunction, save)
+    }
+
+    private fun createConfigurationFromElement(element: PsiElement?, save: Boolean = false): JetRunConfiguration {
+        val dataContext = MapDataContext()
+        dataContext.put(Location.DATA_KEY, PsiLocation(getTestProject(), element))
+
+        val runnerAndConfigurationSettings = ConfigurationContext.getFromContext(dataContext)!!.getConfiguration()
+        if (save) {
+            RunManagerEx.getInstanceEx(myProject).setTemporaryConfiguration(runnerAndConfigurationSettings)
+        }
+        return runnerAndConfigurationSettings!!.getConfiguration() as JetRunConfiguration
     }
 
     private fun configureModule(moduleDir: String, outputParentDir: VirtualFile, configModule: Module = getModule()): CreateModuleResult {
diff --git a/idea/tests/org/jetbrains/kotlin/idea/stubs/ResolveByStubTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/stubs/ResolveByStubTestGenerated.java
index 6d52f481654..295e8ef3c35 100644
--- a/idea/tests/org/jetbrains/kotlin/idea/stubs/ResolveByStubTestGenerated.java
+++ b/idea/tests/org/jetbrains/kotlin/idea/stubs/ResolveByStubTestGenerated.java
@@ -79,6 +79,12 @@ public class ResolveByStubTestGenerated extends AbstractResolveByStubTest {
             doTest(fileName);
         }
 
+        @TestMetadata("TargetedAnnotation.kt")
+        public void testTargetedAnnotation() throws Exception {
+            String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/annotations/TargetedAnnotation.kt");
+            doTest(fileName);
+        }
+
         @TestMetadata("compiler/testData/loadJava/compiledKotlin/annotations/classMembers")
         @TestDataPath("$PROJECT_ROOT")
         @RunWith(JUnit3RunnerWithInners.class)
@@ -168,6 +174,12 @@ public class ResolveByStubTestGenerated extends AbstractResolveByStubTest {
                 doTest(fileName);
             }
 
+            @TestMetadata("DataClass.kt")
+            public void testDataClass() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/annotations/classes/DataClass.kt");
+                doTest(fileName);
+            }
+
             @TestMetadata("Deprecated.kt")
             public void testDeprecated() throws Exception {
                 String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/annotations/classes/Deprecated.kt");
diff --git a/idea/tests/org/jetbrains/kotlin/test/ReferenceUtils.java b/idea/tests/org/jetbrains/kotlin/test/ReferenceUtils.java
index 25070b8c380..647ebfdd9b4 100644
--- a/idea/tests/org/jetbrains/kotlin/test/ReferenceUtils.java
+++ b/idea/tests/org/jetbrains/kotlin/test/ReferenceUtils.java
@@ -21,17 +21,11 @@ import com.intellij.navigation.NavigationItem;
 import com.intellij.psi.PsiElement;
 import com.intellij.psi.PsiPackage;
 import com.intellij.psi.util.PsiTreeUtil;
-import com.intellij.util.PathUtil;
-import kotlin.KotlinPackage;
-import kotlin.jvm.functions.Function1;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.kotlin.idea.test.PluginTestCaseBase;
 import org.jetbrains.kotlin.psi.JetClass;
 import org.jetbrains.kotlin.psi.JetObjectDeclaration;
 import org.junit.Assert;
 
-import java.util.List;
-
 public final class ReferenceUtils {
     private ReferenceUtils() {
     }
@@ -60,18 +54,4 @@ public final class ReferenceUtils {
                ? presentableText
                : locationString + "." + presentableText;
     }
-
-    // purpose of this helper is to deal with the case when navigation element is a file
-    // see ReferenceResolveInJavaTestGenerated.testPackageFacade()
-    @NotNull
-    public static List<String> getExpectedReferences(@NotNull String text) {
-        List<String> prefixes = InTextDirectivesUtils.findLinesWithPrefixesRemoved(text, "// REF:");
-        return KotlinPackage.map(prefixes, new Function1<String, String>() {
-            @Override
-            public String invoke(String s) {
-                String replaced = s.replace("<test dir>", PluginTestCaseBase.getTestDataPathBase());
-                return PathUtil.toSystemDependentName(replaced).replace("//", "/"); //happens on Unix
-            }
-        });
-    }
 }
diff --git a/j2k/src/org/jetbrains/kotlin/j2k/AnnotationConverter.kt b/j2k/src/org/jetbrains/kotlin/j2k/AnnotationConverter.kt
index c23ed641926..cbfb430dce1 100644
--- a/j2k/src/org/jetbrains/kotlin/j2k/AnnotationConverter.kt
+++ b/j2k/src/org/jetbrains/kotlin/j2k/AnnotationConverter.kt
@@ -48,7 +48,7 @@ class AnnotationConverter(private val converter: Converter) {
                 if (child is PsiWhiteSpace) !child.isInSingleLine() else false
             }
 
-            annotations.map { convertAnnotation(it, owner is PsiLocalVariable, newLines) }.filterNotNull() //TODO: brackets are also needed for local classes
+            annotations.map { convertAnnotation(it, withAt = owner is PsiLocalVariable, newLineAfter = newLines) }.filterNotNull() //TODO: '@' is also needed for local classes
         }
         else {
             listOf()
@@ -70,14 +70,14 @@ class AnnotationConverter(private val converter: Converter) {
             LiteralExpression("\"" + StringUtil.escapeStringCharacters(deprecatedTag.content()) + "\"").assignNoPrototype()
         }
         return Annotation(Identifier("deprecated").assignPrototype(deprecatedTag.getNameElement()),
-                          listOf(null to deferredExpression), false, true)
+                          listOf(null to deferredExpression), withAt = false, newLineAfter = true)
                 .assignPrototype(deprecatedTag)
     }
 
     private fun convertModifiersToAnnotations(owner: PsiModifierListOwner): Annotations {
         val list = MODIFIER_TO_ANNOTATION
                 .filter { owner.hasModifierProperty(it.first) }
-                .map { Annotation(Identifier(it.second).assignNoPrototype(), listOf(), false, false).assignNoPrototype() }
+                .map { Annotation(Identifier(it.second).assignNoPrototype(), listOf(), withAt = false, newLineAfter = false).assignNoPrototype() }
         return Annotations(list).assignNoPrototype()
     }
 
@@ -120,47 +120,54 @@ class AnnotationConverter(private val converter: Converter) {
     }
 
     private fun convertAttributeValue(value: PsiAnnotationMemberValue?, expectedType: PsiType?, isVararg: Boolean, isUnnamed: Boolean): List<(CodeConverter) -> Expression> {
-        when (value) {
-            is PsiExpression -> {
-                return listOf({ codeConverter ->
-                                  val expression = if (value is PsiClassObjectAccessExpression) {
-                                      val typeElement = converter.convertTypeElement(value.getOperand())
-                                      ClassLiteralExpression(typeElement.type.toNotNullType())
-                                  }
-                                  else {
-                                      codeConverter.convertExpression(value, expectedType)
-                                  }
-                                  expression.assignPrototype(value)
-                              })
-            }
+        return when (value) {
+            is PsiExpression -> listOf({ codeConverter -> convertExpressionValue(codeConverter, value, expectedType) })
 
             is PsiArrayInitializerMemberValue -> {
                 val componentType = (expectedType as? PsiArrayType)?.getComponentType()
-                val componentsConverted = value.getInitializers().map { convertAttributeValue(it, componentType, false, true).single() }
+                val componentGenerators = value.getInitializers().map { convertAttributeValue(it, componentType, false, true).single() }
                 if (isVararg && isUnnamed) {
-                    return componentsConverted
+                    componentGenerators
                 }
                 else {
-                    val expressionGenerator = { codeConverter: CodeConverter ->
-                        val expectedTypeConverted = converter.typeConverter.convertType(expectedType)
-                        if (expectedTypeConverted is ArrayType) {
-                            val array = createArrayInitializerExpression(expectedTypeConverted, componentsConverted.map { it(codeConverter) }, needExplicitType = false)
-                            if (isVararg) {
-                                StarExpression(array.assignNoPrototype()).assignPrototype(value)
-                            }
-                            else {
-                                array.assignPrototype(value)
-                            }
-                        }
-                        else {
-                            DummyStringExpression(value.getText()!!).assignPrototype(value)
-                        }
-                    }
-                    return listOf(expressionGenerator)
+                    listOf({ codeConverter -> convertArrayInitializerValue(codeConverter, value, componentGenerators, expectedType, isVararg) })
                 }
             }
 
-            else -> return listOf({ codeConverter -> DummyStringExpression(value?.getText() ?: "").assignPrototype(value) })
+            else -> listOf({ codeConverter -> DummyStringExpression(value?.getText() ?: "").assignPrototype(value) })
+        }
+    }
+
+    private fun convertExpressionValue(codeConverter: CodeConverter, value: PsiExpression, expectedType: PsiType?): Expression {
+        val expression = if (value is PsiClassObjectAccessExpression) {
+            val typeElement = converter.convertTypeElement(value.getOperand())
+            ClassLiteralExpression(typeElement.type.toNotNullType())
+        }
+        else {
+            codeConverter.convertExpression(value, expectedType)
+        }
+        return expression.assignPrototype(value)
+    }
+
+    private fun convertArrayInitializerValue(
+            codeConverter: CodeConverter,
+            value: PsiArrayInitializerMemberValue,
+            componentGenerators: List<(CodeConverter) -> Expression>,
+            expectedType: PsiType?,
+            isVararg: Boolean
+    ): Expression {
+        val expectedTypeConverted = converter.typeConverter.convertType(expectedType)
+        return if (expectedTypeConverted is ArrayType) {
+            val array = createArrayInitializerExpression(expectedTypeConverted, componentGenerators.map { it(codeConverter) }, needExplicitType = false)
+            if (isVararg) {
+                StarExpression(array.assignNoPrototype()).assignPrototype(value)
+            }
+            else {
+                array.assignPrototype(value)
+            }
+        }
+        else {
+            DummyStringExpression(value.getText()!!).assignPrototype(value)
         }
     }
 }
diff --git a/j2k/src/org/jetbrains/kotlin/j2k/CodeBuilder.kt b/j2k/src/org/jetbrains/kotlin/j2k/CodeBuilder.kt
index 4589ca7999a..3603fc5c1a9 100644
--- a/j2k/src/org/jetbrains/kotlin/j2k/CodeBuilder.kt
+++ b/j2k/src/org/jetbrains/kotlin/j2k/CodeBuilder.kt
@@ -19,14 +19,18 @@ package org.jetbrains.kotlin.j2k
 import com.intellij.openapi.util.text.StringUtil
 import com.intellij.psi.*
 import com.intellij.psi.javadoc.PsiDocComment
+import com.intellij.util.SmartList
 import org.jetbrains.kotlin.j2k.ast.CommentsAndSpacesInheritance
 import org.jetbrains.kotlin.j2k.ast.Element
+import org.jetbrains.kotlin.j2k.ast.SpacesInheritance
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.psi.psiUtil.isAncestor
-import java.util.*
+import java.util.ArrayList
+import java.util.HashSet
+import java.util.LinkedHashSet
 import kotlin.platform.platformName
 
-fun<T> CodeBuilder.append(generators: Collection<() -> T>, separator: String, prefix: String = "", suffix: String = ""): CodeBuilder {
+fun<T> CodeBuilder.buildList(generators: Collection<() -> T>, separator: String, prefix: String = "", suffix: String = ""): CodeBuilder {
     if (generators.isNotEmpty()) {
         append(prefix)
         var first = true
@@ -44,7 +48,7 @@ fun<T> CodeBuilder.append(generators: Collection<() -> T>, separator: String, pr
 
 platformName("appendElements")
 fun CodeBuilder.append(elements: Collection<Element>, separator: String, prefix: String = "", suffix: String = ""): CodeBuilder {
-    return append(elements.filter { !it.isEmpty }.map { { append(it) } }, separator, prefix, suffix)
+    return buildList(elements.filter { !it.isEmpty }.map { { append(it) } }, separator, prefix, suffix)
 }
 
 class ElementCreationStackTraceRequiredException : RuntimeException()
@@ -79,8 +83,10 @@ class CodeBuilder(private val topElement: PsiElement?) {
             return this
         }
 
+        assert(text.indexOf('\r') < 0, "No '\\r' allowed")
+
         if (endOfLineCommentAtEnd) {
-            if (text[0] != '\n' && text[0] != '\r') builder.append('\n')
+            if (text[0] != '\n') builder.append('\n')
             endOfLineCommentAtEnd = false
         }
 
@@ -117,31 +123,25 @@ class CodeBuilder(private val topElement: PsiElement?) {
         }
 
         val notInsideElements = HashSet<PsiElement>()
-        val prefixElements = ArrayList<PsiElement>(1)
-        val postfixElements = ArrayList<PsiElement>(1)
+        var prefix = Prefix.Empty
+        var postfix = emptyList<PsiElement>()
         for ((prototype, inheritance) in element.prototypes!!) {
             assert(prototype !is PsiComment)
             assert(prototype !is PsiWhiteSpace)
             if (!topElement.isAncestor(prototype)) continue
-            prefixElements.collectPrefixElements(prototype, inheritance, notInsideElements)
-            postfixElements.collectPostfixElements(prototype, inheritance, notInsideElements)
+            prefix += collectPrefixElements(prototype, inheritance, notInsideElements)
+            postfix += collectPostfixElements(prototype, inheritance, notInsideElements)
         }
 
-        commentsAndSpacesUsed.addAll(prefixElements)
-        commentsAndSpacesUsed.addAll(postfixElements)
-
-        for ((i, e) in prefixElements.withIndex()) {
-            if (i == 0 && e is PsiWhiteSpace) {
-                val blankLines = e.newLinesCount() - 1
-                for (_ in 1..blankLines) {
-                    append("\n", false)
-                }
-            }
-            else {
-                appendCommentOrWhiteSpace(e)
+        if (prefix.lineBreaksBefore > 0) {
+            val lineBreaksToAdd = prefix.lineBreaksBefore - builder.trailingLineBreakCount()
+            for (_ in 1..lineBreaksToAdd) {
+                append("\n", false)
             }
         }
 
+        prefix.elements.forEach { appendCommentOrWhiteSpace(it) }
+
         element.generateCode(this)
 
         // scan for all comments inside which are not yet used in the text and put them here to not loose any comment from code
@@ -157,45 +157,80 @@ class CodeBuilder(private val topElement: PsiElement?) {
             }
         }
 
-        postfixElements.forEach { appendCommentOrWhiteSpace(it) }
+        postfix.forEach { appendCommentOrWhiteSpace(it) }
 
         element.postGenerateCode(this)
 
         return this
     }
 
-    private fun MutableList<PsiElement>.collectPrefixElements(element: PsiElement,
-                                                              inheritance: CommentsAndSpacesInheritance,
-                                                              notInsideElements: MutableSet<PsiElement>) {
-        val before = ArrayList<PsiElement>(1).collectCommentsAndSpacesBefore(element)
-        val atStart = ArrayList<PsiElement>(1).collectCommentsAndSpacesAtStart(element)
-        notInsideElements.addAll(atStart)
-
-        if (!inheritance.blankLinesBefore && !inheritance.commentsBefore) return
-
-        val firstSpace = before.lastOrNull() as? PsiWhiteSpace
-        if (!inheritance.commentsBefore) { // take only first whitespace
-            if (firstSpace != null) {
-                add(firstSpace)
+    private data class Prefix(val elements: List<PsiElement>, val lineBreaksBefore: Int) {
+        fun plus(other: Prefix): Prefix {
+            return when {
+                isEmpty() -> other
+                other.isEmpty() -> this
+                else -> Prefix(elements + other.elements, Math.max(lineBreaksBefore, other.lineBreaksBefore))
             }
-            return
         }
 
-        if (!inheritance.blankLinesBefore && firstSpace != null) {
+        private fun isEmpty() = elements.isEmpty() && lineBreaksBefore == 0
+
+        companion object {
+            val Empty = Prefix(emptyList(), 0)
+        }
+    }
+
+    private fun collectPrefixElements(
+            element: PsiElement,
+            inheritance: CommentsAndSpacesInheritance,
+            notInsideElements: MutableSet<PsiElement>
+    ): Prefix {
+        val before = SmartList<PsiElement>().collectCommentsAndSpacesBefore(element)
+        val atStart = SmartList<PsiElement>().collectCommentsAndSpacesAtStart(element)
+        notInsideElements.addAll(atStart)
+
+        if (inheritance.spacesBefore == SpacesInheritance.NONE && !inheritance.commentsBefore) return Prefix.Empty
+
+        val firstSpace = before.lastOrNull() as? PsiWhiteSpace
+        var lineBreaks = 0
+        if (firstSpace != null) {
+            lineBreaks = firstSpace.lineBreakCount()
+            when (inheritance.spacesBefore) {
+                SpacesInheritance.NONE -> lineBreaks = 0
+
+                SpacesInheritance.LINE_BREAKS -> commentsAndSpacesUsed.add(firstSpace)
+
+                SpacesInheritance.BLANK_LINES_ONLY -> {
+                    commentsAndSpacesUsed.add(firstSpace)
+                    if (lineBreaks == 1) lineBreaks = 0
+                }
+            }
+        }
+
+        if (!inheritance.commentsBefore) { // take only whitespace
+            return Prefix(emptyList(), lineBreaks)
+        }
+
+        if (firstSpace != null) {
             before.remove(before.lastIndex)
         }
 
-        addAll(before.reverse())
-        addAll(atStart)
+        val elements = before.reverse() + atStart
+        commentsAndSpacesUsed.addAll(elements)
+        return Prefix(elements, lineBreaks)
     }
 
-    private fun MutableList<PsiElement>.collectPostfixElements(element: PsiElement, inheritance: CommentsAndSpacesInheritance, notInsideElements: MutableSet<PsiElement>) {
-        val atEnd = ArrayList<PsiElement>(1).collectCommentsAndSpacesAtEnd(element)
+    private fun collectPostfixElements(
+            element: PsiElement,
+            inheritance: CommentsAndSpacesInheritance,
+            notInsideElements: MutableSet<PsiElement>
+    ): List<PsiElement> {
+        val atEnd = SmartList<PsiElement>().collectCommentsAndSpacesAtEnd(element)
         notInsideElements.addAll(atEnd)
 
-        if (!inheritance.commentsAfter) return
+        if (!inheritance.commentsAfter) return emptyList()
 
-        val after = ArrayList<PsiElement>(1).collectCommentsAndSpacesAfter(element)
+        val after = SmartList<PsiElement>().collectCommentsAndSpacesAfter(element)
         if (after.isNotEmpty()) {
             val last = after.last()
             if (last is PsiWhiteSpace) {
@@ -203,8 +238,9 @@ class CodeBuilder(private val topElement: PsiElement?) {
             }
         }
 
-        addAll(atEnd.reverse())
-        addAll(after)
+        val result = atEnd.reverse() + after
+        commentsAndSpacesUsed.addAll(result)
+        return result
     }
 
     private fun MutableList<PsiElement>.collectCommentsAndSpacesBefore(element: PsiElement): MutableList<PsiElement> {
@@ -234,7 +270,7 @@ class CodeBuilder(private val topElement: PsiElement?) {
         val next = element.getNextSibling()
         if (next != null) {
             if (next.isCommentOrSpace()) {
-                if (next is PsiWhiteSpace && next.hasNewLines()) return this // do not attach anything on next line after element
+                if (next is PsiWhiteSpace && next.hasLineBreaks()) return this // do not attach anything on next line after element
                 if (next !in commentsAndSpacesUsed) {
                     add(next)
                     collectCommentsAndSpacesAfter(next)
@@ -253,14 +289,14 @@ class CodeBuilder(private val topElement: PsiElement?) {
     private fun MutableList<PsiElement>.collectCommentsAndSpacesAtStart(element: PsiElement): MutableList<PsiElement> {
         var child = element.getFirstChild()
         while(child != null) {
-            if (child!!.isCommentOrSpace()) {
-                if (child !in commentsAndSpacesUsed) add(child!!) else break
+            if (child.isCommentOrSpace()) {
+                if (child !in commentsAndSpacesUsed) add(child) else break
             }
-            else if (!child!!.isEmptyElement()) {
-                collectCommentsAndSpacesAtStart(child!!)
+            else if (!child.isEmptyElement()) {
+                collectCommentsAndSpacesAtStart(child)
                 break
             }
-            child = child!!.getNextSibling()
+            child = child.getNextSibling()
         }
         return this
     }
@@ -268,26 +304,58 @@ class CodeBuilder(private val topElement: PsiElement?) {
     private fun MutableList<PsiElement>.collectCommentsAndSpacesAtEnd(element: PsiElement): MutableList<PsiElement> {
         var child = element.getLastChild()
         while(child != null) {
-            if (child!!.isCommentOrSpace()) {
-                if (child !in commentsAndSpacesUsed) add(child!!) else break
+            if (child.isCommentOrSpace()) {
+                if (child !in commentsAndSpacesUsed) add(child) else break
             }
-            else if (!child!!.isEmptyElement()) {
-                collectCommentsAndSpacesAtEnd(child!!)
+            else if (!child.isEmptyElement()) {
+                collectCommentsAndSpacesAtEnd(child)
                 break
             }
-            child = child!!.getPrevSibling()
+            child = child.getPrevSibling()
         }
         return this
     }
 
-    private fun PsiElement.isCommentOrSpace() = this is PsiComment || this is PsiWhiteSpace
+    private companion object {
+        fun<T> List<T>.plus(other: List<T>): List<T> {
+            when {
+                isEmpty() -> return other
 
-    private fun PsiElement.isEndOfLineComment() = this is PsiComment && getTokenType() == JavaTokenType.END_OF_LINE_COMMENT
+                other.isEmpty() -> return this
 
-    private fun PsiElement.isEmptyElement() = getFirstChild() == null && getTextLength() == 0
+                else -> {
+                    val result = ArrayList<T>(size() + other.size())
+                    result.addAll(this)
+                    result.addAll(other)
+                    return result
+                }
+            }
+        }
 
-    private fun PsiWhiteSpace.newLinesCount() = StringUtil.getLineBreakCount(getText()!!)
+        fun<T> List<T>.reverse(): List<T> {
+            return if (size() <= 1)
+                this
+            else
+                (this as Iterable<T>).reverse()
+        }
 
-    private fun PsiWhiteSpace.hasNewLines() = StringUtil.containsLineBreak(getText()!!)
+        fun PsiElement.isCommentOrSpace() = this is PsiComment || this is PsiWhiteSpace
+
+        fun PsiElement.isEndOfLineComment() = this is PsiComment && getTokenType() == JavaTokenType.END_OF_LINE_COMMENT
+
+        fun PsiElement.isEmptyElement() = getFirstChild() == null && getTextLength() == 0
+
+        fun PsiWhiteSpace.lineBreakCount() = StringUtil.getLineBreakCount(getText())
+
+        fun PsiWhiteSpace.hasLineBreaks() = StringUtil.containsLineBreak(getText())
+
+        fun CharSequence.trailingLineBreakCount(): Int {
+            var i = length() - 1
+            while (i >= 0 && this[i] == '\n') {
+                i--
+            }
+            return length() - i - 1
+        }
+    }
 }
 
diff --git a/j2k/src/org/jetbrains/kotlin/j2k/ConstructorConverter.kt b/j2k/src/org/jetbrains/kotlin/j2k/ConstructorConverter.kt
index 38163250d37..13ada6f895f 100644
--- a/j2k/src/org/jetbrains/kotlin/j2k/ConstructorConverter.kt
+++ b/j2k/src/org/jetbrains/kotlin/j2k/ConstructorConverter.kt
@@ -214,7 +214,11 @@ class ConstructorConverter(
                                   if (isVal(converter.referenceSearcher, field)) Parameter.VarValModifier.Val else Parameter.VarValModifier.Var,
                                   converter.convertAnnotations(parameter) + converter.convertAnnotations(field),
                                   accessModifiers,
-                                  default).assignPrototypes(listOf(parameter, field), CommentsAndSpacesInheritance(blankLinesBefore = false))
+                                  default)
+                                .assignPrototypes(
+                                        PrototypeInfo(parameter, CommentsAndSpacesInheritance.LINE_BREAKS),
+                                        PrototypeInfo(field, CommentsAndSpacesInheritance.NO_SPACES)
+                                )
                     }
                 },
                 correctCodeConverter = { correct() })
@@ -261,7 +265,7 @@ class ConstructorConverter(
             if (expression is PsiReferenceExpression && expression.getQualifier() == null) {
                 val replacement = parameterUsageReplacementMap[expression.getReferenceName()]
                 if (replacement != null) {
-                    val target = expression.getReference()?.resolve()
+                    val target = expression.resolve()
                     if (target is PsiParameter) {
                         val scope = target.getDeclarationScope()
                         // we do not check for exactly this constructor because default values reference parameters in other constructors
diff --git a/j2k/src/org/jetbrains/kotlin/j2k/Converter.kt b/j2k/src/org/jetbrains/kotlin/j2k/Converter.kt
index 33652d8e338..e476666d487 100644
--- a/j2k/src/org/jetbrains/kotlin/j2k/Converter.kt
+++ b/j2k/src/org/jetbrains/kotlin/j2k/Converter.kt
@@ -113,7 +113,7 @@ class Converter private constructor(
         is PsiExpression -> createDefaultCodeConverter().convertExpression(element)
         is PsiImportList -> convertImportList(element)
         is PsiImportStatementBase -> convertImport(element, false)
-        is PsiAnnotation -> annotationConverter.convertAnnotation(element, false, false)
+        is PsiAnnotation -> annotationConverter.convertAnnotation(element, withAt = false, newLineAfter = false)
         is PsiPackageStatement -> PackageStatement(quoteKeywords(element.getPackageName() ?: "")).assignPrototype(element)
         else -> null
     }
@@ -244,19 +244,18 @@ class Converter private constructor(
 
     private fun convertAnnotationType(psiClass: PsiClass): Class {
         val paramModifiers = Modifiers(listOf(Modifier.PUBLIC)).assignNoPrototype()
-        val noBlankLinesInheritance = CommentsAndSpacesInheritance(blankLinesBefore = false)
         val annotationMethods = psiClass.getMethods().filterIsInstance<PsiAnnotationMethod>()
         val (methodsNamedValue, otherMethods) = annotationMethods.partition { it.getName() == "value" }
 
         fun createParameter(type: Type, method: PsiAnnotationMethod): Parameter {
-            type.assignPrototype(method.getReturnTypeElement(), noBlankLinesInheritance)
+            type.assignPrototype(method.getReturnTypeElement(), CommentsAndSpacesInheritance.NO_SPACES)
 
             return Parameter(method.declarationIdentifier(),
                       type,
                       Parameter.VarValModifier.Val,
                       convertAnnotations(method),
                       paramModifiers,
-                      annotationConverter.convertAnnotationMethodDefault(method)).assignPrototype(method, noBlankLinesInheritance)
+                      annotationConverter.convertAnnotationMethodDefault(method)).assignPrototype(method, CommentsAndSpacesInheritance.NO_SPACES)
         }
 
         fun convertType(psiType: PsiType?): Type {
@@ -288,7 +287,7 @@ class Converter private constructor(
         classBody = ClassBody(constructorSignature, classBody.baseClassParams, classBody.members,
                               classBody.companionObjectMembers, classBody.lBrace, classBody.rBrace, classBody.isEnumBody)
 
-        val annotationAnnotation = Annotation(Identifier("annotation").assignNoPrototype(), listOf(), false, false).assignNoPrototype()
+        val annotationAnnotation = Annotation(Identifier("annotation").assignNoPrototype(), listOf(), withAt = false, newLineAfter = false).assignNoPrototype()
         return Class(psiClass.declarationIdentifier(),
                      convertAnnotations(psiClass) + Annotations(listOf(annotationAnnotation)),
                      convertModifiers(psiClass).without(Modifier.ABSTRACT),
@@ -313,13 +312,14 @@ class Converter private constructor(
         }
 
         val name = correction?.identifier ?: field.declarationIdentifier()
-        val converted = if (field is PsiEnumConstant) {
+        if (field is PsiEnumConstant) {
             val argumentList = field.getArgumentList()
             val params = deferredElement { codeConverter ->
                 ExpressionList(codeConverter.convertExpressions(argumentList?.getExpressions() ?: arrayOf<PsiExpression>())).assignPrototype(argumentList)
             }
             val body = field.getInitializingClass()?.let { convertAnonymousClassBody(it) }
-            EnumConstant(name, annotations, modifiers, params, body)
+            return EnumConstant(name, annotations, modifiers, params, body)
+                    .assignPrototype(field, CommentsAndSpacesInheritance.LINE_BREAKS)
         }
         else {
             val isVal = isVal(referenceSearcher, field)
@@ -328,9 +328,9 @@ class Converter private constructor(
                                                       isVal && modifiers.isPrivate)
             val propertyType = typeToDeclare ?: typeConverter.convertVariableType(field)
 
-            addUsageProcessing(FieldToPropertyProcessing(field, correction?.name ?: field.getName(), propertyType.isNullable))
+            addUsageProcessing(FieldToPropertyProcessing(field, correction?.name ?: field.getName()!!, propertyType.isNullable))
 
-            Property(name,
+            return Property(name,
                   annotations,
                   modifiers,
                   propertyType,
@@ -338,9 +338,9 @@ class Converter private constructor(
                   isVal,
                   typeToDeclare != null,
                   shouldGenerateDefaultInitializer(referenceSearcher, field),
-                  if (correction != null) correction.setterAccess else modifiers.accessModifier())
+                  if (correction != null) correction.setterAccess else modifiers.accessModifier()
+            ).assignPrototype(field)
         }
-        return converted.assignPrototype(field)
     }
 
     public fun variableTypeToDeclare(variable: PsiVariable, specifyAlways: Boolean, canChangeType: Boolean): Type? {
@@ -427,11 +427,11 @@ class Converter private constructor(
 
         if (function == null) return null
 
-        if (function.parameterList.parameters.any { it.defaultValue != null }) {
+        if (function.parameterList.parameters.any { it.defaultValue != null } && !function.modifiers.isPrivate) {
             function.annotations += Annotations(
                     listOf(Annotation(Identifier("jvmOverloads").assignNoPrototype(),
                                       listOf(),
-                                      withAt = function is PrimaryConstructor,
+                                      withAt = false,
                                       newLineAfter = false).assignNoPrototype())).assignNoPrototype()
         }
 
@@ -545,7 +545,7 @@ class Converter private constructor(
             Nullability.Nullable -> type = type.toNullableType()
         }
         return Parameter(parameter.declarationIdentifier(), type, varValModifier,
-                         convertAnnotations(parameter), modifiers, defaultValue).assignPrototype(parameter)
+                         convertAnnotations(parameter), modifiers, defaultValue).assignPrototype(parameter, CommentsAndSpacesInheritance.LINE_BREAKS)
     }
 
     public fun convertIdentifier(identifier: PsiIdentifier?): Identifier {
@@ -556,7 +556,7 @@ class Converter private constructor(
 
     public fun convertModifiers(owner: PsiModifierListOwner): Modifiers {
         return Modifiers(MODIFIERS_MAP.filter { owner.hasModifierProperty(it.first) }.map { it.second })
-                .assignPrototype(owner.getModifierList(), CommentsAndSpacesInheritance(blankLinesBefore = false))
+                .assignPrototype(owner.getModifierList(), CommentsAndSpacesInheritance.NO_SPACES)
     }
 
     public fun convertAnonymousClassBody(anonymousClass: PsiAnonymousClass): AnonymousClassBody {
@@ -581,7 +581,7 @@ class Converter private constructor(
             val convertedType = typeConverter.convertType(types[index], Nullability.NotNull)
             null to deferredElement<Expression> { ClassLiteralExpression(convertedType.assignPrototype(refElements[index])) }
         }
-        val annotation = Annotation(Identifier("throws").assignNoPrototype(), arguments, false, true)
+        val annotation = Annotation(Identifier("throws").assignNoPrototype(), arguments, withAt = false, newLineAfter = true)
         return Annotations(listOf(annotation.assignPrototype(throwsList))).assignPrototype(throwsList)
     }
 
diff --git a/j2k/src/org/jetbrains/kotlin/j2k/ExpressionConverter.kt b/j2k/src/org/jetbrains/kotlin/j2k/ExpressionConverter.kt
index 123bce71e6b..81c8a949c61 100644
--- a/j2k/src/org/jetbrains/kotlin/j2k/ExpressionConverter.kt
+++ b/j2k/src/org/jetbrains/kotlin/j2k/ExpressionConverter.kt
@@ -137,6 +137,7 @@ class DefaultExpressionConverter : JavaElementVisitor(), ExpressionConverter {
             is PsiClassType -> {
                 val psiClass = type.resolve() ?: return false
                 if (!psiClass.hasModifierProperty(PsiModifier.FINAL)) return false
+                if (psiClass.isEnum()) return true
 
                 val equalsSignature = GenerateEqualsHelper.getEqualsSignature(converter.project, GlobalSearchScope.allScope(converter.project))
                 val equalsMethod = MethodSignatureUtil.findMethodBySignature(psiClass, equalsSignature, true)
@@ -396,7 +397,7 @@ class DefaultExpressionConverter : JavaElementVisitor(), ExpressionConverter {
         }
 
         val referenceName = expression.getReferenceName()!!
-        val target = expression.getReference()?.resolve()
+        val target = expression.resolve()
         val isNullable = target is PsiVariable && typeConverter.variableNullability(target).isNullable(codeConverter.settings)
         val qualifier = expression.getQualifierExpression()
 
@@ -479,21 +480,26 @@ class DefaultExpressionConverter : JavaElementVisitor(), ExpressionConverter {
         if (isExtension && arguments.isNotEmpty()) {
             arguments = arguments.drop(1)
         }
+
         val resolved = expression.resolveMethod()
         val parameters = resolved?.getParameterList()?.getParameters()
         val expectedTypes = parameters?.map { it.getType() } ?: listOf()
 
-        return if (arguments.size() == expectedTypes.size())
-            (0..arguments.lastIndex).map { i ->
-                val argument = arguments[i]
+        val commentsAndSpacesInheritance = CommentsAndSpacesInheritance.LINE_BREAKS
+
+        return if (arguments.size() == expectedTypes.size()) {
+            arguments.mapIndexed { i, argument ->
                 val converted = codeConverter.convertExpression(argument, expectedTypes[i])
-                if (parameters != null && i == arguments.lastIndex && parameters[i].isVarArgs() && argument.getType() is PsiArrayType)
-                    StarExpression(converted).assignNoPrototype()
+                val result = if (parameters != null && i == arguments.lastIndex && parameters[i].isVarArgs() && argument.getType() is PsiArrayType)
+                    StarExpression(converted)
                 else
                     converted
+                result.assignPrototype(argument, commentsAndSpacesInheritance)
             }
-        else
-            arguments.map { codeConverter.convertExpression(it) }
+        }
+        else {
+            arguments.map { codeConverter.convertExpression(it).assignPrototype(it, commentsAndSpacesInheritance) }
+        }
     }
 
     private fun getOperatorString(tokenType: IElementType): String {
diff --git a/j2k/src/org/jetbrains/kotlin/j2k/ForConverter.kt b/j2k/src/org/jetbrains/kotlin/j2k/ForConverter.kt
index b6e03bb816c..8dfd6d108b2 100644
--- a/j2k/src/org/jetbrains/kotlin/j2k/ForConverter.kt
+++ b/j2k/src/org/jetbrains/kotlin/j2k/ForConverter.kt
@@ -317,6 +317,6 @@ class ForConverter(
         val declarationStatement = this as? PsiDeclarationStatement ?: return listOf()
         return declarationStatement.getDeclaredElements()
                 .filterIsInstance<PsiVariable>()
-                .map { it.getName() }
+                .map { it.getName()!! }
     }
 }
diff --git a/j2k/src/org/jetbrains/kotlin/j2k/JavaToKotlinConverter.kt b/j2k/src/org/jetbrains/kotlin/j2k/JavaToKotlinConverter.kt
index 534584ffe3f..5ea64db9afa 100644
--- a/j2k/src/org/jetbrains/kotlin/j2k/JavaToKotlinConverter.kt
+++ b/j2k/src/org/jetbrains/kotlin/j2k/JavaToKotlinConverter.kt
@@ -59,10 +59,12 @@ public interface PostProcessor {
             }
 
             Errors.VAL_REASSIGNMENT -> { ->
-                val property = (psiElement as? JetSimpleNameExpression)?.getReference()?.resolve() as? JetProperty
-                if (property != null && !property.isVar()) {
-                    val factory = JetPsiFactory(psiElement.getProject())
-                    property.getValOrVarKeyword().replace(factory.createVarKeyword())
+                if (psiElement is JetSimpleNameExpression) {
+                    val property = simpleNameReference(psiElement).resolve() as? JetProperty
+                    if (property != null && !property.isVar()) {
+                        val factory = JetPsiFactory(psiElement.getProject())
+                        property.getValOrVarKeyword().replace(factory.createVarKeyword())
+                    }
                 }
             }
 
@@ -71,6 +73,8 @@ public interface PostProcessor {
     }
 
     public fun doAdditionalProcessing(file: JetFile, rangeMarker: RangeMarker?)
+
+    public fun simpleNameReference(nameExpression: JetSimpleNameExpression): PsiReference
 }
 
 public enum class ParseContext {
@@ -233,7 +237,7 @@ public class JavaToKotlinConverter(
 
                 var references = listOf(reference)
                 for (processor in processors) {
-                    references = references.flatMap { processor.processUsage(it) ?: listOf(it) }
+                    references = references.flatMap { processor.processUsage(it)?.toList() ?: listOf(it) }
                     references.forEach { checkReferenceValid(it) }
                 }
             }
diff --git a/j2k/src/org/jetbrains/kotlin/j2k/ReferenceSearcher.kt b/j2k/src/org/jetbrains/kotlin/j2k/ReferenceSearcher.kt
index 95588e85ab2..91082618d1d 100644
--- a/j2k/src/org/jetbrains/kotlin/j2k/ReferenceSearcher.kt
+++ b/j2k/src/org/jetbrains/kotlin/j2k/ReferenceSearcher.kt
@@ -68,10 +68,10 @@ public object IdeaReferenceSearcher: ReferenceSearcher {
     override fun findUsagesForExternalCodeProcessing(element: PsiElement, searchJava: Boolean, searchKotlin: Boolean): Collection<PsiReference> {
         val fileTypes = ArrayList<FileType>()
         if (searchJava) {
-            fileTypes.add(JavaLanguage.INSTANCE.getAssociatedFileType())
+            fileTypes.add(JavaLanguage.INSTANCE.getAssociatedFileType()!!)
         }
         if (searchKotlin) {
-            fileTypes.add(JetLanguage.INSTANCE.getAssociatedFileType())
+            fileTypes.add(JetLanguage.INSTANCE.getAssociatedFileType()!!)
         }
         val searchScope = GlobalSearchScope.getScopeRestrictedByFileTypes(GlobalSearchScope.projectScope(element.getProject()), *fileTypes.toTypedArray())
         return ReferencesSearch.search(element, searchScope).findAll()
diff --git a/j2k/src/org/jetbrains/kotlin/j2k/ast/Annotation.kt b/j2k/src/org/jetbrains/kotlin/j2k/ast/Annotation.kt
index 489ce3ec83b..70596948153 100644
--- a/j2k/src/org/jetbrains/kotlin/j2k/ast/Annotation.kt
+++ b/j2k/src/org/jetbrains/kotlin/j2k/ast/Annotation.kt
@@ -27,16 +27,18 @@ class Annotation(val name: Identifier, val arguments: List<Pair<Identifier?, Def
         else {
             builder.append(name)
                     .append("(")
-                    .append(arguments.map {
-                        {
-                            if (it.first != null) {
-                                builder append it.first!! append " = " append it.second
-                            }
-                            else {
-                                builder append it.second
-                            }
-                        }
-                    }, ", ")
+                    .buildList(
+                            generators = arguments.map {
+                                {
+                                    if (it.first != null) {
+                                        builder append it.first!! append " = " append it.second
+                                    }
+                                    else {
+                                        builder append it.second
+                                    }
+                                }
+                            },
+                            separator = ", ")
                     .append(")")
         }
     }
@@ -61,6 +63,3 @@ class Annotations(val annotations: List<Annotation>) : Element() {
         val Empty = Annotations(listOf())
     }
 }
-
-fun Annotations.withAt(): Annotations
-        = Annotations(annotations.map { Annotation(it.name, it.arguments, true, it.newLineAfter).assignPrototypesFrom(it) }).assignPrototypesFrom(this)
diff --git a/j2k/src/org/jetbrains/kotlin/j2k/ast/ArrayWithoutInitializationExpression.kt b/j2k/src/org/jetbrains/kotlin/j2k/ast/ArrayWithoutInitializationExpression.kt
index 3e4c123fe45..4d67557ddbc 100644
--- a/j2k/src/org/jetbrains/kotlin/j2k/ast/ArrayWithoutInitializationExpression.kt
+++ b/j2k/src/org/jetbrains/kotlin/j2k/ast/ArrayWithoutInitializationExpression.kt
@@ -17,7 +17,6 @@
 package org.jetbrains.kotlin.j2k.ast
 
 import org.jetbrains.kotlin.j2k.CodeBuilder
-import org.jetbrains.kotlin.j2k.append
 
 class ArrayWithoutInitializationExpression(val type: ArrayType, val expressions: List<Expression>) : Expression() {
     override fun generateCode(builder: CodeBuilder) {
diff --git a/j2k/src/org/jetbrains/kotlin/j2k/ast/Class.kt b/j2k/src/org/jetbrains/kotlin/j2k/ast/Class.kt
index c116e104a7f..e0fae4b5f34 100644
--- a/j2k/src/org/jetbrains/kotlin/j2k/ast/Class.kt
+++ b/j2k/src/org/jetbrains/kotlin/j2k/ast/Class.kt
@@ -18,6 +18,7 @@ package org.jetbrains.kotlin.j2k.ast
 
 import org.jetbrains.kotlin.j2k.CodeBuilder
 import org.jetbrains.kotlin.j2k.append
+import org.jetbrains.kotlin.j2k.buildList
 
 open class Class(
         val name: Identifier,
@@ -52,7 +53,9 @@ open class Class(
         get() = "class"
 
     protected fun appendBaseTypes(builder: CodeBuilder) {
-        builder.append(baseClassSignatureWithParams(builder) + implementsTypes.map { { builder.append(it) } }, ", ", ":")
+        builder.buildList(generators = baseClassSignatureWithParams(builder) + implementsTypes.map { { builder.append(it) } },
+                          separator = ", ",
+                          prefix = ":")
     }
 
     private fun baseClassSignatureWithParams(builder: CodeBuilder): List<() -> CodeBuilder> {
diff --git a/j2k/src/org/jetbrains/kotlin/j2k/ast/ClassBody.kt b/j2k/src/org/jetbrains/kotlin/j2k/ast/ClassBody.kt
index 6296b1ae361..3e5212860b6 100644
--- a/j2k/src/org/jetbrains/kotlin/j2k/ast/ClassBody.kt
+++ b/j2k/src/org/jetbrains/kotlin/j2k/ast/ClassBody.kt
@@ -45,7 +45,7 @@ class ClassBody (
         else {
             val (constants, otherMembers) = membersFiltered.partition { it is EnumConstant }
 
-            builder.append(constants, ",\n")
+            builder.append(constants, ", ")
 
             if (otherMembers.isNotEmpty() || companionObjectMembers.isNotEmpty()) {
                 builder.append(";\n")
diff --git a/j2k/src/org/jetbrains/kotlin/j2k/ast/Constructors.kt b/j2k/src/org/jetbrains/kotlin/j2k/ast/Constructors.kt
index d2190cb2d1e..55bfc95cf58 100644
--- a/j2k/src/org/jetbrains/kotlin/j2k/ast/Constructors.kt
+++ b/j2k/src/org/jetbrains/kotlin/j2k/ast/Constructors.kt
@@ -43,7 +43,7 @@ class PrimaryConstructor(
 
         // assign prototypes later because we don't know yet whether the body is empty or not
         converter.addPostUnfoldDeferredElementsAction {
-            val inheritance = CommentsAndSpacesInheritance(blankLinesBefore = false, commentsAfter = body!!.isEmpty, commentsInside = body.isEmpty)
+            val inheritance = CommentsAndSpacesInheritance(spacesBefore = SpacesInheritance.NONE, commentsAfter = body!!.isEmpty, commentsInside = body.isEmpty)
             signature.assignPrototypesFrom(this, inheritance)
         }
 
@@ -61,7 +61,7 @@ class PrimaryConstructorSignature(val annotations: Annotations, private val modi
         var needConstructorKeyword = false
 
         if (!annotations.isEmpty) {
-            builder append " " append annotations.withAt()
+            builder append " " append annotations
             needConstructorKeyword = true
         }
 
diff --git a/j2k/src/org/jetbrains/kotlin/j2k/ast/Element.kt b/j2k/src/org/jetbrains/kotlin/j2k/ast/Element.kt
index 7a9a5ade433..818228c8bfb 100644
--- a/j2k/src/org/jetbrains/kotlin/j2k/ast/Element.kt
+++ b/j2k/src/org/jetbrains/kotlin/j2k/ast/Element.kt
@@ -24,8 +24,8 @@ fun <TElement: Element> TElement.assignPrototype(prototype: PsiElement?, inherit
     return this
 }
 
-fun <TElement: Element> TElement.assignPrototypes(prototypes: List<PsiElement>, inheritance: CommentsAndSpacesInheritance): TElement {
-    this.prototypes = prototypes.map { PrototypeInfo(it, inheritance) }
+fun <TElement: Element> TElement.assignPrototypes(vararg prototypes: PrototypeInfo): TElement {
+    this.prototypes = prototypes.asList()
     return this
 }
 
@@ -45,10 +45,21 @@ fun <TElement: Element> TElement.assignPrototypesFrom(element: Element, inherita
 
 data class PrototypeInfo(val element: PsiElement, val commentsAndSpacesInheritance: CommentsAndSpacesInheritance)
 
-data class CommentsAndSpacesInheritance(val blankLinesBefore: Boolean = true,
-                                        val commentsBefore: Boolean = true,
-                                        val commentsAfter: Boolean = true,
-                                        val commentsInside: Boolean = true)
+enum class SpacesInheritance {
+    NONE, BLANK_LINES_ONLY, LINE_BREAKS
+}
+
+data class CommentsAndSpacesInheritance(
+        val spacesBefore: SpacesInheritance = SpacesInheritance.BLANK_LINES_ONLY,
+        val commentsBefore: Boolean = true,
+        val commentsAfter: Boolean = true,
+        val commentsInside: Boolean = true
+) {
+    companion object {
+        val NO_SPACES = CommentsAndSpacesInheritance(spacesBefore = SpacesInheritance.NONE)
+        val LINE_BREAKS = CommentsAndSpacesInheritance(spacesBefore = SpacesInheritance.LINE_BREAKS)
+    }
+}
 
 fun Element.canonicalCode(): String {
     val builder = CodeBuilder(null)
diff --git a/j2k/src/org/jetbrains/kotlin/j2k/ast/LocalVariable.kt b/j2k/src/org/jetbrains/kotlin/j2k/ast/LocalVariable.kt
index b0a99b91121..7405b75c015 100644
--- a/j2k/src/org/jetbrains/kotlin/j2k/ast/LocalVariable.kt
+++ b/j2k/src/org/jetbrains/kotlin/j2k/ast/LocalVariable.kt
@@ -18,7 +18,6 @@ package org.jetbrains.kotlin.j2k.ast
 
 import org.jetbrains.kotlin.j2k.ConverterSettings
 import org.jetbrains.kotlin.j2k.CodeBuilder
-import org.jetbrains.kotlin.j2k.append
 
 class LocalVariable(
         private val identifier: Identifier,
diff --git a/j2k/src/org/jetbrains/kotlin/j2k/ast/TypeParameters.kt b/j2k/src/org/jetbrains/kotlin/j2k/ast/TypeParameters.kt
index 38db2f9827c..0c98ac4c477 100644
--- a/j2k/src/org/jetbrains/kotlin/j2k/ast/TypeParameters.kt
+++ b/j2k/src/org/jetbrains/kotlin/j2k/ast/TypeParameters.kt
@@ -44,7 +44,10 @@ class TypeParameterList(val parameters: List<TypeParameter>) : Element() {
 
     fun appendWhere(builder: CodeBuilder): CodeBuilder {
         if (hasWhere()) {
-            builder.append( parameters.map { { it.whereToKotlin(builder) } }, ", ", " where ", "")
+            builder.buildList(generators = parameters.map { { it.whereToKotlin(builder) } },
+                              separator = ", ",
+                              prefix = " where ",
+                              suffix = "")
         }
         return builder
     }
diff --git a/j2k/src/org/jetbrains/kotlin/j2k/usageProcessing/AccessorToPropertyProcessing.kt b/j2k/src/org/jetbrains/kotlin/j2k/usageProcessing/AccessorToPropertyProcessing.kt
index dde1798069d..ec00ac68016 100644
--- a/j2k/src/org/jetbrains/kotlin/j2k/usageProcessing/AccessorToPropertyProcessing.kt
+++ b/j2k/src/org/jetbrains/kotlin/j2k/usageProcessing/AccessorToPropertyProcessing.kt
@@ -19,6 +19,7 @@ package org.jetbrains.kotlin.j2k.usageProcessing
 import com.intellij.psi.*
 import org.jetbrains.kotlin.j2k.AccessorKind
 import org.jetbrains.kotlin.j2k.CodeConverter
+import org.jetbrains.kotlin.j2k.ResolverForConverter
 import org.jetbrains.kotlin.j2k.ast.*
 import org.jetbrains.kotlin.psi.*
 
@@ -53,7 +54,7 @@ class AccessorToPropertyProcessing(val accessorMethod: PsiMethod, val accessorKi
         null
     else
         object : ExternalCodeProcessor {
-            override fun processUsage(reference: PsiReference): Collection<PsiReference>? {
+            override fun processUsage(reference: PsiReference): Array<PsiReference>? {
                 val nameExpr = reference.getElement() as? JetSimpleNameExpression ?: return null
                 val callExpr = nameExpr.getParent() as? JetCallExpression ?: return null
 
@@ -64,7 +65,7 @@ class AccessorToPropertyProcessing(val accessorMethod: PsiMethod, val accessorKi
                 if (accessorKind == AccessorKind.GETTER) {
                     if (arguments.size() != 0) return null // incorrect call
                     propertyNameExpr = callExpr.replace(propertyNameExpr) as JetSimpleNameExpression
-                    return listOf(propertyNameExpr.getReference())
+                    return propertyNameExpr.getReferences()
                 }
                 else {
                     val value = arguments.singleOrNull()?.getArgumentExpression() ?: return null
@@ -76,12 +77,12 @@ class AccessorToPropertyProcessing(val accessorMethod: PsiMethod, val accessorKi
                         callExpr.replace(propertyNameExpr)
                         assignment.getLeft()!!.replace(qualifiedExpression)
                         assignment = qualifiedExpression.replace(assignment) as JetBinaryExpression
-                        return listOf((assignment.getLeft() as JetQualifiedExpression).getSelectorExpression()!!.getReference())
+                        return (assignment.getLeft() as JetQualifiedExpression).getSelectorExpression()!!.getReferences()
                     }
                     else {
                         assignment.getLeft()!!.replace(propertyNameExpr)
                         assignment = callExpr.replace(assignment) as JetBinaryExpression
-                        return listOf(assignment.getLeft()!!.getReference())
+                        return assignment.getLeft()!!.getReferences()
                     }
                 }
 
diff --git a/j2k/src/org/jetbrains/kotlin/j2k/usageProcessing/ElementRenamedCodeProcessor.kt b/j2k/src/org/jetbrains/kotlin/j2k/usageProcessing/ElementRenamedCodeProcessor.kt
index 1a3927fa929..ef0d4608480 100644
--- a/j2k/src/org/jetbrains/kotlin/j2k/usageProcessing/ElementRenamedCodeProcessor.kt
+++ b/j2k/src/org/jetbrains/kotlin/j2k/usageProcessing/ElementRenamedCodeProcessor.kt
@@ -17,10 +17,10 @@
 package org.jetbrains.kotlin.j2k.usageProcessing
 
 import com.intellij.psi.PsiReference
+import org.jetbrains.kotlin.j2k.ResolverForConverter
 
 class ElementRenamedCodeProcessor(private val newName: String) : ExternalCodeProcessor {
-    override fun processUsage(reference: PsiReference): Collection<PsiReference>? {
-        val newReference = reference.handleElementRename(newName).getReference()!!
-        return listOf(newReference)
+    override fun processUsage(reference: PsiReference): Array<PsiReference>? {
+        return reference.handleElementRename(newName).getReferences()
     }
 }
\ No newline at end of file
diff --git a/j2k/src/org/jetbrains/kotlin/j2k/usageProcessing/FieldToPropertyProcessing.kt b/j2k/src/org/jetbrains/kotlin/j2k/usageProcessing/FieldToPropertyProcessing.kt
index 4f968b900c8..d9c55bca34f 100644
--- a/j2k/src/org/jetbrains/kotlin/j2k/usageProcessing/FieldToPropertyProcessing.kt
+++ b/j2k/src/org/jetbrains/kotlin/j2k/usageProcessing/FieldToPropertyProcessing.kt
@@ -68,7 +68,7 @@ class FieldToPropertyProcessing(val field: PsiField, val propertyName: String, v
     private inner class UseAccessorsJavaCodeProcessor : ExternalCodeProcessor {
         private val factory = PsiElementFactory.SERVICE.getInstance(field.getProject())
 
-        override fun processUsage(reference: PsiReference): Collection<PsiReference>? {
+        override fun processUsage(reference: PsiReference): Array<PsiReference>? {
             val refExpr = reference.getElement() as? PsiReferenceExpression ?: return null
             val qualifier = refExpr.getQualifierExpression()
 
@@ -78,7 +78,7 @@ class FieldToPropertyProcessing(val field: PsiField, val propertyName: String, v
                     if (refExpr == parent.getLExpression()) {
                         if (parent.getOperationTokenType() == JavaTokenType.EQ) {
                             val callExpr = parent.replace(generateSetterCall(qualifier, parent.getRExpression() ?: return null)) as PsiMethodCallExpression
-                            return listOf(callExpr.getMethodExpression())
+                            return arrayOf(callExpr.getMethodExpression())
                         }
                         else {
                             val assignmentOpText = parent.getOperationSign().getText()
@@ -107,11 +107,11 @@ class FieldToPropertyProcessing(val field: PsiField, val propertyName: String, v
             }
 
             val callExpr = refExpr.replace(generateGetterCall(qualifier)) as PsiMethodCallExpression
-            return listOf(callExpr.getMethodExpression())
+            return arrayOf(callExpr.getMethodExpression())
         }
 
         //TODO: what if qualifier has side effects?
-        private fun PsiExpression.replaceWithModificationCalls(qualifier: PsiExpression?, op: String, value: PsiExpression): Collection<PsiReference> {
+        private fun PsiExpression.replaceWithModificationCalls(qualifier: PsiExpression?, op: String, value: PsiExpression): Array<PsiReference> {
             var getCall = generateGetterCall(qualifier)
 
             var binary = factory.createExpressionFromText("x $op y", null) as PsiBinaryExpression
@@ -124,7 +124,7 @@ class FieldToPropertyProcessing(val field: PsiField, val propertyName: String, v
             binary = setCall.getArgumentList().getExpressions().single() as PsiBinaryExpression
             getCall = binary.getLOperand() as PsiMethodCallExpression
 
-            return listOf(getCall.getMethodExpression().getReference(), setCall.getMethodExpression().getReference())
+            return arrayOf(getCall.getMethodExpression(), setCall.getMethodExpression())
         }
 
         private fun generateGetterCall(qualifier: PsiExpression?): PsiMethodCallExpression {
diff --git a/j2k/src/org/jetbrains/kotlin/j2k/usageProcessing/MethodIntoObjectProcessing.kt b/j2k/src/org/jetbrains/kotlin/j2k/usageProcessing/MethodIntoObjectProcessing.kt
index d124bc48c23..7efd376cdeb 100644
--- a/j2k/src/org/jetbrains/kotlin/j2k/usageProcessing/MethodIntoObjectProcessing.kt
+++ b/j2k/src/org/jetbrains/kotlin/j2k/usageProcessing/MethodIntoObjectProcessing.kt
@@ -24,19 +24,19 @@ public class MethodIntoObjectProcessing(private val method: PsiMethod, private v
     override val convertedCodeProcessor: ConvertedCodeProcessor? get() = null
 
     override val javaCodeProcessor = object: ExternalCodeProcessor {
-        override fun processUsage(reference: PsiReference): Collection<PsiReference>? {
+        override fun processUsage(reference: PsiReference): Array<PsiReference>? {
             val refExpr = reference.getElement() as? PsiReferenceExpression ?: return null
             val qualifier = refExpr.getQualifierExpression()
             val factory = PsiElementFactory.SERVICE.getInstance(method.getProject())
             if (qualifier != null) {
                 val newQualifier = factory.createExpressionFromText(qualifier.getText() + "." + objectName, null)
                 qualifier.replace(newQualifier)
-                return listOf(reference)
+                return arrayOf(reference)
             }
             else {
                 var qualifiedExpr = factory.createExpressionFromText(objectName + "." + refExpr.getText(), null) as PsiReferenceExpression
                 qualifiedExpr = refExpr.replace(qualifiedExpr) as PsiReferenceExpression
-                return listOf(qualifiedExpr.getReference())
+                return arrayOf(qualifiedExpr)
             }
         }
     }
diff --git a/j2k/src/org/jetbrains/kotlin/j2k/usageProcessing/ToObjectWithOnlyMethodsProcessing.kt b/j2k/src/org/jetbrains/kotlin/j2k/usageProcessing/ToObjectWithOnlyMethodsProcessing.kt
index 768f5e6c916..9b3df209128 100644
--- a/j2k/src/org/jetbrains/kotlin/j2k/usageProcessing/ToObjectWithOnlyMethodsProcessing.kt
+++ b/j2k/src/org/jetbrains/kotlin/j2k/usageProcessing/ToObjectWithOnlyMethodsProcessing.kt
@@ -25,12 +25,12 @@ class ToObjectWithOnlyMethodsProcessing(private val psiClass: PsiClass) : UsageP
     override val convertedCodeProcessor: ConvertedCodeProcessor? get() = null
 
     override val javaCodeProcessor = object: ExternalCodeProcessor {
-        override fun processUsage(reference: PsiReference): Collection<PsiReference>? {
+        override fun processUsage(reference: PsiReference): Array<PsiReference>? {
             val refExpr = reference.getElement() as? PsiReferenceExpression ?: return null
             val factory = PsiElementFactory.SERVICE.getInstance(psiClass.getProject())
             var qualifiedExpr = factory.createExpressionFromText(refExpr.getText() + "." + JvmAbi.INSTANCE_FIELD, null) as PsiReferenceExpression
             qualifiedExpr = refExpr.replace(qualifiedExpr) as PsiReferenceExpression
-            return listOf(qualifiedExpr.getReference())
+            return arrayOf(qualifiedExpr)
         }
     }
 
diff --git a/j2k/src/org/jetbrains/kotlin/j2k/usageProcessing/UsageProcessing.kt b/j2k/src/org/jetbrains/kotlin/j2k/usageProcessing/UsageProcessing.kt
index a08e907e41d..4137d04d942 100644
--- a/j2k/src/org/jetbrains/kotlin/j2k/usageProcessing/UsageProcessing.kt
+++ b/j2k/src/org/jetbrains/kotlin/j2k/usageProcessing/UsageProcessing.kt
@@ -36,7 +36,7 @@ trait ConvertedCodeProcessor {
 }
 
 trait ExternalCodeProcessor {
-    fun processUsage(reference: PsiReference): Collection<PsiReference>?
+    fun processUsage(reference: PsiReference): Array<PsiReference>?
 }
 
 class UsageProcessingExpressionConverter(val processings: Map<PsiElement, Collection<UsageProcessing>>) : SpecialExpressionConverter {
diff --git a/j2k/testData/fileOrElement/annotations/annotationInterface3.kt b/j2k/testData/fileOrElement/annotations/annotationInterface3.kt
index 5bdc3a19d4c..79b2338b2aa 100644
--- a/j2k/testData/fileOrElement/annotations/annotationInterface3.kt
+++ b/j2k/testData/fileOrElement/annotations/annotationInterface3.kt
@@ -2,8 +2,7 @@
 annotation class Anon(public val value: String) {
 
     public enum class E {
-        A,
-        B
+        A, B
     }
 
     companion object {
diff --git a/j2k/testData/fileOrElement/annotations/primaryConstructorAnnotation.java b/j2k/testData/fileOrElement/annotations/primaryConstructorAnnotation.java
new file mode 100644
index 00000000000..d7884d7a6e0
--- /dev/null
+++ b/j2k/testData/fileOrElement/annotations/primaryConstructorAnnotation.java
@@ -0,0 +1,5 @@
+class C {
+    @Deprecated
+    public C() {
+    }
+}
diff --git a/j2k/testData/fileOrElement/annotations/primaryConstructorAnnotation.kt b/j2k/testData/fileOrElement/annotations/primaryConstructorAnnotation.kt
new file mode 100644
index 00000000000..6ec023e61cf
--- /dev/null
+++ b/j2k/testData/fileOrElement/annotations/primaryConstructorAnnotation.kt
@@ -0,0 +1,2 @@
+class C deprecated("")
+constructor()
diff --git a/j2k/testData/fileOrElement/comments/commentsForConstructors.kt b/j2k/testData/fileOrElement/comments/commentsForConstructors.kt
index 65143384217..d957586d9c2 100644
--- a/j2k/testData/fileOrElement/comments/commentsForConstructors.kt
+++ b/j2k/testData/fileOrElement/comments/commentsForConstructors.kt
@@ -1,5 +1,5 @@
 class A// this is a primary constructor
-@jvmOverloads constructor(p: Int = 1) {
+jvmOverloads constructor(p: Int = 1) {
     private val v: Int
 
     init {
diff --git a/j2k/testData/fileOrElement/constructors/allCallsPrimary.kt b/j2k/testData/fileOrElement/constructors/allCallsPrimary.kt
index 641f352b3e2..f27f523b4c2 100644
--- a/j2k/testData/fileOrElement/constructors/allCallsPrimary.kt
+++ b/j2k/testData/fileOrElement/constructors/allCallsPrimary.kt
@@ -1,6 +1,6 @@
 package pack
 
-class C @jvmOverloads constructor(arg1: Int, arg2: Int = 0, arg3: Int = 0)
+class C jvmOverloads constructor(arg1: Int, arg2: Int = 0, arg3: Int = 0)
 
 public object User {
     public fun main() {
diff --git a/j2k/testData/fileOrElement/constructors/constructorAnnotations.kt b/j2k/testData/fileOrElement/constructors/constructorAnnotations.kt
index 6f0536e2457..8c7fca9b05e 100644
--- a/j2k/testData/fileOrElement/constructors/constructorAnnotations.kt
+++ b/j2k/testData/fileOrElement/constructors/constructorAnnotations.kt
@@ -1,7 +1,7 @@
 import javaApi.Anon5
 
 class A
-@Anon5(10)
+Anon5(10)
 constructor(private val a: Int, private val b: Int) {
 
     deprecated("") // this constructor will not be replaced by default parameter value in primary because of this annotation
@@ -9,8 +9,8 @@ constructor(private val a: Int, private val b: Int) {
     }
 }
 
-class B @Anon5(11)
+class B Anon5(11)
 constructor()
 
-class C @Anon5(12)
+class C Anon5(12)
 private constructor()
\ No newline at end of file
diff --git a/j2k/testData/fileOrElement/constructors/fieldsInitializedFromParams9.kt b/j2k/testData/fileOrElement/constructors/fieldsInitializedFromParams9.kt
index 88d23a2e9b6..e4d9bad2519 100644
--- a/j2k/testData/fileOrElement/constructors/fieldsInitializedFromParams9.kt
+++ b/j2k/testData/fileOrElement/constructors/fieldsInitializedFromParams9.kt
@@ -1 +1 @@
-class C @jvmOverloads constructor(private val string: String, a: Int = string.length())
+class C jvmOverloads constructor(private val string: String, a: Int = string.length())
diff --git a/j2k/testData/fileOrElement/constructors/lineBreaksBetweenParameters.java b/j2k/testData/fileOrElement/constructors/lineBreaksBetweenParameters.java
new file mode 100644
index 00000000000..dcdc479bd2a
--- /dev/null
+++ b/j2k/testData/fileOrElement/constructors/lineBreaksBetweenParameters.java
@@ -0,0 +1,23 @@
+class C1 {
+  C1(int arg1,
+     int arg2,
+     int arg3) {
+  }
+
+  C1(int x,
+     int y) {
+      this(x, x + y, 0);
+  }
+}
+
+class C2 {
+  private int arg1;
+  private int arg2;
+
+  C2(int arg1,
+     int arg2,
+     int arg3) {
+      this.arg1 = arg1;
+      this.arg2 = arg2;
+  }
+}
diff --git a/j2k/testData/fileOrElement/constructors/lineBreaksBetweenParameters.kt b/j2k/testData/fileOrElement/constructors/lineBreaksBetweenParameters.kt
new file mode 100644
index 00000000000..76d12031d20
--- /dev/null
+++ b/j2k/testData/fileOrElement/constructors/lineBreaksBetweenParameters.kt
@@ -0,0 +1,12 @@
+class C1(arg1: Int,
+         arg2: Int,
+         arg3: Int) {
+
+    constructor(x: Int,
+                y: Int) : this(x, x + y, 0) {
+    }
+}
+
+class C2(private val arg1: Int,
+         private val arg2: Int,
+         arg3: Int)
diff --git a/j2k/testData/fileOrElement/constructors/nestedClassNameInParameterDefaults.kt b/j2k/testData/fileOrElement/constructors/nestedClassNameInParameterDefaults.kt
index 4cfc913d2e3..76de64b2e04 100644
--- a/j2k/testData/fileOrElement/constructors/nestedClassNameInParameterDefaults.kt
+++ b/j2k/testData/fileOrElement/constructors/nestedClassNameInParameterDefaults.kt
@@ -1,4 +1,4 @@
-class A @jvmOverloads constructor(nested: A.Nested = A.Nested(A.Nested.FIELD)) {
+class A jvmOverloads constructor(nested: A.Nested = A.Nested(A.Nested.FIELD)) {
 
     class Nested(p: Int) {
         companion object {
diff --git a/j2k/testData/fileOrElement/constructors/nestedClassNameInParameterDefaults2.kt b/j2k/testData/fileOrElement/constructors/nestedClassNameInParameterDefaults2.kt
index 47b34921a92..574888bb3c2 100644
--- a/j2k/testData/fileOrElement/constructors/nestedClassNameInParameterDefaults2.kt
+++ b/j2k/testData/fileOrElement/constructors/nestedClassNameInParameterDefaults2.kt
@@ -1,7 +1,7 @@
 // ERROR: Property must be initialized or be abstract
 import A.Nested
 
-class A @jvmOverloads constructor(nested: Nested = Nested(Nested.FIELD)) {
+class A jvmOverloads constructor(nested: Nested = Nested(Nested.FIELD)) {
 
     class Nested(p: Int) {
         companion object {
diff --git a/j2k/testData/fileOrElement/constructors/nestedClassNameInParameterDefaults3.kt b/j2k/testData/fileOrElement/constructors/nestedClassNameInParameterDefaults3.kt
index 02974eb4e03..8b2dbc2204f 100644
--- a/j2k/testData/fileOrElement/constructors/nestedClassNameInParameterDefaults3.kt
+++ b/j2k/testData/fileOrElement/constructors/nestedClassNameInParameterDefaults3.kt
@@ -3,7 +3,7 @@ package pack
 
 import pack.A.Nested
 
-class A @jvmOverloads constructor(nested: Nested = Nested(Nested.FIELD)) {
+class A jvmOverloads constructor(nested: Nested = Nested(Nested.FIELD)) {
 
     class Nested(p: Int) {
         companion object {
diff --git a/j2k/testData/fileOrElement/constructors/nestedClassNameInParameterDefaults4.kt b/j2k/testData/fileOrElement/constructors/nestedClassNameInParameterDefaults4.kt
index 54cda87bb39..7b9aabf0fff 100644
--- a/j2k/testData/fileOrElement/constructors/nestedClassNameInParameterDefaults4.kt
+++ b/j2k/testData/fileOrElement/constructors/nestedClassNameInParameterDefaults4.kt
@@ -3,7 +3,7 @@ package pack
 
 import pack.A.*
 
-class A @jvmOverloads constructor(nested: Nested = Nested(Nested.FIELD)) {
+class A jvmOverloads constructor(nested: Nested = Nested(Nested.FIELD)) {
 
     class Nested(p: Int) {
         companion object {
diff --git a/j2k/testData/fileOrElement/constructors/parameterDefaults1.kt b/j2k/testData/fileOrElement/constructors/parameterDefaults1.kt
index 969d9e5859d..be71bc80587 100644
--- a/j2k/testData/fileOrElement/constructors/parameterDefaults1.kt
+++ b/j2k/testData/fileOrElement/constructors/parameterDefaults1.kt
@@ -1,6 +1,6 @@
 package pack
 
-class C @jvmOverloads constructor(a: Int = 0, b: Int = 0, c: Int = 0, d: Int = 0, e: Int = 0) {
+class C jvmOverloads constructor(a: Int = 0, b: Int = 0, c: Int = 0, d: Int = 0, e: Int = 0) {
 
     constructor(a: Int) : this(a, 0, 0, 0, 1) {
     }
diff --git a/j2k/testData/fileOrElement/constructors/parameterDefaults2.kt b/j2k/testData/fileOrElement/constructors/parameterDefaults2.kt
index 06fd8dd541c..f78ffe62d4f 100644
--- a/j2k/testData/fileOrElement/constructors/parameterDefaults2.kt
+++ b/j2k/testData/fileOrElement/constructors/parameterDefaults2.kt
@@ -1,6 +1,6 @@
 package pack
 
-class C @jvmOverloads constructor(a: Int = 0, b: Int = 0, c: Int = 0, d: Int = 0, e: Int = 0) {
+class C jvmOverloads constructor(a: Int = 0, b: Int = 0, c: Int = 0, d: Int = 0, e: Int = 0) {
 
     constructor(a1: Int, b1: Int, c1: Int) : this(a1, b1, c1, 0, 0) {
     }
diff --git a/j2k/testData/fileOrElement/constructors/parameterDefaults3.kt b/j2k/testData/fileOrElement/constructors/parameterDefaults3.kt
index fb0f2dcd634..3ed89327e4c 100644
--- a/j2k/testData/fileOrElement/constructors/parameterDefaults3.kt
+++ b/j2k/testData/fileOrElement/constructors/parameterDefaults3.kt
@@ -1,6 +1,6 @@
 package pack
 
-class C @jvmOverloads constructor(a: Int = 0, b: Int = 0, c: Int = 0, d: Int = 0, e: Int = 0) {
+class C jvmOverloads constructor(a: Int = 0, b: Int = 0, c: Int = 0, d: Int = 0, e: Int = 0) {
 
     constructor(a: Int, b: Int, c: Int) : this(b, a, c, 0, 0) {
     }
diff --git a/j2k/testData/fileOrElement/constructors/parameterDefaults4.kt b/j2k/testData/fileOrElement/constructors/parameterDefaults4.kt
index 66e6bbb9d8c..c37cbf22911 100644
--- a/j2k/testData/fileOrElement/constructors/parameterDefaults4.kt
+++ b/j2k/testData/fileOrElement/constructors/parameterDefaults4.kt
@@ -1,3 +1,3 @@
 package pack
 
-class C @jvmOverloads constructor(a: Int = 1, b: Int = 2, c: Int = 3, d: Int = 4, e: Int = 5)
+class C jvmOverloads constructor(a: Int = 1, b: Int = 2, c: Int = 3, d: Int = 4, e: Int = 5)
diff --git a/j2k/testData/fileOrElement/constructors/parameterDefaults5.kt b/j2k/testData/fileOrElement/constructors/parameterDefaults5.kt
index 66e6bbb9d8c..c37cbf22911 100644
--- a/j2k/testData/fileOrElement/constructors/parameterDefaults5.kt
+++ b/j2k/testData/fileOrElement/constructors/parameterDefaults5.kt
@@ -1,3 +1,3 @@
 package pack
 
-class C @jvmOverloads constructor(a: Int = 1, b: Int = 2, c: Int = 3, d: Int = 4, e: Int = 5)
+class C jvmOverloads constructor(a: Int = 1, b: Int = 2, c: Int = 3, d: Int = 4, e: Int = 5)
diff --git a/j2k/testData/fileOrElement/constructors/parameterModification.kt b/j2k/testData/fileOrElement/constructors/parameterModification.kt
index 242266a8493..913e836e98c 100644
--- a/j2k/testData/fileOrElement/constructors/parameterModification.kt
+++ b/j2k/testData/fileOrElement/constructors/parameterModification.kt
@@ -1,5 +1,5 @@
 // ERROR: Overload resolution ambiguity:  public constructor C(arg1: kotlin.Int, arg2: kotlin.Int) defined in C kotlin.jvm.jvmOverloads public constructor C(arg1: kotlin.Int, arg2: kotlin.Int = ..., arg3: kotlin.Int = ...) defined in C
-class C @jvmOverloads constructor(arg1: Int, arg2: Int = 0, arg3: Int = 0) {
+class C jvmOverloads constructor(arg1: Int, arg2: Int = 0, arg3: Int = 0) {
     private val field: Int
 
     init {
diff --git a/j2k/testData/fileOrElement/constructors/privateConstructors.kt b/j2k/testData/fileOrElement/constructors/privateConstructors.kt
index 596457e9d9c..ab666511241 100644
--- a/j2k/testData/fileOrElement/constructors/privateConstructors.kt
+++ b/j2k/testData/fileOrElement/constructors/privateConstructors.kt
@@ -1,4 +1,4 @@
-class C @jvmOverloads private constructor(arg1: Int, arg2: Int, arg3: Int = 0) {
+class C private constructor(arg1: Int, arg2: Int, arg3: Int = 0) {
 
     public constructor(arg1: Int) : this(arg1, 0, 0) {
     }
diff --git a/j2k/testData/fileOrElement/dropAccessors/DifferentFieldNameAndDefaultParameterValue.kt b/j2k/testData/fileOrElement/dropAccessors/DifferentFieldNameAndDefaultParameterValue.kt
index 28483976d56..6ea6a413b52 100644
--- a/j2k/testData/fileOrElement/dropAccessors/DifferentFieldNameAndDefaultParameterValue.kt
+++ b/j2k/testData/fileOrElement/dropAccessors/DifferentFieldNameAndDefaultParameterValue.kt
@@ -1 +1 @@
-public class C @jvmOverloads constructor(c: C, public val x: Int = c.x)
+public class C jvmOverloads constructor(c: C, public val x: Int = c.x)
diff --git a/j2k/testData/fileOrElement/enum/fieldsWithPrimaryPrivateConstructor.kt b/j2k/testData/fileOrElement/enum/fieldsWithPrimaryPrivateConstructor.kt
index ddb41f893bf..f0f503b4628 100644
--- a/j2k/testData/fileOrElement/enum/fieldsWithPrimaryPrivateConstructor.kt
+++ b/j2k/testData/fileOrElement/enum/fieldsWithPrimaryPrivateConstructor.kt
@@ -1,7 +1,3 @@
 enum class Color private constructor(public val code: Int) {
-    WHITE(21),
-    BLACK(22),
-    RED(23),
-    YELLOW(24),
-    BLUE(25)
+    WHITE(21), BLACK(22), RED(23), YELLOW(24), BLUE(25)
 }
\ No newline at end of file
diff --git a/j2k/testData/fileOrElement/enum/overrideToString.kt b/j2k/testData/fileOrElement/enum/overrideToString.kt
index 0e183306785..7398b2f16ad 100644
--- a/j2k/testData/fileOrElement/enum/overrideToString.kt
+++ b/j2k/testData/fileOrElement/enum/overrideToString.kt
@@ -1,9 +1,5 @@
 enum class Color {
-    WHITE,
-    BLACK,
-    RED,
-    YELLOW,
-    BLUE;
+    WHITE, BLACK, RED, YELLOW, BLUE;
     override fun toString(): String {
         return "COLOR"
     }
diff --git a/j2k/testData/fileOrElement/enum/runnableImplementation.kt b/j2k/testData/fileOrElement/enum/runnableImplementation.kt
index 8cccda48f33..b98ef8c5fcd 100644
--- a/j2k/testData/fileOrElement/enum/runnableImplementation.kt
+++ b/j2k/testData/fileOrElement/enum/runnableImplementation.kt
@@ -1,9 +1,5 @@
 enum class Color : Runnable {
-    WHITE,
-    BLACK,
-    RED,
-    YELLOW,
-    BLUE;
+    WHITE, BLACK, RED, YELLOW, BLUE;
 
     override fun run() {
         println("name()=" + name() + ", toString()=" + toString())
diff --git a/j2k/testData/fileOrElement/enum/typeSafeEnum.kt b/j2k/testData/fileOrElement/enum/typeSafeEnum.kt
index d6b5b5b6992..efd813b561a 100644
--- a/j2k/testData/fileOrElement/enum/typeSafeEnum.kt
+++ b/j2k/testData/fileOrElement/enum/typeSafeEnum.kt
@@ -1,6 +1,3 @@
 enum class Coin {
-    PENNY,
-    NICKEL,
-    DIME,
-    QUARTER
+    PENNY, NICKEL, DIME, QUARTER
 }
\ No newline at end of file
diff --git a/j2k/testData/fileOrElement/equals/EqOperator.java b/j2k/testData/fileOrElement/equals/EqOperator.java
index b531b011f7f..163a2caf999 100644
--- a/j2k/testData/fileOrElement/equals/EqOperator.java
+++ b/j2k/testData/fileOrElement/equals/EqOperator.java
@@ -20,8 +20,12 @@ class B {
 
 final class BB extends B {}
 
+enum EE {
+    A, B, C
+}
+
 class X {
-    void foo(I i1, I i2, String s1, String s2, C c1, C c2, int i, O o1, O o2, E e1, E e2, BB bb1, BB bb2, int[] arr1, int[] arr2) {
+    void foo(I i1, I i2, String s1, String s2, C c1, C c2, int i, O o1, O o2, E e1, E e2, BB bb1, BB bb2, int[] arr1, int[] arr2, EE ee1, EE ee2) {
         if (i1 == i2) return;
         if (s1 == s2) return;
         if (c1 == c2) return;
@@ -32,6 +36,7 @@ class X {
         if (e1 == e2) return;
         if (bb1 == bb2) return;
         if (arr1 == arr2) return;
+        if (ee1 == ee2 || ee1 == null) return;
 
         if (s1 != s2) return;
         if (c1 != c2) return;
diff --git a/j2k/testData/fileOrElement/equals/EqOperator.kt b/j2k/testData/fileOrElement/equals/EqOperator.kt
index a4c061231cd..b551d93ef08 100644
--- a/j2k/testData/fileOrElement/equals/EqOperator.kt
+++ b/j2k/testData/fileOrElement/equals/EqOperator.kt
@@ -18,8 +18,12 @@ open class B {
 
 class BB : B()
 
+enum class EE {
+    A, B, C
+}
+
 class X {
-    fun foo(i1: I?, i2: I?, s1: String, s2: String, c1: C, c2: C, i: Int, o1: O, o2: O, e1: E, e2: E, bb1: BB, bb2: BB, arr1: IntArray, arr2: IntArray) {
+    fun foo(i1: I?, i2: I?, s1: String, s2: String, c1: C, c2: C, i: Int, o1: O, o2: O, e1: E, e2: E, bb1: BB, bb2: BB, arr1: IntArray, arr2: IntArray, ee1: EE?, ee2: EE) {
         if (i1 === i2) return
         if (s1 === s2) return
         if (c1 == c2) return
@@ -30,6 +34,7 @@ class X {
         if (e1 === e2) return
         if (bb1 === bb2) return
         if (arr1 == arr2) return
+        if (ee1 == ee2 || ee1 == null) return
 
         if (s1 !== s2) return
         if (c1 != c2) return
diff --git a/j2k/testData/fileOrElement/formatting/lineBreaksBetweenArguments.java b/j2k/testData/fileOrElement/formatting/lineBreaksBetweenArguments.java
new file mode 100644
index 00000000000..987e612778f
--- /dev/null
+++ b/j2k/testData/fileOrElement/formatting/lineBreaksBetweenArguments.java
@@ -0,0 +1,10 @@
+class F {
+  void f1(int p1, int p2, int p3, int p4, int... p5) {
+  }
+
+  void f2(int[] array) {
+    f1(1, 2,
+       3, 4,
+       array);
+  }
+}
\ No newline at end of file
diff --git a/j2k/testData/fileOrElement/formatting/lineBreaksBetweenArguments.kt b/j2k/testData/fileOrElement/formatting/lineBreaksBetweenArguments.kt
new file mode 100644
index 00000000000..f9674a2a7eb
--- /dev/null
+++ b/j2k/testData/fileOrElement/formatting/lineBreaksBetweenArguments.kt
@@ -0,0 +1,10 @@
+class F {
+    fun f1(p1: Int, p2: Int, p3: Int, p4: Int, vararg p5: Int) {
+    }
+
+    fun f2(array: IntArray) {
+        f1(1, 2,
+                3, 4,
+                *array)
+    }
+}
diff --git a/j2k/testData/fileOrElement/function/lineBreaksBetweenParameters.java b/j2k/testData/fileOrElement/function/lineBreaksBetweenParameters.java
new file mode 100644
index 00000000000..57e90347270
--- /dev/null
+++ b/j2k/testData/fileOrElement/function/lineBreaksBetweenParameters.java
@@ -0,0 +1,19 @@
+class C {
+    public void foo1(int p1, int p2) {
+    }
+
+    public void foo2(
+            int p1,
+            int p2) {
+    }
+
+    public void foo3(int p1,
+            int p2) {
+    }
+
+    public void foo4(
+            int p1, int p2,
+            int p3, int p4
+    ) {
+    }
+}
\ No newline at end of file
diff --git a/j2k/testData/fileOrElement/function/lineBreaksBetweenParameters.kt b/j2k/testData/fileOrElement/function/lineBreaksBetweenParameters.kt
new file mode 100644
index 00000000000..959616fa353
--- /dev/null
+++ b/j2k/testData/fileOrElement/function/lineBreaksBetweenParameters.kt
@@ -0,0 +1,18 @@
+class C {
+    public fun foo1(p1: Int, p2: Int) {
+    }
+
+    public fun foo2(
+            p1: Int,
+            p2: Int) {
+    }
+
+    public fun foo3(p1: Int,
+                    p2: Int) {
+    }
+
+    public fun foo4(
+            p1: Int, p2: Int,
+            p3: Int, p4: Int) {
+    }
+}
diff --git a/j2k/testData/fileOrElement/list/Lists.kt b/j2k/testData/fileOrElement/list/Lists.kt
index 43f2676a7d7..c8f66c6c118 100644
--- a/j2k/testData/fileOrElement/list/Lists.kt
+++ b/j2k/testData/fileOrElement/list/Lists.kt
@@ -1,4 +1,6 @@
 // ERROR: Unresolved reference: LinkedList
+// ERROR: None of the following functions can be called with the arguments supplied:  public open fun add(e: kotlin.Any): kotlin.Boolean defined in java.util.ArrayList public open fun add(index: kotlin.Int, element: kotlin.Any): kotlin.Unit defined in java.util.ArrayList
+// ERROR: None of the following functions can be called with the arguments supplied:  public open fun add(e: kotlin.Any): kotlin.Boolean defined in java.util.ArrayList public open fun add(index: kotlin.Int, element: kotlin.Any): kotlin.Unit defined in java.util.ArrayList
 import java.util.*
 
 public class Lists {
diff --git a/j2k/testData/fileOrElement/mutableCollections/FunctionParameters.kt b/j2k/testData/fileOrElement/mutableCollections/FunctionParameters.kt
index d6f0a1f5546..0d7419538a0 100644
--- a/j2k/testData/fileOrElement/mutableCollections/FunctionParameters.kt
+++ b/j2k/testData/fileOrElement/mutableCollections/FunctionParameters.kt
@@ -2,7 +2,10 @@
 import java.util.*
 
 class A<T> {
-    fun foo(nonMutableCollection: Collection<String>, mutableCollection: MutableCollection<String>, mutableSet: MutableSet<T>, mutableMap: MutableMap<String, T>) {
+    fun foo(nonMutableCollection: Collection<String>,
+            mutableCollection: MutableCollection<String>,
+            mutableSet: MutableSet<T>,
+            mutableMap: MutableMap<String, T>) {
         mutableCollection.addAll(nonMutableCollection)
         mutableSet.add(mutableMap.remove("a"))
     }
diff --git a/j2k/testData/fileOrElement/newClassExpression/lineBreaks.java b/j2k/testData/fileOrElement/newClassExpression/lineBreaks.java
new file mode 100644
index 00000000000..d146592c022
--- /dev/null
+++ b/j2k/testData/fileOrElement/newClassExpression/lineBreaks.java
@@ -0,0 +1,11 @@
+class C {
+  C(int p1, int p2, int p3){}
+}
+
+class User {
+  void foo() {
+    new C(1,
+          2,
+          3);
+  }
+}
\ No newline at end of file
diff --git a/j2k/testData/fileOrElement/newClassExpression/lineBreaks.kt b/j2k/testData/fileOrElement/newClassExpression/lineBreaks.kt
new file mode 100644
index 00000000000..0360b5286d6
--- /dev/null
+++ b/j2k/testData/fileOrElement/newClassExpression/lineBreaks.kt
@@ -0,0 +1,9 @@
+class C(p1: Int, p2: Int, p3: Int)
+
+class User {
+    fun foo() {
+        C(1,
+                2,
+                3)
+    }
+}
diff --git a/j2k/testData/fileOrElement/overloads/Private.java b/j2k/testData/fileOrElement/overloads/Private.java
new file mode 100644
index 00000000000..f064f32fe48
--- /dev/null
+++ b/j2k/testData/fileOrElement/overloads/Private.java
@@ -0,0 +1,10 @@
+class A {
+    private int bar(String s) {
+        System.out.println("s = " + s);
+        return 0;
+    }
+
+    private int bar() {
+        return bar(null);
+    }
+}
\ No newline at end of file
diff --git a/j2k/testData/fileOrElement/overloads/Private.kt b/j2k/testData/fileOrElement/overloads/Private.kt
new file mode 100644
index 00000000000..c4c1b0b9554
--- /dev/null
+++ b/j2k/testData/fileOrElement/overloads/Private.kt
@@ -0,0 +1,6 @@
+class A {
+    private fun bar(s: String? = null): Int {
+        println("s = " + s!!)
+        return 0
+    }
+}
diff --git a/j2k/tests/org/jetbrains/kotlin/j2k/JavaToKotlinConverterForWebDemoTestGenerated.java b/j2k/tests/org/jetbrains/kotlin/j2k/JavaToKotlinConverterForWebDemoTestGenerated.java
index aaa0fa2214b..3b2bfe64fb9 100644
--- a/j2k/tests/org/jetbrains/kotlin/j2k/JavaToKotlinConverterForWebDemoTestGenerated.java
+++ b/j2k/tests/org/jetbrains/kotlin/j2k/JavaToKotlinConverterForWebDemoTestGenerated.java
@@ -102,6 +102,12 @@ public class JavaToKotlinConverterForWebDemoTestGenerated extends AbstractJavaTo
             String fileName = JetTestUtils.navigationMetadata("j2k/testData/fileOrElement/annotations/jetbrainsNullable.java");
             doTest(fileName);
         }
+
+        @TestMetadata("primaryConstructorAnnotation.java")
+        public void testPrimaryConstructorAnnotation() throws Exception {
+            String fileName = JetTestUtils.navigationMetadata("j2k/testData/fileOrElement/annotations/primaryConstructorAnnotation.java");
+            doTest(fileName);
+        }
     }
 
     @TestMetadata("j2k/testData/fileOrElement/anonymousBlock")
@@ -1162,6 +1168,12 @@ public class JavaToKotlinConverterForWebDemoTestGenerated extends AbstractJavaTo
             doTest(fileName);
         }
 
+        @TestMetadata("lineBreaksBetweenParameters.java")
+        public void testLineBreaksBetweenParameters() throws Exception {
+            String fileName = JetTestUtils.navigationMetadata("j2k/testData/fileOrElement/constructors/lineBreaksBetweenParameters.java");
+            doTest(fileName);
+        }
+
         @TestMetadata("methodCallInFactoryFun.java")
         public void testMethodCallInFactoryFun() throws Exception {
             String fileName = JetTestUtils.navigationMetadata("j2k/testData/fileOrElement/constructors/methodCallInFactoryFun.java");
@@ -2149,6 +2161,12 @@ public class JavaToKotlinConverterForWebDemoTestGenerated extends AbstractJavaTo
             JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("j2k/testData/fileOrElement/formatting"), Pattern.compile("^(.+)\\.java$"), true);
         }
 
+        @TestMetadata("lineBreaksBetweenArguments.java")
+        public void testLineBreaksBetweenArguments() throws Exception {
+            String fileName = JetTestUtils.navigationMetadata("j2k/testData/fileOrElement/formatting/lineBreaksBetweenArguments.java");
+            doTest(fileName);
+        }
+
         @TestMetadata("nonStaticMembers.java")
         public void testNonStaticMembers() throws Exception {
             String fileName = JetTestUtils.navigationMetadata("j2k/testData/fileOrElement/formatting/nonStaticMembers.java");
@@ -2224,6 +2242,12 @@ public class JavaToKotlinConverterForWebDemoTestGenerated extends AbstractJavaTo
             doTest(fileName);
         }
 
+        @TestMetadata("lineBreaksBetweenParameters.java")
+        public void testLineBreaksBetweenParameters() throws Exception {
+            String fileName = JetTestUtils.navigationMetadata("j2k/testData/fileOrElement/function/lineBreaksBetweenParameters.java");
+            doTest(fileName);
+        }
+
         @TestMetadata("main.java")
         public void testMain() throws Exception {
             String fileName = JetTestUtils.navigationMetadata("j2k/testData/fileOrElement/function/main.java");
@@ -3211,6 +3235,12 @@ public class JavaToKotlinConverterForWebDemoTestGenerated extends AbstractJavaTo
             doTest(fileName);
         }
 
+        @TestMetadata("lineBreaks.java")
+        public void testLineBreaks() throws Exception {
+            String fileName = JetTestUtils.navigationMetadata("j2k/testData/fileOrElement/newClassExpression/lineBreaks.java");
+            doTest(fileName);
+        }
+
         @TestMetadata("newAnonymousClass.java")
         public void testNewAnonymousClass() throws Exception {
             String fileName = JetTestUtils.navigationMetadata("j2k/testData/fileOrElement/newClassExpression/newAnonymousClass.java");
@@ -3490,6 +3520,12 @@ public class JavaToKotlinConverterForWebDemoTestGenerated extends AbstractJavaTo
             doTest(fileName);
         }
 
+        @TestMetadata("Private.java")
+        public void testPrivate() throws Exception {
+            String fileName = JetTestUtils.navigationMetadata("j2k/testData/fileOrElement/overloads/Private.java");
+            doTest(fileName);
+        }
+
         @TestMetadata("Simple.java")
         public void testSimple() throws Exception {
             String fileName = JetTestUtils.navigationMetadata("j2k/testData/fileOrElement/overloads/Simple.java");
diff --git a/j2k/tests/org/jetbrains/kotlin/j2k/JavaToKotlinConverterSingleFileTestGenerated.java b/j2k/tests/org/jetbrains/kotlin/j2k/JavaToKotlinConverterSingleFileTestGenerated.java
index 536b309d158..2112ee1469e 100644
--- a/j2k/tests/org/jetbrains/kotlin/j2k/JavaToKotlinConverterSingleFileTestGenerated.java
+++ b/j2k/tests/org/jetbrains/kotlin/j2k/JavaToKotlinConverterSingleFileTestGenerated.java
@@ -102,6 +102,12 @@ public class JavaToKotlinConverterSingleFileTestGenerated extends AbstractJavaTo
             String fileName = JetTestUtils.navigationMetadata("j2k/testData/fileOrElement/annotations/jetbrainsNullable.java");
             doTest(fileName);
         }
+
+        @TestMetadata("primaryConstructorAnnotation.java")
+        public void testPrimaryConstructorAnnotation() throws Exception {
+            String fileName = JetTestUtils.navigationMetadata("j2k/testData/fileOrElement/annotations/primaryConstructorAnnotation.java");
+            doTest(fileName);
+        }
     }
 
     @TestMetadata("j2k/testData/fileOrElement/anonymousBlock")
@@ -1162,6 +1168,12 @@ public class JavaToKotlinConverterSingleFileTestGenerated extends AbstractJavaTo
             doTest(fileName);
         }
 
+        @TestMetadata("lineBreaksBetweenParameters.java")
+        public void testLineBreaksBetweenParameters() throws Exception {
+            String fileName = JetTestUtils.navigationMetadata("j2k/testData/fileOrElement/constructors/lineBreaksBetweenParameters.java");
+            doTest(fileName);
+        }
+
         @TestMetadata("methodCallInFactoryFun.java")
         public void testMethodCallInFactoryFun() throws Exception {
             String fileName = JetTestUtils.navigationMetadata("j2k/testData/fileOrElement/constructors/methodCallInFactoryFun.java");
@@ -2149,6 +2161,12 @@ public class JavaToKotlinConverterSingleFileTestGenerated extends AbstractJavaTo
             JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("j2k/testData/fileOrElement/formatting"), Pattern.compile("^(.+)\\.java$"), true);
         }
 
+        @TestMetadata("lineBreaksBetweenArguments.java")
+        public void testLineBreaksBetweenArguments() throws Exception {
+            String fileName = JetTestUtils.navigationMetadata("j2k/testData/fileOrElement/formatting/lineBreaksBetweenArguments.java");
+            doTest(fileName);
+        }
+
         @TestMetadata("nonStaticMembers.java")
         public void testNonStaticMembers() throws Exception {
             String fileName = JetTestUtils.navigationMetadata("j2k/testData/fileOrElement/formatting/nonStaticMembers.java");
@@ -2224,6 +2242,12 @@ public class JavaToKotlinConverterSingleFileTestGenerated extends AbstractJavaTo
             doTest(fileName);
         }
 
+        @TestMetadata("lineBreaksBetweenParameters.java")
+        public void testLineBreaksBetweenParameters() throws Exception {
+            String fileName = JetTestUtils.navigationMetadata("j2k/testData/fileOrElement/function/lineBreaksBetweenParameters.java");
+            doTest(fileName);
+        }
+
         @TestMetadata("main.java")
         public void testMain() throws Exception {
             String fileName = JetTestUtils.navigationMetadata("j2k/testData/fileOrElement/function/main.java");
@@ -3211,6 +3235,12 @@ public class JavaToKotlinConverterSingleFileTestGenerated extends AbstractJavaTo
             doTest(fileName);
         }
 
+        @TestMetadata("lineBreaks.java")
+        public void testLineBreaks() throws Exception {
+            String fileName = JetTestUtils.navigationMetadata("j2k/testData/fileOrElement/newClassExpression/lineBreaks.java");
+            doTest(fileName);
+        }
+
         @TestMetadata("newAnonymousClass.java")
         public void testNewAnonymousClass() throws Exception {
             String fileName = JetTestUtils.navigationMetadata("j2k/testData/fileOrElement/newClassExpression/newAnonymousClass.java");
@@ -3490,6 +3520,12 @@ public class JavaToKotlinConverterSingleFileTestGenerated extends AbstractJavaTo
             doTest(fileName);
         }
 
+        @TestMetadata("Private.java")
+        public void testPrivate() throws Exception {
+            String fileName = JetTestUtils.navigationMetadata("j2k/testData/fileOrElement/overloads/Private.java");
+            doTest(fileName);
+        }
+
         @TestMetadata("Simple.java")
         public void testSimple() throws Exception {
             String fileName = JetTestUtils.navigationMetadata("j2k/testData/fileOrElement/overloads/Simple.java");
diff --git a/jps-plugin/src/org/jetbrains/kotlin/jps/incremental/IncrementalCacheImpl.kt b/jps-plugin/src/org/jetbrains/kotlin/jps/incremental/IncrementalCacheImpl.kt
index 7e04e7c4052..2fb84a3378a 100644
--- a/jps-plugin/src/org/jetbrains/kotlin/jps/incremental/IncrementalCacheImpl.kt
+++ b/jps-plugin/src/org/jetbrains/kotlin/jps/incremental/IncrementalCacheImpl.kt
@@ -150,14 +150,14 @@ public class IncrementalCacheImpl(targetDataRoot: File) : StorageOwner, Incremen
         val decision = when {
             header.isCompatiblePackageFacadeKind() ->
                 getRecompilationDecision(
-                        protoChanged = protoMap.put(className, BitEncoding.decodeBytes(header.annotationData)),
+                        protoChanged = protoMap.put(className, BitEncoding.decodeBytes(header.annotationData!!)),
                         constantsChanged = false,
                         inlinesChanged = false
                 )
             header.isCompatibleClassKind() ->
                 when (header.classKind!!) {
                     JvmAnnotationNames.KotlinClass.Kind.CLASS -> getRecompilationDecision(
-                            protoChanged = protoMap.put(className, BitEncoding.decodeBytes(header.annotationData)),
+                            protoChanged = protoMap.put(className, BitEncoding.decodeBytes(header.annotationData!!)),
                             constantsChanged = constantsMap.process(className, fileBytes),
                             inlinesChanged = inlineFunctionsMap.process(className, fileBytes)
                     )
diff --git a/jps-plugin/test/org/jetbrains/kotlin/jps/build/AbstractIncrementalJpsTest.kt b/jps-plugin/test/org/jetbrains/kotlin/jps/build/AbstractIncrementalJpsTest.kt
index 6ae59235b9c..5da8374ea31 100644
--- a/jps-plugin/test/org/jetbrains/kotlin/jps/build/AbstractIncrementalJpsTest.kt
+++ b/jps-plugin/test/org/jetbrains/kotlin/jps/build/AbstractIncrementalJpsTest.kt
@@ -292,7 +292,7 @@ public abstract class AbstractIncrementalJpsTest : JpsBuildTestCase() {
 
             val mapping = project.dataManager.getSourceToOutputMap(target)
             mapping.getSources().forEach {
-                val outputs = mapping.getOutputs(it).sort()
+                val outputs = mapping.getOutputs(it)!!.sort()
                 if (outputs.isNotEmpty()) {
                     result.println("source $it -> " + outputs)
                 }
diff --git a/jps-plugin/test/org/jetbrains/kotlin/jps/build/KotlinJpsBuildTest.java b/jps-plugin/test/org/jetbrains/kotlin/jps/build/KotlinJpsBuildTest.java
deleted file mode 100644
index b2e15a5f3bc..00000000000
--- a/jps-plugin/test/org/jetbrains/kotlin/jps/build/KotlinJpsBuildTest.java
+++ /dev/null
@@ -1,675 +0,0 @@
-/*
- * Copyright 2010-2015 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.kotlin.jps.build;
-
-import com.google.common.collect.Lists;
-import com.intellij.openapi.util.Condition;
-import com.intellij.openapi.util.io.FileUtil;
-import com.intellij.openapi.util.io.FileUtilRt;
-import com.intellij.testFramework.LightVirtualFile;
-import com.intellij.util.ArrayUtil;
-import com.intellij.util.containers.ContainerUtil;
-import com.intellij.util.io.ZipUtil;
-import kotlin.KotlinPackage;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-import org.jetbrains.jps.builders.BuildResult;
-import org.jetbrains.jps.builders.impl.BuildDataPathsImpl;
-import org.jetbrains.jps.model.java.JpsJavaDependencyScope;
-import org.jetbrains.jps.model.java.JpsJavaExtensionService;
-import org.jetbrains.jps.model.module.JpsModule;
-import org.jetbrains.jps.util.JpsPathUtil;
-import org.jetbrains.kotlin.codegen.AsmUtil;
-import org.jetbrains.kotlin.load.kotlin.PackagePartClassUtils;
-import org.jetbrains.kotlin.name.FqName;
-import org.jetbrains.kotlin.test.MockLibraryUtil;
-import org.jetbrains.kotlin.utils.PathUtil;
-import org.jetbrains.org.objectweb.asm.ClassReader;
-import org.jetbrains.org.objectweb.asm.ClassVisitor;
-import org.jetbrains.org.objectweb.asm.MethodVisitor;
-import org.jetbrains.org.objectweb.asm.Opcodes;
-
-import java.io.File;
-import java.io.FileNotFoundException;
-import java.io.FileOutputStream;
-import java.io.IOException;
-import java.util.*;
-import java.util.regex.Pattern;
-import java.util.zip.ZipOutputStream;
-
-import static com.intellij.openapi.util.io.FileUtil.toSystemIndependentName;
-
-public class KotlinJpsBuildTest extends AbstractKotlinJpsBuildTestCase {
-    private static final String PROJECT_NAME = "kotlinProject";
-    private static final String ADDITIONAL_MODULE_NAME = "module2";
-    private static final String JDK_NAME = "IDEA_JDK";
-
-    private static final String[] EXCLUDE_FILES = { "Excluded.class", "YetAnotherExcluded.class" };
-    private static final String[] NOTHING = {};
-    private static final String KOTLIN_JS_LIBRARY = "jslib-example";
-    private static final String PATH_TO_KOTLIN_JS_LIBRARY = TEST_DATA_PATH + "general/KotlinJavaScriptProjectWithDirectoryAsLibrary/" + KOTLIN_JS_LIBRARY;
-    private static final String KOTLIN_JS_LIBRARY_JAR = KOTLIN_JS_LIBRARY + ".jar";
-    private static final Set<String> EXPECTED_JS_FILES_IN_OUTPUT_FOR_STDLIB_ONLY = KotlinPackage.hashSetOf(
-            PROJECT_NAME + ".js",
-            PROJECT_NAME + ".meta.js",
-            "lib/kotlin.js",
-            "lib/stdlib.meta.js"
-    );
-    private static final Set<String> EXPECTED_JS_FILES_IN_OUTPUT_FOR_MODULE_STDLIB_ONLY = KotlinPackage.hashSetOf(
-            ADDITIONAL_MODULE_NAME + ".js",
-            ADDITIONAL_MODULE_NAME + ".meta.js",
-            "lib/kotlin.js",
-            "lib/stdlib.meta.js"
-    );
-    private static final Set<String> EXPECTED_JS_FILES_IN_OUTPUT_NO_COPY = KotlinPackage.hashSetOf(
-            PROJECT_NAME + ".js",
-            PROJECT_NAME + ".meta.js"
-    );
-    private static final Set<String> EXPECTED_JS_FILES_IN_OUTPUT_WITH_ADDITIONAL_LIB_AND_DEFAULT_DIR =
-        KotlinPackage.hashSetOf(
-            PROJECT_NAME + ".js",
-            PROJECT_NAME + ".meta.js",
-            "lib/kotlin.js",
-            "lib/stdlib.meta.js",
-            "lib/jslib-example.js",
-            "lib/file0.js",
-            "lib/dir/file1.js",
-            "lib/META-INF-ex/file2.js",
-            "lib/res0.js",
-            "lib/resdir/res1.js");
-    private static final Set<String> EXPECTED_JS_FILES_IN_OUTPUT_WITH_ADDITIONAL_LIB_AND_CUSTOM_DIR =
-        KotlinPackage.hashSetOf(
-            PROJECT_NAME + ".js",
-            PROJECT_NAME + ".meta.js",
-            "custom/kotlin.js",
-            "custom/stdlib.meta.js",
-            "custom/jslib-example.js",
-            "custom/file0.js",
-            "custom/dir/file1.js",
-            "custom/META-INF-ex/file2.js",
-            "custom/res0.js",
-            "custom/resdir/res1.js");
-
-    @Override
-    public void setUp() throws Exception {
-        super.setUp();
-        File sourceFilesRoot = new File(TEST_DATA_PATH + "general/" + getTestName(false));
-        workDir = copyTestDataToTmpDir(sourceFilesRoot);
-        getOrCreateProjectDir();
-    }
-
-    @Override
-    public void tearDown() throws Exception {
-        FileUtil.delete(workDir);
-        super.tearDown();
-    }
-
-    @Override
-    protected File doGetProjectDir() throws IOException {
-        return workDir;
-    }
-
-    private void initProject() {
-        addJdk(JDK_NAME);
-        loadProject(workDir.getAbsolutePath() + File.separator + PROJECT_NAME + ".ipr");
-    }
-
-    public void doTest() {
-        initProject();
-        makeAll().assertSuccessful();
-    }
-
-    public void doTestWithRuntime() {
-        initProject();
-        addKotlinRuntimeDependency();
-        makeAll().assertSuccessful();
-    }
-
-    public void doTestWithKotlinJavaScriptLibrary() {
-        initProject();
-        addKotlinJavaScriptStdlibDependency();
-        createKotlinJavaScriptLibraryArchive();
-        addKotlinJavaScriptDependency(KOTLIN_JS_LIBRARY, new File(workDir, KOTLIN_JS_LIBRARY_JAR));
-        makeAll().assertSuccessful();
-    }
-
-    public void testKotlinProject() {
-        doTest();
-
-        checkWhen(touch("src/test1.kt"), null, packageClasses("kotlinProject", "src/test1.kt", "_DefaultPackage"));
-    }
-
-    public void testKotlinJavaScriptProject() {
-        initProject();
-        addKotlinJavaScriptStdlibDependency();
-        makeAll().assertSuccessful();
-
-        assertEquals(EXPECTED_JS_FILES_IN_OUTPUT_FOR_STDLIB_ONLY, contentOfOutputDir(PROJECT_NAME));
-        checkWhen(touch("src/test1.kt"), null, k2jsOutput(PROJECT_NAME));
-    }
-
-    public void testKotlinJavaScriptProjectWithTwoModules() {
-        initProject();
-        addKotlinJavaScriptStdlibDependency();
-        makeAll().assertSuccessful();
-
-        assertEquals(EXPECTED_JS_FILES_IN_OUTPUT_FOR_STDLIB_ONLY, contentOfOutputDir(PROJECT_NAME));
-        assertEquals(EXPECTED_JS_FILES_IN_OUTPUT_FOR_MODULE_STDLIB_ONLY, contentOfOutputDir(ADDITIONAL_MODULE_NAME));
-
-        checkWhen(touch("src/test1.kt"), null, k2jsOutput(PROJECT_NAME));
-        checkWhen(touch("module2/src/module2.kt"), null, k2jsOutput(ADDITIONAL_MODULE_NAME));
-        checkWhen(new Action[]{ touch("src/test1.kt"), touch("module2/src/module2.kt")}, null, k2jsOutput(PROJECT_NAME,
-                                                                                                          ADDITIONAL_MODULE_NAME));
-    }
-
-    public void testKotlinJavaScriptProjectWithDirectoryAsStdlib() {
-        initProject();
-        File jslibJar = PathUtil.getKotlinPathsForDistDirectory().getJsStdLibJarPath();
-        File jslibDir = new File(workDir, "KotlinJavaScript");
-        try {
-            ZipUtil.extract(jslibJar, jslibDir, null);
-        }
-        catch (IOException ex) {
-            throw new IllegalStateException(ex.getMessage());
-        }
-        addKotlinJavaScriptDependency("KotlinJavaScript", jslibDir);
-        makeAll().assertSuccessful();
-
-        assertEquals(EXPECTED_JS_FILES_IN_OUTPUT_FOR_STDLIB_ONLY, contentOfOutputDir(PROJECT_NAME));
-        checkWhen(touch("src/test1.kt"), null, k2jsOutput(PROJECT_NAME));
-    }
-
-    public void testKotlinJavaScriptProjectWithDirectoryAsLibrary() {
-        initProject();
-        addKotlinJavaScriptStdlibDependency();
-        addKotlinJavaScriptDependency(KOTLIN_JS_LIBRARY, new File(workDir, KOTLIN_JS_LIBRARY));
-        makeAll().assertSuccessful();
-
-        assertEquals(EXPECTED_JS_FILES_IN_OUTPUT_WITH_ADDITIONAL_LIB_AND_DEFAULT_DIR, contentOfOutputDir(PROJECT_NAME));
-        checkWhen(touch("src/test1.kt"), null, k2jsOutput(PROJECT_NAME));
-    }
-
-    public void testKotlinJavaScriptProjectWithLibrary() {
-        doTestWithKotlinJavaScriptLibrary();
-
-        assertEquals(EXPECTED_JS_FILES_IN_OUTPUT_WITH_ADDITIONAL_LIB_AND_DEFAULT_DIR, contentOfOutputDir(PROJECT_NAME));
-        checkWhen(touch("src/test1.kt"), null, k2jsOutput(PROJECT_NAME));
-    }
-
-    public void testKotlinJavaScriptProjectWithLibraryCustomOutputDir() {
-        doTestWithKotlinJavaScriptLibrary();
-
-        assertEquals(EXPECTED_JS_FILES_IN_OUTPUT_WITH_ADDITIONAL_LIB_AND_CUSTOM_DIR, contentOfOutputDir(PROJECT_NAME));
-        checkWhen(touch("src/test1.kt"), null, k2jsOutput(PROJECT_NAME));
-    }
-
-    public void testKotlinJavaScriptProjectWithLibraryNoCopy() {
-        doTestWithKotlinJavaScriptLibrary();
-
-        assertEquals(EXPECTED_JS_FILES_IN_OUTPUT_NO_COPY, contentOfOutputDir(PROJECT_NAME));
-        checkWhen(touch("src/test1.kt"), null, k2jsOutput(PROJECT_NAME));
-    }
-
-    public void testKotlinJavaScriptProjectWithLibraryAndErrors() {
-        initProject();
-        addKotlinJavaScriptStdlibDependency();
-        createKotlinJavaScriptLibraryArchive();
-        addKotlinJavaScriptDependency(KOTLIN_JS_LIBRARY, new File(workDir, KOTLIN_JS_LIBRARY_JAR));
-        makeAll().assertFailed();
-
-        assertEquals(Collections.EMPTY_SET, contentOfOutputDir(PROJECT_NAME));
-    }
-
-    public void testExcludeFolderInSourceRoot() {
-        doTest();
-
-        JpsModule module = myProject.getModules().get(0);
-        assertFilesExistInOutput(module, "Foo.class");
-        assertFilesNotExistInOutput(module, EXCLUDE_FILES);
-
-        checkWhen(touch("src/foo.kt"), null, new String[] {klass("kotlinProject", "Foo")});
-    }
-
-    public void testExcludeModuleFolderInSourceRootOfAnotherModule() {
-        doTest();
-
-        for (JpsModule module : myProject.getModules()) {
-            assertFilesExistInOutput(module, "Foo.class");
-        }
-
-        checkWhen(touch("src/foo.kt"), null, new String[] {klass("kotlinProject", "Foo")});
-        checkWhen(touch("src/module2/src/foo.kt"), null, new String[] {klass("module2", "Foo")});
-    }
-
-    public void testExcludeFileUsingCompilerSettings() {
-        doTest();
-
-        JpsModule module = myProject.getModules().get(0);
-        assertFilesExistInOutput(module, "Foo.class", "Bar.class");
-        assertFilesNotExistInOutput(module, EXCLUDE_FILES);
-
-        checkWhen(touch("src/foo.kt"), null, new String[] {klass("kotlinProject", "Foo")});
-        checkWhen(touch("src/Excluded.kt"), null, NOTHING );
-        checkWhen(touch("src/dir/YetAnotherExcluded.kt"), null, NOTHING);
-    }
-
-    public void testExcludeFolderNonRecursivelyUsingCompilerSettings() {
-        doTest();
-
-        JpsModule module = myProject.getModules().get(0);
-        assertFilesExistInOutput(module, "Foo.class", "Bar.class");
-        assertFilesNotExistInOutput(module, EXCLUDE_FILES);
-
-        checkWhen(touch("src/foo.kt"), null, new String[] {klass("kotlinProject", "Foo")});
-        checkWhen(touch("src/dir/subdir/bar.kt"), null, new String[] { klass("kotlinProject", "Bar")} );
-
-        checkWhen(touch("src/dir/Excluded.kt"), null, NOTHING );
-        checkWhen(touch("src/dir/subdir/YetAnotherExcluded.kt"), null, NOTHING);
-    }
-
-    public void testExcludeFolderRecursivelyUsingCompilerSettings() {
-        doTest();
-
-        JpsModule module = myProject.getModules().get(0);
-        assertFilesExistInOutput(module, "Foo.class", "Bar.class");
-        assertFilesNotExistInOutput(module, EXCLUDE_FILES);
-
-        checkWhen(touch("src/foo.kt"), null, new String[] {klass("kotlinProject", "Foo")});
-
-        checkWhen(touch("src/exclude/Excluded.kt"), null, NOTHING);
-        checkWhen(touch("src/exclude/YetAnotherExcluded.kt"), null, NOTHING);
-        checkWhen(touch("src/exclude/subdir/Excluded.kt"), null, NOTHING);
-        checkWhen(touch("src/exclude/subdir/YetAnotherExcluded.kt"), null, NOTHING);
-    }
-
-    public void testManyFiles() {
-        doTest();
-
-        JpsModule module = myProject.getModules().get(0);
-        assertFilesExistInOutput(module, "foo/FooPackage.class", "boo/BooPackage.class", "foo/Bar.class");
-
-        checkWhen(touch("src/main.kt"), null, packageClasses("kotlinProject", "src/main.kt", "foo.FooPackage"));
-        checkWhen(touch("src/boo.kt"), null, packageClasses("kotlinProject", "src/boo.kt", "boo.BooPackage"));
-        checkWhen(touch("src/Bar.kt"),
-                  new String[] {"src/Bar.kt"},
-                  new String[] {klass("kotlinProject", "foo.Bar")});
-
-        checkWhen(del("src/main.kt"),
-                  new String[] {"src/Bar.kt", "src/boo.kt"},
-                  mergeArrays(
-                      packageClasses("kotlinProject", "src/main.kt", "foo.FooPackage"),
-                      packageClasses("kotlinProject", "src/boo.kt", "boo.BooPackage"),
-                      new String[]{ klass("kotlinProject", "foo.Bar") }
-                  ));
-        assertFilesExistInOutput(module, "boo/BooPackage.class", "foo/Bar.class");
-        assertFilesNotExistInOutput(module, "foo/FooPackage.class");
-
-        checkWhen(touch("src/boo.kt"), null, packageClasses("kotlinProject", "src/boo.kt", "boo.BooPackage"));
-        checkWhen(touch("src/Bar.kt"), null, new String[] {klass("kotlinProject", "foo.Bar")});
-    }
-
-    public void testManyFilesForPackage() {
-        doTest();
-
-        JpsModule module = myProject.getModules().get(0);
-        assertFilesExistInOutput(module, "foo/FooPackage.class", "boo/BooPackage.class", "foo/Bar.class");
-
-        checkWhen(touch("src/main.kt"), null, packageClasses("kotlinProject", "src/main.kt", "foo.FooPackage"));
-        checkWhen(touch("src/boo.kt"), null, packageClasses("kotlinProject", "src/boo.kt", "boo.BooPackage"));
-        checkWhen(touch("src/Bar.kt"),
-                  new String[] {"src/Bar.kt"},
-                  new String[] {
-                          klass("kotlinProject", "foo.Bar"),
-                          klass("kotlinProject", "foo.FooPackage"),
-                          packagePartClass("kotlinProject", "src/Bar.kt", "foo.FooPackage")});
-
-        checkWhen(del("src/main.kt"),
-                  new String[] {"src/Bar.kt", "src/boo.kt"},
-                  mergeArrays(
-                          packageClasses("kotlinProject", "src/main.kt", "foo.FooPackage"),
-                          packageClasses("kotlinProject", "src/Bar.kt", "foo.FooPackage"),
-                          packageClasses("kotlinProject", "src/boo.kt", "boo.BooPackage"),
-                          new String[] {klass("kotlinProject", "foo.Bar")}
-                  ));
-        assertFilesExistInOutput(module, "foo/FooPackage.class", "boo/BooPackage.class", "foo/Bar.class");
-
-        checkWhen(touch("src/boo.kt"), null, packageClasses("kotlinProject", "src/boo.kt", "boo.BooPackage"));
-        checkWhen(touch("src/Bar.kt"), null,
-                  new String[] {
-                          klass("kotlinProject", "foo.Bar"),
-                          klass("kotlinProject", "foo.FooPackage"),
-                          packagePartClass("kotlinProject", "src/Bar.kt", "foo.FooPackage")
-                  });
-    }
-
-    public void testKotlinProjectTwoFilesInOnePackage() {
-        doTest();
-
-        checkWhen(touch("src/test1.kt"), null, packageClasses("kotlinProject", "src/test1.kt", "_DefaultPackage"));
-        checkWhen(touch("src/test2.kt"), null, packageClasses("kotlinProject", "src/test2.kt", "_DefaultPackage"));
-
-        checkWhen(new Action[]{ del("src/test1.kt"), del("src/test2.kt") }, NOTHING,
-                  new String[] {
-                          packagePartClass("kotlinProject", "src/test1.kt", "_DefaultPackage"),
-                          packagePartClass("kotlinProject", "src/test2.kt", "_DefaultPackage"),
-                          klass("kotlinProject", "_DefaultPackage")
-                  });
-
-        assertFilesNotExistInOutput(myProject.getModules().get(0), "_DefaultPackage.class");
-    }
-
-    public void testKotlinJavaProject() {
-        doTestWithRuntime();
-    }
-
-    public void testJKJProject() {
-        doTestWithRuntime();
-    }
-
-    public void testKJKProject() {
-        doTestWithRuntime();
-    }
-
-    public void testKJCircularProject() {
-        doTestWithRuntime();
-    }
-
-    public void testJKJInheritanceProject() {
-        doTestWithRuntime();
-    }
-
-    public void testKJKInheritanceProject() {
-        doTestWithRuntime();
-    }
-
-    public void testCircularDependenciesNoKotlinFiles() {
-        doTest();
-    }
-
-    public void testCircularDependenciesDifferentPackages() {
-        initProject();
-        BuildResult result = makeAll();
-
-        // Check that outputs are located properly
-        assertFilesExistInOutput(findModule("module2"), "kt1/Kt1Package.class");
-        assertFilesExistInOutput(findModule("kotlinProject"), "kt2/Kt2Package.class");
-
-        result.assertSuccessful();
-
-        checkWhen(touch("src/kt2.kt"), null, packageClasses("kotlinProject", "src/kt2.kt", "kt2.Kt2Package"));
-        checkWhen(touch("module2/src/kt1.kt"), null, packageClasses("module2", "module2/src/kt1.kt", "kt1.Kt1Package"));
-    }
-
-    public void testCircularDependenciesSamePackage() throws IOException {
-        initProject();
-        BuildResult result = makeAll();
-        result.assertSuccessful();
-
-        // Check that outputs are located properly
-        File facadeWithA = findFileInOutputDir(findModule("module1"), "test/TestPackage.class");
-        File facadeWithB = findFileInOutputDir(findModule("module2"), "test/TestPackage.class");
-        assertSameElements(getMethodsOfClass(facadeWithA), "<clinit>", "a", "getA");
-        assertSameElements(getMethodsOfClass(facadeWithB), "<clinit>", "b", "getB", "setB");
-
-        checkWhen(touch("module1/src/a.kt"), null, packageClasses("module1", "module1/src/a.kt", "test.TestPackage"));
-        checkWhen(touch("module2/src/b.kt"), null, packageClasses("module2", "module2/src/b.kt", "test.TestPackage"));
-    }
-
-    public void testCircularDependencyWithReferenceToOldVersionLib() throws IOException {
-        initProject();
-
-        File libraryJar = MockLibraryUtil.compileLibraryToJar(
-                workDir.getAbsolutePath() + File.separator + "oldModuleLib/src", "module-lib", false);
-
-        addDependency(JpsJavaDependencyScope.COMPILE, Lists.newArrayList(findModule("module1"), findModule("module2")), false,
-                      "module-lib", libraryJar);
-
-        BuildResult result = makeAll();
-        result.assertSuccessful();
-    }
-
-    public void testDependencyToOldKotlinLib() throws IOException {
-        initProject();
-
-        File libraryJar = MockLibraryUtil.compileLibraryToJar(
-                workDir.getAbsolutePath() + File.separator + "oldModuleLib/src", "module-lib", false);
-
-        addDependency(JpsJavaDependencyScope.COMPILE, Lists.newArrayList(findModule("module")), false, "module-lib", libraryJar);
-
-        addKotlinRuntimeDependency();
-
-        BuildResult result = makeAll();
-        result.assertSuccessful();
-    }
-
-    private void createKotlinJavaScriptLibraryArchive() {
-        File jarFile = new File(workDir, KOTLIN_JS_LIBRARY_JAR);
-        try {
-            ZipOutputStream zip = new ZipOutputStream(new FileOutputStream(jarFile));
-            ZipUtil.addDirToZipRecursively(zip, jarFile, new File(PATH_TO_KOTLIN_JS_LIBRARY), "", null, null);
-            zip.close();
-        }
-        catch (FileNotFoundException ex) {
-            throw new IllegalStateException(ex.getMessage());
-        }
-        catch (IOException ex) {
-            throw new IllegalStateException(ex.getMessage());
-        }
-    }
-
-    @NotNull
-    private static String[] k2jsOutput(String ...moduleNames) {
-        int length = moduleNames.length;
-        String[] result = new String[2 * length];
-        int index = 0;
-        for(String moduleName : moduleNames) {
-            File outputDir = new File("out/production/" + moduleName);
-            result[index++] = toSystemIndependentName(JpsJsModuleUtils.getOutputFile(outputDir, moduleName).getPath());
-            result[index++] = toSystemIndependentName(JpsJsModuleUtils.getOutputMetaFile(outputDir, moduleName).getPath());
-        }
-        return result;
-    }
-
-    @NotNull
-    private Set<String> contentOfOutputDir(String moduleName) {
-        String outputDir = "out/production/" + moduleName;
-        File baseDir = new File(workDir, outputDir);
-        List<File> files = FileUtil.findFilesByMask(Pattern.compile(".*"), baseDir);
-        Set<String> result = new HashSet<String>();
-        for(File file : files) {
-            String relativePath = FileUtil.getRelativePath(baseDir, file);
-            assert relativePath != null : "relativePath should not be null";
-            result.add(toSystemIndependentName(relativePath));
-        }
-        return result;
-    }
-
-    @NotNull
-    private static Set<String> getMethodsOfClass(@NotNull File classFile) throws IOException {
-        final Set<String> result = new TreeSet<String>();
-        new ClassReader(FileUtil.loadFileBytes(classFile)).accept(new ClassVisitor(Opcodes.ASM5) {
-            @Override
-            public MethodVisitor visitMethod(int access, @NotNull String name, @NotNull String desc, String signature, String[] exceptions) {
-                result.add(name);
-                return null;
-            }
-        }, 0);
-        return result;
-    }
-
-    public void testReexportedDependency() {
-        initProject();
-        addKotlinRuntimeDependency(JpsJavaDependencyScope.COMPILE,
-                                   ContainerUtil.filter(myProject.getModules(), new Condition<JpsModule>() {
-                                       @Override
-                                       public boolean value(JpsModule module) {
-                                           return module.getName().equals("module2");
-                                       }
-                                   }), true
-        );
-        makeAll().assertSuccessful();
-    }
-
-    public void testDoNotCreateUselessKotlinIncrementalCaches() throws InterruptedException {
-        initProject();
-        makeAll().assertSuccessful();
-
-        File storageRoot = new BuildDataPathsImpl(myDataStorageRoot).getDataStorageRoot();
-        assertTrue(new File(storageRoot, "targets/java-test/kotlinProject/kotlin").exists());
-        assertFalse(new File(storageRoot, "targets/java-production/kotlinProject/kotlin").exists());
-    }
-
-    @NotNull
-    private JpsModule findModule(@NotNull String name) {
-        for (JpsModule module : myProject.getModules()) {
-            if (module.getName().equals(name)) {
-                return module;
-            }
-        }
-        throw new IllegalStateException("Couldn't find module " + name);
-    }
-
-    private static void assertFilesExistInOutput(JpsModule module, String... relativePaths) {
-        for (String path : relativePaths) {
-            File outputFile = findFileInOutputDir(module, path);
-            assertTrue("Output not written: " +
-                       outputFile.getAbsolutePath() +
-                       "\n Directory contents: \n" +
-                       dirContents(outputFile.getParentFile()),
-                       outputFile.exists());
-        }
-    }
-
-    private static File findFileInOutputDir(JpsModule module, String relativePath) {
-        String outputUrl = JpsJavaExtensionService.getInstance().getOutputUrl(module, false);
-        assertNotNull(outputUrl);
-        File outputDir = new File(JpsPathUtil.urlToPath(outputUrl));
-        return new File(outputDir, relativePath);
-    }
-
-
-    private static void assertFilesNotExistInOutput(JpsModule module, String... relativePaths) {
-        String outputUrl = JpsJavaExtensionService.getInstance().getOutputUrl(module, false);
-        assertNotNull(outputUrl);
-        File outputDir = new File(JpsPathUtil.urlToPath(outputUrl));
-        for (String path : relativePaths) {
-            File outputFile = new File(outputDir, path);
-            assertFalse("Output directory \"" + outputFile.getAbsolutePath() + "\" contains \"" + path + "\"",
-                        outputFile.exists());
-        }
-    }
-
-    private static String dirContents(File dir) {
-        File[] files = dir.listFiles();
-        if (files == null) {
-            return "<not found>";
-        }
-        StringBuilder builder = new StringBuilder();
-        for (File file : files) {
-            builder.append(" * ").append(file.getName()).append("\n");
-        }
-        return builder.toString();
-    }
-
-    private void checkWhen(Action action, @Nullable String[] pathsToCompile, @Nullable String[] pathsToDelete) {
-        checkWhen(new Action[]{action}, pathsToCompile, pathsToDelete);
-    }
-
-    private void checkWhen(Action[] actions, @Nullable String[] pathsToCompile, @Nullable String[] pathsToDelete) {
-        for (Action action : actions) {
-            action.apply();
-        }
-
-        makeAll().assertSuccessful();
-
-        if (pathsToCompile != null) {
-            assertCompiled(KotlinBuilder.KOTLIN_BUILDER_NAME, pathsToCompile);
-        }
-
-        if (pathsToDelete != null) {
-            assertDeleted(pathsToDelete);
-        }
-    }
-
-    private static String klass(String moduleName, String classFqName) {
-        String outputDirPrefix = "out/production/" + moduleName + "/";
-        return outputDirPrefix + classFqName.replace('.', '/') + ".class";
-    }
-
-    private String[] packageClasses(String moduleName, String fileName, String packageClassFqName) {
-        return new String[] {klass(moduleName, packageClassFqName), packagePartClass(moduleName, fileName, packageClassFqName)};
-    }
-
-    private String packagePartClass(String moduleName, String fileName, String packageClassFqName) {
-        String path = FileUtilRt.toSystemIndependentName(new File(workDir, fileName).getAbsolutePath());
-        LightVirtualFile fakeVirtualFile = new LightVirtualFile(path) {
-            @NotNull
-            @Override
-            public String getPath() {
-                // strip extra "/" from the beginning
-                return super.getPath().substring(1);
-            }
-        };
-
-        FqName packagePartFqName = PackagePartClassUtils.getPackagePartFqName(new FqName(packageClassFqName), fakeVirtualFile);
-        return klass(moduleName, AsmUtil.internalNameByFqNameWithoutInnerClasses(packagePartFqName));
-    }
-
-    public static String[] mergeArrays(String[]... stringArrays) {
-        Set<String> result = new HashSet<String>();
-        for (String[] array : stringArrays) {
-            result.addAll(Arrays.asList(array));
-        }
-        return ArrayUtil.toStringArray(result);
-    }
-
-    private enum Operation {
-        CHANGE, DELETE
-    }
-
-    protected Action touch(String path) {
-        return new Action(Operation.CHANGE, path);
-    }
-
-    protected Action del(String path) {
-        return new Action(Operation.DELETE, path);
-    }
-
-    protected class Action {
-        private final Operation operation;
-        private final String path;
-
-        protected Action(Operation operation, String path) {
-            this.operation = operation;
-            this.path = path;
-        }
-
-        protected void apply() {
-            File file = new File(workDir, path);
-
-            if (operation == Operation.CHANGE) {
-                change(file.getAbsolutePath());
-            }
-            else if(operation == Operation.DELETE) {
-                assertTrue("Can not delete file \"" + file.getAbsolutePath() + "\"", file.delete());
-            }
-            else {
-                fail("Unknown operation");
-            }
-        }
-    }
-}
diff --git a/jps-plugin/test/org/jetbrains/kotlin/jps/build/KotlinJpsBuildTest.kt b/jps-plugin/test/org/jetbrains/kotlin/jps/build/KotlinJpsBuildTest.kt
new file mode 100644
index 00000000000..3d1f63bbe35
--- /dev/null
+++ b/jps-plugin/test/org/jetbrains/kotlin/jps/build/KotlinJpsBuildTest.kt
@@ -0,0 +1,704 @@
+/*
+ * Copyright 2010-2015 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.kotlin.jps.build
+
+import com.google.common.collect.Lists
+import com.intellij.openapi.util.Condition
+import com.intellij.openapi.util.io.FileUtil
+import com.intellij.openapi.util.io.FileUtil.toSystemIndependentName
+import com.intellij.openapi.util.io.FileUtilRt
+import com.intellij.testFramework.LightVirtualFile
+import com.intellij.testFramework.UsefulTestCase
+import com.intellij.util.ArrayUtil
+import com.intellij.util.containers.ContainerUtil
+import com.intellij.util.io.ZipUtil
+import org.jetbrains.jps.api.CanceledStatus
+import org.jetbrains.jps.builders.BuildResult
+import org.jetbrains.jps.builders.CompileScopeTestBuilder
+import org.jetbrains.jps.builders.JpsBuildTestCase
+import org.jetbrains.jps.builders.TestProjectBuilderLogger
+import org.jetbrains.jps.builders.impl.BuildDataPathsImpl
+import org.jetbrains.jps.builders.logging.BuildLoggingManager
+import org.jetbrains.jps.incremental.BuilderRegistry
+import org.jetbrains.jps.incremental.IncProjectBuilder
+import org.jetbrains.jps.incremental.messages.BuildMessage
+import org.jetbrains.jps.model.java.JpsJavaDependencyScope
+import org.jetbrains.jps.model.java.JpsJavaExtensionService
+import org.jetbrains.jps.model.module.JpsModule
+import org.jetbrains.jps.util.JpsPathUtil
+import org.jetbrains.kotlin.codegen.AsmUtil
+import org.jetbrains.kotlin.load.kotlin.PackagePartClassUtils
+import org.jetbrains.kotlin.name.FqName
+import org.jetbrains.kotlin.test.MockLibraryUtil
+import org.jetbrains.kotlin.utils.PathUtil
+import org.jetbrains.org.objectweb.asm.ClassReader
+import org.jetbrains.org.objectweb.asm.ClassVisitor
+import org.jetbrains.org.objectweb.asm.MethodVisitor
+import org.jetbrains.org.objectweb.asm.Opcodes
+import java.io.*
+import java.util.Arrays
+import java.util.Collections
+import java.util.HashSet
+import java.util.TreeSet
+import java.util.regex.Pattern
+import java.util.zip.ZipOutputStream
+import kotlin.test.*
+
+public class KotlinJpsBuildTest : AbstractKotlinJpsBuildTestCase() {
+    companion object {
+        private val PROJECT_NAME = "kotlinProject"
+        private val ADDITIONAL_MODULE_NAME = "module2"
+        private val JDK_NAME = "IDEA_JDK"
+
+        private val EXCLUDE_FILES = arrayOf("Excluded.class", "YetAnotherExcluded.class")
+        private val NOTHING = arrayOf<String>()
+        private val KOTLIN_JS_LIBRARY = "jslib-example"
+        private val PATH_TO_KOTLIN_JS_LIBRARY = AbstractKotlinJpsBuildTestCase.TEST_DATA_PATH + "general/KotlinJavaScriptProjectWithDirectoryAsLibrary/" + KOTLIN_JS_LIBRARY
+        private val KOTLIN_JS_LIBRARY_JAR = "$KOTLIN_JS_LIBRARY.jar"
+        private val EXPECTED_JS_FILES_IN_OUTPUT_FOR_STDLIB_ONLY = hashSetOf(
+                "$PROJECT_NAME.js",
+                "$PROJECT_NAME.meta.js",
+                "lib/kotlin.js",
+                "lib/stdlib.meta.js"
+        )
+        private val EXPECTED_JS_FILES_IN_OUTPUT_FOR_MODULE_STDLIB_ONLY = hashSetOf(
+                "$ADDITIONAL_MODULE_NAME.js",
+                "$ADDITIONAL_MODULE_NAME.meta.js",
+                "lib/kotlin.js",
+                "lib/stdlib.meta.js"
+        )
+        private val EXPECTED_JS_FILES_IN_OUTPUT_NO_COPY = hashSetOf("$PROJECT_NAME.js", "$PROJECT_NAME.meta.js")
+        private val EXPECTED_JS_FILES_IN_OUTPUT_WITH_ADDITIONAL_LIB_AND_DEFAULT_DIR = hashSetOf(
+                "$PROJECT_NAME.js",
+                "$PROJECT_NAME.meta.js",
+                "lib/kotlin.js",
+                "lib/stdlib.meta.js",
+                "lib/jslib-example.js",
+                "lib/file0.js",
+                "lib/dir/file1.js",
+                "lib/META-INF-ex/file2.js",
+                "lib/res0.js",
+                "lib/resdir/res1.js"
+        )
+        private val EXPECTED_JS_FILES_IN_OUTPUT_WITH_ADDITIONAL_LIB_AND_CUSTOM_DIR = hashSetOf(
+                "$PROJECT_NAME.js",
+                "$PROJECT_NAME.meta.js",
+                "custom/kotlin.js",
+                "custom/stdlib.meta.js",
+                "custom/jslib-example.js",
+                "custom/file0.js",
+                "custom/dir/file1.js",
+                "custom/META-INF-ex/file2.js",
+                "custom/res0.js",
+                "custom/resdir/res1.js"
+        )
+
+        private fun k2jsOutput(vararg moduleNames: String): Array<String> {
+            val list = arrayListOf<String>()
+            for (moduleName in moduleNames) {
+                val outputDir = File("out/production/$moduleName")
+                list.add(toSystemIndependentName(JpsJsModuleUtils.getOutputFile(outputDir, moduleName).getPath()))
+                list.add(toSystemIndependentName(JpsJsModuleUtils.getOutputMetaFile(outputDir, moduleName).getPath()))
+            }
+            return list.toTypedArray()
+        }
+
+        private fun getMethodsOfClass(classFile: File): Set<String> {
+            val result = TreeSet<String>()
+            ClassReader(FileUtil.loadFileBytes(classFile)).accept(object : ClassVisitor(Opcodes.ASM5) {
+                override fun visitMethod(access: Int, name: String, desc: String, signature: String?, exceptions: Array<String>?): MethodVisitor? {
+                    result.add(name)
+                    return null
+                }
+            }, 0)
+            return result
+        }
+
+        private fun assertFilesExistInOutput(module: JpsModule, vararg relativePaths: String) {
+            for (path in relativePaths) {
+                val outputFile = findFileInOutputDir(module, path)
+                assertTrue(outputFile.exists(), "Output not written: " + outputFile.getAbsolutePath() + "\n Directory contents: \n" + dirContents(outputFile.getParentFile()))
+            }
+        }
+
+        private fun findFileInOutputDir(module: JpsModule, relativePath: String): File {
+            val outputUrl = JpsJavaExtensionService.getInstance().getOutputUrl(module, false)
+            assertNotNull(outputUrl)
+            val outputDir = File(JpsPathUtil.urlToPath(outputUrl))
+            return File(outputDir, relativePath)
+        }
+
+
+        private fun assertFilesNotExistInOutput(module: JpsModule, vararg relativePaths: String) {
+            val outputUrl = JpsJavaExtensionService.getInstance().getOutputUrl(module, false)
+            assertNotNull(outputUrl)
+            val outputDir = File(JpsPathUtil.urlToPath(outputUrl))
+            for (path in relativePaths) {
+                val outputFile = File(outputDir, path)
+                assertFalse(outputFile.exists(), "Output directory \"" + outputFile.getAbsolutePath() + "\" contains \"" + path + "\"")
+            }
+        }
+
+        private fun dirContents(dir: File): String {
+            val files = dir.listFiles() ?: return "<not found>"
+            val builder = StringBuilder()
+            for (file in files) {
+                builder.append(" * ").append(file.getName()).append("\n")
+            }
+            return builder.toString()
+        }
+
+        private fun klass(moduleName: String, classFqName: String): String {
+            val outputDirPrefix = "out/production/$moduleName/"
+            return outputDirPrefix + classFqName.replace('.', '/') + ".class"
+        }
+
+        public fun mergeArrays(vararg stringArrays: Array<String>): Array<String> {
+            val result = HashSet<String>()
+            for (array in stringArrays) {
+                result.addAll(Arrays.asList(*array))
+            }
+            return ArrayUtil.toStringArray(result)
+        }
+    }
+
+    override fun setUp() {
+        super.setUp()
+        val sourceFilesRoot = File(AbstractKotlinJpsBuildTestCase.TEST_DATA_PATH + "general/" + getTestName(false))
+        workDir = AbstractKotlinJpsBuildTestCase.copyTestDataToTmpDir(sourceFilesRoot)
+        getOrCreateProjectDir()
+    }
+
+    override fun tearDown() {
+        FileUtil.delete(workDir)
+        super.tearDown()
+    }
+
+    override fun doGetProjectDir(): File = workDir
+
+    private fun initProject() {
+        addJdk(JDK_NAME)
+        loadProject(workDir.getAbsolutePath() + File.separator + PROJECT_NAME + ".ipr")
+    }
+
+    public fun doTest() {
+        initProject()
+        makeAll().assertSuccessful()
+    }
+
+    public fun doTestWithRuntime() {
+        initProject()
+        addKotlinRuntimeDependency()
+        makeAll().assertSuccessful()
+    }
+
+    public fun doTestWithKotlinJavaScriptLibrary() {
+        initProject()
+        addKotlinJavaScriptStdlibDependency()
+        createKotlinJavaScriptLibraryArchive()
+        addKotlinJavaScriptDependency(KOTLIN_JS_LIBRARY, File(workDir, KOTLIN_JS_LIBRARY_JAR))
+        makeAll().assertSuccessful()
+    }
+
+    public fun testKotlinProject() {
+        doTest()
+
+        checkWhen(touch("src/test1.kt"), null, packageClasses("kotlinProject", "src/test1.kt", "_DefaultPackage"))
+    }
+
+    public fun testKotlinJavaScriptProject() {
+        initProject()
+        addKotlinJavaScriptStdlibDependency()
+        makeAll().assertSuccessful()
+
+        assertEquals(EXPECTED_JS_FILES_IN_OUTPUT_FOR_STDLIB_ONLY, contentOfOutputDir(PROJECT_NAME))
+        checkWhen(touch("src/test1.kt"), null, k2jsOutput(PROJECT_NAME))
+    }
+
+    public fun testKotlinJavaScriptProjectWithTwoModules() {
+        initProject()
+        addKotlinJavaScriptStdlibDependency()
+        makeAll().assertSuccessful()
+
+        assertEquals(EXPECTED_JS_FILES_IN_OUTPUT_FOR_STDLIB_ONLY, contentOfOutputDir(PROJECT_NAME))
+        assertEquals(EXPECTED_JS_FILES_IN_OUTPUT_FOR_MODULE_STDLIB_ONLY, contentOfOutputDir(ADDITIONAL_MODULE_NAME))
+
+        checkWhen(touch("src/test1.kt"), null, k2jsOutput(PROJECT_NAME))
+        checkWhen(touch("module2/src/module2.kt"), null, k2jsOutput(ADDITIONAL_MODULE_NAME))
+        checkWhen(arrayOf(touch("src/test1.kt"), touch("module2/src/module2.kt")), null, k2jsOutput(PROJECT_NAME, ADDITIONAL_MODULE_NAME))
+    }
+
+    public fun testKotlinJavaScriptProjectWithDirectoryAsStdlib() {
+        initProject()
+        val jslibJar = PathUtil.getKotlinPathsForDistDirectory().getJsStdLibJarPath()
+        val jslibDir = File(workDir, "KotlinJavaScript")
+        try {
+            ZipUtil.extract(jslibJar, jslibDir, null)
+        }
+        catch (ex: IOException) {
+            throw IllegalStateException(ex.getMessage())
+        }
+
+        addKotlinJavaScriptDependency("KotlinJavaScript", jslibDir)
+        makeAll().assertSuccessful()
+
+        assertEquals(EXPECTED_JS_FILES_IN_OUTPUT_FOR_STDLIB_ONLY, contentOfOutputDir(PROJECT_NAME))
+        checkWhen(touch("src/test1.kt"), null, k2jsOutput(PROJECT_NAME))
+    }
+
+    public fun testKotlinJavaScriptProjectWithDirectoryAsLibrary() {
+        initProject()
+        addKotlinJavaScriptStdlibDependency()
+        addKotlinJavaScriptDependency(KOTLIN_JS_LIBRARY, File(workDir, KOTLIN_JS_LIBRARY))
+        makeAll().assertSuccessful()
+
+        assertEquals(EXPECTED_JS_FILES_IN_OUTPUT_WITH_ADDITIONAL_LIB_AND_DEFAULT_DIR, contentOfOutputDir(PROJECT_NAME))
+        checkWhen(touch("src/test1.kt"), null, k2jsOutput(PROJECT_NAME))
+    }
+
+    public fun testKotlinJavaScriptProjectWithLibrary() {
+        doTestWithKotlinJavaScriptLibrary()
+
+        assertEquals(EXPECTED_JS_FILES_IN_OUTPUT_WITH_ADDITIONAL_LIB_AND_DEFAULT_DIR, contentOfOutputDir(PROJECT_NAME))
+        checkWhen(touch("src/test1.kt"), null, k2jsOutput(PROJECT_NAME))
+    }
+
+    public fun testKotlinJavaScriptProjectWithLibraryCustomOutputDir() {
+        doTestWithKotlinJavaScriptLibrary()
+
+        assertEquals(EXPECTED_JS_FILES_IN_OUTPUT_WITH_ADDITIONAL_LIB_AND_CUSTOM_DIR, contentOfOutputDir(PROJECT_NAME))
+        checkWhen(touch("src/test1.kt"), null, k2jsOutput(PROJECT_NAME))
+    }
+
+    public fun testKotlinJavaScriptProjectWithLibraryNoCopy() {
+        doTestWithKotlinJavaScriptLibrary()
+
+        assertEquals(EXPECTED_JS_FILES_IN_OUTPUT_NO_COPY, contentOfOutputDir(PROJECT_NAME))
+        checkWhen(touch("src/test1.kt"), null, k2jsOutput(PROJECT_NAME))
+    }
+
+    public fun testKotlinJavaScriptProjectWithLibraryAndErrors() {
+        initProject()
+        addKotlinJavaScriptStdlibDependency()
+        createKotlinJavaScriptLibraryArchive()
+        addKotlinJavaScriptDependency(KOTLIN_JS_LIBRARY, File(workDir, KOTLIN_JS_LIBRARY_JAR))
+        makeAll().assertFailed()
+
+        assertEquals(Collections.EMPTY_SET, contentOfOutputDir(PROJECT_NAME))
+    }
+
+    public fun testExcludeFolderInSourceRoot() {
+        doTest()
+
+        val module = myProject.getModules().get(0)
+        assertFilesExistInOutput(module, "Foo.class")
+        assertFilesNotExistInOutput(module, *EXCLUDE_FILES)
+
+        checkWhen(touch("src/foo.kt"), null, arrayOf(klass("kotlinProject", "Foo")))
+    }
+
+    public fun testExcludeModuleFolderInSourceRootOfAnotherModule() {
+        doTest()
+
+        for (module in myProject.getModules()) {
+            assertFilesExistInOutput(module, "Foo.class")
+        }
+
+        checkWhen(touch("src/foo.kt"), null, arrayOf(klass("kotlinProject", "Foo")))
+        checkWhen(touch("src/module2/src/foo.kt"), null, arrayOf(klass("module2", "Foo")))
+    }
+
+    public fun testExcludeFileUsingCompilerSettings() {
+        doTest()
+
+        val module = myProject.getModules().get(0)
+        assertFilesExistInOutput(module, "Foo.class", "Bar.class")
+        assertFilesNotExistInOutput(module, *EXCLUDE_FILES)
+
+        checkWhen(touch("src/foo.kt"), null, arrayOf(klass("kotlinProject", "Foo")))
+        checkWhen(touch("src/Excluded.kt"), null, NOTHING)
+        checkWhen(touch("src/dir/YetAnotherExcluded.kt"), null, NOTHING)
+    }
+
+    public fun testExcludeFolderNonRecursivelyUsingCompilerSettings() {
+        doTest()
+
+        val module = myProject.getModules().get(0)
+        assertFilesExistInOutput(module, "Foo.class", "Bar.class")
+        assertFilesNotExistInOutput(module, *EXCLUDE_FILES)
+
+        checkWhen(touch("src/foo.kt"), null, arrayOf(klass("kotlinProject", "Foo")))
+        checkWhen(touch("src/dir/subdir/bar.kt"), null, arrayOf(klass("kotlinProject", "Bar")))
+
+        checkWhen(touch("src/dir/Excluded.kt"), null, NOTHING)
+        checkWhen(touch("src/dir/subdir/YetAnotherExcluded.kt"), null, NOTHING)
+    }
+
+    public fun testExcludeFolderRecursivelyUsingCompilerSettings() {
+        doTest()
+
+        val module = myProject.getModules().get(0)
+        assertFilesExistInOutput(module, "Foo.class", "Bar.class")
+        assertFilesNotExistInOutput(module, *EXCLUDE_FILES)
+
+        checkWhen(touch("src/foo.kt"), null, arrayOf(klass("kotlinProject", "Foo")))
+
+        checkWhen(touch("src/exclude/Excluded.kt"), null, NOTHING)
+        checkWhen(touch("src/exclude/YetAnotherExcluded.kt"), null, NOTHING)
+        checkWhen(touch("src/exclude/subdir/Excluded.kt"), null, NOTHING)
+        checkWhen(touch("src/exclude/subdir/YetAnotherExcluded.kt"), null, NOTHING)
+    }
+
+    public fun testManyFiles() {
+        doTest()
+
+        val module = myProject.getModules().get(0)
+        assertFilesExistInOutput(module, "foo/FooPackage.class", "boo/BooPackage.class", "foo/Bar.class")
+
+        checkWhen(touch("src/main.kt"), null, packageClasses("kotlinProject", "src/main.kt", "foo.FooPackage"))
+        checkWhen(touch("src/boo.kt"), null, packageClasses("kotlinProject", "src/boo.kt", "boo.BooPackage"))
+        checkWhen(touch("src/Bar.kt"), arrayOf("src/Bar.kt"), arrayOf(klass("kotlinProject", "foo.Bar")))
+
+        checkWhen(del("src/main.kt"), arrayOf("src/Bar.kt", "src/boo.kt"), mergeArrays(packageClasses("kotlinProject", "src/main.kt", "foo.FooPackage"), packageClasses("kotlinProject", "src/boo.kt", "boo.BooPackage"), arrayOf(klass("kotlinProject", "foo.Bar"))))
+        assertFilesExistInOutput(module, "boo/BooPackage.class", "foo/Bar.class")
+        assertFilesNotExistInOutput(module, "foo/FooPackage.class")
+
+        checkWhen(touch("src/boo.kt"), null, packageClasses("kotlinProject", "src/boo.kt", "boo.BooPackage"))
+        checkWhen(touch("src/Bar.kt"), null, arrayOf(klass("kotlinProject", "foo.Bar")))
+    }
+
+    public fun testManyFilesForPackage() {
+        doTest()
+
+        val module = myProject.getModules().get(0)
+        assertFilesExistInOutput(module, "foo/FooPackage.class", "boo/BooPackage.class", "foo/Bar.class")
+
+        checkWhen(touch("src/main.kt"), null, packageClasses("kotlinProject", "src/main.kt", "foo.FooPackage"))
+        checkWhen(touch("src/boo.kt"), null, packageClasses("kotlinProject", "src/boo.kt", "boo.BooPackage"))
+        checkWhen(touch("src/Bar.kt"), arrayOf("src/Bar.kt"), arrayOf(klass("kotlinProject", "foo.Bar"), klass("kotlinProject", "foo.FooPackage"), packagePartClass("kotlinProject", "src/Bar.kt", "foo.FooPackage")))
+
+        checkWhen(del("src/main.kt"), arrayOf("src/Bar.kt", "src/boo.kt"), mergeArrays(packageClasses("kotlinProject", "src/main.kt", "foo.FooPackage"), packageClasses("kotlinProject", "src/Bar.kt", "foo.FooPackage"), packageClasses("kotlinProject", "src/boo.kt", "boo.BooPackage"), arrayOf(klass("kotlinProject", "foo.Bar"))))
+        assertFilesExistInOutput(module, "foo/FooPackage.class", "boo/BooPackage.class", "foo/Bar.class")
+
+        checkWhen(touch("src/boo.kt"), null, packageClasses("kotlinProject", "src/boo.kt", "boo.BooPackage"))
+        checkWhen(touch("src/Bar.kt"), null, arrayOf(klass("kotlinProject", "foo.Bar"), klass("kotlinProject", "foo.FooPackage"), packagePartClass("kotlinProject", "src/Bar.kt", "foo.FooPackage")))
+    }
+
+    public fun testKotlinProjectTwoFilesInOnePackage() {
+        doTest()
+
+        checkWhen(touch("src/test1.kt"), null, packageClasses("kotlinProject", "src/test1.kt", "_DefaultPackage"))
+        checkWhen(touch("src/test2.kt"), null, packageClasses("kotlinProject", "src/test2.kt", "_DefaultPackage"))
+
+        checkWhen(arrayOf(del("src/test1.kt"), del("src/test2.kt")), NOTHING, arrayOf(packagePartClass("kotlinProject", "src/test1.kt", "_DefaultPackage"), packagePartClass("kotlinProject", "src/test2.kt", "_DefaultPackage"), klass("kotlinProject", "_DefaultPackage")))
+
+        assertFilesNotExistInOutput(myProject.getModules().get(0), "_DefaultPackage.class")
+    }
+
+    public fun testKotlinJavaProject() {
+        doTestWithRuntime()
+    }
+
+    public fun testJKJProject() {
+        doTestWithRuntime()
+    }
+
+    public fun testKJKProject() {
+        doTestWithRuntime()
+    }
+
+    public fun testKJCircularProject() {
+        doTestWithRuntime()
+    }
+
+    public fun testJKJInheritanceProject() {
+        doTestWithRuntime()
+    }
+
+    public fun testKJKInheritanceProject() {
+        doTestWithRuntime()
+    }
+
+    public fun testCircularDependenciesNoKotlinFiles() {
+        doTest()
+    }
+
+    public fun testCircularDependenciesDifferentPackages() {
+        initProject()
+        val result = makeAll()
+
+        // Check that outputs are located properly
+        assertFilesExistInOutput(findModule("module2"), "kt1/Kt1Package.class")
+        assertFilesExistInOutput(findModule("kotlinProject"), "kt2/Kt2Package.class")
+
+        result.assertSuccessful()
+
+        checkWhen(touch("src/kt2.kt"), null, packageClasses("kotlinProject", "src/kt2.kt", "kt2.Kt2Package"))
+        checkWhen(touch("module2/src/kt1.kt"), null, packageClasses("module2", "module2/src/kt1.kt", "kt1.Kt1Package"))
+    }
+
+    public fun testCircularDependenciesSamePackage() {
+        initProject()
+        val result = makeAll()
+        result.assertSuccessful()
+
+        // Check that outputs are located properly
+        val facadeWithA = findFileInOutputDir(findModule("module1"), "test/TestPackage.class")
+        val facadeWithB = findFileInOutputDir(findModule("module2"), "test/TestPackage.class")
+        UsefulTestCase.assertSameElements(getMethodsOfClass(facadeWithA), "<clinit>", "a", "getA")
+        UsefulTestCase.assertSameElements(getMethodsOfClass(facadeWithB), "<clinit>", "b", "getB", "setB")
+
+        checkWhen(touch("module1/src/a.kt"), null, packageClasses("module1", "module1/src/a.kt", "test.TestPackage"))
+        checkWhen(touch("module2/src/b.kt"), null, packageClasses("module2", "module2/src/b.kt", "test.TestPackage"))
+    }
+
+    public fun testCircularDependencyWithReferenceToOldVersionLib() {
+        initProject()
+
+        val libraryJar = MockLibraryUtil.compileLibraryToJar(workDir.getAbsolutePath() + File.separator + "oldModuleLib/src", "module-lib", false)
+
+        AbstractKotlinJpsBuildTestCase.addDependency(JpsJavaDependencyScope.COMPILE, Lists.newArrayList(findModule("module1"), findModule("module2")), false, "module-lib", libraryJar)
+
+        val result = makeAll()
+        result.assertSuccessful()
+    }
+
+    public fun testDependencyToOldKotlinLib() {
+        initProject()
+
+        val libraryJar = MockLibraryUtil.compileLibraryToJar(workDir.getAbsolutePath() + File.separator + "oldModuleLib/src", "module-lib", false)
+
+        AbstractKotlinJpsBuildTestCase.addDependency(JpsJavaDependencyScope.COMPILE, Lists.newArrayList(findModule("module")), false, "module-lib", libraryJar)
+
+        addKotlinRuntimeDependency()
+
+        val result = makeAll()
+        result.assertSuccessful()
+    }
+
+    private fun createKotlinJavaScriptLibraryArchive() {
+        val jarFile = File(workDir, KOTLIN_JS_LIBRARY_JAR)
+        try {
+            val zip = ZipOutputStream(FileOutputStream(jarFile))
+            ZipUtil.addDirToZipRecursively(zip, jarFile, File(PATH_TO_KOTLIN_JS_LIBRARY), "", null, null)
+            zip.close()
+        }
+        catch (ex: FileNotFoundException) {
+            throw IllegalStateException(ex.getMessage())
+        }
+        catch (ex: IOException) {
+            throw IllegalStateException(ex.getMessage())
+        }
+
+    }
+
+    private fun contentOfOutputDir(moduleName: String): Set<String> {
+        val outputDir = "out/production/$moduleName"
+        val baseDir = File(workDir, outputDir)
+        val files = FileUtil.findFilesByMask(Pattern.compile(".*"), baseDir)
+        val result = HashSet<String>()
+        for (file in files) {
+            val relativePath = FileUtil.getRelativePath(baseDir, file)
+            assert(relativePath != null, "relativePath should not be null")
+            result.add(toSystemIndependentName(relativePath!!))
+        }
+        return result
+    }
+
+    public fun testReexportedDependency() {
+        initProject()
+        AbstractKotlinJpsBuildTestCase.addKotlinRuntimeDependency(JpsJavaDependencyScope.COMPILE, ContainerUtil.filter(myProject.getModules(), object : Condition<JpsModule> {
+            override fun value(module: JpsModule): Boolean {
+                return module.getName() == "module2"
+            }
+        }), true)
+        makeAll().assertSuccessful()
+    }
+
+    public fun testDoNotCreateUselessKotlinIncrementalCaches() {
+        initProject()
+        makeAll().assertSuccessful()
+
+        val storageRoot = BuildDataPathsImpl(myDataStorageRoot).getDataStorageRoot()
+        assertTrue(File(storageRoot, "targets/java-test/kotlinProject/kotlin").exists())
+        assertFalse(File(storageRoot, "targets/java-production/kotlinProject/kotlin").exists())
+    }
+
+    public fun testCancelLongKotlinCompilation() {
+        generateLongKotlinFile("Foo.kt", "foo", "Foo")
+        initProject()
+
+        val start = System.currentTimeMillis()
+        val canceledStatus = CanceledStatus() { System.currentTimeMillis() - start > 2000 }
+
+        val logger = TestProjectBuilderLogger()
+        val buildResult = BuildResult()
+        buildCustom(canceledStatus, logger, buildResult)
+        val interval = System.currentTimeMillis() - start
+
+        assertCanceled(buildResult)
+        buildResult.assertSuccessful()
+        assert(interval < 8000, "expected time for canceled compilation < 8000 ms, but $interval")
+
+        val module = myProject.getModules().get(0)
+        assertFilesNotExistInOutput(module, "foo/Foo.class")
+
+        val expectedLog = workDir.getAbsolutePath() + File.separator + "expected.log"
+        checkFullLog(logger, File(expectedLog))
+    }
+
+    public fun testCancelKotlinCompilation() {
+        initProject()
+        makeAll().assertSuccessful()
+
+        val module = myProject.getModules().get(0)
+        assertFilesExistInOutput(module, "foo/Bar.class")
+
+        val buildResult = BuildResult()
+        val canceledStatus = object: CanceledStatus {
+            var checkFromIndex = 0;
+
+            public override fun isCanceled(): Boolean {
+                val messages = buildResult.getMessages(BuildMessage.Kind.INFO)
+                for (i in checkFromIndex..messages.size()-1) {
+                    if (messages.get(i).getMessageText().startsWith("Kotlin JPS plugin version")) return true;
+                }
+
+                checkFromIndex = messages.size();
+                return false;
+            }
+        }
+
+        touch("src/Bar.kt").apply()
+        buildCustom(canceledStatus, TestProjectBuilderLogger(), buildResult)
+        assertCanceled(buildResult)
+
+        assertFilesNotExistInOutput(module, "foo/Bar.class")
+    }
+
+    private fun buildCustom(canceledStatus: CanceledStatus, logger: TestProjectBuilderLogger,buildResult: BuildResult) {
+        val scopeBuilder = CompileScopeTestBuilder.make().all()
+        val descriptor = this.createProjectDescriptor(BuildLoggingManager(logger))
+        try {
+            val builder = IncProjectBuilder(descriptor, BuilderRegistry.getInstance(), this.myBuildParams, canceledStatus, null, true)
+            builder.addMessageHandler(buildResult)
+            builder.build(scopeBuilder.build(), false)
+        }
+        finally {
+            descriptor.release()
+        }
+    }
+
+    private fun checkFullLog(logger: TestProjectBuilderLogger, expectedLogFile: File) {
+        UsefulTestCase.assertSameLinesWithFile(expectedLogFile.getAbsolutePath(), logger.getFullLog(getOrCreateProjectDir(), myDataStorageRoot))
+    }
+
+    private fun assertCanceled(buildResult: BuildResult) {
+        val list = buildResult.getMessages(BuildMessage.Kind.INFO)
+        assertTrue("The build has been canceled".equals(list.last().getMessageText()))
+    }
+
+    private fun generateLongKotlinFile(filePath: String, packagename: String, className: String)  {
+        val file = File(workDir.getAbsolutePath() + File.separator + "src" + File.separator + filePath)
+        FileUtilRt.createIfNotExists(file)
+        val writer = BufferedWriter(FileWriter(file))
+        try {
+            writer.write("package $packagename\n\n")
+            writer.write("public class $className {\n")
+
+            for (i in 0..10000) {
+                writer.write("fun f$i():Int = $i\n\n")
+            }
+
+            writer.write("}\n")
+        }
+        finally {
+            writer.close()
+        }
+    }
+
+    private fun findModule(name: String): JpsModule {
+        for (module in myProject.getModules()) {
+            if (module.getName() == name) {
+                return module
+            }
+        }
+        throw IllegalStateException("Couldn't find module $name")
+    }
+
+    private fun checkWhen(action: Action, pathsToCompile: Array<String>?, pathsToDelete: Array<String>?) {
+        checkWhen(arrayOf(action), pathsToCompile, pathsToDelete)
+    }
+
+    private fun checkWhen(actions: Array<Action>, pathsToCompile: Array<String>?, pathsToDelete: Array<String>?) {
+        for (action in actions) {
+            action.apply()
+        }
+
+        makeAll().assertSuccessful()
+
+        if (pathsToCompile != null) {
+            assertCompiled(KotlinBuilder.KOTLIN_BUILDER_NAME, *pathsToCompile)
+        }
+
+        if (pathsToDelete != null) {
+            assertDeleted(*pathsToDelete)
+        }
+    }
+
+    private fun packageClasses(moduleName: String, fileName: String, packageClassFqName: String): Array<String> {
+        return arrayOf(klass(moduleName, packageClassFqName), packagePartClass(moduleName, fileName, packageClassFqName))
+    }
+
+    private fun packagePartClass(moduleName: String, fileName: String, packageClassFqName: String): String {
+        val path = FileUtilRt.toSystemIndependentName(File(workDir, fileName).getAbsolutePath())
+        val fakeVirtualFile = object : LightVirtualFile(path) {
+            override fun getPath(): String {
+                // strip extra "/" from the beginning
+                return super.getPath().substring(1)
+            }
+        }
+
+        val packagePartFqName = PackagePartClassUtils.getPackagePartFqName(FqName(packageClassFqName), fakeVirtualFile)
+        return klass(moduleName, AsmUtil.internalNameByFqNameWithoutInnerClasses(packagePartFqName))
+    }
+
+    private enum class Operation {
+        CHANGE,
+        DELETE
+    }
+
+    protected fun touch(path: String): Action = Action(Operation.CHANGE, path)
+
+    protected fun del(path: String): Action = Action(Operation.DELETE, path)
+
+    protected fun change(filePath: String): Unit = JpsBuildTestCase.change(filePath)
+
+    protected inner class Action constructor(private val operation: Operation, private val path: String) {
+        fun apply() {
+            val file = File(workDir, path)
+            when (operation) {
+                Operation.CHANGE ->
+                    change(file.getAbsolutePath())
+                Operation.DELETE ->
+                    assertTrue(file.delete(), "Can not delete file \"" + file.getAbsolutePath() + "\"")
+                else ->
+                    fail("Unknown operation")
+            }
+        }
+    }
+}
diff --git a/jps-plugin/testData/general/CancelKotlinCompilation/kotlinProject.iml b/jps-plugin/testData/general/CancelKotlinCompilation/kotlinProject.iml
new file mode 100644
index 00000000000..0c4fb67a3d4
--- /dev/null
+++ b/jps-plugin/testData/general/CancelKotlinCompilation/kotlinProject.iml
@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="JAVA_MODULE" version="4">
+  <component name="NewModuleRootManager" inherit-compiler-output="true">
+    <exclude-output />
+    <content url="file://$MODULE_DIR$">
+      <sourceFolder url="file://$MODULE_DIR$/src" isTestSource="false" />
+    </content>
+    <orderEntry type="jdk" jdkName="IDEA_JDK" jdkType="JavaSDK" />
+    <orderEntry type="sourceFolder" forTests="false" />
+    <orderEntry type="library" name="KotlinRuntime" level="project" />
+  </component>
+</module>
diff --git a/jps-plugin/testData/general/CancelKotlinCompilation/kotlinProject.ipr b/jps-plugin/testData/general/CancelKotlinCompilation/kotlinProject.ipr
new file mode 100644
index 00000000000..8226e21ade3
--- /dev/null
+++ b/jps-plugin/testData/general/CancelKotlinCompilation/kotlinProject.ipr
@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="CompilerConfiguration">
+    <option name="DEFAULT_COMPILER" value="Javac" />
+  </component>
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/kotlinProject.iml" filepath="$PROJECT_DIR$/kotlinProject.iml" />
+    </modules>
+  </component>
+  <component name="ProjectRootManager" version="2" languageLevel="JDK_1_6" assert-keyword="true" jdk-15="true" project-jdk-name="IDEA_JDK" project-jdk-type="JavaSDK">
+    <output url="file://$PROJECT_DIR$/out" />
+  </component>
+</project>
diff --git a/jps-plugin/testData/general/CancelKotlinCompilation/src/Bar.kt b/jps-plugin/testData/general/CancelKotlinCompilation/src/Bar.kt
new file mode 100644
index 00000000000..2c990ada4c7
--- /dev/null
+++ b/jps-plugin/testData/general/CancelKotlinCompilation/src/Bar.kt
@@ -0,0 +1,3 @@
+package foo
+
+class Bar
diff --git a/jps-plugin/testData/general/CancelLongKotlinCompilation/expected.log b/jps-plugin/testData/general/CancelLongKotlinCompilation/expected.log
new file mode 100644
index 00000000000..d5d22ab8abe
--- /dev/null
+++ b/jps-plugin/testData/general/CancelLongKotlinCompilation/expected.log
@@ -0,0 +1,3 @@
+Compiling files:
+src/Foo.kt
+End of files
\ No newline at end of file
diff --git a/jps-plugin/testData/general/CancelLongKotlinCompilation/kotlinProject.iml b/jps-plugin/testData/general/CancelLongKotlinCompilation/kotlinProject.iml
new file mode 100644
index 00000000000..0c4fb67a3d4
--- /dev/null
+++ b/jps-plugin/testData/general/CancelLongKotlinCompilation/kotlinProject.iml
@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="JAVA_MODULE" version="4">
+  <component name="NewModuleRootManager" inherit-compiler-output="true">
+    <exclude-output />
+    <content url="file://$MODULE_DIR$">
+      <sourceFolder url="file://$MODULE_DIR$/src" isTestSource="false" />
+    </content>
+    <orderEntry type="jdk" jdkName="IDEA_JDK" jdkType="JavaSDK" />
+    <orderEntry type="sourceFolder" forTests="false" />
+    <orderEntry type="library" name="KotlinRuntime" level="project" />
+  </component>
+</module>
diff --git a/jps-plugin/testData/general/CancelLongKotlinCompilation/kotlinProject.ipr b/jps-plugin/testData/general/CancelLongKotlinCompilation/kotlinProject.ipr
new file mode 100644
index 00000000000..8226e21ade3
--- /dev/null
+++ b/jps-plugin/testData/general/CancelLongKotlinCompilation/kotlinProject.ipr
@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="CompilerConfiguration">
+    <option name="DEFAULT_COMPILER" value="Javac" />
+  </component>
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/kotlinProject.iml" filepath="$PROJECT_DIR$/kotlinProject.iml" />
+    </modules>
+  </component>
+  <component name="ProjectRootManager" version="2" languageLevel="JDK_1_6" assert-keyword="true" jdk-15="true" project-jdk-name="IDEA_JDK" project-jdk-type="JavaSDK">
+    <output url="file://$PROJECT_DIR$/out" />
+  </component>
+</project>
diff --git a/js/js.frontend/src/org/jetbrains/kotlin/js/PredefinedAnnotation.kt b/js/js.frontend/src/org/jetbrains/kotlin/js/PredefinedAnnotation.kt
index 1f0aa70c6f0..c7a3ae65c42 100644
--- a/js/js.frontend/src/org/jetbrains/kotlin/js/PredefinedAnnotation.kt
+++ b/js/js.frontend/src/org/jetbrains/kotlin/js/PredefinedAnnotation.kt
@@ -30,6 +30,6 @@ public enum class PredefinedAnnotation(fqName: String) {
 
     companion object {
         // TODO: replace with straight assignment when KT-5761 will be fixed
-        val WITH_CUSTOM_NAME by Delegates.lazy { setOf(LIBRARY, NATIVE) }
+        val WITH_CUSTOM_NAME by lazy { setOf(LIBRARY, NATIVE) }
     }
 }
diff --git a/js/js.frontend/src/org/jetbrains/kotlin/js/analyze/TopDownAnalyzerFacadeForJS.java b/js/js.frontend/src/org/jetbrains/kotlin/js/analyze/TopDownAnalyzerFacadeForJS.java
index cec630a64a6..abaf86be75c 100644
--- a/js/js.frontend/src/org/jetbrains/kotlin/js/analyze/TopDownAnalyzerFacadeForJS.java
+++ b/js/js.frontend/src/org/jetbrains/kotlin/js/analyze/TopDownAnalyzerFacadeForJS.java
@@ -43,6 +43,7 @@ public final class TopDownAnalyzerFacadeForJS {
     public static final List<ImportPath> DEFAULT_IMPORTS = ImmutableList.of(
             new ImportPath("java.lang.*"),
             new ImportPath("kotlin.*"),
+            new ImportPath("kotlin.annotation.*"),
             new ImportPath("kotlin.js.*")
     );
 
diff --git a/js/js.frontend/src/org/jetbrains/kotlin/js/resolve/diagnostics/DefaultErrorMessagesJs.kt b/js/js.frontend/src/org/jetbrains/kotlin/js/resolve/diagnostics/DefaultErrorMessagesJs.kt
index d36ed24be5b..23be132b183 100644
--- a/js/js.frontend/src/org/jetbrains/kotlin/js/resolve/diagnostics/DefaultErrorMessagesJs.kt
+++ b/js/js.frontend/src/org/jetbrains/kotlin/js/resolve/diagnostics/DefaultErrorMessagesJs.kt
@@ -19,9 +19,8 @@ package org.jetbrains.kotlin.js.resolve.diagnostics
 import org.jetbrains.kotlin.diagnostics.rendering.DefaultErrorMessages
 import org.jetbrains.kotlin.diagnostics.rendering.DiagnosticFactoryToRendererMap
 import org.jetbrains.kotlin.diagnostics.rendering.Renderers
-import kotlin.properties.Delegates
 
-private val DIAGNOSTIC_FACTORY_TO_RENDERER by Delegates.lazy {
+private val DIAGNOSTIC_FACTORY_TO_RENDERER by lazy {
     with(DiagnosticFactoryToRendererMap()) {
 
         put(ErrorsJs.NATIVE_ANNOTATIONS_ALLOWED_ONLY_ON_MEMBER_OR_EXTENSION_FUN,
diff --git a/js/js.frontend/src/org/jetbrains/kotlin/js/resolve/diagnostics/JsCallChecker.kt b/js/js.frontend/src/org/jetbrains/kotlin/js/resolve/diagnostics/JsCallChecker.kt
index 9a4cf2dd0d5..9cb24cfde40 100644
--- a/js/js.frontend/src/org/jetbrains/kotlin/js/resolve/diagnostics/JsCallChecker.kt
+++ b/js/js.frontend/src/org/jetbrains/kotlin/js/resolve/diagnostics/JsCallChecker.kt
@@ -20,37 +20,28 @@ import com.google.dart.compiler.backend.js.ast.JsFunctionScope
 import com.google.dart.compiler.backend.js.ast.JsProgram
 import com.google.dart.compiler.backend.js.ast.JsRootScope
 import com.google.gwt.dev.js.parserExceptions.AbortParsingException
-import com.google.gwt.dev.js.rhino.*
-import com.google.gwt.dev.js.rhino.Utils.*
-import org.jetbrains.annotations.TestOnly
+import com.google.gwt.dev.js.rhino.CodePosition
+import com.google.gwt.dev.js.rhino.ErrorReporter
+import com.google.gwt.dev.js.rhino.Utils.isEndOfLine
+import com.intellij.openapi.util.TextRange
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns
 import org.jetbrains.kotlin.descriptors.CallableDescriptor
 import org.jetbrains.kotlin.descriptors.SimpleFunctionDescriptor
 import org.jetbrains.kotlin.diagnostics.DiagnosticFactory1
-import org.jetbrains.kotlin.diagnostics.DiagnosticSink
-import org.jetbrains.kotlin.diagnostics.ParametrizedDiagnostic
+import org.jetbrains.kotlin.js.parser.parse
 import org.jetbrains.kotlin.js.patterns.DescriptorPredicate
 import org.jetbrains.kotlin.js.patterns.PatternBuilder
-import org.jetbrains.kotlin.js.resolve.diagnostics.ErrorsJs
 import org.jetbrains.kotlin.psi.JetCallExpression
 import org.jetbrains.kotlin.psi.JetExpression
 import org.jetbrains.kotlin.psi.JetLiteralStringTemplateEntry
 import org.jetbrains.kotlin.psi.JetStringTemplateExpression
-import org.jetbrains.kotlin.renderer.Renderer
-import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.BindingTrace
+import org.jetbrains.kotlin.resolve.TemporaryBindingTrace
 import org.jetbrains.kotlin.resolve.calls.checkers.CallChecker
 import org.jetbrains.kotlin.resolve.calls.context.BasicCallResolutionContext
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall
 import org.jetbrains.kotlin.resolve.constants.evaluate.ConstantExpressionEvaluator
-import org.jetbrains.kotlin.types.JetType
-
-import com.intellij.openapi.util.TextRange
-import org.jetbrains.kotlin.js.parser.parse
-import java.io.StringReader
-
 import kotlin.platform.platformStatic
-import org.jetbrains.kotlin.resolve.TemporaryBindingTrace
 
 public class JsCallChecker : CallChecker {
 
@@ -84,7 +75,7 @@ public class JsCallChecker : CallChecker {
             return
         }
 
-        val code = evaluationResult.getValue() as String
+        val code = evaluationResult.getValue(stringType) as String
         val errorReporter = JsCodeErrorReporter(argument, code, context.trace)
 
         try {
diff --git a/js/js.frontend/src/org/jetbrains/kotlin/js/resolve/diagnostics/jsRenderers.kt b/js/js.frontend/src/org/jetbrains/kotlin/js/resolve/diagnostics/jsRenderers.kt
index 2a43145c6a8..546833050de 100644
--- a/js/js.frontend/src/org/jetbrains/kotlin/js/resolve/diagnostics/jsRenderers.kt
+++ b/js/js.frontend/src/org/jetbrains/kotlin/js/resolve/diagnostics/jsRenderers.kt
@@ -31,7 +31,7 @@ object RenderFirstLineOfElementText : Renderer<PsiElement> {
 abstract class JsCallDataRenderer : Renderer<JsCallData> {
     protected abstract fun format(data: JsCallDataWithCode): String
 
-    override fun render(data: JsCallData?): String =
+    override fun render(data: JsCallData): String =
             when (data) {
                 is JsCallDataWithCode -> format(data)
                 is JsCallData -> data.message
diff --git a/js/js.frontend/src/org/jetbrains/kotlin/js/resolve/nativeAnnotationCheckers.kt b/js/js.frontend/src/org/jetbrains/kotlin/js/resolve/nativeAnnotationCheckers.kt
index fdebcbd3f77..dff2309a3a7 100644
--- a/js/js.frontend/src/org/jetbrains/kotlin/js/resolve/nativeAnnotationCheckers.kt
+++ b/js/js.frontend/src/org/jetbrains/kotlin/js/resolve/nativeAnnotationCheckers.kt
@@ -26,6 +26,7 @@ import org.jetbrains.kotlin.js.resolve.diagnostics.ErrorsJs
 import org.jetbrains.kotlin.js.translate.utils.AnnotationsUtils
 import org.jetbrains.kotlin.psi.JetDeclaration
 import org.jetbrains.kotlin.psi.JetNamedFunction
+import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.DeclarationChecker
 import org.jetbrains.kotlin.resolve.DescriptorUtils
 import org.jetbrains.kotlin.types.TypeUtils
@@ -35,9 +36,13 @@ private abstract class AbstractNativeAnnotationsChecker(private val requiredAnno
 
     open fun additionalCheck(declaration: JetNamedFunction, descriptor: FunctionDescriptor, diagnosticHolder: DiagnosticSink) {}
 
-    override fun check(declaration: JetDeclaration, descriptor: DeclarationDescriptor, diagnosticHolder: DiagnosticSink) {
-        val annotationDescriptor = descriptor.getAnnotations().findAnnotation(requiredAnnotation.fqName)
-        if (annotationDescriptor == null) return
+    override fun check(
+            declaration: JetDeclaration,
+            descriptor: DeclarationDescriptor,
+            diagnosticHolder: DiagnosticSink,
+            bindingContext: BindingContext
+    ) {
+        val annotationDescriptor = descriptor.getAnnotations().findAnnotation(requiredAnnotation.fqName) ?: return
 
         if (declaration !is JetNamedFunction || descriptor !is FunctionDescriptor) {
             diagnosticHolder.report(ErrorsJs.NATIVE_ANNOTATIONS_ALLOWED_ONLY_ON_MEMBER_OR_EXTENSION_FUN.on(declaration, annotationDescriptor.getType()))
diff --git a/js/js.frontend/src/org/jetbrains/kotlin/js/resolve/unsupportedFeatureCheckers.kt b/js/js.frontend/src/org/jetbrains/kotlin/js/resolve/unsupportedFeatureCheckers.kt
index 8ac9a876d8a..dcefa7fd311 100644
--- a/js/js.frontend/src/org/jetbrains/kotlin/js/resolve/unsupportedFeatureCheckers.kt
+++ b/js/js.frontend/src/org/jetbrains/kotlin/js/resolve/unsupportedFeatureCheckers.kt
@@ -26,12 +26,17 @@ import org.jetbrains.kotlin.diagnostics.rendering.renderKindWithName
 import org.jetbrains.kotlin.js.resolve.diagnostics.ErrorsJs
 import org.jetbrains.kotlin.js.translate.utils.AnnotationsUtils
 import org.jetbrains.kotlin.psi.*
+import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.DeclarationChecker
 import org.jetbrains.kotlin.resolve.DescriptorUtils
 
 class ClassDeclarationChecker : DeclarationChecker {
-    override fun check(declaration: JetDeclaration, descriptor: DeclarationDescriptor, diagnosticHolder: DiagnosticSink) {
-
+    override fun check(
+            declaration: JetDeclaration,
+            descriptor: DeclarationDescriptor,
+            diagnosticHolder: DiagnosticSink,
+            bindingContext: BindingContext
+    ) {
         if (declaration !is JetClassOrObject || declaration is JetObjectDeclaration || declaration is JetEnumEntry) return
 
         // hack to avoid to get diagnostics when compile kotlin builtins
diff --git a/js/js.frontend/src/org/jetbrains/kotlin/js/translate/utils/AnnotationsUtils.java b/js/js.frontend/src/org/jetbrains/kotlin/js/translate/utils/AnnotationsUtils.java
index ac87a14892d..88217baddd6 100644
--- a/js/js.frontend/src/org/jetbrains/kotlin/js/translate/utils/AnnotationsUtils.java
+++ b/js/js.frontend/src/org/jetbrains/kotlin/js/translate/utils/AnnotationsUtils.java
@@ -27,7 +27,7 @@ import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptor;
 import org.jetbrains.kotlin.js.PredefinedAnnotation;
 import org.jetbrains.kotlin.name.FqName;
 import org.jetbrains.kotlin.resolve.DescriptorUtils;
-import org.jetbrains.kotlin.resolve.constants.CompileTimeConstant;
+import org.jetbrains.kotlin.resolve.constants.ConstantValue;
 
 import java.util.List;
 import java.util.Set;
@@ -53,7 +53,7 @@ public final class AnnotationsUtils {
         if (annotationDescriptor.getAllValueArguments().isEmpty()) {
             return null;
         }
-        CompileTimeConstant<?> constant = annotationDescriptor.getAllValueArguments().values().iterator().next();
+        ConstantValue<?> constant = annotationDescriptor.getAllValueArguments().values().iterator().next();
         //TODO: this is a quick fix for unsupported default args problem
         if (constant == null) {
             return null;
diff --git a/js/js.inliner/src/org/jetbrains/kotlin/js/inline/ExpressionDecomposer.kt b/js/js.inliner/src/org/jetbrains/kotlin/js/inline/ExpressionDecomposer.kt
index c32c8037caf..9f7dafd40c1 100644
--- a/js/js.inliner/src/org/jetbrains/kotlin/js/inline/ExpressionDecomposer.kt
+++ b/js/js.inliner/src/org/jetbrains/kotlin/js/inline/ExpressionDecomposer.kt
@@ -17,15 +17,10 @@
 package org.jetbrains.kotlin.js.inline.util
 
 import com.google.dart.compiler.backend.js.ast.*
-import com.google.dart.compiler.backend.js.ast.metadata.*
+import com.intellij.util.SmartList
 import org.jetbrains.kotlin.js.translate.utils.JsAstUtils.*
 import org.jetbrains.kotlin.js.translate.utils.jsAstUtils.*
-
 import kotlin.platform.platformStatic
-import kotlin.properties.Delegates
-
-import com.intellij.util.SmartList
-import org.jetbrains.kotlin.js.translate.context.Namer
 
 /**
  * If inline function consists of multiple statements,
@@ -324,7 +319,7 @@ class ExpressionDecomposer private constructor(
     private inner class Temporary(val value: JsExpression? = null) {
         val name: JsName = scope.declareTemporary()
 
-        val variable: JsVars by Delegates.lazy {
+        val variable: JsVars by lazy {
             newVar(name, value)
         }
 
diff --git a/js/js.inliner/src/org/jetbrains/kotlin/js/inline/FunctionInlineMutator.kt b/js/js.inliner/src/org/jetbrains/kotlin/js/inline/FunctionInlineMutator.kt
index 23504491288..b77f5d82c33 100644
--- a/js/js.inliner/src/org/jetbrains/kotlin/js/inline/FunctionInlineMutator.kt
+++ b/js/js.inliner/src/org/jetbrains/kotlin/js/inline/FunctionInlineMutator.kt
@@ -74,13 +74,13 @@ private constructor(
         var thisReplacement = getThisReplacement(call)
         if (thisReplacement == null || thisReplacement is JsLiteral.JsThisRef) return
 
-        if (thisReplacement!!.needToAlias()) {
+        if (thisReplacement.needToAlias()) {
             val thisName = namingContext.getFreshName(getThisAlias())
             namingContext.newVar(thisName, thisReplacement)
             thisReplacement = thisName.makeRef()
         }
 
-        replaceThisReference(body, thisReplacement!!)
+        replaceThisReference(body, thisReplacement)
     }
 
     private fun removeStatementsAfterTopReturn() {
diff --git a/js/js.inliner/src/org/jetbrains/kotlin/js/inline/FunctionReader.kt b/js/js.inliner/src/org/jetbrains/kotlin/js/inline/FunctionReader.kt
index 4ae6038fbb8..5d7bdb0e6ba 100644
--- a/js/js.inliner/src/org/jetbrains/kotlin/js/inline/FunctionReader.kt
+++ b/js/js.inliner/src/org/jetbrains/kotlin/js/inline/FunctionReader.kt
@@ -92,7 +92,7 @@ public class FunctionReader(private val context: TranslationContext) {
     public fun contains(descriptor: CallableDescriptor): Boolean {
         val moduleName = getExternalModuleName(descriptor)
         val currentModuleName = context.getConfig().getModuleId()
-        return currentModuleName != moduleName && moduleName in moduleJsDefinition
+        return currentModuleName != moduleName && moduleName != null && moduleName in moduleJsDefinition
     }
 
     public fun get(descriptor: CallableDescriptor): JsFunction = functionCache.get(descriptor)
@@ -123,8 +123,8 @@ public class FunctionReader(private val context: TranslationContext) {
         val moduleNameLiteral = context.program().getStringLiteral(moduleName)
         val moduleReference =  context.namer().getModuleReference(moduleNameLiteral)
 
-        val replacements = hashMapOf(moduleRootVariable[moduleName] to moduleReference,
-                                     moduleKotlinVariable[moduleName] to Namer.KOTLIN_OBJECT_REF)
+        val replacements = hashMapOf(moduleRootVariable[moduleName]!! to moduleReference,
+                                     moduleKotlinVariable[moduleName]!! to Namer.KOTLIN_OBJECT_REF)
         replaceExternalNames(function, replacements)
         return function
     }
diff --git a/js/js.inliner/src/org/jetbrains/kotlin/js/inline/clean/removeDefaultInitializers.kt b/js/js.inliner/src/org/jetbrains/kotlin/js/inline/clean/removeDefaultInitializers.kt
index 081abe92ef6..192094d6ad7 100644
--- a/js/js.inliner/src/org/jetbrains/kotlin/js/inline/clean/removeDefaultInitializers.kt
+++ b/js/js.inliner/src/org/jetbrains/kotlin/js/inline/clean/removeDefaultInitializers.kt
@@ -97,7 +97,7 @@ private fun isNameInitialized(
     val expr = (lastThenStmt as? JsExpressionStatement)?.getExpression()
     if (expr !is JsBinaryOperation) return false
 
-    val op = expr.getOperator()!!
+    val op = expr.getOperator()
     if (!op.isAssignment()) return false
 
     val arg1 = expr.getArg1()
diff --git a/js/js.inliner/src/org/jetbrains/kotlin/js/inline/clean/removeUnusedLocalFunctionDeclarations.kt b/js/js.inliner/src/org/jetbrains/kotlin/js/inline/clean/removeUnusedLocalFunctionDeclarations.kt
index 1fa6bf708b4..ffffb4618e8 100644
--- a/js/js.inliner/src/org/jetbrains/kotlin/js/inline/clean/removeUnusedLocalFunctionDeclarations.kt
+++ b/js/js.inliner/src/org/jetbrains/kotlin/js/inline/clean/removeUnusedLocalFunctionDeclarations.kt
@@ -51,7 +51,7 @@ private class UnusedInstanceCollector : JsVisitorWithContextImpl() {
         val name = x.getName()!!
         val statementContext = getLastStatementLevelContext()
         val currentStatement = statementContext.getCurrentNode()
-        tracker.addCandidateForRemoval(name, currentStatement)
+        tracker.addCandidateForRemoval(name, currentStatement!!)
 
         val references = collectReferencesInside(x)
         references.filterNotNull()
@@ -60,8 +60,8 @@ private class UnusedInstanceCollector : JsVisitorWithContextImpl() {
         return false
     }
 
-    override fun visit(x: JsNameRef?, ctx: JsContext<*>?): Boolean {
-        val name = x?.getName()
+    override fun visit(x: JsNameRef, ctx: JsContext<*>): Boolean {
+        val name = x.getName()
 
         if (name != null) {
             tracker.markReachable(name)
diff --git a/js/js.inliner/src/org/jetbrains/kotlin/js/inline/context/FunctionContext.kt b/js/js.inliner/src/org/jetbrains/kotlin/js/inline/context/FunctionContext.kt
index 7b46a926b60..a9337127d60 100644
--- a/js/js.inliner/src/org/jetbrains/kotlin/js/inline/context/FunctionContext.kt
+++ b/js/js.inliner/src/org/jetbrains/kotlin/js/inline/context/FunctionContext.kt
@@ -121,7 +121,7 @@ abstract class FunctionContext(
 
         /** in case 4, 5 get ref (reduce 4, 5 to 2, 3 accordingly) */
         if (callQualifier is JsNameRef) {
-            val staticRef = (callQualifier as JsNameRef).getName()?.staticRef
+            val staticRef = callQualifier.getName()?.staticRef
 
             callQualifier = when (staticRef) {
                 is JsNameRef -> staticRef
diff --git a/js/js.inliner/src/org/jetbrains/kotlin/js/inline/context/InliningContext.kt b/js/js.inliner/src/org/jetbrains/kotlin/js/inline/context/InliningContext.kt
index a7eccc37387..6cf196b0c3e 100644
--- a/js/js.inliner/src/org/jetbrains/kotlin/js/inline/context/InliningContext.kt
+++ b/js/js.inliner/src/org/jetbrains/kotlin/js/inline/context/InliningContext.kt
@@ -19,7 +19,7 @@ package org.jetbrains.kotlin.js.inline.context
 import com.google.dart.compiler.backend.js.ast.JsContext
 import com.google.dart.compiler.backend.js.ast.JsStatement
 
-trait InliningContext {
+interface InliningContext {
     public val statementContext: JsContext<JsStatement>
     public val functionContext: FunctionContext
 
diff --git a/js/js.inliner/src/org/jetbrains/kotlin/js/inline/util/invocationUtils.kt b/js/js.inliner/src/org/jetbrains/kotlin/js/inline/util/invocationUtils.kt
index 337ade0890c..ec6199d3caa 100644
--- a/js/js.inliner/src/org/jetbrains/kotlin/js/inline/util/invocationUtils.kt
+++ b/js/js.inliner/src/org/jetbrains/kotlin/js/inline/util/invocationUtils.kt
@@ -47,14 +47,14 @@ public fun getSimpleIdent(call: JsInvocation): String? {
     qualifiers@ while (qualifier != null) {
         when (qualifier) {
             is JsInvocation -> {
-                val callableQualifier = qualifier as JsInvocation
+                val callableQualifier = qualifier
                 qualifier = callableQualifier.getQualifier()
 
                 if (isCallInvocation(callableQualifier)) {
                     qualifier = (qualifier as? JsNameRef)?.getQualifier()
                 }
             }
-            is HasName -> return (qualifier as HasName).getName()?.getIdent()
+            is HasName -> return qualifier.getName()?.getIdent()
             else -> break@qualifiers
         }
     }
diff --git a/js/js.libraries/src/core/kotlin.kt b/js/js.libraries/src/core/kotlin.kt
index 219612926b3..a7d14df3900 100644
--- a/js/js.libraries/src/core/kotlin.kt
+++ b/js/js.libraries/src/core/kotlin.kt
@@ -61,3 +61,22 @@ public fun lazy<T>(initializer: () -> T): Lazy<T> = UnsafeLazyImpl(initializer)
  *
  * The [mode] parameter is ignored. */
 public fun lazy<T>(mode: LazyThreadSafetyMode, initializer: () -> T): Lazy<T> = UnsafeLazyImpl(initializer)
+
+
+private fun arrayCopyResize(source: dynamic, newSize: Int, defaultValue: Any?): dynamic {
+    val result = source.slice(0, newSize)
+    var index: Int = source.length
+    if (newSize > index) {
+        result.length = newSize
+        while (index < newSize) result[index++] = defaultValue
+    }
+    return result
+}
+
+private fun <T> arrayPlusCollection(array: dynamic, collection: Collection<T>): dynamic {
+    val result = array.slice(0)
+    result.length += collection.size()
+    var index: Int = array.length
+    for (element in collection) result[index++] = element
+    return result
+}
\ No newline at end of file
diff --git a/js/js.libraries/src/core/kotlin_special.kt b/js/js.libraries/src/core/kotlin_special.kt
index a04427d27d2..a8e8ea898eb 100644
--- a/js/js.libraries/src/core/kotlin_special.kt
+++ b/js/js.libraries/src/core/kotlin_special.kt
@@ -75,3 +75,417 @@ public inline fun ShortArray.asList(): List<Short> {
     return (this as Array<Short>).asList()
 }
 
+/**
+ * Returns new array which is a copy of the original array.
+ */
+suppress("NOTHING_TO_INLINE")
+public inline fun <T> Array<out T>.copyOf(): Array<T> {
+    return (this: dynamic).slice(0)
+}
+
+/**
+ * Returns new array which is a copy of the original array.
+ */
+suppress("NOTHING_TO_INLINE")
+public inline fun BooleanArray.copyOf(): BooleanArray {
+    return (this: dynamic).slice(0)
+}
+
+/**
+ * Returns new array which is a copy of the original array.
+ */
+suppress("NOTHING_TO_INLINE")
+public inline fun ByteArray.copyOf(): ByteArray {
+    return (this: dynamic).slice(0)
+}
+
+/**
+ * Returns new array which is a copy of the original array.
+ */
+suppress("NOTHING_TO_INLINE")
+public inline fun CharArray.copyOf(): CharArray {
+    return (this: dynamic).slice(0)
+}
+
+/**
+ * Returns new array which is a copy of the original array.
+ */
+suppress("NOTHING_TO_INLINE")
+public inline fun DoubleArray.copyOf(): DoubleArray {
+    return (this: dynamic).slice(0)
+}
+
+/**
+ * Returns new array which is a copy of the original array.
+ */
+suppress("NOTHING_TO_INLINE")
+public inline fun FloatArray.copyOf(): FloatArray {
+    return (this: dynamic).slice(0)
+}
+
+/**
+ * Returns new array which is a copy of the original array.
+ */
+suppress("NOTHING_TO_INLINE")
+public inline fun IntArray.copyOf(): IntArray {
+    return (this: dynamic).slice(0)
+}
+
+/**
+ * Returns new array which is a copy of the original array.
+ */
+suppress("NOTHING_TO_INLINE")
+public inline fun LongArray.copyOf(): LongArray {
+    return (this: dynamic).slice(0)
+}
+
+/**
+ * Returns new array which is a copy of the original array.
+ */
+suppress("NOTHING_TO_INLINE")
+public inline fun ShortArray.copyOf(): ShortArray {
+    return (this: dynamic).slice(0)
+}
+
+/**
+ * Returns new array which is a copy of the original array.
+ */
+public fun BooleanArray.copyOf(newSize: Int): BooleanArray {
+    return arrayCopyResize(this, newSize, false)
+}
+
+/**
+ * Returns new array which is a copy of the original array.
+ */
+public fun ByteArray.copyOf(newSize: Int): ByteArray {
+    return arrayCopyResize(this, newSize, 0)
+}
+
+/**
+ * Returns new array which is a copy of the original array.
+ */
+public fun CharArray.copyOf(newSize: Int): CharArray {
+    return arrayCopyResize(this, newSize, '\u0000')
+}
+
+/**
+ * Returns new array which is a copy of the original array.
+ */
+public fun ShortArray.copyOf(newSize: Int): ShortArray {
+    return arrayCopyResize(this, newSize, 0)
+}
+
+/**
+ * Returns new array which is a copy of the original array.
+ */
+public fun IntArray.copyOf(newSize: Int): IntArray {
+    return arrayCopyResize(this, newSize, 0)
+}
+
+/**
+ * Returns new array which is a copy of the original array.
+ */
+public fun LongArray.copyOf(newSize: Int): LongArray {
+    return arrayCopyResize(this, newSize, 0L)
+}
+
+/**
+ * Returns new array which is a copy of the original array.
+ */
+public fun FloatArray.copyOf(newSize: Int): FloatArray {
+    return arrayCopyResize(this, newSize, 0.0f)
+}
+
+/**
+ * Returns new array which is a copy of the original array.
+ */
+public fun DoubleArray.copyOf(newSize: Int): DoubleArray {
+    return arrayCopyResize(this, newSize, 0.0)
+}
+
+/**
+ * Returns new array which is a copy of the original array.
+ */
+public fun <T> Array<out T>.copyOf(newSize: Int): Array<T?> {
+    return arrayCopyResize(this, newSize, null)
+}
+
+/**
+ * Returns new array which is a copy of range of original array.
+ */
+suppress("NOTHING_TO_INLINE")
+public inline fun <T> Array<out T>.copyOfRange(from: Int, to: Int): Array<T> {
+    return (this: dynamic).slice(from, to)
+}
+
+/**
+ * Returns new array which is a copy of range of original array.
+ */
+suppress("NOTHING_TO_INLINE")
+public inline fun BooleanArray.copyOfRange(from: Int, to: Int): BooleanArray {
+    return (this: dynamic).slice(from, to)
+}
+
+/**
+ * Returns new array which is a copy of range of original array.
+ */
+suppress("NOTHING_TO_INLINE")
+public inline fun ByteArray.copyOfRange(from: Int, to: Int): ByteArray {
+    return (this: dynamic).slice(from, to)
+}
+
+/**
+ * Returns new array which is a copy of range of original array.
+ */
+suppress("NOTHING_TO_INLINE")
+public inline fun CharArray.copyOfRange(from: Int, to: Int): CharArray {
+    return (this: dynamic).slice(from, to)
+}
+
+/**
+ * Returns new array which is a copy of range of original array.
+ */
+suppress("NOTHING_TO_INLINE")
+public inline fun DoubleArray.copyOfRange(from: Int, to: Int): DoubleArray {
+    return (this: dynamic).slice(from, to)
+}
+
+/**
+ * Returns new array which is a copy of range of original array.
+ */
+suppress("NOTHING_TO_INLINE")
+public inline fun FloatArray.copyOfRange(from: Int, to: Int): FloatArray {
+    return (this: dynamic).slice(from, to)
+}
+
+/**
+ * Returns new array which is a copy of range of original array.
+ */
+suppress("NOTHING_TO_INLINE")
+public inline fun IntArray.copyOfRange(from: Int, to: Int): IntArray {
+    return (this: dynamic).slice(from, to)
+}
+
+/**
+ * Returns new array which is a copy of range of original array.
+ */
+suppress("NOTHING_TO_INLINE")
+public inline fun LongArray.copyOfRange(from: Int, to: Int): LongArray {
+    return (this: dynamic).slice(from, to)
+}
+
+/**
+ * Returns new array which is a copy of range of original array.
+ */
+suppress("NOTHING_TO_INLINE")
+public inline fun ShortArray.copyOfRange(from: Int, to: Int): ShortArray {
+    return (this: dynamic).slice(from, to)
+}
+
+/**
+ * Returns an array containing all elements of the original array and then all elements of the given [array].
+ */
+suppress("NOTHING_TO_INLINE")
+public inline fun <T> Array<out T>.plus(array: Array<out T>): Array<T> {
+    return (this: dynamic).concat(array)
+}
+
+/**
+ * Returns an array containing all elements of the original array and then all elements of the given [array].
+ */
+suppress("NOTHING_TO_INLINE")
+public inline fun BooleanArray.plus(array: BooleanArray): BooleanArray {
+    return (this: dynamic).concat(array)
+}
+
+/**
+ * Returns an array containing all elements of the original array and then all elements of the given [array].
+ */
+suppress("NOTHING_TO_INLINE")
+public inline fun ByteArray.plus(array: ByteArray): ByteArray {
+    return (this: dynamic).concat(array)
+}
+
+/**
+ * Returns an array containing all elements of the original array and then all elements of the given [array].
+ */
+suppress("NOTHING_TO_INLINE")
+public inline fun CharArray.plus(array: CharArray): CharArray {
+    return (this: dynamic).concat(array)
+}
+
+/**
+ * Returns an array containing all elements of the original array and then all elements of the given [array].
+ */
+suppress("NOTHING_TO_INLINE")
+public inline fun DoubleArray.plus(array: DoubleArray): DoubleArray {
+    return (this: dynamic).concat(array)
+}
+
+/**
+ * Returns an array containing all elements of the original array and then all elements of the given [array].
+ */
+suppress("NOTHING_TO_INLINE")
+public inline fun FloatArray.plus(array: FloatArray): FloatArray {
+    return (this: dynamic).concat(array)
+}
+
+/**
+ * Returns an array containing all elements of the original array and then all elements of the given [array].
+ */
+suppress("NOTHING_TO_INLINE")
+public inline fun IntArray.plus(array: IntArray): IntArray {
+    return (this: dynamic).concat(array)
+}
+
+/**
+ * Returns an array containing all elements of the original array and then all elements of the given [array].
+ */
+suppress("NOTHING_TO_INLINE")
+public inline fun LongArray.plus(array: LongArray): LongArray {
+    return (this: dynamic).concat(array)
+}
+
+/**
+ * Returns an array containing all elements of the original array and then all elements of the given [array].
+ */
+suppress("NOTHING_TO_INLINE")
+public inline fun ShortArray.plus(array: ShortArray): ShortArray {
+    return (this: dynamic).concat(array)
+}
+
+/**
+ * Returns an array containing all elements of the original array and then all elements of the given [collection].
+ */
+public fun <T> Array<out T>.plus(collection: Collection<T>): Array<T> {
+    return arrayPlusCollection(this, collection)
+}
+
+/**
+ * Returns an array containing all elements of the original array and then all elements of the given [collection].
+ */
+public fun BooleanArray.plus(collection: Collection<Boolean>): BooleanArray {
+    return arrayPlusCollection(this, collection)
+}
+
+/**
+ * Returns an array containing all elements of the original array and then all elements of the given [collection].
+ */
+public fun ByteArray.plus(collection: Collection<Byte>): ByteArray {
+    return arrayPlusCollection(this, collection)
+}
+
+/**
+ * Returns an array containing all elements of the original array and then all elements of the given [collection].
+ */
+public fun CharArray.plus(collection: Collection<Char>): CharArray {
+    return arrayPlusCollection(this, collection)
+}
+
+/**
+ * Returns an array containing all elements of the original array and then all elements of the given [collection].
+ */
+public fun DoubleArray.plus(collection: Collection<Double>): DoubleArray {
+    return arrayPlusCollection(this, collection)
+}
+
+/**
+ * Returns an array containing all elements of the original array and then all elements of the given [collection].
+ */
+public fun FloatArray.plus(collection: Collection<Float>): FloatArray {
+    return arrayPlusCollection(this, collection)
+}
+
+/**
+ * Returns an array containing all elements of the original array and then all elements of the given [collection].
+ */
+public fun IntArray.plus(collection: Collection<Int>): IntArray {
+    return arrayPlusCollection(this, collection)
+}
+
+/**
+ * Returns an array containing all elements of the original array and then all elements of the given [collection].
+ */
+public fun LongArray.plus(collection: Collection<Long>): LongArray {
+    return arrayPlusCollection(this, collection)
+}
+
+/**
+ * Returns an array containing all elements of the original array and then all elements of the given [collection].
+ */
+public fun ShortArray.plus(collection: Collection<Short>): ShortArray {
+    return arrayPlusCollection(this, collection)
+}
+
+/**
+ * Returns an array containing all elements of the original array and then the given [element].
+ */
+suppress("NOTHING_TO_INLINE")
+public inline fun <T> Array<out T>.plus(element: T): Array<T> {
+    return (this: dynamic).concat(arrayOf(element))
+}
+
+/**
+ * Returns an array containing all elements of the original array and then the given [element].
+ */
+suppress("NOTHING_TO_INLINE")
+public inline fun BooleanArray.plus(element: Boolean): BooleanArray {
+    return (this: dynamic).concat(arrayOf(element))
+}
+
+/**
+ * Returns an array containing all elements of the original array and then the given [element].
+ */
+suppress("NOTHING_TO_INLINE")
+public inline fun ByteArray.plus(element: Byte): ByteArray {
+    return (this: dynamic).concat(arrayOf(element))
+}
+
+/**
+ * Returns an array containing all elements of the original array and then the given [element].
+ */
+suppress("NOTHING_TO_INLINE")
+public inline fun CharArray.plus(element: Char): CharArray {
+    return (this: dynamic).concat(arrayOf(element))
+}
+
+/**
+ * Returns an array containing all elements of the original array and then the given [element].
+ */
+suppress("NOTHING_TO_INLINE")
+public inline fun DoubleArray.plus(element: Double): DoubleArray {
+    return (this: dynamic).concat(arrayOf(element))
+}
+
+/**
+ * Returns an array containing all elements of the original array and then the given [element].
+ */
+suppress("NOTHING_TO_INLINE")
+public inline fun FloatArray.plus(element: Float): FloatArray {
+    return (this: dynamic).concat(arrayOf(element))
+}
+
+/**
+ * Returns an array containing all elements of the original array and then the given [element].
+ */
+suppress("NOTHING_TO_INLINE")
+public inline fun IntArray.plus(element: Int): IntArray {
+    return (this: dynamic).concat(arrayOf(element))
+}
+
+/**
+ * Returns an array containing all elements of the original array and then the given [element].
+ */
+suppress("NOTHING_TO_INLINE")
+public inline fun LongArray.plus(element: Long): LongArray {
+    return (this: dynamic).concat(arrayOf(element))
+}
+
+/**
+ * Returns an array containing all elements of the original array and then the given [element].
+ */
+suppress("NOTHING_TO_INLINE")
+public inline fun ShortArray.plus(element: Short): ShortArray {
+    return (this: dynamic).concat(arrayOf(element))
+}
+
diff --git a/js/js.serializer/src/org/jetbrains/kotlin/serialization/js/ClassSerializationUtil.kt b/js/js.serializer/src/org/jetbrains/kotlin/serialization/js/ClassSerializationUtil.kt
index 2c3ca566442..efa03d072ed 100644
--- a/js/js.serializer/src/org/jetbrains/kotlin/serialization/js/ClassSerializationUtil.kt
+++ b/js/js.serializer/src/org/jetbrains/kotlin/serialization/js/ClassSerializationUtil.kt
@@ -22,7 +22,7 @@ import org.jetbrains.kotlin.serialization.DescriptorSerializer
 import org.jetbrains.kotlin.serialization.ProtoBuf
 
 public object ClassSerializationUtil {
-    public trait Sink {
+    public interface Sink {
         fun writeClass(classDescriptor: ClassDescriptor, classProto: ProtoBuf.Class)
     }
 
diff --git a/js/js.serializer/src/org/jetbrains/kotlin/serialization/js/KotlinJavascriptAnnotationAndConstantLoader.kt b/js/js.serializer/src/org/jetbrains/kotlin/serialization/js/KotlinJavascriptAnnotationAndConstantLoader.kt
index 33e9db38c2f..880df62257e 100644
--- a/js/js.serializer/src/org/jetbrains/kotlin/serialization/js/KotlinJavascriptAnnotationAndConstantLoader.kt
+++ b/js/js.serializer/src/org/jetbrains/kotlin/serialization/js/KotlinJavascriptAnnotationAndConstantLoader.kt
@@ -18,14 +18,14 @@ package org.jetbrains.kotlin.serialization.js
 
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor
 import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptor
-import org.jetbrains.kotlin.resolve.constants.CompileTimeConstant
+import org.jetbrains.kotlin.resolve.constants.ConstantValue
 import org.jetbrains.kotlin.serialization.ProtoBuf
 import org.jetbrains.kotlin.serialization.deserialization.*
 import org.jetbrains.kotlin.types.JetType
 
 class KotlinJavascriptAnnotationAndConstantLoader(
         module: ModuleDescriptor
-) : AnnotationAndConstantLoader<AnnotationDescriptor, CompileTimeConstant<*>> {
+) : AnnotationAndConstantLoader<AnnotationDescriptor, ConstantValue<*>> {
     private val deserializer = AnnotationDeserializer(module)
 
     override fun loadClassAnnotations(
@@ -67,7 +67,7 @@ class KotlinJavascriptAnnotationAndConstantLoader(
             proto: ProtoBuf.Callable,
             nameResolver: NameResolver,
             expectedType: JetType
-    ): CompileTimeConstant<*>? {
+    ): ConstantValue<*>? {
         val value = proto.getExtension(JsProtoBuf.compileTimeValue)
         return deserializer.resolveValue(expectedType, value, nameResolver)
     }
diff --git a/js/js.serializer/src/org/jetbrains/kotlin/serialization/js/KotlinJavascriptPackageFragment.kt b/js/js.serializer/src/org/jetbrains/kotlin/serialization/js/KotlinJavascriptPackageFragment.kt
index 9f71c3f853e..2d81434b26d 100644
--- a/js/js.serializer/src/org/jetbrains/kotlin/serialization/js/KotlinJavascriptPackageFragment.kt
+++ b/js/js.serializer/src/org/jetbrains/kotlin/serialization/js/KotlinJavascriptPackageFragment.kt
@@ -16,11 +16,11 @@
 
 package org.jetbrains.kotlin.serialization.js
 
-import org.jetbrains.kotlin.serialization.deserialization.DeserializedPackageFragment
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.serialization.ProtoBuf
+import org.jetbrains.kotlin.serialization.deserialization.DeserializedPackageFragment
 import org.jetbrains.kotlin.storage.StorageManager
 import java.io.InputStream
 
@@ -31,9 +31,9 @@ public class KotlinJavascriptPackageFragment(
         loadResource: (path: String) -> InputStream?
 ) : DeserializedPackageFragment(fqName, storageManager, module, KotlinJavascriptSerializedResourcePaths, loadResource) {
 
-    protected override fun loadClassNames(fqName: FqName, packageProto: ProtoBuf.Package): Collection<Name> {
+    protected override fun loadClassNames(packageProto: ProtoBuf.Package): Collection<Name> {
         val classesStream = loadResourceSure(KotlinJavascriptSerializedResourcePaths.getClassesInPackageFilePath(fqName))
-        val classesProto = JsProtoBuf.Classes.parseFrom(classesStream, serializedResourcePaths.EXTENSION_REGISTRY)
+        val classesProto = JsProtoBuf.Classes.parseFrom(classesStream, serializedResourcePaths.extensionRegistry)
         return classesProto.getClassNameList()?.map { id -> nameResolver.getName(id) } ?: listOf()
     }
 }
diff --git a/js/js.serializer/src/org/jetbrains/kotlin/serialization/js/KotlinJavascriptSerializedResourcePaths.kt b/js/js.serializer/src/org/jetbrains/kotlin/serialization/js/KotlinJavascriptSerializedResourcePaths.kt
index 85d56722589..c9f26583143 100644
--- a/js/js.serializer/src/org/jetbrains/kotlin/serialization/js/KotlinJavascriptSerializedResourcePaths.kt
+++ b/js/js.serializer/src/org/jetbrains/kotlin/serialization/js/KotlinJavascriptSerializedResourcePaths.kt
@@ -23,10 +23,10 @@ import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.serialization.SerializedResourcePaths
 
 public object KotlinJavascriptSerializedResourcePaths : SerializedResourcePaths() {
-    public override val EXTENSION_REGISTRY: ExtensionRegistryLite = ExtensionRegistryLite.newInstance()
+    public override val extensionRegistry: ExtensionRegistryLite = ExtensionRegistryLite.newInstance()
 
     init {
-        JsProtoBuf.registerAllExtensions(EXTENSION_REGISTRY)
+        JsProtoBuf.registerAllExtensions(extensionRegistry)
     }
 
     private val CLASSES_FILE_EXTENSION = "kotlin_classes"
diff --git a/js/js.serializer/src/org/jetbrains/kotlin/serialization/js/KotlinJavascriptSerializerExtension.kt b/js/js.serializer/src/org/jetbrains/kotlin/serialization/js/KotlinJavascriptSerializerExtension.kt
index 90d5eec26a9..1d260058e72 100644
--- a/js/js.serializer/src/org/jetbrains/kotlin/serialization/js/KotlinJavascriptSerializerExtension.kt
+++ b/js/js.serializer/src/org/jetbrains/kotlin/serialization/js/KotlinJavascriptSerializerExtension.kt
@@ -21,7 +21,6 @@ import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.descriptors.PropertyDescriptor
 import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor
 import org.jetbrains.kotlin.resolve.constants.NullValue
-import org.jetbrains.kotlin.resolve.descriptorUtil.builtIns
 import org.jetbrains.kotlin.serialization.AnnotationSerializer
 import org.jetbrains.kotlin.serialization.ProtoBuf
 import org.jetbrains.kotlin.serialization.SerializerExtension
@@ -29,9 +28,12 @@ import org.jetbrains.kotlin.serialization.StringTable
 import org.jetbrains.kotlin.types.JetType
 
 public object KotlinJavascriptSerializerExtension : SerializerExtension() {
+
+    private val annotationSerializer = AnnotationSerializer()
+
     override fun serializeClass(descriptor: ClassDescriptor, proto: ProtoBuf.Class.Builder, stringTable: StringTable) {
         for (annotation in descriptor.getAnnotations()) {
-            proto.addExtension(JsProtoBuf.classAnnotation, AnnotationSerializer.serializeAnnotation(annotation, stringTable))
+            proto.addExtension(JsProtoBuf.classAnnotation, annotationSerializer.serializeAnnotation(annotation, stringTable))
         }
     }
 
@@ -41,13 +43,13 @@ public object KotlinJavascriptSerializerExtension : SerializerExtension() {
             stringTable: StringTable
     ) {
         for (annotation in callable.getAnnotations()) {
-            proto.addExtension(JsProtoBuf.callableAnnotation, AnnotationSerializer.serializeAnnotation(annotation, stringTable))
+            proto.addExtension(JsProtoBuf.callableAnnotation, annotationSerializer.serializeAnnotation(annotation, stringTable))
         }
         val propertyDescriptor = callable as? PropertyDescriptor ?: return
-        val compileTimeConstant = propertyDescriptor.getCompileTimeInitializer()
-        if (compileTimeConstant != null && compileTimeConstant !is NullValue) {
-            val type = compileTimeConstant.getType(propertyDescriptor.builtIns)
-            proto.setExtension(JsProtoBuf.compileTimeValue, AnnotationSerializer.valueProto(compileTimeConstant, type, stringTable).build())
+        val constantInitializer = propertyDescriptor.getCompileTimeInitializer()
+        if (constantInitializer != null && constantInitializer !is NullValue) {
+            val type = constantInitializer.type
+            proto.setExtension(JsProtoBuf.compileTimeValue, annotationSerializer.valueProto(constantInitializer, type, stringTable).build())
         }
     }
 
@@ -57,13 +59,13 @@ public object KotlinJavascriptSerializerExtension : SerializerExtension() {
             stringTable: StringTable
     ) {
         for (annotation in descriptor.getAnnotations()) {
-            proto.addExtension(JsProtoBuf.parameterAnnotation, AnnotationSerializer.serializeAnnotation(annotation, stringTable))
+            proto.addExtension(JsProtoBuf.parameterAnnotation, annotationSerializer.serializeAnnotation(annotation, stringTable))
         }
     }
 
     override fun serializeType(type: JetType, proto: ProtoBuf.Type.Builder, stringTable: StringTable) {
         for (annotation in type.getAnnotations()) {
-            proto.addExtension(JsProtoBuf.typeAnnotation, AnnotationSerializer.serializeAnnotation(annotation, stringTable))
+            proto.addExtension(JsProtoBuf.typeAnnotation, annotationSerializer.serializeAnnotation(annotation, stringTable))
         }
     }
 }
diff --git a/js/js.serializer/src/org/jetbrains/kotlin/serialization/js/jsProtoBufUtil.kt b/js/js.serializer/src/org/jetbrains/kotlin/serialization/js/jsProtoBufUtil.kt
index d083e035be9..18b978f5c6f 100644
--- a/js/js.serializer/src/org/jetbrains/kotlin/serialization/js/jsProtoBufUtil.kt
+++ b/js/js.serializer/src/org/jetbrains/kotlin/serialization/js/jsProtoBufUtil.kt
@@ -23,13 +23,13 @@ import org.jetbrains.kotlin.serialization.deserialization.NameResolver
 import java.io.ByteArrayInputStream
 
 public fun ByteArray.toPackageData(nameResolver: NameResolver): PackageData {
-    val registry = KotlinJavascriptSerializedResourcePaths.EXTENSION_REGISTRY
+    val registry = KotlinJavascriptSerializedResourcePaths.extensionRegistry
     val packageProto = ProtoBuf.Package.parseFrom(ByteArrayInputStream(this), registry)
     return PackageData(nameResolver, packageProto)
 }
 
 public fun ByteArray.toClassData(nameResolver: NameResolver): ClassData {
-    val registry = KotlinJavascriptSerializedResourcePaths.EXTENSION_REGISTRY
+    val registry = KotlinJavascriptSerializedResourcePaths.extensionRegistry
     val classProto = ProtoBuf.Class.parseFrom(ByteArrayInputStream(this), registry)
     return ClassData(nameResolver, classProto)
 }
diff --git a/js/js.tests/test/org/jetbrains/kotlin/js/test/semantics/FunctionCallableReferenceTest.java b/js/js.tests/test/org/jetbrains/kotlin/js/test/semantics/FunctionCallableReferenceTest.java
index 60efbcdfdb0..efc5855e43c 100644
--- a/js/js.tests/test/org/jetbrains/kotlin/js/test/semantics/FunctionCallableReferenceTest.java
+++ b/js/js.tests/test/org/jetbrains/kotlin/js/test/semantics/FunctionCallableReferenceTest.java
@@ -122,7 +122,7 @@ public final class FunctionCallableReferenceTest extends AbstractCallableReferen
         checkFooBoxIsOk();
     }
 
-    public void testClassMemberAndExtensionCompatibility() throws Exception {
+    public void testClassMemberAndNonExtensionCompatibility() throws Exception {
         checkFooBoxIsOk();
     }
 
diff --git a/js/js.tests/test/org/jetbrains/kotlin/js/test/semantics/ObjectTest.java b/js/js.tests/test/org/jetbrains/kotlin/js/test/semantics/ObjectTest.java
index f1a2f0d9cc8..2b5e4b88d6f 100644
--- a/js/js.tests/test/org/jetbrains/kotlin/js/test/semantics/ObjectTest.java
+++ b/js/js.tests/test/org/jetbrains/kotlin/js/test/semantics/ObjectTest.java
@@ -59,4 +59,8 @@ public final class ObjectTest extends SingleFileTranslationTest {
     public void testLambdaInObjectInsideObject() throws Exception {
         checkFooBoxIsOk();
     }
+
+    public void testDontPolluteObject() throws Exception {
+        checkFooBoxIsOk();
+    }
 }
diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/translate/callTranslator/CallInfo.kt b/js/js.translator/src/org/jetbrains/kotlin/js/translate/callTranslator/CallInfo.kt
index ebedcd05af7..1ccae4fe2a7 100644
--- a/js/js.translator/src/org/jetbrains/kotlin/js/translate/callTranslator/CallInfo.kt
+++ b/js/js.translator/src/org/jetbrains/kotlin/js/translate/callTranslator/CallInfo.kt
@@ -32,7 +32,7 @@ import com.google.dart.compiler.backend.js.ast.JsLiteral
 import com.google.dart.compiler.backend.js.ast.JsConditional
 import com.google.dart.compiler.backend.js.ast.JsBlock
 
-trait CallInfo {
+interface CallInfo {
     val context: TranslationContext
     val resolvedCall: ResolvedCall<out CallableDescriptor>
 
@@ -87,7 +87,7 @@ fun TranslationContext.getCallInfo(resolvedCall: ResolvedCall<out FunctionDescri
             var receiverRef = explicitReceivers.extensionReceiver
             if (receiverRef != null) {
                 receiverRef = this.declareTemporary(null).reference()
-                this.addStatementToCurrentBlock(JsAstUtils.assignment(receiverRef!!, explicitReceivers.extensionReceiver!!).makeStmt())
+                this.addStatementToCurrentBlock(JsAstUtils.assignment(receiverRef, explicitReceivers.extensionReceiver!!).makeStmt())
             }
             ExplicitReceivers(receiverOrThisRef, receiverRef)
         }
@@ -138,11 +138,11 @@ private fun TranslationContext.createCallInfo(resolvedCall: ResolvedCall<out Cal
         when (resolvedCall.getExplicitReceiverKind()) {
             BOTH_RECEIVERS, EXTENSION_RECEIVER -> {
                 notNullConditional = TranslationUtils.notNullConditional(extensionReceiver!!, JsLiteral.NULL, this)
-                extensionReceiver = notNullConditional!!.getThenExpression()
+                extensionReceiver = notNullConditional.getThenExpression()
             }
             else -> {
                 notNullConditional = TranslationUtils.notNullConditional(dispatchReceiver!!, JsLiteral.NULL, this)
-                dispatchReceiver = notNullConditional!!.getThenExpression()
+                dispatchReceiver = notNullConditional.getThenExpression()
             }
         }
     }
diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/translate/callTranslator/CallInfoExtensions.kt b/js/js.translator/src/org/jetbrains/kotlin/js/translate/callTranslator/CallInfoExtensions.kt
index decdb1a8980..da728341415 100644
--- a/js/js.translator/src/org/jetbrains/kotlin/js/translate/callTranslator/CallInfoExtensions.kt
+++ b/js/js.translator/src/org/jetbrains/kotlin/js/translate/callTranslator/CallInfoExtensions.kt
@@ -56,10 +56,10 @@ fun VariableAccessInfo.getAccessFunctionName(): String {
     val descriptor = variableDescriptor
     if (descriptor is PropertyDescriptor && descriptor.isExtension) {
         val propertyAccessorDescriptor = if (isGetAccess()) descriptor.getGetter() else descriptor.getSetter()
-        return context.getNameForDescriptor(propertyAccessorDescriptor).getIdent()
+        return context.getNameForDescriptor(propertyAccessorDescriptor!!).getIdent()
     }
     else {
-        return Namer.getNameForAccessor(variableName.getIdent()!!, isGetAccess(), false)
+        return Namer.getNameForAccessor(variableName.getIdent(), isGetAccess(), false)
     }
 }
 
diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/translate/callTranslator/CallTranslator.kt b/js/js.translator/src/org/jetbrains/kotlin/js/translate/callTranslator/CallTranslator.kt
index 488903971a1..8400503a556 100644
--- a/js/js.translator/src/org/jetbrains/kotlin/js/translate/callTranslator/CallTranslator.kt
+++ b/js/js.translator/src/org/jetbrains/kotlin/js/translate/callTranslator/CallTranslator.kt
@@ -25,7 +25,7 @@ import org.jetbrains.kotlin.js.translate.general.Translation
 import org.jetbrains.kotlin.js.translate.reference.CallArgumentTranslator
 import org.jetbrains.kotlin.js.translate.utils.AnnotationsUtils
 import org.jetbrains.kotlin.psi.Call.CallType
-import org.jetbrains.kotlin.resolve.calls.CallResolverUtil
+import org.jetbrains.kotlin.resolve.calls.callResolverUtil.isInvokeCallOnVariable
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall
 import org.jetbrains.kotlin.resolve.calls.model.VariableAsFunctionResolvedCall
 import org.jetbrains.kotlin.resolve.calls.tasks.ExplicitReceiverKind
@@ -102,7 +102,7 @@ private fun translateCall(context: TranslationContext,
     }
 
     val call = resolvedCall.getCall()
-    if (call.getCallType() == CallType.INVOKE && !CallResolverUtil.isInvokeCallOnVariable(call)) {
+    if (call.getCallType() == CallType.INVOKE && !isInvokeCallOnVariable(call)) {
         val explicitReceiversForInvoke = computeExplicitReceiversForInvoke(context, resolvedCall, explicitReceivers)
         return translateFunctionCall(context, resolvedCall, explicitReceiversForInvoke)
     }
@@ -154,7 +154,7 @@ fun computeExplicitReceiversForInvoke(
     }
 }
 
-trait CallCase<I : CallInfo> {
+interface CallCase<I : CallInfo> {
 
     protected fun I.unsupported(message: String = "") : Nothing = throw IllegalStateException("this case unsupported. $this")
 
@@ -183,11 +183,11 @@ trait CallCase<I : CallInfo> {
     }
 }
 
-trait FunctionCallCase : CallCase<FunctionCallInfo>
+interface FunctionCallCase : CallCase<FunctionCallInfo>
 
-trait VariableAccessCase : CallCase<VariableAccessInfo>
+interface VariableAccessCase : CallCase<VariableAccessInfo>
 
-trait DelegateIntrinsic<I : CallInfo> {
+interface DelegateIntrinsic<I : CallInfo> {
     fun I.canBeApply(): Boolean = true
     fun I.getDescriptor(): CallableDescriptor
     fun I.getArgs(): List<JsExpression>
diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/translate/callTranslator/FunctionCallCases.kt b/js/js.translator/src/org/jetbrains/kotlin/js/translate/callTranslator/FunctionCallCases.kt
index 63efd4a7e9a..0261621774c 100644
--- a/js/js.translator/src/org/jetbrains/kotlin/js/translate/callTranslator/FunctionCallCases.kt
+++ b/js/js.translator/src/org/jetbrains/kotlin/js/translate/callTranslator/FunctionCallCases.kt
@@ -173,13 +173,11 @@ object InvokeIntrinsic : FunctionCallCase {
             funDeclaration == callableDescriptor.builtIns.getFunction(parameterCount) ||
             funDeclaration == reflectionTypes.getKFunction(parameterCount)
         else
-            funDeclaration == callableDescriptor.builtIns.getExtensionFunction(parameterCount) ||
-            funDeclaration == reflectionTypes.getKExtensionFunction(parameterCount) ||
-            funDeclaration == reflectionTypes.getKMemberFunction(parameterCount)
+            funDeclaration == callableDescriptor.builtIns.getExtensionFunction(parameterCount)
     }
 
     override fun FunctionCallInfo.dispatchReceiver(): JsExpression {
-        return JsInvocation(dispatchReceiver, argumentsInfo.translateArguments)
+        return JsInvocation(dispatchReceiver!!, argumentsInfo.translateArguments)
     }
 
     /**
@@ -242,7 +240,7 @@ object DynamicInvokeAndBracketAccessCallCase : FunctionCallCase {
         val callType = resolvedCall.getCall().getCallType()
         return when (callType) {
             Call.CallType.INVOKE ->
-                JsInvocation(dispatchReceiver, arguments)
+                JsInvocation(dispatchReceiver!!, arguments)
             Call.CallType.ARRAY_GET_METHOD ->
                 JsArrayAccess(dispatchReceiver, arguments[0])
             Call.CallType.ARRAY_SET_METHOD ->
diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/translate/context/Namer.java b/js/js.translator/src/org/jetbrains/kotlin/js/translate/context/Namer.java
index 0128e3a84f2..b547e8a96bc 100644
--- a/js/js.translator/src/org/jetbrains/kotlin/js/translate/context/Namer.java
+++ b/js/js.translator/src/org/jetbrains/kotlin/js/translate/context/Namer.java
@@ -17,8 +17,8 @@
 package org.jetbrains.kotlin.js.translate.context;
 
 import com.google.dart.compiler.backend.js.ast.*;
-import com.google.dart.compiler.backend.js.ast.metadata.TypeCheck;
 import com.google.dart.compiler.backend.js.ast.metadata.MetadataPackage;
+import com.google.dart.compiler.backend.js.ast.metadata.TypeCheck;
 import com.intellij.openapi.util.text.StringUtil;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
@@ -71,6 +71,7 @@ public final class Namer {
     private static final String OBJECT_OBJECT_NAME = "createObject";
     private static final String CALLABLE_REF_FOR_MEMBER_FUNCTION_NAME = "getCallableRefForMemberFunction";
     private static final String CALLABLE_REF_FOR_EXTENSION_FUNCTION_NAME = "getCallableRefForExtensionFunction";
+    private static final String CALLABLE_REF_FOR_LOCAL_EXTENSION_FUNCTION_NAME = "getCallableRefForLocalExtensionFunction";
     private static final String CALLABLE_REF_FOR_CONSTRUCTOR_NAME = "getCallableRefForConstructor";
     private static final String CALLABLE_REF_FOR_TOP_LEVEL_PROPERTY = "getCallableRefForTopLevelProperty";
     private static final String CALLABLE_REF_FOR_MEMBER_PROPERTY = "getCallableRefForMemberProperty";
@@ -261,6 +262,8 @@ public final class Namer {
     @NotNull
     private final JsName callableRefForExtensionFunctionName;
     @NotNull
+    private final JsName callableRefForLocalExtensionFunctionName;
+    @NotNull
     private final JsName callableRefForConstructorName;
     @NotNull
     private final JsName callableRefForTopLevelProperty;
@@ -295,6 +298,7 @@ public final class Namer {
         objectName = kotlinScope.declareName(OBJECT_OBJECT_NAME);
         callableRefForMemberFunctionName = kotlinScope.declareName(CALLABLE_REF_FOR_MEMBER_FUNCTION_NAME);
         callableRefForExtensionFunctionName = kotlinScope.declareName(CALLABLE_REF_FOR_EXTENSION_FUNCTION_NAME);
+        callableRefForLocalExtensionFunctionName = kotlinScope.declareName(CALLABLE_REF_FOR_LOCAL_EXTENSION_FUNCTION_NAME);
         callableRefForConstructorName = kotlinScope.declareName(CALLABLE_REF_FOR_CONSTRUCTOR_NAME);
         callableRefForTopLevelProperty = kotlinScope.declareName(CALLABLE_REF_FOR_TOP_LEVEL_PROPERTY);
         callableRefForMemberProperty = kotlinScope.declareName(CALLABLE_REF_FOR_MEMBER_PROPERTY);
@@ -344,6 +348,11 @@ public final class Namer {
         return kotlin(callableRefForExtensionFunctionName);
     }
 
+    @NotNull
+    public JsExpression callableRefForLocalExtensionFunctionReference() {
+        return kotlin(callableRefForLocalExtensionFunctionName);
+    }
+
     @NotNull
     public JsExpression callableRefForConstructorReference() {
         return kotlin(callableRefForConstructorName);
diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/translate/declaration/FileDeclaration.kt b/js/js.translator/src/org/jetbrains/kotlin/js/translate/declaration/FileDeclaration.kt
index 937600e9e31..4d9aa5d1148 100644
--- a/js/js.translator/src/org/jetbrains/kotlin/js/translate/declaration/FileDeclaration.kt
+++ b/js/js.translator/src/org/jetbrains/kotlin/js/translate/declaration/FileDeclaration.kt
@@ -39,7 +39,7 @@ class FileDeclarationVisitor(
 
     private val initializer = JsAstUtils.createFunctionWithEmptyBody(context.scope())
     private val initializerContext = context.contextWithScope(initializer)
-    private val initializerStatements = initializer.getBody()!!.getStatements()!!
+    private val initializerStatements = initializer.getBody().getStatements()
     private val initializerVisitor = InitializerVisitor(initializerStatements)
 
     fun computeInitializer(): JsFunction? {
diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/translate/expression/ExpressionVisitor.java b/js/js.translator/src/org/jetbrains/kotlin/js/translate/expression/ExpressionVisitor.java
index 951c2deb0d0..e1aae4567b7 100644
--- a/js/js.translator/src/org/jetbrains/kotlin/js/translate/expression/ExpressionVisitor.java
+++ b/js/js.translator/src/org/jetbrains/kotlin/js/translate/expression/ExpressionVisitor.java
@@ -41,6 +41,7 @@ import org.jetbrains.kotlin.resolve.BindingContext;
 import org.jetbrains.kotlin.resolve.BindingContextUtils;
 import org.jetbrains.kotlin.resolve.bindingContextUtil.BindingContextUtilPackage;
 import org.jetbrains.kotlin.resolve.constants.CompileTimeConstant;
+import org.jetbrains.kotlin.resolve.constants.ConstantValue;
 import org.jetbrains.kotlin.resolve.constants.NullValue;
 import org.jetbrains.kotlin.resolve.constants.evaluate.ConstantExpressionEvaluator;
 import org.jetbrains.kotlin.resolve.inline.InlineUtil;
@@ -75,14 +76,13 @@ public final class ExpressionVisitor extends TranslatorVisitor<JsNode> {
     @NotNull
     private static JsNode translateConstantExpression(@NotNull JetConstantExpression expression, @NotNull TranslationContext context) {
         CompileTimeConstant<?> compileTimeValue = ConstantExpressionEvaluator.getConstant(expression, context.bindingContext());
-
         assert compileTimeValue != null : message(expression, "Expression is not compile time value: " + expression.getText() + " ");
-
-        if (compileTimeValue instanceof NullValue) {
+        JetType expectedType = context.bindingContext().getType(expression);
+        ConstantValue<?> constant = compileTimeValue.toConstantValue(expectedType != null ? expectedType : TypeUtils.NO_EXPECTED_TYPE);
+        if (constant instanceof NullValue) {
             return JsLiteral.NULL;
         }
-
-        Object value = getCompileTimeValue(context.bindingContext(), expression, compileTimeValue);
+        Object value = constant.getValue();
         if (value instanceof Integer || value instanceof Short || value instanceof Byte) {
             return context.program().getNumberLiteral(((Number) value).intValue());
         }
diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/translate/expression/MultiDeclarationTranslator.java b/js/js.translator/src/org/jetbrains/kotlin/js/translate/expression/MultiDeclarationTranslator.java
index 81a07830247..d98c0bbb095 100644
--- a/js/js.translator/src/org/jetbrains/kotlin/js/translate/expression/MultiDeclarationTranslator.java
+++ b/js/js.translator/src/org/jetbrains/kotlin/js/translate/expression/MultiDeclarationTranslator.java
@@ -82,7 +82,7 @@ public class MultiDeclarationTranslator extends AbstractTranslator {
         for (JetMultiDeclarationEntry entry : multiDeclaration.getEntries()) {
             ResolvedCall<FunctionDescriptor> entryInitCall =  context().bindingContext().get(BindingContext.COMPONENT_RESOLVED_CALL, entry);
             assert entryInitCall != null : "Entry init call must be not null";
-            JsExpression entryInitializer = CallTranslator.INSTANCE$.translate(context(), entryInitCall, multiObjNameRef);
+            JsExpression entryInitializer = CallTranslator.translate(context(), entryInitCall, multiObjNameRef);
             FunctionDescriptor candidateDescriptor = entryInitCall.getCandidateDescriptor();
             if (CallExpressionTranslator.shouldBeInlined(candidateDescriptor)) {
                 setInlineCallMetadata(entryInitializer, entry, entryInitCall, context());
diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/translate/intrinsic/functions/factories/PrimitiveBinaryOperationFIF.java b/js/js.translator/src/org/jetbrains/kotlin/js/translate/intrinsic/functions/factories/PrimitiveBinaryOperationFIF.java
index dddc90a77d0..39b5ee4cc9c 100644
--- a/js/js.translator/src/org/jetbrains/kotlin/js/translate/intrinsic/functions/factories/PrimitiveBinaryOperationFIF.java
+++ b/js/js.translator/src/org/jetbrains/kotlin/js/translate/intrinsic/functions/factories/PrimitiveBinaryOperationFIF.java
@@ -43,7 +43,7 @@ import static org.jetbrains.kotlin.js.patterns.PatternBuilder.pattern;
 public enum PrimitiveBinaryOperationFIF implements FunctionIntrinsicFactory {
     INSTANCE;
 
-    private static abstract class BinaryOperationInstrinsicBase extends FunctionIntrinsic {
+    private static abstract class BinaryOperationIntrinsicBase extends FunctionIntrinsic {
         @NotNull
         public abstract JsExpression doApply(@NotNull JsExpression left, @NotNull JsExpression right, @NotNull TranslationContext context);
 
@@ -60,7 +60,7 @@ public enum PrimitiveBinaryOperationFIF implements FunctionIntrinsicFactory {
     }
 
     @NotNull
-    private static final BinaryOperationInstrinsicBase RANGE_TO_INTRINSIC = new BinaryOperationInstrinsicBase() {
+    private static final BinaryOperationIntrinsicBase RANGE_TO_INTRINSIC = new BinaryOperationIntrinsicBase() {
         @NotNull
         @Override
         public JsExpression doApply(@NotNull JsExpression left, @NotNull JsExpression right, @NotNull TranslationContext context) {
@@ -70,7 +70,7 @@ public enum PrimitiveBinaryOperationFIF implements FunctionIntrinsicFactory {
     };
 
     @NotNull
-    private static final BinaryOperationInstrinsicBase CHAR_RANGE_TO_INTRINSIC = new BinaryOperationInstrinsicBase() {
+    private static final BinaryOperationIntrinsicBase CHAR_RANGE_TO_INTRINSIC = new BinaryOperationIntrinsicBase() {
         @NotNull
         @Override
         public JsExpression doApply(@NotNull JsExpression left, @NotNull JsExpression right, @NotNull TranslationContext context) {
@@ -80,7 +80,7 @@ public enum PrimitiveBinaryOperationFIF implements FunctionIntrinsicFactory {
     };
 
     @NotNull
-    private static final BinaryOperationInstrinsicBase INTEGER_DIVISION_INTRINSIC = new BinaryOperationInstrinsicBase() {
+    private static final BinaryOperationIntrinsicBase INTEGER_DIVISION_INTRINSIC = new BinaryOperationIntrinsicBase() {
         @NotNull
         @Override
         public JsExpression doApply(@NotNull JsExpression left, @NotNull JsExpression right, @NotNull TranslationContext context) {
@@ -90,7 +90,7 @@ public enum PrimitiveBinaryOperationFIF implements FunctionIntrinsicFactory {
     };
 
     @NotNull
-    private static final BinaryOperationInstrinsicBase BUILTINS_COMPARE_TO_INTRINSIC = new BinaryOperationInstrinsicBase() {
+    private static final BinaryOperationIntrinsicBase BUILTINS_COMPARE_TO_INTRINSIC = new BinaryOperationIntrinsicBase() {
         @NotNull
         @Override
         public JsExpression doApply(@NotNull JsExpression left, @NotNull JsExpression right, @NotNull TranslationContext context) {
@@ -99,7 +99,7 @@ public enum PrimitiveBinaryOperationFIF implements FunctionIntrinsicFactory {
     };
 
     @NotNull
-    private static final BinaryOperationInstrinsicBase PRIMITIVE_NUMBER_COMPARE_TO_INTRINSIC = new BinaryOperationInstrinsicBase() {
+    private static final BinaryOperationIntrinsicBase PRIMITIVE_NUMBER_COMPARE_TO_INTRINSIC = new BinaryOperationIntrinsicBase() {
         @NotNull
         @Override
         public JsExpression doApply(@NotNull JsExpression left, @NotNull JsExpression right, @NotNull TranslationContext context) {
@@ -134,14 +134,6 @@ public enum PrimitiveBinaryOperationFIF implements FunctionIntrinsicFactory {
     @Nullable
     @Override
     public FunctionIntrinsic getIntrinsic(@NotNull FunctionDescriptor descriptor) {
-        if (pattern("Int|Short|Byte|Double|Float.compareTo(Char)").apply(descriptor)) {
-            return new WithCharAsSecondOperandFunctionIntrinsic(PRIMITIVE_NUMBER_COMPARE_TO_INTRINSIC);
-        }
-
-        if (pattern("Char.compareTo(Int|Short|Byte|Double|Float)").apply(descriptor)) {
-            return new WithCharAsFirstOperandFunctionIntrinsic(PRIMITIVE_NUMBER_COMPARE_TO_INTRINSIC);
-        }
-
         if (pattern("Char.rangeTo(Char)").apply(descriptor)) {
             return CHAR_RANGE_TO_INTRINSIC;
         }
@@ -161,13 +153,7 @@ public enum PrimitiveBinaryOperationFIF implements FunctionIntrinsicFactory {
 
 
         if (pattern("Int|Short|Byte.div(Int|Short|Byte)").apply(descriptor)) {
-                return INTEGER_DIVISION_INTRINSIC;
-        }
-        if (pattern("Char.div(Int|Short|Byte)").apply(descriptor)) {
-            return new WithCharAsFirstOperandFunctionIntrinsic(INTEGER_DIVISION_INTRINSIC);
-        }
-        if (pattern("Int|Short|Byte.div(Char)").apply(descriptor)) {
-            return new WithCharAsSecondOperandFunctionIntrinsic(INTEGER_DIVISION_INTRINSIC);
+            return INTEGER_DIVISION_INTRINSIC;
         }
         if (descriptor.getName().equals(Name.identifier("rangeTo"))) {
             return RANGE_TO_INTRINSIC;
@@ -179,13 +165,13 @@ public enum PrimitiveBinaryOperationFIF implements FunctionIntrinsicFactory {
             }
         }
         JsBinaryOperator operator = getOperator(descriptor);
-        BinaryOperationInstrinsicBase result = new PrimitiveBinaryOperationFunctionIntrinsic(operator);
+        BinaryOperationIntrinsicBase result = new PrimitiveBinaryOperationFunctionIntrinsic(operator);
 
-        if (pattern("Char.plus|minus|times|div|mod(Int|Short|Byte|Double|Float)").apply(descriptor)) {
-            return new WithCharAsFirstOperandFunctionIntrinsic(result);
+        if (pattern("Char.plus|minus(Int)").apply(descriptor)) {
+            return new CharAndIntBinaryOperationFunctionIntrinsic(result);
         }
-        if (pattern("Int|Short|Byte|Double|Float.plus|minus|times|div|mod(Char)").apply(descriptor)) {
-            return new WithCharAsSecondOperandFunctionIntrinsic(result);
+        if (pattern("Char.minus(Char)").apply(descriptor)) {
+            return new CharAndCharBinaryOperationFunctionIntrinsic(result);
         }
         return result;
     }
@@ -203,7 +189,7 @@ public enum PrimitiveBinaryOperationFIF implements FunctionIntrinsicFactory {
         return OperatorTable.getBinaryOperator(token);
     }
 
-    private static class PrimitiveBinaryOperationFunctionIntrinsic extends BinaryOperationInstrinsicBase {
+    private static class PrimitiveBinaryOperationFunctionIntrinsic extends BinaryOperationIntrinsicBase {
 
         @NotNull
         private final JsBinaryOperator operator;
@@ -219,35 +205,35 @@ public enum PrimitiveBinaryOperationFIF implements FunctionIntrinsicFactory {
         }
     }
 
-    private static class WithCharAsFirstOperandFunctionIntrinsic extends BinaryOperationInstrinsicBase {
+    private static class CharAndIntBinaryOperationFunctionIntrinsic extends BinaryOperationIntrinsicBase {
 
         @NotNull
-        private final BinaryOperationInstrinsicBase functionIntrinsic;
+        private final BinaryOperationIntrinsicBase functionIntrinsic;
 
-        private WithCharAsFirstOperandFunctionIntrinsic(@NotNull BinaryOperationInstrinsicBase functionIntrinsic) {
+        private CharAndIntBinaryOperationFunctionIntrinsic(@NotNull BinaryOperationIntrinsicBase functionIntrinsic) {
             this.functionIntrinsic = functionIntrinsic;
         }
 
         @NotNull
         @Override
         public JsExpression doApply(@NotNull JsExpression left, @NotNull JsExpression right, @NotNull TranslationContext context) {
-            return functionIntrinsic.doApply(JsAstUtils.charToInt(left), right, context);
+            return JsAstUtils.toChar(functionIntrinsic.doApply(JsAstUtils.charToInt(left), right, context));
         }
     }
 
-    private static class WithCharAsSecondOperandFunctionIntrinsic extends BinaryOperationInstrinsicBase {
+    private static class CharAndCharBinaryOperationFunctionIntrinsic extends BinaryOperationIntrinsicBase {
 
         @NotNull
-        private final BinaryOperationInstrinsicBase functionIntrinsic;
+        private final BinaryOperationIntrinsicBase functionIntrinsic;
 
-        private WithCharAsSecondOperandFunctionIntrinsic(@NotNull BinaryOperationInstrinsicBase functionIntrinsic) {
+        private CharAndCharBinaryOperationFunctionIntrinsic(@NotNull BinaryOperationIntrinsicBase functionIntrinsic) {
             this.functionIntrinsic = functionIntrinsic;
         }
 
         @NotNull
         @Override
         public JsExpression doApply(@NotNull JsExpression left, @NotNull JsExpression right, @NotNull TranslationContext context) {
-            return functionIntrinsic.doApply(left, JsAstUtils.charToInt(right), context);
+            return functionIntrinsic.doApply(JsAstUtils.charToInt(left), JsAstUtils.charToInt(right), context);
         }
     }
 }
diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/translate/intrinsic/objects/objectsIntrinsics.kt b/js/js.translator/src/org/jetbrains/kotlin/js/translate/intrinsic/objects/objectsIntrinsics.kt
index 50ab97646e8..2040087319f 100644
--- a/js/js.translator/src/org/jetbrains/kotlin/js/translate/intrinsic/objects/objectsIntrinsics.kt
+++ b/js/js.translator/src/org/jetbrains/kotlin/js/translate/intrinsic/objects/objectsIntrinsics.kt
@@ -46,7 +46,7 @@ public class ObjectIntrinsics {
     }
 }
 
-public trait ObjectIntrinsic {
+public interface ObjectIntrinsic {
     fun apply(context: TranslationContext): JsExpression
     fun exists(): Boolean = true
 }
diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/translate/intrinsic/operation/binaryOperationIntrinsics.kt b/js/js.translator/src/org/jetbrains/kotlin/js/translate/intrinsic/operation/binaryOperationIntrinsics.kt
index c2fa42d5cba..135187f6467 100644
--- a/js/js.translator/src/org/jetbrains/kotlin/js/translate/intrinsic/operation/binaryOperationIntrinsics.kt
+++ b/js/js.translator/src/org/jetbrains/kotlin/js/translate/intrinsic/operation/binaryOperationIntrinsics.kt
@@ -26,7 +26,7 @@ import gnu.trove.THashMap
 import com.google.dart.compiler.backend.js.ast.JsExpression
 import com.google.common.collect.ImmutableSet
 
-public trait BinaryOperationIntrinsic {
+public interface BinaryOperationIntrinsic {
 
     fun apply(expression: JetBinaryExpression, left: JsExpression, right: JsExpression, context: TranslationContext): JsExpression
 
@@ -71,7 +71,7 @@ public class BinaryOperationIntrinsics {
     }
 }
 
-trait BinaryOperationIntrinsicFactory {
+interface BinaryOperationIntrinsicFactory {
 
     public fun getSupportTokens(): ImmutableSet<out JetToken>
 
diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/translate/operation/OverloadedAssignmentTranslator.java b/js/js.translator/src/org/jetbrains/kotlin/js/translate/operation/OverloadedAssignmentTranslator.java
index b40f6b10e23..964be2b7ff2 100644
--- a/js/js.translator/src/org/jetbrains/kotlin/js/translate/operation/OverloadedAssignmentTranslator.java
+++ b/js/js.translator/src/org/jetbrains/kotlin/js/translate/operation/OverloadedAssignmentTranslator.java
@@ -57,6 +57,6 @@ public final class OverloadedAssignmentTranslator extends AssignmentTranslator {
 
     @NotNull
     private JsExpression overloadedMethodInvocation() {
-        return CallTranslator.INSTANCE$.translate(context(), resolvedCall, accessTranslator.translateAsGet());
+        return CallTranslator.translate(context(), resolvedCall, accessTranslator.translateAsGet());
     }
 }
diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/translate/operation/OverloadedIncrementTranslator.java b/js/js.translator/src/org/jetbrains/kotlin/js/translate/operation/OverloadedIncrementTranslator.java
index 5b45c120384..390d31a538a 100644
--- a/js/js.translator/src/org/jetbrains/kotlin/js/translate/operation/OverloadedIncrementTranslator.java
+++ b/js/js.translator/src/org/jetbrains/kotlin/js/translate/operation/OverloadedIncrementTranslator.java
@@ -42,7 +42,7 @@ public final class OverloadedIncrementTranslator extends IncrementTranslator {
     @Override
     @NotNull
     protected JsExpression operationExpression(@NotNull JsExpression receiver) {
-        return CallTranslator.INSTANCE$.translate(context(), resolvedCall, receiver);
+        return CallTranslator.translate(context(), resolvedCall, receiver);
     }
 
 }
diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/translate/operation/UnaryOperationTranslator.java b/js/js.translator/src/org/jetbrains/kotlin/js/translate/operation/UnaryOperationTranslator.java
index 951a1344628..73b1e1ced05 100644
--- a/js/js.translator/src/org/jetbrains/kotlin/js/translate/operation/UnaryOperationTranslator.java
+++ b/js/js.translator/src/org/jetbrains/kotlin/js/translate/operation/UnaryOperationTranslator.java
@@ -29,7 +29,6 @@ import org.jetbrains.kotlin.lexer.JetTokens;
 import org.jetbrains.kotlin.psi.JetConstantExpression;
 import org.jetbrains.kotlin.psi.JetExpression;
 import org.jetbrains.kotlin.psi.JetUnaryExpression;
-import org.jetbrains.kotlin.resolve.BindingContext;
 import org.jetbrains.kotlin.resolve.BindingContextUtils;
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall;
 import org.jetbrains.kotlin.resolve.constants.CompileTimeConstant;
@@ -83,7 +82,7 @@ public final class UnaryOperationTranslator {
         }
 
         ResolvedCall<? extends FunctionDescriptor> resolvedCall = getFunctionResolvedCallWithAssert(expression, context.bindingContext());
-        return CallTranslator.INSTANCE$.translate(context, resolvedCall, baseExpression);
+        return CallTranslator.translate(context, resolvedCall, baseExpression);
     }
 
     private static boolean isExclForBinaryEqualLikeExpr(@NotNull JetUnaryExpression expression, @NotNull JsExpression baseExpression) {
diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/translate/reference/ArrayAccessTranslator.java b/js/js.translator/src/org/jetbrains/kotlin/js/translate/reference/ArrayAccessTranslator.java
index c3f8fa03a4b..4e79ee539f0 100644
--- a/js/js.translator/src/org/jetbrains/kotlin/js/translate/reference/ArrayAccessTranslator.java
+++ b/js/js.translator/src/org/jetbrains/kotlin/js/translate/reference/ArrayAccessTranslator.java
@@ -82,7 +82,7 @@ public class ArrayAccessTranslator extends AbstractTranslator implements AccessT
         if (!isGetter) {
             context = contextWithValueParameterAliasInArrayGetAccess(toSetTo);
         }
-        return CallTranslator.INSTANCE$.translate(context, resolvedCall, arrayExpression);
+        return CallTranslator.translate(context, resolvedCall, arrayExpression);
     }
 
     @NotNull
diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/translate/reference/CallArgumentTranslator.kt b/js/js.translator/src/org/jetbrains/kotlin/js/translate/reference/CallArgumentTranslator.kt
index 35932a4f309..9a6a2a01d69 100644
--- a/js/js.translator/src/org/jetbrains/kotlin/js/translate/reference/CallArgumentTranslator.kt
+++ b/js/js.translator/src/org/jetbrains/kotlin/js/translate/reference/CallArgumentTranslator.kt
@@ -150,14 +150,14 @@ public class CallArgumentTranslator private constructor(
             concatArguments!!.addAll(result)
 
             if (!argsBeforeVararg!!.isEmpty()) {
-                concatArguments!!.add(0, JsArrayLiteral(argsBeforeVararg))
+                concatArguments.add(0, JsArrayLiteral(argsBeforeVararg))
             }
 
-            result = SmartList(concatArgumentsIfNeeded(concatArguments!!))
+            result = SmartList(concatArgumentsIfNeeded(concatArguments))
 
             if (receiver != null) {
                 cachedReceiver = context().getOrDeclareTemporaryConstVariable(receiver)
-                result.add(0, cachedReceiver!!.reference())
+                result.add(0, cachedReceiver.reference())
             }
             else {
                 result.add(0, JsLiteral.NULL)
@@ -204,6 +204,7 @@ public class CallArgumentTranslator private constructor(
 
             val argumentExpression = valueArguments.get(0).getArgumentExpression()
             assert(argumentExpression != null)
+            argumentExpression!!
 
             val jsExpression = Translation.translateAsExpression(argumentExpression, context)
             result.add(jsExpression)
@@ -250,6 +251,7 @@ public class CallArgumentTranslator private constructor(
             for (argument in arguments) {
                 val argumentExpression = argument.getArgumentExpression()
                 assert(argumentExpression != null)
+                argumentExpression!!
                 val argContext = context.innerBlock()
                 val argExpression = Translation.translateAsExpression(argumentExpression, argContext)
                 list.add(argExpression)
diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/translate/reference/CallExpressionTranslator.java b/js/js.translator/src/org/jetbrains/kotlin/js/translate/reference/CallExpressionTranslator.java
index 5d6fc2fa0ef..235ff76853d 100644
--- a/js/js.translator/src/org/jetbrains/kotlin/js/translate/reference/CallExpressionTranslator.java
+++ b/js/js.translator/src/org/jetbrains/kotlin/js/translate/reference/CallExpressionTranslator.java
@@ -97,7 +97,7 @@ public final class CallExpressionTranslator extends AbstractCallExpressionTransl
 
     @NotNull
     private JsExpression translate() {
-        return CallTranslator.INSTANCE$.translate(context(), resolvedCall, receiver);
+        return CallTranslator.translate(context(), resolvedCall, receiver);
     }
 
     @NotNull
@@ -130,7 +130,7 @@ public final class CallExpressionTranslator extends AbstractCallExpressionTransl
         CompileTimeConstant<?> constant = ConstantExpressionEvaluator.evaluate(jsCodeExpression, bindingTrace, stringType);
 
         assert constant != null: "jsCode must be compile time string " + jsCodeExpression;
-        String jsCode = (String) constant.getValue();
+        String jsCode = (String) constant.getValue(stringType);
         assert jsCode != null: jsCodeExpression.toString();
 
         // Parser can change local or global scope.
diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/translate/reference/CallableReferenceTranslator.kt b/js/js.translator/src/org/jetbrains/kotlin/js/translate/reference/CallableReferenceTranslator.kt
index 05541d35f27..bfc9d85fda0 100644
--- a/js/js.translator/src/org/jetbrains/kotlin/js/translate/reference/CallableReferenceTranslator.kt
+++ b/js/js.translator/src/org/jetbrains/kotlin/js/translate/reference/CallableReferenceTranslator.kt
@@ -130,15 +130,18 @@ object CallableReferenceTranslator {
         assert(receiverParameterDescriptor != null, "receiverParameter for extension should not be null")
 
         val jsFunctionRef = ReferenceTranslator.translateAsFQReference(descriptor, context)
-        if (descriptor.getVisibility() == Visibilities.LOCAL)
-            return jsFunctionRef
+        if (descriptor.getVisibility() == Visibilities.LOCAL) {
+            return JsInvocation(context.namer().callableRefForLocalExtensionFunctionReference(), jsFunctionRef)
+        }
+
         else if (AnnotationsUtils.isNativeObject(descriptor)) {
             val jetType = receiverParameterDescriptor!!.getType()
             val receiverClassDescriptor = DescriptorUtils.getClassDescriptorForType(jetType)
             return translateAsMemberFunctionReference(descriptor, receiverClassDescriptor, context)
         }
-        else
+        else {
             return JsInvocation(context.namer().callableRefForExtensionFunctionReference(), jsFunctionRef)
+        }
     }
 
     private fun translateForMemberFunction(descriptor: FunctionDescriptor, context: TranslationContext): JsExpression {
diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/translate/utils/BindingUtils.java b/js/js.translator/src/org/jetbrains/kotlin/js/translate/utils/BindingUtils.java
index e54e943e65a..68bf898c4f2 100644
--- a/js/js.translator/src/org/jetbrains/kotlin/js/translate/utils/BindingUtils.java
+++ b/js/js.translator/src/org/jetbrains/kotlin/js/translate/utils/BindingUtils.java
@@ -27,7 +27,6 @@ import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils;
 import org.jetbrains.kotlin.resolve.DescriptorUtils;
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall;
 import org.jetbrains.kotlin.resolve.constants.CompileTimeConstant;
-import org.jetbrains.kotlin.resolve.constants.IntegerValueTypeConstant;
 import org.jetbrains.kotlin.resolve.constants.evaluate.ConstantExpressionEvaluator;
 import org.jetbrains.kotlin.types.JetType;
 import org.jetbrains.kotlin.types.TypeUtils;
@@ -159,14 +158,8 @@ public final class BindingUtils {
 
     @Nullable
     public static Object getCompileTimeValue(@NotNull BindingContext context, @NotNull JetExpression expression, @NotNull CompileTimeConstant<?> constant) {
-        if (constant != null) {
-            if (constant instanceof IntegerValueTypeConstant) {
-                JetType expectedType = context.getType(expression);
-                return ((IntegerValueTypeConstant) constant).getValue(expectedType == null ? TypeUtils.NO_EXPECTED_TYPE : expectedType);
-            }
-            return constant.getValue();
-        }
-        return null;
+        JetType expectedType = context.getType(expression);
+        return constant.getValue(expectedType == null ? TypeUtils.NO_EXPECTED_TYPE : expectedType);
     }
 
     @NotNull
diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/translate/utils/PsiUtils.java b/js/js.translator/src/org/jetbrains/kotlin/js/translate/utils/PsiUtils.java
index 62cc3b86bf3..67e695c204c 100644
--- a/js/js.translator/src/org/jetbrains/kotlin/js/translate/utils/PsiUtils.java
+++ b/js/js.translator/src/org/jetbrains/kotlin/js/translate/utils/PsiUtils.java
@@ -119,7 +119,7 @@ public final class PsiUtils {
     @NotNull
     public static List<JetParameter> getPrimaryConstructorParameters(@NotNull JetClassOrObject classDeclaration) {
         if (classDeclaration instanceof JetClass) {
-            return ((JetClass) classDeclaration).getPrimaryConstructorParameters();
+            return classDeclaration.getPrimaryConstructorParameters();
         }
         return Collections.emptyList();
     }
diff --git a/js/js.translator/testData/callableReference/function/cases/abstractClassMember.kt b/js/js.translator/testData/callableReference/function/cases/abstractClassMember.kt
index e9a395ff2d1..d06c57e9ea9 100644
--- a/js/js.translator/testData/callableReference/function/cases/abstractClassMember.kt
+++ b/js/js.translator/testData/callableReference/function/cases/abstractClassMember.kt
@@ -9,4 +9,4 @@ class B : A() {
     override fun foo() = "OK"
 }
 
-fun box(): String = B().(A::foo)()
+fun box(): String = (A::foo)(B())
diff --git a/js/js.translator/testData/callableReference/function/cases/booleanNotIntrinsic.kt b/js/js.translator/testData/callableReference/function/cases/booleanNotIntrinsic.kt
index e08772611c0..1366015c246 100644
--- a/js/js.translator/testData/callableReference/function/cases/booleanNotIntrinsic.kt
+++ b/js/js.translator/testData/callableReference/function/cases/booleanNotIntrinsic.kt
@@ -2,7 +2,7 @@
 package foo
 
 fun box(): String {
-    if (true.(Boolean::not)() != false) return "Fail 1"
-    if (false.(Boolean::not)() != true) return "Fail 2"
+    if ((Boolean::not)(true) != false) return "Fail 1"
+    if ((Boolean::not)(false) != true) return "Fail 2"
     return "OK"
 }
diff --git a/js/js.translator/testData/callableReference/function/cases/classMemberAndExtension.kt b/js/js.translator/testData/callableReference/function/cases/classMemberAndExtension.kt
index e3297fc6d7e..bcf27dd2b3c 100644
--- a/js/js.translator/testData/callableReference/function/cases/classMemberAndExtension.kt
+++ b/js/js.translator/testData/callableReference/function/cases/classMemberAndExtension.kt
@@ -12,14 +12,14 @@ fun box():String {
 
     val a = A()
 
-    var r = a.(A::memBar)("!!")
+    var r = (A::memBar)(a, "!!")
     if (r != "sA:memBar:!!") return r
 
-    r = a.(A::extBar)("!!")
+    r = (A::extBar)(a, "!!")
     if (r != "sA:extBar:!!") return r
 
-    r = a.(A::locExtBar)("!!")
+    r = (A::locExtBar)(a, "!!")
     if (r != "sA:locExtBar:!!") return r
 
     return "OK"
-}
\ No newline at end of file
+}
diff --git a/js/js.translator/testData/callableReference/function/cases/classMemberAndExtensionCompatibility.kt b/js/js.translator/testData/callableReference/function/cases/classMemberAndNonExtensionCompatibility.kt
similarity index 75%
rename from js/js.translator/testData/callableReference/function/cases/classMemberAndExtensionCompatibility.kt
rename to js/js.translator/testData/callableReference/function/cases/classMemberAndNonExtensionCompatibility.kt
index da9091f4f2d..9bb628371d3 100644
--- a/js/js.translator/testData/callableReference/function/cases/classMemberAndExtensionCompatibility.kt
+++ b/js/js.translator/testData/callableReference/function/cases/classMemberAndNonExtensionCompatibility.kt
@@ -1,7 +1,7 @@
 package foo
 
-fun run(a: A, arg: String, funRef:A.(String) -> String): String {
-    return a.(funRef)(arg)
+fun run(a: A, arg: String, funRef:(A, String) -> String): String {
+    return funRef(a, arg)
 }
 
 class A {
@@ -25,8 +25,8 @@ fun box():String {
     r = run(a, "!!", A::locExtBar)
     if (r != "sA:locExtBar:!!") return r
 
-    r = run(a, "!!") {A.(other:String):String -> s + ":literal:" + other }
+    r = run(a, "!!") {(a: A, other: String): String -> a.s + ":literal:" + other }
     if (r != "sA:literal:!!") return r
 
     return "OK"
-}
\ No newline at end of file
+}
diff --git a/js/js.translator/testData/callableReference/function/cases/classMemberFromClass.kt b/js/js.translator/testData/callableReference/function/cases/classMemberFromClass.kt
index 437d60f1b74..6ccd9aba4f6 100644
--- a/js/js.translator/testData/callableReference/function/cases/classMemberFromClass.kt
+++ b/js/js.translator/testData/callableReference/function/cases/classMemberFromClass.kt
@@ -4,7 +4,7 @@ package foo
 class A {
     fun bar(k: Int) = k
 
-    fun result() = this.(::bar)(111)
+    fun result() = (::bar)(this, 111)
 }
 
 fun box(): String {
diff --git a/js/js.translator/testData/callableReference/function/cases/classMemberFromExtension.kt b/js/js.translator/testData/callableReference/function/cases/classMemberFromExtension.kt
index 3320e69657e..4355161af61 100644
--- a/js/js.translator/testData/callableReference/function/cases/classMemberFromExtension.kt
+++ b/js/js.translator/testData/callableReference/function/cases/classMemberFromExtension.kt
@@ -6,7 +6,7 @@ class A {
     fun k(k: Int) = k
 }
 
-fun A.bar() = this.(::o)() + this.(A::k)(222)
+fun A.bar() = (::o)(this) + (A::k)(this, 222)
 
 fun box(): String {
     val result = A().bar()
diff --git a/js/js.translator/testData/callableReference/function/cases/classMemberFromTopLevelStringNoArgs.kt b/js/js.translator/testData/callableReference/function/cases/classMemberFromTopLevelStringNoArgs.kt
index 88c380b34e3..324b957b0af 100644
--- a/js/js.translator/testData/callableReference/function/cases/classMemberFromTopLevelStringNoArgs.kt
+++ b/js/js.translator/testData/callableReference/function/cases/classMemberFromTopLevelStringNoArgs.kt
@@ -1,22 +1,12 @@
 // This test was adapted from compiler/testData/codegen/boxWithStdlib/callableReference/function/.
 package foo
 
-fun run(arg1: A, funRef:A.() -> String): String {
-    return arg1.funRef()
-}
-
 class A {
     fun foo() = "OK"
 }
 
 fun box(): String {
     val x = A::foo
-    var r = A().x()
-    if (r != "OK") return r
-
-    r = run(A(), A::foo)
-    if (r != "OK") return r
-
-    return "OK"
+    var r = x(A())
+    return r
 }
-
diff --git a/js/js.translator/testData/callableReference/function/cases/classMemberFromTopLevelStringOneStringArg.kt b/js/js.translator/testData/callableReference/function/cases/classMemberFromTopLevelStringOneStringArg.kt
index d38f4139e12..23c5409bd29 100644
--- a/js/js.translator/testData/callableReference/function/cases/classMemberFromTopLevelStringOneStringArg.kt
+++ b/js/js.translator/testData/callableReference/function/cases/classMemberFromTopLevelStringOneStringArg.kt
@@ -1,21 +1,13 @@
 // This test was adapted from compiler/testData/codegen/boxWithStdlib/callableReference/function/.
 package foo
 
-fun run(arg1: A, arg2: String, funRef:A.(String) -> String): String {
-    return arg1.funRef(arg2)
-}
-
 class A {
     fun foo(result: String):String = result
 }
 
 fun box(): String {
     val x = A::foo
-    var r = A().x("OK")
+    var r = x(A(), "OK")
 
-    if (r != "OK") return r
-
-    r = run(A(), "OK", A::foo)
-    if (r != "OK") return r
-    return "OK"
+    return r
 }
diff --git a/js/js.translator/testData/callableReference/function/cases/classMemberFromTopLevelUnitNoArgs.kt b/js/js.translator/testData/callableReference/function/cases/classMemberFromTopLevelUnitNoArgs.kt
index b9305e91102..a10c1899391 100644
--- a/js/js.translator/testData/callableReference/function/cases/classMemberFromTopLevelUnitNoArgs.kt
+++ b/js/js.translator/testData/callableReference/function/cases/classMemberFromTopLevelUnitNoArgs.kt
@@ -1,10 +1,6 @@
 // This test was adapted from compiler/testData/codegen/boxWithStdlib/callableReference/function/.
 package foo
 
-fun run(arg1: A, funRef:A.() -> Unit): Unit {
-    return arg1.funRef()
-}
-
 class A {
     var result = "Fail"
     
@@ -16,14 +12,6 @@ class A {
 fun box(): String {
     val a = A()
     val x = A::foo
-    a.x()
-    var r = a.result
-    if (r != "OK") return r
-
-    val a1 = A()
-    run(a1, A::foo)
-    r = a.result
-    if (r != "OK") return r
-
-    return "OK"
+    x(a)
+    return a.result
 }
diff --git a/js/js.translator/testData/callableReference/function/cases/classMemberFromTopLevelUnitOneStringArg.kt b/js/js.translator/testData/callableReference/function/cases/classMemberFromTopLevelUnitOneStringArg.kt
index 4b5bbcc85dd..88c55e2be28 100644
--- a/js/js.translator/testData/callableReference/function/cases/classMemberFromTopLevelUnitOneStringArg.kt
+++ b/js/js.translator/testData/callableReference/function/cases/classMemberFromTopLevelUnitOneStringArg.kt
@@ -1,10 +1,6 @@
 // This test was adapted from compiler/testData/codegen/boxWithStdlib/callableReference/function/.
 package foo
 
-fun run(arg1: A, arg2: String, funRef:A.(String) -> Unit): Unit {
-    return arg1.funRef(arg2)
-}
-
 class A {
     var result = "Fail"
     
@@ -16,14 +12,6 @@ class A {
 fun box(): String {
     val a = A()
     val x = A::foo
-    a.x("OK")
-    var r = a.result
-    if (r != "OK") return r
-
-    val a1 = A()
-    run(a1, "OK", A::foo)
-    r = a1.result
-    if (r != "OK") return r
-
-    return "OK"
+    x(a, "OK")
+    return a.result
 }
diff --git a/js/js.translator/testData/callableReference/function/cases/classMemberOverridden.kt b/js/js.translator/testData/callableReference/function/cases/classMemberOverridden.kt
index b5084c182dd..00fac713bef 100644
--- a/js/js.translator/testData/callableReference/function/cases/classMemberOverridden.kt
+++ b/js/js.translator/testData/callableReference/function/cases/classMemberOverridden.kt
@@ -11,6 +11,6 @@ class B : A() {
 fun box(): String {
     val b = B()
     var ref = A::foo
-    val result = b.(ref)("1", "2")
+    val result = ref(b, "1", "2")
     return (if (result == "fooB:12") "OK" else result)
 }
diff --git a/js/js.translator/testData/callableReference/function/cases/classMemberOverriddenInObject.kt b/js/js.translator/testData/callableReference/function/cases/classMemberOverriddenInObject.kt
index ac2a4f3716f..0ad39d5ad91 100644
--- a/js/js.translator/testData/callableReference/function/cases/classMemberOverriddenInObject.kt
+++ b/js/js.translator/testData/callableReference/function/cases/classMemberOverriddenInObject.kt
@@ -10,6 +10,6 @@ object B : A() {
 
 fun box(): String {
     var ref = B::foo
-    val result = B.(ref)("1", "2")
+    val result = ref(B, "1", "2")
     return (if (result == "fooB:12") "OK" else result)
 }
diff --git a/js/js.translator/testData/callableReference/function/cases/extension.kt b/js/js.translator/testData/callableReference/function/cases/extension.kt
index 704a1f0b8c4..ad6c89fab9d 100644
--- a/js/js.translator/testData/callableReference/function/cases/extension.kt
+++ b/js/js.translator/testData/callableReference/function/cases/extension.kt
@@ -5,5 +5,5 @@ class A
 
 fun box(): String {
     fun A.foo() = "OK"
-    return A().(A::foo)()
+    return (A::foo)(A())
 }
diff --git a/js/js.translator/testData/callableReference/function/cases/extensionFromClass.kt b/js/js.translator/testData/callableReference/function/cases/extensionFromClass.kt
index 03d12c89dc1..80806ebd149 100644
--- a/js/js.translator/testData/callableReference/function/cases/extensionFromClass.kt
+++ b/js/js.translator/testData/callableReference/function/cases/extensionFromClass.kt
@@ -2,7 +2,7 @@
 package foo
 
 class A {
-    fun result() = this.(::bar)("OK")
+    fun result() = (::bar)(this, "OK")
 }
 
 fun A.bar(x: String) = x
diff --git a/js/js.translator/testData/callableReference/function/cases/extensionFromExtension.kt b/js/js.translator/testData/callableReference/function/cases/extensionFromExtension.kt
index 39f76b5b8a6..17fab022176 100644
--- a/js/js.translator/testData/callableReference/function/cases/extensionFromExtension.kt
+++ b/js/js.translator/testData/callableReference/function/cases/extensionFromExtension.kt
@@ -3,7 +3,7 @@ package foo
 
 class A
 
-fun A.foo() = this.(A::bar)("OK")
+fun A.foo() = (A::bar)(this, "OK")
 
 fun A.bar(x: String) = x
 
diff --git a/js/js.translator/testData/callableReference/function/cases/extensionFromTopLevel.kt b/js/js.translator/testData/callableReference/function/cases/extensionFromTopLevel.kt
index 01468e38276..797f52eda1d 100644
--- a/js/js.translator/testData/callableReference/function/cases/extensionFromTopLevel.kt
+++ b/js/js.translator/testData/callableReference/function/cases/extensionFromTopLevel.kt
@@ -1,8 +1,8 @@
 // This test was adapted from compiler/testData/codegen/boxWithStdlib/callableReference/function/.
 package foo
 
-fun <T> run(arg1: A, arg2: T, funRef:A.(T) -> T): T {
-    return arg1.funRef(arg2)
+fun <T> run(arg1: A, arg2: T, funRef:(A, T) -> T): T {
+    return funRef(arg1, arg2)
 }
 
 class A {
@@ -17,9 +17,9 @@ fun A.bar(x: Int): Int {
 fun box(): Boolean {
     val funRef = A::bar
     val obj = A()
-    var result = obj.(funRef)(25)
+    var result = funRef(obj, 25)
     if (result != 25 || obj.xx != 200) return false
 
     result = run(A(), 25, funRef)
     return result == 25 && obj.xx == 200
-}
\ No newline at end of file
+}
diff --git a/js/js.translator/testData/callableReference/function/cases/extensionFromTopLevelStringNoArgs.kt b/js/js.translator/testData/callableReference/function/cases/extensionFromTopLevelStringNoArgs.kt
index 26a597855d3..8b5bcd4e06e 100644
--- a/js/js.translator/testData/callableReference/function/cases/extensionFromTopLevelStringNoArgs.kt
+++ b/js/js.translator/testData/callableReference/function/cases/extensionFromTopLevelStringNoArgs.kt
@@ -11,7 +11,7 @@ fun A.foo() = "OK"
 
 fun box(): String {
     val x = A::foo
-    var r = A().x()
+    var r = x(A())
     if (r != "OK") return r
 
     r = run(A(), A::foo)
diff --git a/js/js.translator/testData/callableReference/function/cases/extensionFromTopLevelStringOneStringArg.kt b/js/js.translator/testData/callableReference/function/cases/extensionFromTopLevelStringOneStringArg.kt
index 3c4d6976e6f..cdcb5d09a0a 100644
--- a/js/js.translator/testData/callableReference/function/cases/extensionFromTopLevelStringOneStringArg.kt
+++ b/js/js.translator/testData/callableReference/function/cases/extensionFromTopLevelStringOneStringArg.kt
@@ -11,7 +11,7 @@ fun A.foo(result: String) = result
 
 fun box(): String {
     val x = A::foo
-    var r = A().x("OK")
+    var r = x(A(), "OK")
     if (r != "OK") return r
 
     r = run(A(), "OK", A::foo)
diff --git a/js/js.translator/testData/callableReference/function/cases/extensionFromTopLevelUnitNoArgs.kt b/js/js.translator/testData/callableReference/function/cases/extensionFromTopLevelUnitNoArgs.kt
index 4ca7aa999f6..5feb3ac7d12 100644
--- a/js/js.translator/testData/callableReference/function/cases/extensionFromTopLevelUnitNoArgs.kt
+++ b/js/js.translator/testData/callableReference/function/cases/extensionFromTopLevelUnitNoArgs.kt
@@ -1,10 +1,6 @@
 // This test was adapted from compiler/testData/codegen/boxWithStdlib/callableReference/function/.
 package foo
 
-fun run(arg1: A, funRef:A.() -> Unit): Unit {
-    return arg1.funRef()
-}
-
 class A {
     var result = "Fail"
 }
@@ -16,11 +12,7 @@ fun A.foo() {
 fun box(): String {
     val a = A()
     val x = A::foo
-    a.x()
+    x(a)
 
-    if (a.result != "OK") return a.result
-
-    val a1 = A()
-    run(a1, A::foo)
     return a.result
 }
diff --git a/js/js.translator/testData/callableReference/function/cases/extensionFromTopLevelUnitOneStringArg.kt b/js/js.translator/testData/callableReference/function/cases/extensionFromTopLevelUnitOneStringArg.kt
index 303595bd7fd..025c997a3db 100644
--- a/js/js.translator/testData/callableReference/function/cases/extensionFromTopLevelUnitOneStringArg.kt
+++ b/js/js.translator/testData/callableReference/function/cases/extensionFromTopLevelUnitOneStringArg.kt
@@ -16,7 +16,7 @@ fun A.foo(newResult: String) {
 fun box(): String {
     val a = A()
     val x = A::foo
-    a.x("OK")
+    x(a, "OK")
 
     if (a.result != "OK") return a.result
 
diff --git a/js/js.translator/testData/callableReference/function/cases/extensionToPrimitive.kt b/js/js.translator/testData/callableReference/function/cases/extensionToPrimitive.kt
index f4d9ebc8410..d47f70664cf 100644
--- a/js/js.translator/testData/callableReference/function/cases/extensionToPrimitive.kt
+++ b/js/js.translator/testData/callableReference/function/cases/extensionToPrimitive.kt
@@ -3,5 +3,5 @@ package foo
 
 fun box(): String {
     fun Int.is42With(that: Int) = this + 2 * that == 42
-    return if (16.(Int::is42With)(13)) "OK" else "Fail"
+    return if ((Int::is42With)(16, 13)) "OK" else "Fail"
 }
diff --git a/js/js.translator/testData/callableReference/function/cases/extensionWithClosure.kt b/js/js.translator/testData/callableReference/function/cases/extensionWithClosure.kt
index 03db48e36ae..dc0bf4868f9 100644
--- a/js/js.translator/testData/callableReference/function/cases/extensionWithClosure.kt
+++ b/js/js.translator/testData/callableReference/function/cases/extensionWithClosure.kt
@@ -9,6 +9,6 @@ fun box(): String {
     fun A.ext() { result = "OK" }
 
     val f = A::ext
-    A().f()
+    f(A())
     return result
 }
diff --git a/js/js.translator/testData/callableReference/function/cases/localAndTopLevelExtensions.kt b/js/js.translator/testData/callableReference/function/cases/localAndTopLevelExtensions.kt
index 49b58d9439d..9ccfd7ef4e1 100644
--- a/js/js.translator/testData/callableReference/function/cases/localAndTopLevelExtensions.kt
+++ b/js/js.translator/testData/callableReference/function/cases/localAndTopLevelExtensions.kt
@@ -1,6 +1,6 @@
 package foo
 
-fun Int.sum0(other: Int): Int = this + other;
+fun Int.sum0(other: Int): Int = this + other
 
 fun box(): String {
     fun Int.sum1(other: Int): Int = this + other
@@ -13,8 +13,8 @@ fun box(): String {
     x = x.sum2(5)
 
     var y = 10
-    y = y.(Int::sum0)(5)
-    y = y.(Int::sum1)(5)
+    y = (Int::sum0)(y, 5)
+    y = (Int::sum1)(y, 5)
     y = y.sum2(5)
 
     var result:String = (if (x == y && x == 25) "OK" else "x=${x} y=${y}")
diff --git a/js/js.translator/testData/callableReference/function/cases/stringNativeExtension.kt b/js/js.translator/testData/callableReference/function/cases/stringNativeExtension.kt
index 52a1655a976..8153191281f 100644
--- a/js/js.translator/testData/callableReference/function/cases/stringNativeExtension.kt
+++ b/js/js.translator/testData/callableReference/function/cases/stringNativeExtension.kt
@@ -2,7 +2,7 @@ package foo
 
 fun box(): String {
     var s = "abc"
-    assertEquals("ABC", s.(String::toUpperCase)())
+    assertEquals("ABC", (String::toUpperCase)(s))
 
     return "OK"
 }
diff --git a/js/js.translator/testData/callableReference/property/cases/kClassInstanceIsInitializedFirst.kt b/js/js.translator/testData/callableReference/property/cases/kClassInstanceIsInitializedFirst.kt
index de0f3d9157b..6682058120e 100644
--- a/js/js.translator/testData/callableReference/property/cases/kClassInstanceIsInitializedFirst.kt
+++ b/js/js.translator/testData/callableReference/property/cases/kClassInstanceIsInitializedFirst.kt
@@ -1,11 +1,11 @@
 // This test was adapted from compiler/testData/codegen/boxWithStdlib/callableReference/property/.
 package foo
 
-import kotlin.reflect.KMemberProperty
+import kotlin.reflect.KProperty1
 
 class A {
     companion object {
-        val ref: KMemberProperty<A, String> = A::foo
+        val ref: KProperty1<A, String> = A::foo
     }
 
     val foo: String = "OK"
diff --git a/js/js.translator/testData/char/cases/charBinaryOperations.kt b/js/js.translator/testData/char/cases/charBinaryOperations.kt
index f774fd69cc1..aaca3495760 100644
--- a/js/js.translator/testData/char/cases/charBinaryOperations.kt
+++ b/js/js.translator/testData/char/cases/charBinaryOperations.kt
@@ -2,76 +2,10 @@ package foo
 
 fun box(): String {
 
-    assertEquals(75, 10 + 'A')
-    assertEquals(75, (10: Short) + 'A')
-    assertEquals(75, (10: Byte) + 'A')
-    assertEquals(75.0, 10.0 + 'A')
-    assertEquals(75.0, 10.0f + 'A')
-    assertEquals(75L, 10L + 'A')
+    assertEquals('K', 'A' + 10)
+    assertEquals('7', 'A' - 10)
 
-    assertEquals(75, 'A' + 10)
-    assertEquals(75, 'A' + (10: Short))
-    assertEquals(75, 'A' + (10: Byte))
-    assertEquals(75.0, 'A' + 10.0)
-    assertEquals(75.0, 'A' + 10.0f)
-    assertEquals(75L, 'A' + 10L)
-
-    assertEquals(-55, 10 - 'A')
-    assertEquals(-55, (10: Short) - 'A')
-    assertEquals(-55, (10: Byte) - 'A')
-    assertEquals(-55.0, 10.0 - 'A')
-    assertEquals(-55.0, 10.0f - 'A')
-    assertEquals(-55L, 10L - 'A')
-
-    assertEquals(55, 'A' - 10)
-    assertEquals(55, 'A' - (10: Short))
-    assertEquals(55, 'A' - (10: Byte))
-    assertEquals(55.0, 'A' - 10.0)
-    assertEquals(55.0, 'A' - 10.0f)
-    assertEquals(55L, 'A' - 10L)
-
-    assertEquals(650, 10 * 'A')
-    assertEquals(650, (10: Short) * 'A')
-    assertEquals(650, (10: Byte) * 'A')
-    assertEquals(650.0, 10.0 * 'A')
-    assertEquals(650.0, 10.0f * 'A')
-    assertEquals(650L, 10L * 'A')
-
-    assertEquals(650, 'A' * 10)
-    assertEquals(650, 'A' * (10: Short))
-    assertEquals(650, 'A' * (10: Byte))
-    assertEquals(650.0, 'A' * 10.0)
-    assertEquals(650.0, 'A' * 10.0f)
-    assertEquals(650L, 'A' * 10L)
-
-    assertEquals(1, 100 / 'A')
-    assertEquals(1, (100: Short) / 'A')
-    assertEquals(1, (100: Byte) / 'A')
-    assertEquals(100.0 / 65.0, 100.0 / 'A')
-    assertEquals(100.0 / 65.0, 100.0f / 'A')
-    assertEquals(1L, 100L / 'A')
-
-    assertEquals(6, 'A' / 10)
-    assertEquals(6, 'A' / (10: Short))
-    assertEquals(6, 'A' / (10: Byte))
-    assertEquals(6.5, 'A' / 10.0)
-    assertEquals(6.5, 'A' / 10.0f)
-    assertEquals(6L, 'A' / 10L)
-
-    assertEquals(35, 100 % 'A')
-    assertEquals(35, (100: Short) % 'A')
-    assertEquals(35, (100: Byte) % 'A')
-    // TODO Uncomment when KT-5860 (Double.mod(Char) is absent) will be fixed
-    //assertEquals(35.0, 100.0 % 'A')
-    assertEquals(35.0, 100.0f % 'A')
-    assertEquals(35L, 100L % 'A')
-
-    assertEquals(5, 'A' % 10)
-    assertEquals(5, 'A' % (10: Short))
-    assertEquals(5, 'A' % (10: Byte))
-    assertEquals(5.0, 'A' % 10.0)
-    assertEquals(5.0, 'A' % 10.0f)
-    assertEquals(5L, 'A' % 10L)
+    assertEquals(3, 'd' - 'a')
 
     return "OK"
 }
\ No newline at end of file
diff --git a/js/js.translator/testData/char/cases/charCompareToIntrinsic.kt b/js/js.translator/testData/char/cases/charCompareToIntrinsic.kt
index 481a557fe74..945a97fab91 100644
--- a/js/js.translator/testData/char/cases/charCompareToIntrinsic.kt
+++ b/js/js.translator/testData/char/cases/charCompareToIntrinsic.kt
@@ -2,19 +2,10 @@ package foo
 
 fun box(): String {
 
-    assertEquals(true, 64 < 'A')
-    assertEquals(true, (64: Short) < 'A')
-    assertEquals(true, (64: Byte) < 'A')
-    assertEquals(true, 64L < 'A')
-    assertEquals(true, 64.0 < 'A')
-    assertEquals(true, 64.0f < 'A')
-
-    assertEquals(true, 'A' > 64)
-    assertEquals(true, 'A' > (64: Short))
-    assertEquals(true, 'A' > (64: Byte))
-    assertEquals(true, 'A' > 64L)
-    assertEquals(true, 'A' > 64.0)
-    assertEquals(true, 'A' > 64.0f)
+    assertEquals(true, 'A' < '\uFFFF')
+    assertEquals(true, 'A' > '\u0000')
+    assertEquals(true, 'A' <= '\u0041')
+    assertEquals(true, 'A' >= '\u0041')
 
     return "OK"
 }
\ No newline at end of file
diff --git a/js/js.translator/testData/char/cases/charUnaryOperations.kt b/js/js.translator/testData/char/cases/charUnaryOperations.kt
index e73f8baaca2..38489196be2 100644
--- a/js/js.translator/testData/char/cases/charUnaryOperations.kt
+++ b/js/js.translator/testData/char/cases/charUnaryOperations.kt
@@ -21,9 +21,5 @@ fun box(): String {
     --x
     assertEquals('C', x)
 
-    assertEquals(67, +x)
-    assertEquals(-67, -x)
-
-
     return "OK"
 }
\ No newline at end of file
diff --git a/js/js.translator/testData/expression/invoke/cases/invokeWithImplicitDispatchReceiverAndExtensionReceiver.kt b/js/js.translator/testData/expression/invoke/cases/invokeWithImplicitDispatchReceiverAndExtensionReceiver.kt
index d0f0c2b23ba..5c32ed9f60b 100644
--- a/js/js.translator/testData/expression/invoke/cases/invokeWithImplicitDispatchReceiverAndExtensionReceiver.kt
+++ b/js/js.translator/testData/expression/invoke/cases/invokeWithImplicitDispatchReceiverAndExtensionReceiver.kt
@@ -3,10 +3,10 @@ package foo
 fun A.f(s: String) = value + s
 
 class A(val value: String) {
-    fun bar(s: String) = (::f)(s)
+    fun bar(s: String) = (::f)(this, s)
 }
 
-fun A.baz(s: String) = (::f)(s)
+fun A.baz(s: String) = (::f)(this, s)
 
 fun box(): String {
     val a = A("aaa")
diff --git a/js/js.translator/testData/kotlin_lib_ecma5.js b/js/js.translator/testData/kotlin_lib_ecma5.js
index fb93b455480..fd799ac5cd8 100644
--- a/js/js.translator/testData/kotlin_lib_ecma5.js
+++ b/js/js.translator/testData/kotlin_lib_ecma5.js
@@ -175,9 +175,7 @@ var Kotlin = {};
     Kotlin.createObjectNow = function (bases, constructor, functions) {
         var noNameClass = Kotlin.createClassNow(bases, constructor, functions);
         var obj = new noNameClass();
-        obj.$metadata$ = {
-            type: Kotlin.TYPE.OBJECT
-        };
+        noNameClass.$metadata$.type = Kotlin.TYPE.OBJECT;
         return  obj;
     };
 
@@ -337,7 +335,9 @@ var Kotlin = {};
     // TODO Store callable references for members in class
     Kotlin.getCallableRefForMemberFunction = function (klass, memberName) {
         return function () {
-            return this[memberName].apply(this, arguments);
+            var args = [].slice.call(arguments);
+            var instance = args.shift();
+            return instance[memberName].apply(instance, args);
         };
     };
 
@@ -345,9 +345,15 @@ var Kotlin = {};
     // extFun expected receiver as the first argument
     Kotlin.getCallableRefForExtensionFunction = function (extFun) {
         return function () {
-          var args = [this];
-          Array.prototype.push.apply(args, arguments);
-          return extFun.apply(null, args);
+            return extFun.apply(null, arguments);
+        };
+    };
+
+    Kotlin.getCallableRefForLocalExtensionFunction = function (extFun) {
+        return function () {
+            var args = [].slice.call(arguments);
+            var instance = args.shift();
+            return extFun.apply(instance, args);
         };
     };
 
diff --git a/js/js.translator/testData/multiPackage/cases/reflectionFromOtherPackage/b.kt b/js/js.translator/testData/multiPackage/cases/reflectionFromOtherPackage/b.kt
index cbc31257a28..625ccbd9772 100644
--- a/js/js.translator/testData/multiPackage/cases/reflectionFromOtherPackage/b.kt
+++ b/js/js.translator/testData/multiPackage/cases/reflectionFromOtherPackage/b.kt
@@ -7,9 +7,9 @@ fun A.ext2(s: String): String = "A.ext2: ${this.v} ${s}"
 fun box(): Boolean {
 
     assertEquals("topLevelFun: A", (::topLevelFun)("A"))
-    assertEquals("A.ext1: test B", A("test").(A::ext1)("B"))
-    assertEquals("A.ext2: test B", A("test").(A::ext2)("B"))
-    assertEquals("memA: test C", A("test").(A::memA)("C"))
+    assertEquals("A.ext1: test B", (A::ext1)(A("test"), "B"))
+    assertEquals("A.ext2: test B", (A::ext2)(A("test"), "B"))
+    assertEquals("memA: test C", (A::memA)(A("test"), "C"))
 
     assertEquals(100, ::topLevelVar.get())
     ::topLevelVar.set(500)
@@ -25,5 +25,5 @@ fun box(): Boolean {
     (A::extProp).set(a, "new text")
     assertEquals("new text", (A::extProp).get(a))
 
-    return true;
-}
\ No newline at end of file
+    return true
+}
diff --git a/js/js.translator/testData/native/cases/nativeExtensionLikeMember.kt b/js/js.translator/testData/native/cases/nativeExtensionLikeMember.kt
index d088358614c..956da932d1f 100644
--- a/js/js.translator/testData/native/cases/nativeExtensionLikeMember.kt
+++ b/js/js.translator/testData/native/cases/nativeExtensionLikeMember.kt
@@ -22,8 +22,8 @@ fun box(): String {
     assertEquals("A.bar A", a.bar())
     assertEquals("B.bar B", b.bar())
 
-    assertEquals("A.bar A", a.(A::bar)())
-    assertEquals("B.bar B", b.(A::bar)())
+    assertEquals("A.bar A", (A::bar)(a))
+    assertEquals("B.bar B", (A::bar)(b))
 
     a.prop = "prop"
     assertEquals("prop", a.prop)
@@ -31,10 +31,10 @@ fun box(): String {
 
     a = b
     assertEquals("B.bar B", a.bar())
-    assertEquals("B.bar B", a.(A::bar)())
+    assertEquals("B.bar B", (A::bar)(a))
 
     assertEquals("B prop", a.prop)
     assertEquals("B prop", (A::prop).get(a))
 
-    return "OK";
+    return "OK"
 }
diff --git a/js/js.translator/testData/native/cases/passMemberOrExtFromNative.kt b/js/js.translator/testData/native/cases/passMemberOrExtFromNative.kt
index 8cca0493769..fb70ffbc1b2 100644
--- a/js/js.translator/testData/native/cases/passMemberOrExtFromNative.kt
+++ b/js/js.translator/testData/native/cases/passMemberOrExtFromNative.kt
@@ -16,13 +16,13 @@ fun box(): String {
     val a = A("test")
 
     assertEquals("A.m test 4 boo", a.m(4, "boo"))
-    assertEquals("A.m test 4 boo", bar(a, A::m))
+    assertEquals("A.m test 4 boo", bar(a, fun A.(i, s) = (A::m)(this, i, s)))
 
     assertEquals("nativeExt test 4 boo", a.nativeExt(4, "boo"))
-    assertEquals("nativeExt test 4 boo", bar(a, A::nativeExt))
+    assertEquals("nativeExt test 4 boo", bar(a, fun A.(i, s) = (A::nativeExt)(this, i, s)))
 
     assertEquals("nativeExt2 test 4 boo", a.nativeExt2(4, "boo"))
-    assertEquals("nativeExt2 test 4 boo", bar(a, A::nativeExt2))
+    assertEquals("nativeExt2 test 4 boo", bar(a, fun A.(i, s) = (A::nativeExt2)(this, i, s)))
 
     return "OK"
 }
diff --git a/js/js.translator/testData/native/cases/passMemberOrExtToNative.kt b/js/js.translator/testData/native/cases/passMemberOrExtToNative.kt
index 125a2c5eeed..57c1f0e0e5d 100644
--- a/js/js.translator/testData/native/cases/passMemberOrExtToNative.kt
+++ b/js/js.translator/testData/native/cases/passMemberOrExtToNative.kt
@@ -21,18 +21,18 @@ fun box(): String {
 
     fun A.LocalExt(i:Int, s:String): String = "A::LocalExt ${this.v} $i $s"
 
-    r = bar(a, A::topLevelExt)
+    r = bar(a, fun A.(i, s) = (A::topLevelExt)(this, i, s))
     if (r != "A::topLevelExt test 4 boo") return r
 
-    r = bar(a, A::LocalExt)
+    r = bar(a, fun A.(i, s) = (A::LocalExt)(this, i, s))
     if (r != "A::LocalExt test 4 boo") return r
 
-    r = bar(a, A::m)
+    r = bar(a, fun A.(i, s) = (A::m)(this, i, s))
     if (r != "A.m test 4 boo") return r
 
     val b = B("test")
-    r = bar(b, A::m)
+    r = bar(b, fun A.(i, s) = (A::m)(this, i, s))
     if (r != "B.m test 4 boo") return r
 
     return "OK"
-}
\ No newline at end of file
+}
diff --git a/js/js.translator/testData/number/cases/numberCompareTo.kt b/js/js.translator/testData/number/cases/numberCompareTo.kt
index 82e9fc17a53..9507a39d539 100644
--- a/js/js.translator/testData/number/cases/numberCompareTo.kt
+++ b/js/js.translator/testData/number/cases/numberCompareTo.kt
@@ -19,7 +19,6 @@ fun box(): String {
     assertEquals(-1, 1 compareTo (2:Byte))
     assertEquals(-1, 1 compareTo 2.0)
     assertEquals(-1, 1 compareTo 2.0f)
-    assertEquals(-1, 1 compareTo 'A')
 
     assertEquals(1, 10 compareTo 2L)
     assertEquals(1, 10 compareTo 2)
@@ -43,7 +42,6 @@ fun box(): String {
     assertEquals(-1, (1: Short) compareTo (2:Byte))
     assertEquals(-1, (1: Short) compareTo 2.0)
     assertEquals(-1, (1: Short) compareTo 2.0f)
-    assertEquals(-1, (1: Short) compareTo 'A')
 
     assertEquals(1, (10: Byte) compareTo 2L)
     assertEquals(-1, (10: Byte) compareTo 7540113804746346429L)
@@ -53,7 +51,6 @@ fun box(): String {
     assertEquals(1, ((10: Byte): Comparable<Byte>) compareTo (2:Byte))
     assertEquals(1, (10: Byte) compareTo 2.0)
     assertEquals(1, (10: Byte) compareTo 2.0f)
-    assertEquals(-1, (10: Byte) compareTo 'A')
 
     assertEquals(0, 2.0 compareTo 2L)
     assertEquals(-1, 2.0 compareTo 7540113804746346429L)
@@ -63,7 +60,6 @@ fun box(): String {
     assertEquals(0, 2.0 compareTo 2.0)
     assertEquals(0, (2.0: Comparable<Double>) compareTo 2.0)
     assertEquals(0, 2.0 compareTo 2.0f)
-    assertEquals(-1, 2.0 compareTo 'A')
 
     assertEquals(1, 3.0f compareTo 2L)
     assertEquals(-1, 3.0f compareTo 7540113804746346429L)
@@ -72,7 +68,6 @@ fun box(): String {
     assertEquals(1, 3.0f compareTo (2:Byte))
     assertEquals(1, 3.0f compareTo 2.0)
     assertEquals(1, 3.0f compareTo 2.0f)
-    assertEquals(-1, 3.0f compareTo 'A')
     assertEquals(1, (3.0f: Comparable<Float>) compareTo 2.0f)
 
     assertEquals(1, 10L compareTo 2L)
@@ -83,15 +78,7 @@ fun box(): String {
     assertEquals(1, 10L compareTo (2:Byte))
     assertEquals(1, 10L compareTo 2.0)
     assertEquals(1, 10L compareTo 2.0f)
-    assertEquals(-1, 10L compareTo 'A')
 
-    assertEquals(-1, 'A' compareTo 200L)
-    assertEquals(-1, 'A' compareTo 7540113804746346429L)
-    assertEquals(1, 'A' compareTo 2)
-    assertEquals(1, 'A' compareTo (2:Short))
-    assertEquals(1, 'A' compareTo (2:Byte))
-    assertEquals(1, 'A' compareTo 2.0)
-    assertEquals(1, 'A' compareTo 2.0f)
     assertEquals(0, 'A' compareTo 'A')
 
     assertEquals(-1, 1L compareTo 2L)
diff --git a/js/js.translator/testData/object/cases/dontPolluteObject.kt b/js/js.translator/testData/object/cases/dontPolluteObject.kt
new file mode 100644
index 00000000000..9349125a2b6
--- /dev/null
+++ b/js/js.translator/testData/object/cases/dontPolluteObject.kt
@@ -0,0 +1,45 @@
+package foo
+
+object EmptyObject {}
+
+object SomeObject {
+    val foo = 1
+    var bar = "t"
+    fun baz() {}
+}
+
+val emptyObjectExpr = object {}
+
+val someObjectExpr = object {
+    val foo = 1
+    var bar = "t"
+    fun baz() {}
+}
+
+val o = js("Object")
+
+fun keys(a: Any): List<String> {
+    val arr: Array<String> = o.keys(a)
+    return arr.toList()
+}
+
+fun getOwnPropertyNames(a: Any): List<String> {
+    val arr: Array<String> = o.getOwnPropertyNames(a)
+    return arr.toList()
+}
+
+fun box(): String {
+    assertEquals(listOf(), getOwnPropertyNames(EmptyObject))
+    assertEquals(listOf(), keys(EmptyObject))
+
+    assertEquals(listOf("foo", "bar"), getOwnPropertyNames(SomeObject))
+    assertEquals(listOf("foo", "bar"), keys(SomeObject))
+
+    assertEquals(listOf(), getOwnPropertyNames(emptyObjectExpr))
+    assertEquals(listOf(), keys(emptyObjectExpr))
+
+    assertEquals(listOf("foo", "bar"), getOwnPropertyNames(someObjectExpr))
+    assertEquals(listOf("foo", "bar"), keys(someObjectExpr))
+
+    return "OK"
+}
diff --git a/js/js.translator/testData/operatorOverloading/cases/overloadPlusAssignViaPlusExtensionFunction.kt b/js/js.translator/testData/operatorOverloading/cases/overloadPlusAssignViaPlusExtensionFunction.kt
index 626b81099b6..7c7d5f155c2 100644
--- a/js/js.translator/testData/operatorOverloading/cases/overloadPlusAssignViaPlusExtensionFunction.kt
+++ b/js/js.translator/testData/operatorOverloading/cases/overloadPlusAssignViaPlusExtensionFunction.kt
@@ -1,19 +1,16 @@
 package foo
 
-import java.util.*
+open class Foo<out T>(open val value: T)
+open class MutableFoo<T>(override var value: T): Foo<T>(value)
+
+fun <T> Foo<T>.plus(x: T): Foo<T> = Foo(x)
+
+// overloading:
+fun <T> MutableFoo<T>.plus(x: T): MutableFoo<T> = MutableFoo(x)
 
-fun <T> ArrayList<T>.plus(other: Collection<T>): ArrayList<T> {
-    val c = ArrayList<T>()
-    c.addAll(this)
-    c.addAll(other)
-    return c
-}
 
 fun box(): Boolean {
-    var v1 = ArrayList<String>()
-    val v2 = ArrayList<String>()
-    v1.add("foo")
-    v2.add("bar")
-    v1 += v2
-    return (v1.size() == 2 && v1[0] == "foo" && v1[1] == "bar")
+    var f = MutableFoo(1)
+    f += 2
+    return (f is MutableFoo && f.value == 2)
 }
diff --git a/jslib_files.xml b/jslib_files.xml
index 6b228850dba..2c6a294e24e 100644
--- a/jslib_files.xml
+++ b/jslib_files.xml
@@ -2,6 +2,7 @@
     <fileset id="kotlin.builtin.files" dir="${basedir}/core/builtins">
         <include name="native/kotlin/Iterator.kt"/>
         <include name="native/kotlin/Collections.kt"/>
+        <include name="src/kotlin/annotation/Annotations.kt"/>
         <include name="src/kotlin/Function.kt"/>
         <include name="src/kotlin/Iterators.kt"/>
         <include name="src/kotlin/Range.kt"/>
@@ -16,6 +17,7 @@
 
         <fileset dir="${basedir}/core/builtins/src">
             <include name="kotlin/reflect/**/*.kt"/>
+            <include name="kotlin/annotation/Annotations.kt"/>
         </fileset>
 
         <fileset dir="${basedir}/libraries/stdlib/src">
diff --git a/libraries/examples/annotation-processor-example/src/main/kotlin/example/ExampleAnnotation.kt b/libraries/examples/annotation-processor-example/src/main/kotlin/example/ExampleAnnotation.kt
index a88da9823f6..0da7a817597 100644
--- a/libraries/examples/annotation-processor-example/src/main/kotlin/example/ExampleAnnotation.kt
+++ b/libraries/examples/annotation-processor-example/src/main/kotlin/example/ExampleAnnotation.kt
@@ -1,6 +1,8 @@
 package example
 
 import java.lang.annotation.ElementType
+import java.lang.annotation.Inherited
 import java.lang.annotation.Target
 
+@Inherited
 annotation public class ExampleAnnotation
\ No newline at end of file
diff --git a/libraries/stdlib/src/generated/_Elements.kt b/libraries/stdlib/src/generated/_Elements.kt
index d57c2d248ce..e308581f8e1 100644
--- a/libraries/stdlib/src/generated/_Elements.kt
+++ b/libraries/stdlib/src/generated/_Elements.kt
@@ -13,6 +13,7 @@ import java.util.Collections // TODO: it's temporary while we have java.util.Col
 /**
  * Returns 1st *element* from the collection.
  */
+suppress("NOTHING_TO_INLINE")
 public inline fun <T> Array<out T>.component1(): T {
     return get(0)
 }
@@ -20,6 +21,7 @@ public inline fun <T> Array<out T>.component1(): T {
 /**
  * Returns 1st *element* from the collection.
  */
+suppress("NOTHING_TO_INLINE")
 public inline fun BooleanArray.component1(): Boolean {
     return get(0)
 }
@@ -27,6 +29,7 @@ public inline fun BooleanArray.component1(): Boolean {
 /**
  * Returns 1st *element* from the collection.
  */
+suppress("NOTHING_TO_INLINE")
 public inline fun ByteArray.component1(): Byte {
     return get(0)
 }
@@ -34,6 +37,7 @@ public inline fun ByteArray.component1(): Byte {
 /**
  * Returns 1st *element* from the collection.
  */
+suppress("NOTHING_TO_INLINE")
 public inline fun CharArray.component1(): Char {
     return get(0)
 }
@@ -41,6 +45,7 @@ public inline fun CharArray.component1(): Char {
 /**
  * Returns 1st *element* from the collection.
  */
+suppress("NOTHING_TO_INLINE")
 public inline fun DoubleArray.component1(): Double {
     return get(0)
 }
@@ -48,6 +53,7 @@ public inline fun DoubleArray.component1(): Double {
 /**
  * Returns 1st *element* from the collection.
  */
+suppress("NOTHING_TO_INLINE")
 public inline fun FloatArray.component1(): Float {
     return get(0)
 }
@@ -55,6 +61,7 @@ public inline fun FloatArray.component1(): Float {
 /**
  * Returns 1st *element* from the collection.
  */
+suppress("NOTHING_TO_INLINE")
 public inline fun IntArray.component1(): Int {
     return get(0)
 }
@@ -62,6 +69,7 @@ public inline fun IntArray.component1(): Int {
 /**
  * Returns 1st *element* from the collection.
  */
+suppress("NOTHING_TO_INLINE")
 public inline fun LongArray.component1(): Long {
     return get(0)
 }
@@ -69,6 +77,7 @@ public inline fun LongArray.component1(): Long {
 /**
  * Returns 1st *element* from the collection.
  */
+suppress("NOTHING_TO_INLINE")
 public inline fun ShortArray.component1(): Short {
     return get(0)
 }
@@ -76,6 +85,7 @@ public inline fun ShortArray.component1(): Short {
 /**
  * Returns 1st *element* from the collection.
  */
+suppress("NOTHING_TO_INLINE")
 public inline fun <T> List<T>.component1(): T {
     return get(0)
 }
@@ -83,6 +93,7 @@ public inline fun <T> List<T>.component1(): T {
 /**
  * Returns 2nd *element* from the collection.
  */
+suppress("NOTHING_TO_INLINE")
 public inline fun <T> Array<out T>.component2(): T {
     return get(1)
 }
@@ -90,6 +101,7 @@ public inline fun <T> Array<out T>.component2(): T {
 /**
  * Returns 2nd *element* from the collection.
  */
+suppress("NOTHING_TO_INLINE")
 public inline fun BooleanArray.component2(): Boolean {
     return get(1)
 }
@@ -97,6 +109,7 @@ public inline fun BooleanArray.component2(): Boolean {
 /**
  * Returns 2nd *element* from the collection.
  */
+suppress("NOTHING_TO_INLINE")
 public inline fun ByteArray.component2(): Byte {
     return get(1)
 }
@@ -104,6 +117,7 @@ public inline fun ByteArray.component2(): Byte {
 /**
  * Returns 2nd *element* from the collection.
  */
+suppress("NOTHING_TO_INLINE")
 public inline fun CharArray.component2(): Char {
     return get(1)
 }
@@ -111,6 +125,7 @@ public inline fun CharArray.component2(): Char {
 /**
  * Returns 2nd *element* from the collection.
  */
+suppress("NOTHING_TO_INLINE")
 public inline fun DoubleArray.component2(): Double {
     return get(1)
 }
@@ -118,6 +133,7 @@ public inline fun DoubleArray.component2(): Double {
 /**
  * Returns 2nd *element* from the collection.
  */
+suppress("NOTHING_TO_INLINE")
 public inline fun FloatArray.component2(): Float {
     return get(1)
 }
@@ -125,6 +141,7 @@ public inline fun FloatArray.component2(): Float {
 /**
  * Returns 2nd *element* from the collection.
  */
+suppress("NOTHING_TO_INLINE")
 public inline fun IntArray.component2(): Int {
     return get(1)
 }
@@ -132,6 +149,7 @@ public inline fun IntArray.component2(): Int {
 /**
  * Returns 2nd *element* from the collection.
  */
+suppress("NOTHING_TO_INLINE")
 public inline fun LongArray.component2(): Long {
     return get(1)
 }
@@ -139,6 +157,7 @@ public inline fun LongArray.component2(): Long {
 /**
  * Returns 2nd *element* from the collection.
  */
+suppress("NOTHING_TO_INLINE")
 public inline fun ShortArray.component2(): Short {
     return get(1)
 }
@@ -146,6 +165,7 @@ public inline fun ShortArray.component2(): Short {
 /**
  * Returns 2nd *element* from the collection.
  */
+suppress("NOTHING_TO_INLINE")
 public inline fun <T> List<T>.component2(): T {
     return get(1)
 }
@@ -153,6 +173,7 @@ public inline fun <T> List<T>.component2(): T {
 /**
  * Returns 3rd *element* from the collection.
  */
+suppress("NOTHING_TO_INLINE")
 public inline fun <T> Array<out T>.component3(): T {
     return get(2)
 }
@@ -160,6 +181,7 @@ public inline fun <T> Array<out T>.component3(): T {
 /**
  * Returns 3rd *element* from the collection.
  */
+suppress("NOTHING_TO_INLINE")
 public inline fun BooleanArray.component3(): Boolean {
     return get(2)
 }
@@ -167,6 +189,7 @@ public inline fun BooleanArray.component3(): Boolean {
 /**
  * Returns 3rd *element* from the collection.
  */
+suppress("NOTHING_TO_INLINE")
 public inline fun ByteArray.component3(): Byte {
     return get(2)
 }
@@ -174,6 +197,7 @@ public inline fun ByteArray.component3(): Byte {
 /**
  * Returns 3rd *element* from the collection.
  */
+suppress("NOTHING_TO_INLINE")
 public inline fun CharArray.component3(): Char {
     return get(2)
 }
@@ -181,6 +205,7 @@ public inline fun CharArray.component3(): Char {
 /**
  * Returns 3rd *element* from the collection.
  */
+suppress("NOTHING_TO_INLINE")
 public inline fun DoubleArray.component3(): Double {
     return get(2)
 }
@@ -188,6 +213,7 @@ public inline fun DoubleArray.component3(): Double {
 /**
  * Returns 3rd *element* from the collection.
  */
+suppress("NOTHING_TO_INLINE")
 public inline fun FloatArray.component3(): Float {
     return get(2)
 }
@@ -195,6 +221,7 @@ public inline fun FloatArray.component3(): Float {
 /**
  * Returns 3rd *element* from the collection.
  */
+suppress("NOTHING_TO_INLINE")
 public inline fun IntArray.component3(): Int {
     return get(2)
 }
@@ -202,6 +229,7 @@ public inline fun IntArray.component3(): Int {
 /**
  * Returns 3rd *element* from the collection.
  */
+suppress("NOTHING_TO_INLINE")
 public inline fun LongArray.component3(): Long {
     return get(2)
 }
@@ -209,6 +237,7 @@ public inline fun LongArray.component3(): Long {
 /**
  * Returns 3rd *element* from the collection.
  */
+suppress("NOTHING_TO_INLINE")
 public inline fun ShortArray.component3(): Short {
     return get(2)
 }
@@ -216,6 +245,7 @@ public inline fun ShortArray.component3(): Short {
 /**
  * Returns 3rd *element* from the collection.
  */
+suppress("NOTHING_TO_INLINE")
 public inline fun <T> List<T>.component3(): T {
     return get(2)
 }
@@ -223,6 +253,7 @@ public inline fun <T> List<T>.component3(): T {
 /**
  * Returns 4th *element* from the collection.
  */
+suppress("NOTHING_TO_INLINE")
 public inline fun <T> Array<out T>.component4(): T {
     return get(3)
 }
@@ -230,6 +261,7 @@ public inline fun <T> Array<out T>.component4(): T {
 /**
  * Returns 4th *element* from the collection.
  */
+suppress("NOTHING_TO_INLINE")
 public inline fun BooleanArray.component4(): Boolean {
     return get(3)
 }
@@ -237,6 +269,7 @@ public inline fun BooleanArray.component4(): Boolean {
 /**
  * Returns 4th *element* from the collection.
  */
+suppress("NOTHING_TO_INLINE")
 public inline fun ByteArray.component4(): Byte {
     return get(3)
 }
@@ -244,6 +277,7 @@ public inline fun ByteArray.component4(): Byte {
 /**
  * Returns 4th *element* from the collection.
  */
+suppress("NOTHING_TO_INLINE")
 public inline fun CharArray.component4(): Char {
     return get(3)
 }
@@ -251,6 +285,7 @@ public inline fun CharArray.component4(): Char {
 /**
  * Returns 4th *element* from the collection.
  */
+suppress("NOTHING_TO_INLINE")
 public inline fun DoubleArray.component4(): Double {
     return get(3)
 }
@@ -258,6 +293,7 @@ public inline fun DoubleArray.component4(): Double {
 /**
  * Returns 4th *element* from the collection.
  */
+suppress("NOTHING_TO_INLINE")
 public inline fun FloatArray.component4(): Float {
     return get(3)
 }
@@ -265,6 +301,7 @@ public inline fun FloatArray.component4(): Float {
 /**
  * Returns 4th *element* from the collection.
  */
+suppress("NOTHING_TO_INLINE")
 public inline fun IntArray.component4(): Int {
     return get(3)
 }
@@ -272,6 +309,7 @@ public inline fun IntArray.component4(): Int {
 /**
  * Returns 4th *element* from the collection.
  */
+suppress("NOTHING_TO_INLINE")
 public inline fun LongArray.component4(): Long {
     return get(3)
 }
@@ -279,6 +317,7 @@ public inline fun LongArray.component4(): Long {
 /**
  * Returns 4th *element* from the collection.
  */
+suppress("NOTHING_TO_INLINE")
 public inline fun ShortArray.component4(): Short {
     return get(3)
 }
@@ -286,6 +325,7 @@ public inline fun ShortArray.component4(): Short {
 /**
  * Returns 4th *element* from the collection.
  */
+suppress("NOTHING_TO_INLINE")
 public inline fun <T> List<T>.component4(): T {
     return get(3)
 }
@@ -293,6 +333,7 @@ public inline fun <T> List<T>.component4(): T {
 /**
  * Returns 5th *element* from the collection.
  */
+suppress("NOTHING_TO_INLINE")
 public inline fun <T> Array<out T>.component5(): T {
     return get(4)
 }
@@ -300,6 +341,7 @@ public inline fun <T> Array<out T>.component5(): T {
 /**
  * Returns 5th *element* from the collection.
  */
+suppress("NOTHING_TO_INLINE")
 public inline fun BooleanArray.component5(): Boolean {
     return get(4)
 }
@@ -307,6 +349,7 @@ public inline fun BooleanArray.component5(): Boolean {
 /**
  * Returns 5th *element* from the collection.
  */
+suppress("NOTHING_TO_INLINE")
 public inline fun ByteArray.component5(): Byte {
     return get(4)
 }
@@ -314,6 +357,7 @@ public inline fun ByteArray.component5(): Byte {
 /**
  * Returns 5th *element* from the collection.
  */
+suppress("NOTHING_TO_INLINE")
 public inline fun CharArray.component5(): Char {
     return get(4)
 }
@@ -321,6 +365,7 @@ public inline fun CharArray.component5(): Char {
 /**
  * Returns 5th *element* from the collection.
  */
+suppress("NOTHING_TO_INLINE")
 public inline fun DoubleArray.component5(): Double {
     return get(4)
 }
@@ -328,6 +373,7 @@ public inline fun DoubleArray.component5(): Double {
 /**
  * Returns 5th *element* from the collection.
  */
+suppress("NOTHING_TO_INLINE")
 public inline fun FloatArray.component5(): Float {
     return get(4)
 }
@@ -335,6 +381,7 @@ public inline fun FloatArray.component5(): Float {
 /**
  * Returns 5th *element* from the collection.
  */
+suppress("NOTHING_TO_INLINE")
 public inline fun IntArray.component5(): Int {
     return get(4)
 }
@@ -342,6 +389,7 @@ public inline fun IntArray.component5(): Int {
 /**
  * Returns 5th *element* from the collection.
  */
+suppress("NOTHING_TO_INLINE")
 public inline fun LongArray.component5(): Long {
     return get(4)
 }
@@ -349,6 +397,7 @@ public inline fun LongArray.component5(): Long {
 /**
  * Returns 5th *element* from the collection.
  */
+suppress("NOTHING_TO_INLINE")
 public inline fun ShortArray.component5(): Short {
     return get(4)
 }
@@ -356,6 +405,7 @@ public inline fun ShortArray.component5(): Short {
 /**
  * Returns 5th *element* from the collection.
  */
+suppress("NOTHING_TO_INLINE")
 public inline fun <T> List<T>.component5(): T {
     return get(4)
 }
@@ -600,9 +650,9 @@ public inline fun ShortArray.elementAtOrElse(index: Int, defaultValue: (Int) ->
 /**
  * Returns an element at the given [index] or the result of calling the [defaultValue] function if the [index] is out of bounds of this collection.
  */
-public inline fun <T> Iterable<T>.elementAtOrElse(index: Int, defaultValue: (Int) -> T): T {
+public fun <T> Iterable<T>.elementAtOrElse(index: Int, defaultValue: (Int) -> T): T {
     if (this is List<T>)
-        return this.elementAtOrElse(index, defaultValue)
+        return this.getOrElse(index, defaultValue)
     if (index < 0)
         return defaultValue(index)
     val iterator = iterator()
@@ -625,7 +675,7 @@ public inline fun <T> List<T>.elementAtOrElse(index: Int, defaultValue: (Int) ->
 /**
  * Returns an element at the given [index] or the result of calling the [defaultValue] function if the [index] is out of bounds of this collection.
  */
-public inline fun <T> Sequence<T>.elementAtOrElse(index: Int, defaultValue: (Int) -> T): T {
+public fun <T> Sequence<T>.elementAtOrElse(index: Int, defaultValue: (Int) -> T): T {
     if (index < 0)
         return defaultValue(index)
     val iterator = iterator()
@@ -713,7 +763,7 @@ public fun ShortArray.elementAtOrNull(index: Int): Short? {
  */
 public fun <T> Iterable<T>.elementAtOrNull(index: Int): T? {
     if (this is List<T>)
-        return this.elementAtOrNull(index)
+        return this.getOrNull(index)
     if (index < 0)
         return null
     val iterator = iterator()
@@ -1229,6 +1279,160 @@ public inline fun String.firstOrNull(predicate: (Char) -> Boolean): Char? {
     return null
 }
 
+/**
+ * Returns an element at the given [index] or the result of calling the [defaultValue] function if the [index] is out of bounds of this collection.
+ */
+public inline fun <T> Array<out T>.getOrElse(index: Int, defaultValue: (Int) -> T): T {
+    return if (index >= 0 && index <= lastIndex) get(index) else defaultValue(index)
+}
+
+/**
+ * Returns an element at the given [index] or the result of calling the [defaultValue] function if the [index] is out of bounds of this collection.
+ */
+public inline fun BooleanArray.getOrElse(index: Int, defaultValue: (Int) -> Boolean): Boolean {
+    return if (index >= 0 && index <= lastIndex) get(index) else defaultValue(index)
+}
+
+/**
+ * Returns an element at the given [index] or the result of calling the [defaultValue] function if the [index] is out of bounds of this collection.
+ */
+public inline fun ByteArray.getOrElse(index: Int, defaultValue: (Int) -> Byte): Byte {
+    return if (index >= 0 && index <= lastIndex) get(index) else defaultValue(index)
+}
+
+/**
+ * Returns an element at the given [index] or the result of calling the [defaultValue] function if the [index] is out of bounds of this collection.
+ */
+public inline fun CharArray.getOrElse(index: Int, defaultValue: (Int) -> Char): Char {
+    return if (index >= 0 && index <= lastIndex) get(index) else defaultValue(index)
+}
+
+/**
+ * Returns an element at the given [index] or the result of calling the [defaultValue] function if the [index] is out of bounds of this collection.
+ */
+public inline fun DoubleArray.getOrElse(index: Int, defaultValue: (Int) -> Double): Double {
+    return if (index >= 0 && index <= lastIndex) get(index) else defaultValue(index)
+}
+
+/**
+ * Returns an element at the given [index] or the result of calling the [defaultValue] function if the [index] is out of bounds of this collection.
+ */
+public inline fun FloatArray.getOrElse(index: Int, defaultValue: (Int) -> Float): Float {
+    return if (index >= 0 && index <= lastIndex) get(index) else defaultValue(index)
+}
+
+/**
+ * Returns an element at the given [index] or the result of calling the [defaultValue] function if the [index] is out of bounds of this collection.
+ */
+public inline fun IntArray.getOrElse(index: Int, defaultValue: (Int) -> Int): Int {
+    return if (index >= 0 && index <= lastIndex) get(index) else defaultValue(index)
+}
+
+/**
+ * Returns an element at the given [index] or the result of calling the [defaultValue] function if the [index] is out of bounds of this collection.
+ */
+public inline fun LongArray.getOrElse(index: Int, defaultValue: (Int) -> Long): Long {
+    return if (index >= 0 && index <= lastIndex) get(index) else defaultValue(index)
+}
+
+/**
+ * Returns an element at the given [index] or the result of calling the [defaultValue] function if the [index] is out of bounds of this collection.
+ */
+public inline fun ShortArray.getOrElse(index: Int, defaultValue: (Int) -> Short): Short {
+    return if (index >= 0 && index <= lastIndex) get(index) else defaultValue(index)
+}
+
+/**
+ * Returns an element at the given [index] or the result of calling the [defaultValue] function if the [index] is out of bounds of this collection.
+ */
+public inline fun <T> List<T>.getOrElse(index: Int, defaultValue: (Int) -> T): T {
+    return if (index >= 0 && index <= lastIndex) get(index) else defaultValue(index)
+}
+
+/**
+ * Returns an element at the given [index] or the result of calling the [defaultValue] function if the [index] is out of bounds of this collection.
+ */
+public inline fun String.getOrElse(index: Int, defaultValue: (Int) -> Char): Char {
+    return if (index >= 0 && index <= lastIndex) get(index) else defaultValue(index)
+}
+
+/**
+ * Returns an element at the given [index] or `null` if the [index] is out of bounds of this collection.
+ */
+public fun <T> Array<out T>.getOrNull(index: Int): T? {
+    return if (index >= 0 && index <= lastIndex) get(index) else null
+}
+
+/**
+ * Returns an element at the given [index] or `null` if the [index] is out of bounds of this collection.
+ */
+public fun BooleanArray.getOrNull(index: Int): Boolean? {
+    return if (index >= 0 && index <= lastIndex) get(index) else null
+}
+
+/**
+ * Returns an element at the given [index] or `null` if the [index] is out of bounds of this collection.
+ */
+public fun ByteArray.getOrNull(index: Int): Byte? {
+    return if (index >= 0 && index <= lastIndex) get(index) else null
+}
+
+/**
+ * Returns an element at the given [index] or `null` if the [index] is out of bounds of this collection.
+ */
+public fun CharArray.getOrNull(index: Int): Char? {
+    return if (index >= 0 && index <= lastIndex) get(index) else null
+}
+
+/**
+ * Returns an element at the given [index] or `null` if the [index] is out of bounds of this collection.
+ */
+public fun DoubleArray.getOrNull(index: Int): Double? {
+    return if (index >= 0 && index <= lastIndex) get(index) else null
+}
+
+/**
+ * Returns an element at the given [index] or `null` if the [index] is out of bounds of this collection.
+ */
+public fun FloatArray.getOrNull(index: Int): Float? {
+    return if (index >= 0 && index <= lastIndex) get(index) else null
+}
+
+/**
+ * Returns an element at the given [index] or `null` if the [index] is out of bounds of this collection.
+ */
+public fun IntArray.getOrNull(index: Int): Int? {
+    return if (index >= 0 && index <= lastIndex) get(index) else null
+}
+
+/**
+ * Returns an element at the given [index] or `null` if the [index] is out of bounds of this collection.
+ */
+public fun LongArray.getOrNull(index: Int): Long? {
+    return if (index >= 0 && index <= lastIndex) get(index) else null
+}
+
+/**
+ * Returns an element at the given [index] or `null` if the [index] is out of bounds of this collection.
+ */
+public fun ShortArray.getOrNull(index: Int): Short? {
+    return if (index >= 0 && index <= lastIndex) get(index) else null
+}
+
+/**
+ * Returns an element at the given [index] or `null` if the [index] is out of bounds of this collection.
+ */
+public fun <T> List<T>.getOrNull(index: Int): T? {
+    return if (index >= 0 && index <= lastIndex) get(index) else null
+}
+
+/**
+ * Returns an element at the given [index] or `null` if the [index] is out of bounds of this collection.
+ */
+public fun String.getOrNull(index: Int): Char? {
+    return if (index >= 0 && index <= lastIndex) get(index) else null
+}
+
 /**
  * Returns first index of [element], or -1 if the collection does not contain element.
  */
diff --git a/libraries/stdlib/src/generated/_Generators.kt b/libraries/stdlib/src/generated/_Generators.kt
index 899edd8e78c..51ba432eb21 100644
--- a/libraries/stdlib/src/generated/_Generators.kt
+++ b/libraries/stdlib/src/generated/_Generators.kt
@@ -14,11 +14,10 @@ import java.util.Collections // TODO: it's temporary while we have java.util.Col
  * Returns a list of values built from elements of both collections with same indexes using provided [transform]. List has length of shortest collection.
  */
 public inline fun <T, R, V> Array<out T>.merge(array: Array<out R>, transform: (T, R) -> V): List<V> {
-    val first = iterator()
-    val second = array.iterator()
-    val list = ArrayList<V>(Math.min(size(), array.size()))
-    while (first.hasNext() && second.hasNext()) {
-        list.add(transform(first.next(), second.next()))
+    val size = Math.min(size(), array.size())
+    val list = ArrayList<V>(size)
+    for (i in 0..size-1) {
+        list.add(transform(this[i], array[i]))
     }
     return list
 }
@@ -27,11 +26,10 @@ public inline fun <T, R, V> Array<out T>.merge(array: Array<out R>, transform: (
  * Returns a list of values built from elements of both collections with same indexes using provided [transform]. List has length of shortest collection.
  */
 public inline fun <R, V> BooleanArray.merge(array: Array<out R>, transform: (Boolean, R) -> V): List<V> {
-    val first = iterator()
-    val second = array.iterator()
-    val list = ArrayList<V>(Math.min(size(), array.size()))
-    while (first.hasNext() && second.hasNext()) {
-        list.add(transform(first.next(), second.next()))
+    val size = Math.min(size(), array.size())
+    val list = ArrayList<V>(size)
+    for (i in 0..size-1) {
+        list.add(transform(this[i], array[i]))
     }
     return list
 }
@@ -40,11 +38,10 @@ public inline fun <R, V> BooleanArray.merge(array: Array<out R>, transform: (Boo
  * Returns a list of values built from elements of both collections with same indexes using provided [transform]. List has length of shortest collection.
  */
 public inline fun <R, V> ByteArray.merge(array: Array<out R>, transform: (Byte, R) -> V): List<V> {
-    val first = iterator()
-    val second = array.iterator()
-    val list = ArrayList<V>(Math.min(size(), array.size()))
-    while (first.hasNext() && second.hasNext()) {
-        list.add(transform(first.next(), second.next()))
+    val size = Math.min(size(), array.size())
+    val list = ArrayList<V>(size)
+    for (i in 0..size-1) {
+        list.add(transform(this[i], array[i]))
     }
     return list
 }
@@ -53,11 +50,10 @@ public inline fun <R, V> ByteArray.merge(array: Array<out R>, transform: (Byte,
  * Returns a list of values built from elements of both collections with same indexes using provided [transform]. List has length of shortest collection.
  */
 public inline fun <R, V> CharArray.merge(array: Array<out R>, transform: (Char, R) -> V): List<V> {
-    val first = iterator()
-    val second = array.iterator()
-    val list = ArrayList<V>(Math.min(size(), array.size()))
-    while (first.hasNext() && second.hasNext()) {
-        list.add(transform(first.next(), second.next()))
+    val size = Math.min(size(), array.size())
+    val list = ArrayList<V>(size)
+    for (i in 0..size-1) {
+        list.add(transform(this[i], array[i]))
     }
     return list
 }
@@ -66,11 +62,10 @@ public inline fun <R, V> CharArray.merge(array: Array<out R>, transform: (Char,
  * Returns a list of values built from elements of both collections with same indexes using provided [transform]. List has length of shortest collection.
  */
 public inline fun <R, V> DoubleArray.merge(array: Array<out R>, transform: (Double, R) -> V): List<V> {
-    val first = iterator()
-    val second = array.iterator()
-    val list = ArrayList<V>(Math.min(size(), array.size()))
-    while (first.hasNext() && second.hasNext()) {
-        list.add(transform(first.next(), second.next()))
+    val size = Math.min(size(), array.size())
+    val list = ArrayList<V>(size)
+    for (i in 0..size-1) {
+        list.add(transform(this[i], array[i]))
     }
     return list
 }
@@ -79,11 +74,10 @@ public inline fun <R, V> DoubleArray.merge(array: Array<out R>, transform: (Doub
  * Returns a list of values built from elements of both collections with same indexes using provided [transform]. List has length of shortest collection.
  */
 public inline fun <R, V> FloatArray.merge(array: Array<out R>, transform: (Float, R) -> V): List<V> {
-    val first = iterator()
-    val second = array.iterator()
-    val list = ArrayList<V>(Math.min(size(), array.size()))
-    while (first.hasNext() && second.hasNext()) {
-        list.add(transform(first.next(), second.next()))
+    val size = Math.min(size(), array.size())
+    val list = ArrayList<V>(size)
+    for (i in 0..size-1) {
+        list.add(transform(this[i], array[i]))
     }
     return list
 }
@@ -92,11 +86,10 @@ public inline fun <R, V> FloatArray.merge(array: Array<out R>, transform: (Float
  * Returns a list of values built from elements of both collections with same indexes using provided [transform]. List has length of shortest collection.
  */
 public inline fun <R, V> IntArray.merge(array: Array<out R>, transform: (Int, R) -> V): List<V> {
-    val first = iterator()
-    val second = array.iterator()
-    val list = ArrayList<V>(Math.min(size(), array.size()))
-    while (first.hasNext() && second.hasNext()) {
-        list.add(transform(first.next(), second.next()))
+    val size = Math.min(size(), array.size())
+    val list = ArrayList<V>(size)
+    for (i in 0..size-1) {
+        list.add(transform(this[i], array[i]))
     }
     return list
 }
@@ -105,11 +98,10 @@ public inline fun <R, V> IntArray.merge(array: Array<out R>, transform: (Int, R)
  * Returns a list of values built from elements of both collections with same indexes using provided [transform]. List has length of shortest collection.
  */
 public inline fun <R, V> LongArray.merge(array: Array<out R>, transform: (Long, R) -> V): List<V> {
-    val first = iterator()
-    val second = array.iterator()
-    val list = ArrayList<V>(Math.min(size(), array.size()))
-    while (first.hasNext() && second.hasNext()) {
-        list.add(transform(first.next(), second.next()))
+    val size = Math.min(size(), array.size())
+    val list = ArrayList<V>(size)
+    for (i in 0..size-1) {
+        list.add(transform(this[i], array[i]))
     }
     return list
 }
@@ -118,11 +110,10 @@ public inline fun <R, V> LongArray.merge(array: Array<out R>, transform: (Long,
  * Returns a list of values built from elements of both collections with same indexes using provided [transform]. List has length of shortest collection.
  */
 public inline fun <R, V> ShortArray.merge(array: Array<out R>, transform: (Short, R) -> V): List<V> {
-    val first = iterator()
-    val second = array.iterator()
-    val list = ArrayList<V>(Math.min(size(), array.size()))
-    while (first.hasNext() && second.hasNext()) {
-        list.add(transform(first.next(), second.next()))
+    val size = Math.min(size(), array.size())
+    val list = ArrayList<V>(size)
+    for (i in 0..size-1) {
+        list.add(transform(this[i], array[i]))
     }
     return list
 }
@@ -131,11 +122,12 @@ public inline fun <R, V> ShortArray.merge(array: Array<out R>, transform: (Short
  * Returns a list of values built from elements of both collections with same indexes using provided [transform]. List has length of shortest collection.
  */
 public inline fun <T, R, V> Iterable<T>.merge(array: Array<out R>, transform: (T, R) -> V): List<V> {
-    val first = iterator()
-    val second = array.iterator()
-    val list = ArrayList<V>(collectionSizeOrDefault(10))
-    while (first.hasNext() && second.hasNext()) {
-        list.add(transform(first.next(), second.next()))
+    val arraySize = array.size()
+    val list = ArrayList<V>(Math.min(collectionSizeOrDefault(10), arraySize))
+    var i = 0
+    for (element in this) {
+        if (i >= arraySize) break
+        list.add(transform(element, array[i++]))
     }
     return list
 }
@@ -144,11 +136,10 @@ public inline fun <T, R, V> Iterable<T>.merge(array: Array<out R>, transform: (T
  * Returns a list of values built from elements of both collections with same indexes using provided [transform]. List has length of shortest collection.
  */
 public inline fun <V> BooleanArray.merge(array: BooleanArray, transform: (Boolean, Boolean) -> V): List<V> {
-    val first = iterator()
-    val second = array.iterator()
-    val list = ArrayList<V>(Math.min(size(), array.size()))
-    while (first.hasNext() && second.hasNext()) {
-        list.add(transform(first.next(), second.next()))
+    val size = Math.min(size(), array.size())
+    val list = ArrayList<V>(size)
+    for (i in 0..size-1) {
+        list.add(transform(this[i], array[i]))
     }
     return list
 }
@@ -157,11 +148,10 @@ public inline fun <V> BooleanArray.merge(array: BooleanArray, transform: (Boolea
  * Returns a list of values built from elements of both collections with same indexes using provided [transform]. List has length of shortest collection.
  */
 public inline fun <V> ByteArray.merge(array: ByteArray, transform: (Byte, Byte) -> V): List<V> {
-    val first = iterator()
-    val second = array.iterator()
-    val list = ArrayList<V>(Math.min(size(), array.size()))
-    while (first.hasNext() && second.hasNext()) {
-        list.add(transform(first.next(), second.next()))
+    val size = Math.min(size(), array.size())
+    val list = ArrayList<V>(size)
+    for (i in 0..size-1) {
+        list.add(transform(this[i], array[i]))
     }
     return list
 }
@@ -170,11 +160,10 @@ public inline fun <V> ByteArray.merge(array: ByteArray, transform: (Byte, Byte)
  * Returns a list of values built from elements of both collections with same indexes using provided [transform]. List has length of shortest collection.
  */
 public inline fun <V> CharArray.merge(array: CharArray, transform: (Char, Char) -> V): List<V> {
-    val first = iterator()
-    val second = array.iterator()
-    val list = ArrayList<V>(Math.min(size(), array.size()))
-    while (first.hasNext() && second.hasNext()) {
-        list.add(transform(first.next(), second.next()))
+    val size = Math.min(size(), array.size())
+    val list = ArrayList<V>(size)
+    for (i in 0..size-1) {
+        list.add(transform(this[i], array[i]))
     }
     return list
 }
@@ -183,11 +172,10 @@ public inline fun <V> CharArray.merge(array: CharArray, transform: (Char, Char)
  * Returns a list of values built from elements of both collections with same indexes using provided [transform]. List has length of shortest collection.
  */
 public inline fun <V> DoubleArray.merge(array: DoubleArray, transform: (Double, Double) -> V): List<V> {
-    val first = iterator()
-    val second = array.iterator()
-    val list = ArrayList<V>(Math.min(size(), array.size()))
-    while (first.hasNext() && second.hasNext()) {
-        list.add(transform(first.next(), second.next()))
+    val size = Math.min(size(), array.size())
+    val list = ArrayList<V>(size)
+    for (i in 0..size-1) {
+        list.add(transform(this[i], array[i]))
     }
     return list
 }
@@ -196,11 +184,10 @@ public inline fun <V> DoubleArray.merge(array: DoubleArray, transform: (Double,
  * Returns a list of values built from elements of both collections with same indexes using provided [transform]. List has length of shortest collection.
  */
 public inline fun <V> FloatArray.merge(array: FloatArray, transform: (Float, Float) -> V): List<V> {
-    val first = iterator()
-    val second = array.iterator()
-    val list = ArrayList<V>(Math.min(size(), array.size()))
-    while (first.hasNext() && second.hasNext()) {
-        list.add(transform(first.next(), second.next()))
+    val size = Math.min(size(), array.size())
+    val list = ArrayList<V>(size)
+    for (i in 0..size-1) {
+        list.add(transform(this[i], array[i]))
     }
     return list
 }
@@ -209,11 +196,10 @@ public inline fun <V> FloatArray.merge(array: FloatArray, transform: (Float, Flo
  * Returns a list of values built from elements of both collections with same indexes using provided [transform]. List has length of shortest collection.
  */
 public inline fun <V> IntArray.merge(array: IntArray, transform: (Int, Int) -> V): List<V> {
-    val first = iterator()
-    val second = array.iterator()
-    val list = ArrayList<V>(Math.min(size(), array.size()))
-    while (first.hasNext() && second.hasNext()) {
-        list.add(transform(first.next(), second.next()))
+    val size = Math.min(size(), array.size())
+    val list = ArrayList<V>(size)
+    for (i in 0..size-1) {
+        list.add(transform(this[i], array[i]))
     }
     return list
 }
@@ -222,11 +208,10 @@ public inline fun <V> IntArray.merge(array: IntArray, transform: (Int, Int) -> V
  * Returns a list of values built from elements of both collections with same indexes using provided [transform]. List has length of shortest collection.
  */
 public inline fun <V> LongArray.merge(array: LongArray, transform: (Long, Long) -> V): List<V> {
-    val first = iterator()
-    val second = array.iterator()
-    val list = ArrayList<V>(Math.min(size(), array.size()))
-    while (first.hasNext() && second.hasNext()) {
-        list.add(transform(first.next(), second.next()))
+    val size = Math.min(size(), array.size())
+    val list = ArrayList<V>(size)
+    for (i in 0..size-1) {
+        list.add(transform(this[i], array[i]))
     }
     return list
 }
@@ -235,11 +220,10 @@ public inline fun <V> LongArray.merge(array: LongArray, transform: (Long, Long)
  * Returns a list of values built from elements of both collections with same indexes using provided [transform]. List has length of shortest collection.
  */
 public inline fun <V> ShortArray.merge(array: ShortArray, transform: (Short, Short) -> V): List<V> {
-    val first = iterator()
-    val second = array.iterator()
-    val list = ArrayList<V>(Math.min(size(), array.size()))
-    while (first.hasNext() && second.hasNext()) {
-        list.add(transform(first.next(), second.next()))
+    val size = Math.min(size(), array.size())
+    val list = ArrayList<V>(size)
+    for (i in 0..size-1) {
+        list.add(transform(this[i], array[i]))
     }
     return list
 }
@@ -248,11 +232,12 @@ public inline fun <V> ShortArray.merge(array: ShortArray, transform: (Short, Sho
  * Returns a list of values built from elements of both collections with same indexes using provided [transform]. List has length of shortest collection.
  */
 public inline fun <T, R, V> Array<out T>.merge(other: Iterable<R>, transform: (T, R) -> V): List<V> {
-    val first = iterator()
-    val second = other.iterator()
-    val list = ArrayList<V>(size())
-    while (first.hasNext() && second.hasNext()) {
-        list.add(transform(first.next(), second.next()))
+    val arraySize = size()
+    val list = ArrayList<V>(Math.min(other.collectionSizeOrDefault(10), arraySize))
+    var i = 0
+    for (element in other) {
+        if (i >= arraySize) break
+        list.add(transform(this[i++], element))
     }
     return list
 }
@@ -261,11 +246,12 @@ public inline fun <T, R, V> Array<out T>.merge(other: Iterable<R>, transform: (T
  * Returns a list of values built from elements of both collections with same indexes using provided [transform]. List has length of shortest collection.
  */
 public inline fun <R, V> BooleanArray.merge(other: Iterable<R>, transform: (Boolean, R) -> V): List<V> {
-    val first = iterator()
-    val second = other.iterator()
-    val list = ArrayList<V>(size())
-    while (first.hasNext() && second.hasNext()) {
-        list.add(transform(first.next(), second.next()))
+    val arraySize = size()
+    val list = ArrayList<V>(Math.min(other.collectionSizeOrDefault(10), arraySize))
+    var i = 0
+    for (element in other) {
+        if (i >= arraySize) break
+        list.add(transform(this[i++], element))
     }
     return list
 }
@@ -274,11 +260,12 @@ public inline fun <R, V> BooleanArray.merge(other: Iterable<R>, transform: (Bool
  * Returns a list of values built from elements of both collections with same indexes using provided [transform]. List has length of shortest collection.
  */
 public inline fun <R, V> ByteArray.merge(other: Iterable<R>, transform: (Byte, R) -> V): List<V> {
-    val first = iterator()
-    val second = other.iterator()
-    val list = ArrayList<V>(size())
-    while (first.hasNext() && second.hasNext()) {
-        list.add(transform(first.next(), second.next()))
+    val arraySize = size()
+    val list = ArrayList<V>(Math.min(other.collectionSizeOrDefault(10), arraySize))
+    var i = 0
+    for (element in other) {
+        if (i >= arraySize) break
+        list.add(transform(this[i++], element))
     }
     return list
 }
@@ -287,11 +274,12 @@ public inline fun <R, V> ByteArray.merge(other: Iterable<R>, transform: (Byte, R
  * Returns a list of values built from elements of both collections with same indexes using provided [transform]. List has length of shortest collection.
  */
 public inline fun <R, V> CharArray.merge(other: Iterable<R>, transform: (Char, R) -> V): List<V> {
-    val first = iterator()
-    val second = other.iterator()
-    val list = ArrayList<V>(size())
-    while (first.hasNext() && second.hasNext()) {
-        list.add(transform(first.next(), second.next()))
+    val arraySize = size()
+    val list = ArrayList<V>(Math.min(other.collectionSizeOrDefault(10), arraySize))
+    var i = 0
+    for (element in other) {
+        if (i >= arraySize) break
+        list.add(transform(this[i++], element))
     }
     return list
 }
@@ -300,11 +288,12 @@ public inline fun <R, V> CharArray.merge(other: Iterable<R>, transform: (Char, R
  * Returns a list of values built from elements of both collections with same indexes using provided [transform]. List has length of shortest collection.
  */
 public inline fun <R, V> DoubleArray.merge(other: Iterable<R>, transform: (Double, R) -> V): List<V> {
-    val first = iterator()
-    val second = other.iterator()
-    val list = ArrayList<V>(size())
-    while (first.hasNext() && second.hasNext()) {
-        list.add(transform(first.next(), second.next()))
+    val arraySize = size()
+    val list = ArrayList<V>(Math.min(other.collectionSizeOrDefault(10), arraySize))
+    var i = 0
+    for (element in other) {
+        if (i >= arraySize) break
+        list.add(transform(this[i++], element))
     }
     return list
 }
@@ -313,11 +302,12 @@ public inline fun <R, V> DoubleArray.merge(other: Iterable<R>, transform: (Doubl
  * Returns a list of values built from elements of both collections with same indexes using provided [transform]. List has length of shortest collection.
  */
 public inline fun <R, V> FloatArray.merge(other: Iterable<R>, transform: (Float, R) -> V): List<V> {
-    val first = iterator()
-    val second = other.iterator()
-    val list = ArrayList<V>(size())
-    while (first.hasNext() && second.hasNext()) {
-        list.add(transform(first.next(), second.next()))
+    val arraySize = size()
+    val list = ArrayList<V>(Math.min(other.collectionSizeOrDefault(10), arraySize))
+    var i = 0
+    for (element in other) {
+        if (i >= arraySize) break
+        list.add(transform(this[i++], element))
     }
     return list
 }
@@ -326,11 +316,12 @@ public inline fun <R, V> FloatArray.merge(other: Iterable<R>, transform: (Float,
  * Returns a list of values built from elements of both collections with same indexes using provided [transform]. List has length of shortest collection.
  */
 public inline fun <R, V> IntArray.merge(other: Iterable<R>, transform: (Int, R) -> V): List<V> {
-    val first = iterator()
-    val second = other.iterator()
-    val list = ArrayList<V>(size())
-    while (first.hasNext() && second.hasNext()) {
-        list.add(transform(first.next(), second.next()))
+    val arraySize = size()
+    val list = ArrayList<V>(Math.min(other.collectionSizeOrDefault(10), arraySize))
+    var i = 0
+    for (element in other) {
+        if (i >= arraySize) break
+        list.add(transform(this[i++], element))
     }
     return list
 }
@@ -339,11 +330,12 @@ public inline fun <R, V> IntArray.merge(other: Iterable<R>, transform: (Int, R)
  * Returns a list of values built from elements of both collections with same indexes using provided [transform]. List has length of shortest collection.
  */
 public inline fun <R, V> LongArray.merge(other: Iterable<R>, transform: (Long, R) -> V): List<V> {
-    val first = iterator()
-    val second = other.iterator()
-    val list = ArrayList<V>(size())
-    while (first.hasNext() && second.hasNext()) {
-        list.add(transform(first.next(), second.next()))
+    val arraySize = size()
+    val list = ArrayList<V>(Math.min(other.collectionSizeOrDefault(10), arraySize))
+    var i = 0
+    for (element in other) {
+        if (i >= arraySize) break
+        list.add(transform(this[i++], element))
     }
     return list
 }
@@ -352,11 +344,12 @@ public inline fun <R, V> LongArray.merge(other: Iterable<R>, transform: (Long, R
  * Returns a list of values built from elements of both collections with same indexes using provided [transform]. List has length of shortest collection.
  */
 public inline fun <R, V> ShortArray.merge(other: Iterable<R>, transform: (Short, R) -> V): List<V> {
-    val first = iterator()
-    val second = other.iterator()
-    val list = ArrayList<V>(size())
-    while (first.hasNext() && second.hasNext()) {
-        list.add(transform(first.next(), second.next()))
+    val arraySize = size()
+    val list = ArrayList<V>(Math.min(other.collectionSizeOrDefault(10), arraySize))
+    var i = 0
+    for (element in other) {
+        if (i >= arraySize) break
+        list.add(transform(this[i++], element))
     }
     return list
 }
@@ -367,7 +360,7 @@ public inline fun <R, V> ShortArray.merge(other: Iterable<R>, transform: (Short,
 public inline fun <T, R, V> Iterable<T>.merge(other: Iterable<R>, transform: (T, R) -> V): List<V> {
     val first = iterator()
     val second = other.iterator()
-    val list = ArrayList<V>(collectionSizeOrDefault(10))
+    val list = ArrayList<V>(Math.min(collectionSizeOrDefault(10), other.collectionSizeOrDefault(10)))
     while (first.hasNext() && second.hasNext()) {
         list.add(transform(first.next(), second.next()))
     }
@@ -382,7 +375,147 @@ public fun <T, R, V> Sequence<T>.merge(sequence: Sequence<R>, transform: (T, R)
 }
 
 /**
- * Splits original collection into pair of collections,
+ * Returns a list containing all elements of the original collection except the elements contained in the given [array].
+ */
+public fun <T> Iterable<T>.minus(array: Array<out T>): List<T> {
+    if (array.isEmpty()) return this.toList()
+    val other = array.toHashSet()
+    return this.filterNot { it in other }
+}
+
+/**
+ * Returns a sequence containing all elements of original sequence except the elements contained in the given [array].
+ * Note that the source sequence and the array being subtracted are iterated only when an `iterator` is requested from
+ * the resulting sequence. Changing any of them between successive calls to `iterator` may affect the result.
+ */
+public fun <T> Sequence<T>.minus(array: Array<out T>): Sequence<T> {
+    if (array.isEmpty()) return this
+    return object: Sequence<T> {
+        override fun iterator(): Iterator<T> {
+            val other = array.toHashSet()
+            return this@minus.filterNot { it in other }.iterator()
+        }
+    }
+}
+
+/**
+ * Returns a set containing all elements of the original set except the elements contained in the given [array].
+ */
+public fun <T> Set<T>.minus(array: Array<out T>): Set<T> {
+    val result = LinkedHashSet<T>(this)
+    result.removeAll(array)
+    return result
+}
+
+/**
+ * Returns a list containing all elements of the original collection except the elements contained in the given [collection].
+ */
+public fun <T> Iterable<T>.minus(collection: Iterable<T>): List<T> {
+    val other = collection.convertToSetForSetOperationWith(this)
+    if (other.isEmpty())
+        return this.toList()
+    return this.filterNot { it in other }
+}
+
+/**
+ * Returns a sequence containing all elements of original sequence except the elements contained in the given [collection].
+ * Note that the source sequence and the collection being subtracted are iterated only when an `iterator` is requested from
+ * the resulting sequence. Changing any of them between successive calls to `iterator` may affect the result.
+ */
+public fun <T> Sequence<T>.minus(collection: Iterable<T>): Sequence<T> {
+    return object: Sequence<T> {
+        override fun iterator(): Iterator<T> {
+            val other = collection.convertToSetForSetOperation()
+            if (other.isEmpty())
+                return this@minus.iterator()
+            else
+                return this@minus.filterNot { it in other }.iterator()
+        }
+    }
+}
+
+/**
+ * Returns a set containing all elements of the original set except the elements contained in the given [collection].
+ */
+public fun <T> Set<T>.minus(collection: Iterable<T>): Set<T> {
+    val other = collection.convertToSetForSetOperationWith(this)
+    if (other.isEmpty())
+        return this.toSet()
+    if (other is Set)
+        return this.filterNotTo(LinkedHashSet<T>()) { it in other }
+    val result = LinkedHashSet<T>(this)
+    result.removeAll(other)
+    return result
+}
+
+/**
+ * Returns a list containing all elements of the original collection without the first occurrence of the given [element].
+ */
+public fun <T> Iterable<T>.minus(element: T): List<T> {
+    val result = ArrayList<T>(collectionSizeOrDefault(10))
+    var removed = false
+    return this.filterTo(result) { if (!removed && it == element) { removed = true; false } else true }
+}
+
+/**
+ * Returns a sequence containing all elements of the original sequence without the first occurrence of the given [element].
+ */
+public fun <T> Sequence<T>.minus(element: T): Sequence<T> {
+    return object: Sequence<T> {
+        override fun iterator(): Iterator<T> {
+            var removed = false
+            return this@minus.filter { if (!removed && it == element) { removed = true; false } else true }.iterator()
+        }
+    }
+}
+
+/**
+ * Returns a set containing all elements of the original set except the given [element].
+ */
+public fun <T> Set<T>.minus(element: T): Set<T> {
+    val result = LinkedHashSet<T>(mapCapacity(size()))
+    var removed = false
+    return this.filterTo(result) { if (!removed && it == element) { removed = true; false } else true }
+}
+
+/**
+ * Returns a list containing all elements of the original collection except the elements contained in the given [sequence].
+ */
+public fun <T> Iterable<T>.minus(sequence: Sequence<T>): List<T> {
+    val other = sequence.toHashSet()
+    if (other.isEmpty())
+        return this.toList()
+    return this.filterNot { it in other }
+}
+
+/**
+ * Returns a sequence containing all elements of original sequence except the elements contained in the given [sequence].
+ * Note that the source sequence and the sequence being subtracted are iterated only when an `iterator` is requested from
+ * the resulting sequence. Changing any of them between successive calls to `iterator` may affect the result.
+ */
+public fun <T> Sequence<T>.minus(sequence: Sequence<T>): Sequence<T> {
+    return object: Sequence<T> {
+        override fun iterator(): Iterator<T> {
+            val other = sequence.toHashSet()
+            if (other.isEmpty())
+                return this@minus.iterator()
+            else
+                return this@minus.filterNot { it in other }.iterator()
+        }
+    }
+}
+
+/**
+ * Returns a set containing all elements of the original set except the elements contained in the given [sequence].
+ */
+public fun <T> Set<T>.minus(sequence: Sequence<T>): Set<T> {
+    val result = LinkedHashSet<T>(this)
+    result.removeAll(sequence)
+    return result
+}
+
+/**
+ * Splits the original collection into pair of collections,
  * where *first* collection contains elements for which [predicate] yielded `true`,
  * while *second* collection contains elements for which [predicate] yielded `false`.
  */
@@ -400,7 +533,7 @@ public inline fun <T> Array<out T>.partition(predicate: (T) -> Boolean): Pair<Li
 }
 
 /**
- * Splits original collection into pair of collections,
+ * Splits the original collection into pair of collections,
  * where *first* collection contains elements for which [predicate] yielded `true`,
  * while *second* collection contains elements for which [predicate] yielded `false`.
  */
@@ -418,7 +551,7 @@ public inline fun BooleanArray.partition(predicate: (Boolean) -> Boolean): Pair<
 }
 
 /**
- * Splits original collection into pair of collections,
+ * Splits the original collection into pair of collections,
  * where *first* collection contains elements for which [predicate] yielded `true`,
  * while *second* collection contains elements for which [predicate] yielded `false`.
  */
@@ -436,7 +569,7 @@ public inline fun ByteArray.partition(predicate: (Byte) -> Boolean): Pair<List<B
 }
 
 /**
- * Splits original collection into pair of collections,
+ * Splits the original collection into pair of collections,
  * where *first* collection contains elements for which [predicate] yielded `true`,
  * while *second* collection contains elements for which [predicate] yielded `false`.
  */
@@ -454,7 +587,7 @@ public inline fun CharArray.partition(predicate: (Char) -> Boolean): Pair<List<C
 }
 
 /**
- * Splits original collection into pair of collections,
+ * Splits the original collection into pair of collections,
  * where *first* collection contains elements for which [predicate] yielded `true`,
  * while *second* collection contains elements for which [predicate] yielded `false`.
  */
@@ -472,7 +605,7 @@ public inline fun DoubleArray.partition(predicate: (Double) -> Boolean): Pair<Li
 }
 
 /**
- * Splits original collection into pair of collections,
+ * Splits the original collection into pair of collections,
  * where *first* collection contains elements for which [predicate] yielded `true`,
  * while *second* collection contains elements for which [predicate] yielded `false`.
  */
@@ -490,7 +623,7 @@ public inline fun FloatArray.partition(predicate: (Float) -> Boolean): Pair<List
 }
 
 /**
- * Splits original collection into pair of collections,
+ * Splits the original collection into pair of collections,
  * where *first* collection contains elements for which [predicate] yielded `true`,
  * while *second* collection contains elements for which [predicate] yielded `false`.
  */
@@ -508,7 +641,7 @@ public inline fun IntArray.partition(predicate: (Int) -> Boolean): Pair<List<Int
 }
 
 /**
- * Splits original collection into pair of collections,
+ * Splits the original collection into pair of collections,
  * where *first* collection contains elements for which [predicate] yielded `true`,
  * while *second* collection contains elements for which [predicate] yielded `false`.
  */
@@ -526,7 +659,7 @@ public inline fun LongArray.partition(predicate: (Long) -> Boolean): Pair<List<L
 }
 
 /**
- * Splits original collection into pair of collections,
+ * Splits the original collection into pair of collections,
  * where *first* collection contains elements for which [predicate] yielded `true`,
  * while *second* collection contains elements for which [predicate] yielded `false`.
  */
@@ -544,7 +677,7 @@ public inline fun ShortArray.partition(predicate: (Short) -> Boolean): Pair<List
 }
 
 /**
- * Splits original collection into pair of collections,
+ * Splits the original collection into pair of collections,
  * where *first* collection contains elements for which [predicate] yielded `true`,
  * while *second* collection contains elements for which [predicate] yielded `false`.
  */
@@ -562,7 +695,7 @@ public inline fun <T> Iterable<T>.partition(predicate: (T) -> Boolean): Pair<Lis
 }
 
 /**
- * Splits original collection into pair of collections,
+ * Splits the original collection into pair of collections,
  * where *first* collection contains elements for which [predicate] yielded `true`,
  * while *second* collection contains elements for which [predicate] yielded `false`.
  */
@@ -580,9 +713,9 @@ public inline fun <T> Sequence<T>.partition(predicate: (T) -> Boolean): Pair<Lis
 }
 
 /**
- * Splits original collection into pair of collections,
- * where *first* collection contains elements for which [predicate] yielded `true`,
- * while *second* collection contains elements for which [predicate] yielded `false`.
+ * Splits the original string into pair of strings,
+ * where *first* string contains characters for which [predicate] yielded `true`,
+ * while *second* string contains characters for which [predicate] yielded `false`.
  */
 public inline fun String.partition(predicate: (Char) -> Boolean): Pair<String, String> {
     val first = StringBuilder()
@@ -598,326 +731,168 @@ public inline fun String.partition(predicate: (Char) -> Boolean): Pair<String, S
 }
 
 /**
- * Returns a list containing all elements of original collection and then all elements of the given [array].
+ * Returns a list containing all elements of the original collection and then all elements of the given [array].
  */
-public fun <T> Array<out T>.plus(array: Array<out T>): List<T> {
-    val answer = ArrayList<T>(size() + array.size())
-    for (thisElement in this) answer.add(thisElement)
-    answer.addAll(array)
-    return answer
+public fun <T> Collection<T>.plus(array: Array<out T>): List<T> {
+    val result = ArrayList<T>(this.size() + array.size())
+    result.addAll(this)
+    result.addAll(array)
+    return result
 }
 
 /**
- * Returns a list containing all elements of original collection and then all elements of the given [array].
- */
-public fun BooleanArray.plus(array: Array<out Boolean>): List<Boolean> {
-    val answer = ArrayList<Boolean>(size() + array.size())
-    for (thisElement in this) answer.add(thisElement)
-    answer.addAll(array)
-    return answer
-}
-
-/**
- * Returns a list containing all elements of original collection and then all elements of the given [array].
- */
-public fun ByteArray.plus(array: Array<out Byte>): List<Byte> {
-    val answer = ArrayList<Byte>(size() + array.size())
-    for (thisElement in this) answer.add(thisElement)
-    answer.addAll(array)
-    return answer
-}
-
-/**
- * Returns a list containing all elements of original collection and then all elements of the given [array].
- */
-public fun CharArray.plus(array: Array<out Char>): List<Char> {
-    val answer = ArrayList<Char>(size() + array.size())
-    for (thisElement in this) answer.add(thisElement)
-    answer.addAll(array)
-    return answer
-}
-
-/**
- * Returns a list containing all elements of original collection and then all elements of the given [array].
- */
-public fun DoubleArray.plus(array: Array<out Double>): List<Double> {
-    val answer = ArrayList<Double>(size() + array.size())
-    for (thisElement in this) answer.add(thisElement)
-    answer.addAll(array)
-    return answer
-}
-
-/**
- * Returns a list containing all elements of original collection and then all elements of the given [array].
- */
-public fun FloatArray.plus(array: Array<out Float>): List<Float> {
-    val answer = ArrayList<Float>(size() + array.size())
-    for (thisElement in this) answer.add(thisElement)
-    answer.addAll(array)
-    return answer
-}
-
-/**
- * Returns a list containing all elements of original collection and then all elements of the given [array].
- */
-public fun IntArray.plus(array: Array<out Int>): List<Int> {
-    val answer = ArrayList<Int>(size() + array.size())
-    for (thisElement in this) answer.add(thisElement)
-    answer.addAll(array)
-    return answer
-}
-
-/**
- * Returns a list containing all elements of original collection and then all elements of the given [array].
- */
-public fun LongArray.plus(array: Array<out Long>): List<Long> {
-    val answer = ArrayList<Long>(size() + array.size())
-    for (thisElement in this) answer.add(thisElement)
-    answer.addAll(array)
-    return answer
-}
-
-/**
- * Returns a list containing all elements of original collection and then all elements of the given [array].
- */
-public fun ShortArray.plus(array: Array<out Short>): List<Short> {
-    val answer = ArrayList<Short>(size() + array.size())
-    for (thisElement in this) answer.add(thisElement)
-    answer.addAll(array)
-    return answer
-}
-
-/**
- * Returns a list containing all elements of original collection and then all elements of the given [array].
+ * Returns a list containing all elements of the original collection and then all elements of the given [array].
  */
 public fun <T> Iterable<T>.plus(array: Array<out T>): List<T> {
-    val answer = ArrayList<T>(collectionSizeOrDefault(10) + array.size())
-    for (thisElement in this) answer.add(thisElement)
-    answer.addAll(array)
-    return answer
+    if (this is Collection) return this.plus(array)
+    val result = ArrayList<T>()
+    result.addAll(this)
+    result.addAll(array)
+    return result
 }
 
 /**
- * Returns a list containing all elements of original collection and then all elements of the given [collection].
+ * Returns a sequence containing all elements of original sequence and then all elements of the given [array].
+ * Note that the source sequence and the array being added are iterated only when an `iterator` is requested from
+ * the resulting sequence. Changing any of them between successive calls to `iterator` may affect the result.
  */
-public fun <T> Array<out T>.plus(collection: Iterable<T>): List<T> {
-    val answer = ArrayList<T>(size() + collection.collectionSizeOrDefault(10))
-    for (thisElement in this) answer.add(thisElement)
-    answer.addAll(collection)
-    return answer
+public fun <T> Sequence<T>.plus(array: Array<out T>): Sequence<T> {
+    return this.plus(array.asList())
 }
 
 /**
- * Returns a list containing all elements of original collection and then all elements of the given [collection].
+ * Returns a set containing all elements both of the original set and the given [array].
  */
-public fun BooleanArray.plus(collection: Iterable<Boolean>): List<Boolean> {
-    val answer = ArrayList<Boolean>(size() + collection.collectionSizeOrDefault(10))
-    for (thisElement in this) answer.add(thisElement)
-    answer.addAll(collection)
-    return answer
+public fun <T> Set<T>.plus(array: Array<out T>): Set<T> {
+    val result = LinkedHashSet<T>(mapCapacity(this.size() + array.size()))
+    result.addAll(this)
+    result.addAll(array)
+    return result
 }
 
 /**
- * Returns a list containing all elements of original collection and then all elements of the given [collection].
+ * Returns a list containing all elements of the original collection and then all elements of the given [collection].
  */
-public fun ByteArray.plus(collection: Iterable<Byte>): List<Byte> {
-    val answer = ArrayList<Byte>(size() + collection.collectionSizeOrDefault(10))
-    for (thisElement in this) answer.add(thisElement)
-    answer.addAll(collection)
-    return answer
+public fun <T> Collection<T>.plus(collection: Iterable<T>): List<T> {
+    if (collection is Collection) {
+        val result = ArrayList<T>(this.size() + collection.size())
+        result.addAll(this)
+        result.addAll(collection)
+        return result
+    } else {
+        val result = ArrayList<T>(this)
+        result.addAll(collection)
+        return result
+    }
 }
 
 /**
- * Returns a list containing all elements of original collection and then all elements of the given [collection].
- */
-public fun CharArray.plus(collection: Iterable<Char>): List<Char> {
-    val answer = ArrayList<Char>(size() + collection.collectionSizeOrDefault(10))
-    for (thisElement in this) answer.add(thisElement)
-    answer.addAll(collection)
-    return answer
-}
-
-/**
- * Returns a list containing all elements of original collection and then all elements of the given [collection].
- */
-public fun DoubleArray.plus(collection: Iterable<Double>): List<Double> {
-    val answer = ArrayList<Double>(size() + collection.collectionSizeOrDefault(10))
-    for (thisElement in this) answer.add(thisElement)
-    answer.addAll(collection)
-    return answer
-}
-
-/**
- * Returns a list containing all elements of original collection and then all elements of the given [collection].
- */
-public fun FloatArray.plus(collection: Iterable<Float>): List<Float> {
-    val answer = ArrayList<Float>(size() + collection.collectionSizeOrDefault(10))
-    for (thisElement in this) answer.add(thisElement)
-    answer.addAll(collection)
-    return answer
-}
-
-/**
- * Returns a list containing all elements of original collection and then all elements of the given [collection].
- */
-public fun IntArray.plus(collection: Iterable<Int>): List<Int> {
-    val answer = ArrayList<Int>(size() + collection.collectionSizeOrDefault(10))
-    for (thisElement in this) answer.add(thisElement)
-    answer.addAll(collection)
-    return answer
-}
-
-/**
- * Returns a list containing all elements of original collection and then all elements of the given [collection].
- */
-public fun LongArray.plus(collection: Iterable<Long>): List<Long> {
-    val answer = ArrayList<Long>(size() + collection.collectionSizeOrDefault(10))
-    for (thisElement in this) answer.add(thisElement)
-    answer.addAll(collection)
-    return answer
-}
-
-/**
- * Returns a list containing all elements of original collection and then all elements of the given [collection].
- */
-public fun ShortArray.plus(collection: Iterable<Short>): List<Short> {
-    val answer = ArrayList<Short>(size() + collection.collectionSizeOrDefault(10))
-    for (thisElement in this) answer.add(thisElement)
-    answer.addAll(collection)
-    return answer
-}
-
-/**
- * Returns a list containing all elements of original collection and then all elements of the given [collection].
+ * Returns a list containing all elements of the original collection and then all elements of the given [collection].
  */
 public fun <T> Iterable<T>.plus(collection: Iterable<T>): List<T> {
-    val answer = ArrayList<T>(collectionSizeOrDefault(10) + collection.collectionSizeOrDefault(10))
-    for (thisElement in this) answer.add(thisElement)
-    answer.addAll(collection)
-    return answer
+    if (this is Collection) return this.plus(collection)
+    val result = ArrayList<T>()
+    result.addAll(this)
+    result.addAll(collection)
+    return result
 }
 
 /**
  * Returns a sequence containing all elements of original sequence and then all elements of the given [collection].
+ * Note that the source sequence and the collection being added are iterated only when an `iterator` is requested from
+ * the resulting sequence. Changing any of them between successive calls to `iterator` may affect the result.
  */
 public fun <T> Sequence<T>.plus(collection: Iterable<T>): Sequence<T> {
     return sequenceOf(this, collection.asSequence()).flatten()
 }
 
 /**
- * Returns a list containing all elements of original collection and then the given [element].
+ * Returns a set containing all elements both of the original set and the given [collection].
  */
-public fun <T> Array<out T>.plus(element: T): List<T> {
-    val answer = ArrayList<T>(size()+1)
-    for (thisElement in this) answer.add(thisElement)
-    answer.add(element)
-    return answer
+public fun <T> Set<T>.plus(collection: Iterable<T>): Set<T> {
+    val result = LinkedHashSet<T>(mapCapacity(collection.collectionSizeOrNull()?.let { this.size() + it } ?: this.size() * 2))
+    result.addAll(this)
+    result.addAll(collection)
+    return result
 }
 
 /**
- * Returns a list containing all elements of original collection and then the given [element].
+ * Returns a list containing all elements of the original collection and then the given [element].
  */
-public fun BooleanArray.plus(element: Boolean): List<Boolean> {
-    val answer = ArrayList<Boolean>(size()+1)
-    for (thisElement in this) answer.add(thisElement)
-    answer.add(element)
-    return answer
+public fun <T> Collection<T>.plus(element: T): List<T> {
+    val result = ArrayList<T>(size() + 1)
+    result.addAll(this)
+    result.add(element)
+    return result
 }
 
 /**
- * Returns a list containing all elements of original collection and then the given [element].
- */
-public fun ByteArray.plus(element: Byte): List<Byte> {
-    val answer = ArrayList<Byte>(size()+1)
-    for (thisElement in this) answer.add(thisElement)
-    answer.add(element)
-    return answer
-}
-
-/**
- * Returns a list containing all elements of original collection and then the given [element].
- */
-public fun CharArray.plus(element: Char): List<Char> {
-    val answer = ArrayList<Char>(size()+1)
-    for (thisElement in this) answer.add(thisElement)
-    answer.add(element)
-    return answer
-}
-
-/**
- * Returns a list containing all elements of original collection and then the given [element].
- */
-public fun DoubleArray.plus(element: Double): List<Double> {
-    val answer = ArrayList<Double>(size()+1)
-    for (thisElement in this) answer.add(thisElement)
-    answer.add(element)
-    return answer
-}
-
-/**
- * Returns a list containing all elements of original collection and then the given [element].
- */
-public fun FloatArray.plus(element: Float): List<Float> {
-    val answer = ArrayList<Float>(size()+1)
-    for (thisElement in this) answer.add(thisElement)
-    answer.add(element)
-    return answer
-}
-
-/**
- * Returns a list containing all elements of original collection and then the given [element].
- */
-public fun IntArray.plus(element: Int): List<Int> {
-    val answer = ArrayList<Int>(size()+1)
-    for (thisElement in this) answer.add(thisElement)
-    answer.add(element)
-    return answer
-}
-
-/**
- * Returns a list containing all elements of original collection and then the given [element].
- */
-public fun LongArray.plus(element: Long): List<Long> {
-    val answer = ArrayList<Long>(size()+1)
-    for (thisElement in this) answer.add(thisElement)
-    answer.add(element)
-    return answer
-}
-
-/**
- * Returns a list containing all elements of original collection and then the given [element].
- */
-public fun ShortArray.plus(element: Short): List<Short> {
-    val answer = ArrayList<Short>(size()+1)
-    for (thisElement in this) answer.add(thisElement)
-    answer.add(element)
-    return answer
-}
-
-/**
- * Returns a list containing all elements of original collection and then the given [element].
+ * Returns a list containing all elements of the original collection and then the given [element].
  */
 public fun <T> Iterable<T>.plus(element: T): List<T> {
-    val answer = ArrayList<T>(collectionSizeOrNull()?.let { it + 1 } ?: 10)
-    for (thisElement in this) answer.add(thisElement)
-    answer.add(element)
-    return answer
+    if (this is Collection) return this.plus(element)
+    val result = ArrayList<T>()
+    result.addAll(this)
+    result.add(element)
+    return result
 }
 
 /**
- * Returns a sequence containing all elements of original sequence and then the given [element].
+ * Returns a sequence containing all elements of the original sequence and then the given [element].
  */
 public fun <T> Sequence<T>.plus(element: T): Sequence<T> {
     return sequenceOf(this, sequenceOf(element)).flatten()
 }
 
+/**
+ * Returns a set containing all elements of the original set and then the given [element].
+ */
+public fun <T> Set<T>.plus(element: T): Set<T> {
+    val result = LinkedHashSet<T>(mapCapacity(size() + 1))
+    result.addAll(this)
+    result.add(element)
+    return result
+}
+
+/**
+ * Returns a list containing all elements of the original collection and then all elements of the given [sequence].
+ */
+public fun <T> Collection<T>.plus(sequence: Sequence<T>): List<T> {
+    val result = ArrayList<T>(this.size() + 10)
+    result.addAll(this)
+    result.addAll(sequence)
+    return result
+}
+
+/**
+ * Returns a list containing all elements of the original collection and then all elements of the given [sequence].
+ */
+public fun <T> Iterable<T>.plus(sequence: Sequence<T>): List<T> {
+    val result = ArrayList<T>()
+    result.addAll(this)
+    result.addAll(sequence)
+    return result
+}
+
 /**
  * Returns a sequence containing all elements of original sequence and then all elements of the given [sequence].
+ * Note that the source sequence and the sequence being added are iterated only when an `iterator` is requested from
+ * the resulting sequence. Changing any of them between successive calls to `iterator` may affect the result.
  */
 public fun <T> Sequence<T>.plus(sequence: Sequence<T>): Sequence<T> {
     return sequenceOf(this, sequence).flatten()
 }
 
+/**
+ * Returns a set containing all elements both of the original set and the given [sequence].
+ */
+public fun <T> Set<T>.plus(sequence: Sequence<T>): Set<T> {
+    val result = LinkedHashSet<T>(mapCapacity(this.size() * 2))
+    result.addAll(this)
+    result.addAll(sequence)
+    return result
+}
+
 /**
  * Returns a list of pairs built from elements of both collections with same indexes. List has length of shortest collection.
  */
diff --git a/libraries/stdlib/src/generated/_Numeric.kt b/libraries/stdlib/src/generated/_Numeric.kt
index df318f6ca04..d5c21a19a87 100644
--- a/libraries/stdlib/src/generated/_Numeric.kt
+++ b/libraries/stdlib/src/generated/_Numeric.kt
@@ -421,7 +421,7 @@ public fun IntArray.sum(): Int {
 platformName("sumOfLong")
 public fun Iterable<Long>.sum(): Long {
     val iterator = iterator()
-    var sum: Long = 0
+    var sum: Long = 0L
     while (iterator.hasNext()) {
         sum += iterator.next()
     }
@@ -434,7 +434,7 @@ public fun Iterable<Long>.sum(): Long {
 platformName("sumOfLong")
 public fun Sequence<Long>.sum(): Long {
     val iterator = iterator()
-    var sum: Long = 0
+    var sum: Long = 0L
     while (iterator.hasNext()) {
         sum += iterator.next()
     }
@@ -447,7 +447,7 @@ public fun Sequence<Long>.sum(): Long {
 platformName("sumOfLong")
 public fun Array<out Long>.sum(): Long {
     val iterator = iterator()
-    var sum: Long = 0
+    var sum: Long = 0L
     while (iterator.hasNext()) {
         sum += iterator.next()
     }
@@ -459,7 +459,7 @@ public fun Array<out Long>.sum(): Long {
  */
 public fun LongArray.sum(): Long {
     val iterator = iterator()
-    var sum: Long = 0
+    var sum: Long = 0L
     while (iterator.hasNext()) {
         sum += iterator.next()
     }
diff --git a/libraries/stdlib/src/generated/_Ranges.kt b/libraries/stdlib/src/generated/_Ranges.kt
index 0b283ce0a43..5d68386518e 100644
--- a/libraries/stdlib/src/generated/_Ranges.kt
+++ b/libraries/stdlib/src/generated/_Ranges.kt
@@ -98,7 +98,7 @@ public fun IntRange.reversed(): IntProgression {
  * Returns a progression that goes over this range in reverse direction.
  */
 public fun LongRange.reversed(): LongProgression {
-    return LongProgression(end, start, -1.toLong())
+    return LongProgression(end, start, -1L)
 }
 
 /**
diff --git a/libraries/stdlib/src/generated/_Sequences.kt b/libraries/stdlib/src/generated/_Sequences.kt
index d2e1b314b20..6e99878fc17 100644
--- a/libraries/stdlib/src/generated/_Sequences.kt
+++ b/libraries/stdlib/src/generated/_Sequences.kt
@@ -14,6 +14,7 @@ import java.util.Collections // TODO: it's temporary while we have java.util.Col
  * Returns a sequence from the given collection.
  */
 public fun <T> Array<out T>.asSequence(): Sequence<T> {
+    if (isEmpty()) return emptySequence()
     return object : Sequence<T> {
         override fun iterator(): Iterator<T> {
             return this@asSequence.iterator()
@@ -25,6 +26,7 @@ public fun <T> Array<out T>.asSequence(): Sequence<T> {
  * Returns a sequence from the given collection.
  */
 public fun BooleanArray.asSequence(): Sequence<Boolean> {
+    if (isEmpty()) return emptySequence()
     return object : Sequence<Boolean> {
         override fun iterator(): Iterator<Boolean> {
             return this@asSequence.iterator()
@@ -36,6 +38,7 @@ public fun BooleanArray.asSequence(): Sequence<Boolean> {
  * Returns a sequence from the given collection.
  */
 public fun ByteArray.asSequence(): Sequence<Byte> {
+    if (isEmpty()) return emptySequence()
     return object : Sequence<Byte> {
         override fun iterator(): Iterator<Byte> {
             return this@asSequence.iterator()
@@ -47,6 +50,7 @@ public fun ByteArray.asSequence(): Sequence<Byte> {
  * Returns a sequence from the given collection.
  */
 public fun CharArray.asSequence(): Sequence<Char> {
+    if (isEmpty()) return emptySequence()
     return object : Sequence<Char> {
         override fun iterator(): Iterator<Char> {
             return this@asSequence.iterator()
@@ -58,6 +62,7 @@ public fun CharArray.asSequence(): Sequence<Char> {
  * Returns a sequence from the given collection.
  */
 public fun DoubleArray.asSequence(): Sequence<Double> {
+    if (isEmpty()) return emptySequence()
     return object : Sequence<Double> {
         override fun iterator(): Iterator<Double> {
             return this@asSequence.iterator()
@@ -69,6 +74,7 @@ public fun DoubleArray.asSequence(): Sequence<Double> {
  * Returns a sequence from the given collection.
  */
 public fun FloatArray.asSequence(): Sequence<Float> {
+    if (isEmpty()) return emptySequence()
     return object : Sequence<Float> {
         override fun iterator(): Iterator<Float> {
             return this@asSequence.iterator()
@@ -80,6 +86,7 @@ public fun FloatArray.asSequence(): Sequence<Float> {
  * Returns a sequence from the given collection.
  */
 public fun IntArray.asSequence(): Sequence<Int> {
+    if (isEmpty()) return emptySequence()
     return object : Sequence<Int> {
         override fun iterator(): Iterator<Int> {
             return this@asSequence.iterator()
@@ -91,6 +98,7 @@ public fun IntArray.asSequence(): Sequence<Int> {
  * Returns a sequence from the given collection.
  */
 public fun LongArray.asSequence(): Sequence<Long> {
+    if (isEmpty()) return emptySequence()
     return object : Sequence<Long> {
         override fun iterator(): Iterator<Long> {
             return this@asSequence.iterator()
@@ -102,6 +110,7 @@ public fun LongArray.asSequence(): Sequence<Long> {
  * Returns a sequence from the given collection.
  */
 public fun ShortArray.asSequence(): Sequence<Short> {
+    if (isEmpty()) return emptySequence()
     return object : Sequence<Short> {
         override fun iterator(): Iterator<Short> {
             return this@asSequence.iterator()
@@ -142,6 +151,7 @@ public fun <T> Sequence<T>.asSequence(): Sequence<T> {
  * Returns a sequence from the given collection.
  */
 public fun String.asSequence(): Sequence<Char> {
+    if (isEmpty()) return emptySequence()
     return object : Sequence<Char> {
         override fun iterator(): Iterator<Char> {
             return this@asSequence.iterator()
diff --git a/libraries/stdlib/src/generated/_SpecialJVM.kt b/libraries/stdlib/src/generated/_SpecialJVM.kt
index b4502eb4aef..004e2e79538 100644
--- a/libraries/stdlib/src/generated/_SpecialJVM.kt
+++ b/libraries/stdlib/src/generated/_SpecialJVM.kt
@@ -25,7 +25,7 @@ public fun BooleanArray.asList(): List<Boolean> {
         override fun size(): Int = this@asList.size()
         override fun isEmpty(): Boolean = this@asList.isEmpty()
         override fun contains(o: Any?): Boolean = this@asList.contains(o as Boolean)
-        override fun iterator(): Iterator<Boolean> = this@asList.iterator()
+        override fun iterator(): MutableIterator<Boolean> = this@asList.iterator() as MutableIterator<Boolean>
         override fun get(index: Int): Boolean = this@asList[index]
         override fun indexOf(o: Any?): Int = this@asList.indexOf(o as Boolean)
         override fun lastIndexOf(o: Any?): Int = this@asList.lastIndexOf(o as Boolean)
@@ -40,7 +40,7 @@ public fun ByteArray.asList(): List<Byte> {
         override fun size(): Int = this@asList.size()
         override fun isEmpty(): Boolean = this@asList.isEmpty()
         override fun contains(o: Any?): Boolean = this@asList.contains(o as Byte)
-        override fun iterator(): Iterator<Byte> = this@asList.iterator()
+        override fun iterator(): MutableIterator<Byte> = this@asList.iterator() as MutableIterator<Byte>
         override fun get(index: Int): Byte = this@asList[index]
         override fun indexOf(o: Any?): Int = this@asList.indexOf(o as Byte)
         override fun lastIndexOf(o: Any?): Int = this@asList.lastIndexOf(o as Byte)
@@ -55,7 +55,7 @@ public fun CharArray.asList(): List<Char> {
         override fun size(): Int = this@asList.size()
         override fun isEmpty(): Boolean = this@asList.isEmpty()
         override fun contains(o: Any?): Boolean = this@asList.contains(o as Char)
-        override fun iterator(): Iterator<Char> = this@asList.iterator()
+        override fun iterator(): MutableIterator<Char> = this@asList.iterator() as MutableIterator<Char>
         override fun get(index: Int): Char = this@asList[index]
         override fun indexOf(o: Any?): Int = this@asList.indexOf(o as Char)
         override fun lastIndexOf(o: Any?): Int = this@asList.lastIndexOf(o as Char)
@@ -70,7 +70,7 @@ public fun DoubleArray.asList(): List<Double> {
         override fun size(): Int = this@asList.size()
         override fun isEmpty(): Boolean = this@asList.isEmpty()
         override fun contains(o: Any?): Boolean = this@asList.contains(o as Double)
-        override fun iterator(): Iterator<Double> = this@asList.iterator()
+        override fun iterator(): MutableIterator<Double> = this@asList.iterator() as MutableIterator<Double>
         override fun get(index: Int): Double = this@asList[index]
         override fun indexOf(o: Any?): Int = this@asList.indexOf(o as Double)
         override fun lastIndexOf(o: Any?): Int = this@asList.lastIndexOf(o as Double)
@@ -85,7 +85,7 @@ public fun FloatArray.asList(): List<Float> {
         override fun size(): Int = this@asList.size()
         override fun isEmpty(): Boolean = this@asList.isEmpty()
         override fun contains(o: Any?): Boolean = this@asList.contains(o as Float)
-        override fun iterator(): Iterator<Float> = this@asList.iterator()
+        override fun iterator(): MutableIterator<Float> = this@asList.iterator() as MutableIterator<Float>
         override fun get(index: Int): Float = this@asList[index]
         override fun indexOf(o: Any?): Int = this@asList.indexOf(o as Float)
         override fun lastIndexOf(o: Any?): Int = this@asList.lastIndexOf(o as Float)
@@ -100,7 +100,7 @@ public fun IntArray.asList(): List<Int> {
         override fun size(): Int = this@asList.size()
         override fun isEmpty(): Boolean = this@asList.isEmpty()
         override fun contains(o: Any?): Boolean = this@asList.contains(o as Int)
-        override fun iterator(): Iterator<Int> = this@asList.iterator()
+        override fun iterator(): MutableIterator<Int> = this@asList.iterator() as MutableIterator<Int>
         override fun get(index: Int): Int = this@asList[index]
         override fun indexOf(o: Any?): Int = this@asList.indexOf(o as Int)
         override fun lastIndexOf(o: Any?): Int = this@asList.lastIndexOf(o as Int)
@@ -115,7 +115,7 @@ public fun LongArray.asList(): List<Long> {
         override fun size(): Int = this@asList.size()
         override fun isEmpty(): Boolean = this@asList.isEmpty()
         override fun contains(o: Any?): Boolean = this@asList.contains(o as Long)
-        override fun iterator(): Iterator<Long> = this@asList.iterator()
+        override fun iterator(): MutableIterator<Long> = this@asList.iterator() as MutableIterator<Long>
         override fun get(index: Int): Long = this@asList[index]
         override fun indexOf(o: Any?): Int = this@asList.indexOf(o as Long)
         override fun lastIndexOf(o: Any?): Int = this@asList.lastIndexOf(o as Long)
@@ -130,7 +130,7 @@ public fun ShortArray.asList(): List<Short> {
         override fun size(): Int = this@asList.size()
         override fun isEmpty(): Boolean = this@asList.isEmpty()
         override fun contains(o: Any?): Boolean = this@asList.contains(o as Short)
-        override fun iterator(): Iterator<Short> = this@asList.iterator()
+        override fun iterator(): MutableIterator<Short> = this@asList.iterator() as MutableIterator<Short>
         override fun get(index: Int): Short = this@asList[index]
         override fun indexOf(o: Any?): Int = this@asList.indexOf(o as Short)
         override fun lastIndexOf(o: Any?): Int = this@asList.lastIndexOf(o as Short)
@@ -196,8 +196,8 @@ public fun ShortArray.binarySearch(element: Short, fromIndex: Int = 0, toIndex:
 /**
  * Returns new array which is a copy of the original array.
  */
-public fun <T> Array<out T>.copyOf(): Array<T> {
-    return Arrays.copyOf(this, size()) as Array<T>
+public fun <T> Array<out T>.copyOf(): Array<out T> {
+    return Arrays.copyOf(this, size())
 }
 
 /**
@@ -259,8 +259,16 @@ public fun ShortArray.copyOf(): ShortArray {
 /**
  * Returns new array which is a copy of the original array.
  */
-public fun <T> Array<out T>.copyOf(newSize: Int): Array<T?> {
-    return Arrays.copyOf(this, newSize) as Array<T?>
+platformName("mutableCopyOf")
+public fun <T> Array<T>.copyOf(): Array<T> {
+    return Arrays.copyOf(this, size())
+}
+
+/**
+ * Returns new array which is a copy of the original array.
+ */
+public fun <T> Array<out T>.copyOf(newSize: Int): Array<out T?> {
+    return Arrays.copyOf(this, newSize)
 }
 
 /**
@@ -319,10 +327,18 @@ public fun ShortArray.copyOf(newSize: Int): ShortArray {
     return Arrays.copyOf(this, newSize)
 }
 
+/**
+ * Returns new array which is a copy of the original array.
+ */
+platformName("mutableCopyOf")
+public fun <T> Array<T>.copyOf(newSize: Int): Array<T?> {
+    return Arrays.copyOf(this, newSize)
+}
+
 /**
  * Returns new array which is a copy of range of original array.
  */
-public fun <T> Array<out T>.copyOfRange(from: Int, to: Int): Array<T> {
+public fun <T> Array<out T>.copyOfRange(from: Int, to: Int): Array<out T> {
     return Arrays.copyOfRange(this, from, to)
 }
 
@@ -383,11 +399,11 @@ public fun ShortArray.copyOfRange(from: Int, to: Int): ShortArray {
 }
 
 /**
- * Fills original array with the provided value.
+ * Returns new array which is a copy of range of original array.
  */
-public fun <T> Array<out T>.fill(element: T): Array<out T> {
-    Arrays.fill(this, element)
-    return this
+platformName("mutableCopyOfRange")
+public fun <T> Array<T>.copyOfRange(from: Int, to: Int): Array<T> {
+    return Arrays.copyOfRange(this, from, to)
 }
 
 /**
@@ -454,6 +470,14 @@ public fun ShortArray.fill(element: Short): ShortArray {
     return this
 }
 
+/**
+ * Fills original array with the provided value.
+ */
+public fun <T> Array<T>.fill(element: T): Array<T> {
+    Arrays.fill(this, element)
+    return this
+}
+
 /**
  * Returns a list containing all elements that are instances of specified type parameter R.
  */
@@ -544,6 +568,285 @@ public fun <C : MutableCollection<in R>, R> Sequence<*>.filterIsInstanceTo(desti
     return destination
 }
 
+/**
+ * Returns an array containing all elements of the original array and then all elements of the given [array].
+ */
+public fun BooleanArray.plus(array: BooleanArray): BooleanArray {
+    val thisSize = size()
+    val arraySize = array.size()
+    val result = Arrays.copyOf(this, thisSize + arraySize)
+    System.arraycopy(array, 0, result, thisSize, arraySize)
+    return result
+}
+
+/**
+ * Returns an array containing all elements of the original array and then all elements of the given [array].
+ */
+public fun ByteArray.plus(array: ByteArray): ByteArray {
+    val thisSize = size()
+    val arraySize = array.size()
+    val result = Arrays.copyOf(this, thisSize + arraySize)
+    System.arraycopy(array, 0, result, thisSize, arraySize)
+    return result
+}
+
+/**
+ * Returns an array containing all elements of the original array and then all elements of the given [array].
+ */
+public fun CharArray.plus(array: CharArray): CharArray {
+    val thisSize = size()
+    val arraySize = array.size()
+    val result = Arrays.copyOf(this, thisSize + arraySize)
+    System.arraycopy(array, 0, result, thisSize, arraySize)
+    return result
+}
+
+/**
+ * Returns an array containing all elements of the original array and then all elements of the given [array].
+ */
+public fun DoubleArray.plus(array: DoubleArray): DoubleArray {
+    val thisSize = size()
+    val arraySize = array.size()
+    val result = Arrays.copyOf(this, thisSize + arraySize)
+    System.arraycopy(array, 0, result, thisSize, arraySize)
+    return result
+}
+
+/**
+ * Returns an array containing all elements of the original array and then all elements of the given [array].
+ */
+public fun FloatArray.plus(array: FloatArray): FloatArray {
+    val thisSize = size()
+    val arraySize = array.size()
+    val result = Arrays.copyOf(this, thisSize + arraySize)
+    System.arraycopy(array, 0, result, thisSize, arraySize)
+    return result
+}
+
+/**
+ * Returns an array containing all elements of the original array and then all elements of the given [array].
+ */
+public fun IntArray.plus(array: IntArray): IntArray {
+    val thisSize = size()
+    val arraySize = array.size()
+    val result = Arrays.copyOf(this, thisSize + arraySize)
+    System.arraycopy(array, 0, result, thisSize, arraySize)
+    return result
+}
+
+/**
+ * Returns an array containing all elements of the original array and then all elements of the given [array].
+ */
+public fun LongArray.plus(array: LongArray): LongArray {
+    val thisSize = size()
+    val arraySize = array.size()
+    val result = Arrays.copyOf(this, thisSize + arraySize)
+    System.arraycopy(array, 0, result, thisSize, arraySize)
+    return result
+}
+
+/**
+ * Returns an array containing all elements of the original array and then all elements of the given [array].
+ */
+public fun ShortArray.plus(array: ShortArray): ShortArray {
+    val thisSize = size()
+    val arraySize = array.size()
+    val result = Arrays.copyOf(this, thisSize + arraySize)
+    System.arraycopy(array, 0, result, thisSize, arraySize)
+    return result
+}
+
+/**
+ * Returns an array containing all elements of the original array and then all elements of the given [array].
+ */
+public fun <T> Array<T>.plus(array: Array<out T>): Array<T> {
+    val thisSize = size()
+    val arraySize = array.size()
+    val result = Arrays.copyOf(this, thisSize + arraySize)
+    System.arraycopy(array, 0, result, thisSize, arraySize)
+    return result
+}
+
+/**
+ * Returns an array containing all elements of the original array and then all elements of the given [collection].
+ */
+public fun BooleanArray.plus(collection: Collection<Boolean>): BooleanArray {
+    var index = size()
+    val result = Arrays.copyOf(this, index + collection.size())
+    for (element in collection) result[index++] = element
+    return result
+}
+
+/**
+ * Returns an array containing all elements of the original array and then all elements of the given [collection].
+ */
+public fun ByteArray.plus(collection: Collection<Byte>): ByteArray {
+    var index = size()
+    val result = Arrays.copyOf(this, index + collection.size())
+    for (element in collection) result[index++] = element
+    return result
+}
+
+/**
+ * Returns an array containing all elements of the original array and then all elements of the given [collection].
+ */
+public fun CharArray.plus(collection: Collection<Char>): CharArray {
+    var index = size()
+    val result = Arrays.copyOf(this, index + collection.size())
+    for (element in collection) result[index++] = element
+    return result
+}
+
+/**
+ * Returns an array containing all elements of the original array and then all elements of the given [collection].
+ */
+public fun DoubleArray.plus(collection: Collection<Double>): DoubleArray {
+    var index = size()
+    val result = Arrays.copyOf(this, index + collection.size())
+    for (element in collection) result[index++] = element
+    return result
+}
+
+/**
+ * Returns an array containing all elements of the original array and then all elements of the given [collection].
+ */
+public fun FloatArray.plus(collection: Collection<Float>): FloatArray {
+    var index = size()
+    val result = Arrays.copyOf(this, index + collection.size())
+    for (element in collection) result[index++] = element
+    return result
+}
+
+/**
+ * Returns an array containing all elements of the original array and then all elements of the given [collection].
+ */
+public fun IntArray.plus(collection: Collection<Int>): IntArray {
+    var index = size()
+    val result = Arrays.copyOf(this, index + collection.size())
+    for (element in collection) result[index++] = element
+    return result
+}
+
+/**
+ * Returns an array containing all elements of the original array and then all elements of the given [collection].
+ */
+public fun LongArray.plus(collection: Collection<Long>): LongArray {
+    var index = size()
+    val result = Arrays.copyOf(this, index + collection.size())
+    for (element in collection) result[index++] = element
+    return result
+}
+
+/**
+ * Returns an array containing all elements of the original array and then all elements of the given [collection].
+ */
+public fun ShortArray.plus(collection: Collection<Short>): ShortArray {
+    var index = size()
+    val result = Arrays.copyOf(this, index + collection.size())
+    for (element in collection) result[index++] = element
+    return result
+}
+
+/**
+ * Returns an array containing all elements of the original array and then all elements of the given [collection].
+ */
+public fun <T> Array<T>.plus(collection: Collection<T>): Array<T> {
+    var index = size()
+    val result = Arrays.copyOf(this, index + collection.size())
+    for (element in collection) result[index++] = element
+    return result
+}
+
+/**
+ * Returns an array containing all elements of the original array and then the given [element].
+ */
+public fun BooleanArray.plus(element: Boolean): BooleanArray {
+    val index = size()
+    val result = Arrays.copyOf(this, index + 1)
+    result[index] = element
+    return result
+}
+
+/**
+ * Returns an array containing all elements of the original array and then the given [element].
+ */
+public fun ByteArray.plus(element: Byte): ByteArray {
+    val index = size()
+    val result = Arrays.copyOf(this, index + 1)
+    result[index] = element
+    return result
+}
+
+/**
+ * Returns an array containing all elements of the original array and then the given [element].
+ */
+public fun CharArray.plus(element: Char): CharArray {
+    val index = size()
+    val result = Arrays.copyOf(this, index + 1)
+    result[index] = element
+    return result
+}
+
+/**
+ * Returns an array containing all elements of the original array and then the given [element].
+ */
+public fun DoubleArray.plus(element: Double): DoubleArray {
+    val index = size()
+    val result = Arrays.copyOf(this, index + 1)
+    result[index] = element
+    return result
+}
+
+/**
+ * Returns an array containing all elements of the original array and then the given [element].
+ */
+public fun FloatArray.plus(element: Float): FloatArray {
+    val index = size()
+    val result = Arrays.copyOf(this, index + 1)
+    result[index] = element
+    return result
+}
+
+/**
+ * Returns an array containing all elements of the original array and then the given [element].
+ */
+public fun IntArray.plus(element: Int): IntArray {
+    val index = size()
+    val result = Arrays.copyOf(this, index + 1)
+    result[index] = element
+    return result
+}
+
+/**
+ * Returns an array containing all elements of the original array and then the given [element].
+ */
+public fun LongArray.plus(element: Long): LongArray {
+    val index = size()
+    val result = Arrays.copyOf(this, index + 1)
+    result[index] = element
+    return result
+}
+
+/**
+ * Returns an array containing all elements of the original array and then the given [element].
+ */
+public fun ShortArray.plus(element: Short): ShortArray {
+    val index = size()
+    val result = Arrays.copyOf(this, index + 1)
+    result[index] = element
+    return result
+}
+
+/**
+ * Returns an array containing all elements of the original array and then the given [element].
+ */
+public fun <T> Array<T>.plus(element: T): Array<T> {
+    val index = size()
+    val result = Arrays.copyOf(this, index + 1)
+    result[index] = element
+    return result
+}
+
 /**
  * Sorts array or range in array inplace.
  */
diff --git a/libraries/stdlib/src/kotlin/collections/ArraysJVM.kt b/libraries/stdlib/src/kotlin/collections/ArraysJVM.kt
index 729e9dddb36..0a5b2103b0b 100644
--- a/libraries/stdlib/src/kotlin/collections/ArraysJVM.kt
+++ b/libraries/stdlib/src/kotlin/collections/ArraysJVM.kt
@@ -52,12 +52,18 @@ import kotlin.jvm.internal.Intrinsic
  */
 @Intrinsic("kotlin.arrays.array") public fun booleanArrayOf(vararg content : Boolean) : BooleanArray = content
 
+// TODO: Move inputStream to kotlin.io
+/**
+ * Creates an input stream for reading data from this byte array.
+ */
+deprecated("Use inputStream() method instead.", ReplaceWith("this.inputStream()"))
+public val ByteArray.inputStream : ByteArrayInputStream
+    get() = inputStream()
 
 /**
  * Creates an input stream for reading data from this byte array.
  */
-public val ByteArray.inputStream : ByteArrayInputStream
-    get() = ByteArrayInputStream(this)
+public fun ByteArray.inputStream(): ByteArrayInputStream = ByteArrayInputStream(this)
 
 /**
  * Creates an input stream for reading data from the specified portion of this byte array.
diff --git a/libraries/stdlib/src/kotlin/collections/JUtil.kt b/libraries/stdlib/src/kotlin/collections/JUtil.kt
index 0b3971f7428..44c1aa0cd84 100644
--- a/libraries/stdlib/src/kotlin/collections/JUtil.kt
+++ b/libraries/stdlib/src/kotlin/collections/JUtil.kt
@@ -126,4 +126,27 @@ public fun <T> Iterable<T>.collectionSizeOrNull(): Int? = if (this is Collection
 /**
  * Returns the size of this iterable if it is known, or the specified [default] value otherwise.
  */
-public fun <T> Iterable<T>.collectionSizeOrDefault(default: Int): Int = if (this is Collection<*>) size() else default
\ No newline at end of file
+public fun <T> Iterable<T>.collectionSizeOrDefault(default: Int): Int = if (this is Collection<*>) size() else default
+
+/** Returns true when it's safe to convert this collection to a set without changing contains method behavior. */
+private fun <T> Collection<T>.safeToConvertToSet() = size() > 2 && this is ArrayList
+
+/** Converts this collection to a set, when it's worth so and it doesn't change contains method behavior. */
+private fun <T> Iterable<T>.convertToSetForSetOperationWith(source: Iterable<T>): Collection<T> =
+        when(this) {
+            is Set -> this
+            is Collection ->
+                when {
+                    source is Collection && source.size() < 2 -> this
+                    else -> if (this.safeToConvertToSet()) toHashSet() else this
+                }
+            else -> toHashSet()
+        }
+
+/** Converts this collection to a set, when it's worth so and it doesn't change contains method behavior. */
+private fun <T> Iterable<T>.convertToSetForSetOperation(): Collection<T> =
+        when(this) {
+            is Set -> this
+            is Collection -> if (this.safeToConvertToSet()) toHashSet() else this
+            else -> toHashSet()
+        }
diff --git a/libraries/stdlib/src/kotlin/collections/Maps.kt b/libraries/stdlib/src/kotlin/collections/Maps.kt
index 2a694cc2aea..4e2fbee23a7 100644
--- a/libraries/stdlib/src/kotlin/collections/Maps.kt
+++ b/libraries/stdlib/src/kotlin/collections/Maps.kt
@@ -222,6 +222,15 @@ public fun <K, V> MutableMap<K, V>.putAll(values: Iterable<Pair<K,V>>): Unit {
     }
 }
 
+/**
+ * Puts all the elements of the given sequence into this [MutableMap] with the first component in the pair being the key and the second the value.
+ */
+public fun <K, V> MutableMap<K, V>.putAll(values: Sequence<Pair<K,V>>): Unit {
+    for ((key, value) in values) {
+        put(key, value)
+    }
+}
+
 /**
  * Returns a new map with entries having the keys of this map and the values obtained by applying the `transform`
  * function to each entry in this [Map].
@@ -311,31 +320,33 @@ public inline fun <K, V> Map<K, V>.filterNot(predicate: (Map.Entry<K, V>) -> Boo
     return filterNotTo(LinkedHashMap<K, V>(), predicate)
 }
 
-/**
- * Appends or replaces the given [pair] in this mutable map.
- */
-public fun <K, V> MutableMap<K, V>.plusAssign(pair: Pair<K, V>) {
-    put(pair.first, pair.second)
-}
-
-/**
- * Appends or replaces all pairs from the given collection of [pairs] in this mutable map.
- */
-public fun <K, V> MutableMap<K, V>.plusAssign(pairs: Iterable<Pair<K, V>>) {
-    putAll(pairs)
-}
-
-/**
- * Appends or replaces all entries from the given [map] in this mutable map.
- */
-public fun <K, V> MutableMap<K, V>.plusAssign(map: Map<K, V>) {
-    putAll(map)
-}
-
 /**
  * Returns a new map containing all key-value pairs from the given collection of pairs.
  */
 public fun <K, V> Iterable<Pair<K, V>>.toMap(): Map<K, V> {
+    val result = LinkedHashMap<K, V>(collectionSizeOrNull()?.let { mapCapacity(it) } ?: 16)
+    for (element in this) {
+        result.put(element.first, element.second)
+    }
+    return result
+}
+
+/**
+ * Returns a new map containing all key-value pairs from the given array of pairs.
+ */
+public fun <K, V> Array<Pair<K, V>>.toMap(): Map<K, V> {
+    val result = LinkedHashMap<K, V>(mapCapacity(size()))
+    for (element in this) {
+        result.put(element.first, element.second)
+    }
+    return result
+}
+
+/**
+ * Returns a new map containing all key-value pairs from the given sequence of pairs.
+ */
+
+public fun <K, V> Sequence<Pair<K, V>>.toMap(): Map<K, V> {
     val result = LinkedHashMap<K, V>()
     for (element in this) {
         result.put(element.first, element.second)
@@ -366,6 +377,24 @@ public fun <K, V> Map<K, V>.plus(pairs: Iterable<Pair<K, V>>): Map<K, V> {
     return newMap
 }
 
+/**
+ * Creates a new read-only map by replacing or adding entries to this map from a given array of key-value [pairs].
+ */
+public fun <K, V> Map<K, V>.plus(pairs: Array<Pair<K, V>>): Map<K, V> {
+    val newMap = this.toLinkedMap()
+    newMap.putAll(*pairs)
+    return newMap
+}
+
+/**
+ * Creates a new read-only map by replacing or adding entries to this map from a given sequence of key-value [pairs].
+ */
+public fun <K, V> Map<K, V>.plus(pairs: Sequence<Pair<K, V>>): Map<K, V> {
+    val newMap = this.toLinkedMap()
+    newMap.putAll(pairs)
+    return newMap
+}
+
 /**
  * Creates a new read-only map by replacing or adding entries to this map from another [map].
  */
@@ -375,21 +404,101 @@ public fun <K, V> Map<K, V>.plus(map: Map<K, V>): Map<K, V> {
     return newMap
 }
 
+/**
+ * Appends or replaces the given [pair] in this mutable map.
+ */
+public fun <K, V> MutableMap<K, V>.plusAssign(pair: Pair<K, V>) {
+    put(pair.first, pair.second)
+}
+
+/**
+ * Appends or replaces all pairs from the given collection of [pairs] in this mutable map.
+ */
+public fun <K, V> MutableMap<K, V>.plusAssign(pairs: Iterable<Pair<K, V>>) {
+    putAll(pairs)
+}
+
+/**
+ * Appends or replaces all pairs from the given array of [pairs] in this mutable map.
+ */
+public fun <K, V> MutableMap<K, V>.plusAssign(pairs: Array<Pair<K, V>>) {
+    putAll(*pairs)
+}
+
+/**
+ * Appends or replaces all pairs from the given sequence of [pairs] in this mutable map.
+ */
+public fun <K, V> MutableMap<K, V>.plusAssign(pairs: Sequence<Pair<K, V>>) {
+    putAll(pairs)
+}
+
+/**
+ * Appends or replaces all entries from the given [map] in this mutable map.
+ */
+public fun <K, V> MutableMap<K, V>.plusAssign(map: Map<K, V>) {
+    putAll(map)
+}
+
 /**
  * Creates a new read-only map by removing a [key] from this map.
  */
 public fun <K, V> Map<K, V>.minus(key: K): Map<K, V> {
-    return this.filterKeys { key != it }
+    val result = LinkedHashMap<K, V>(this)
+    result.minusAssign(key)
+    return result
 }
 
 /**
  * Creates a new read-only map by removing a collection of [keys] from this map.
  */
 public fun <K, V> Map<K, V>.minus(keys: Iterable<K>): Map<K, V> {
-    val result = LinkedHashMap<K, V>()
-    result.putAll(this)
-    for (entry in keys) {
-        result.remove(entry)
-    }
+    val result = LinkedHashMap<K, V>(this)
+    result.minusAssign(keys)
     return result
-}
\ No newline at end of file
+}
+
+/**
+ * Creates a new read-only map by removing a array of [keys] from this map.
+ */
+public fun <K, V> Map<K, V>.minus(keys: Array<K>): Map<K, V> {
+    val result = LinkedHashMap<K, V>(this)
+    result.minusAssign(keys)
+    return result
+}
+
+/**
+ * Creates a new read-only map by removing a sequence of [keys] from this map.
+ */
+public fun <K, V> Map<K, V>.minus(keys: Sequence<K>): Map<K, V> {
+    val result = LinkedHashMap<K, V>(this)
+    result.minusAssign(keys)
+    return result
+}
+
+/**
+ * Removes the given [key] from this mutable map.
+ */
+public fun <K, V> MutableMap<K, V>.minusAssign(key: K) {
+    remove(key)
+}
+
+/**
+ * Removes all the given [keys] from this mutable map.
+ */
+public fun <K, V> MutableMap<K, V>.minusAssign(keys: Iterable<K>) {
+    for (key in keys) remove(key)
+}
+
+/**
+ * Removes all the given [keys] from this mutable map.
+ */
+public fun <K, V> MutableMap<K, V>.minusAssign(keys: Array<K>) {
+    for (key in keys) remove(key)
+}
+
+/**
+ * Removes all the given [keys] from this mutable map.
+ */
+public fun <K, V> MutableMap<K, V>.minusAssign(keys: Sequence<K>) {
+    for (key in keys) remove(key)
+}
diff --git a/libraries/stdlib/src/kotlin/collections/MutableCollections.kt b/libraries/stdlib/src/kotlin/collections/MutableCollections.kt
index 81d4e2b0ffb..8c5006046f5 100644
--- a/libraries/stdlib/src/kotlin/collections/MutableCollections.kt
+++ b/libraries/stdlib/src/kotlin/collections/MutableCollections.kt
@@ -1,5 +1,61 @@
 package kotlin
 
+/**
+ * Adds the specified [element] to this mutable collection.
+ */
+public fun <T> MutableCollection<in T>.plusAssign(element: T) {
+    this.add(element)
+}
+
+/**
+ * Adds all elements of the given [collection] to this mutable collection.
+ */
+public fun <T> MutableCollection<in T>.plusAssign(collection: Iterable<T>) {
+    this.addAll(collection)
+}
+
+/**
+ * Adds all elements of the given [array] to this mutable collection.
+ */
+public fun <T> MutableCollection<in T>.plusAssign(array: Array<T>) {
+    this.addAll(array)
+}
+
+/**
+ * Adds all elements of the given [sequence] to this mutable collection.
+ */
+public fun <T> MutableCollection<in T>.plusAssign(sequence: Sequence<T>) {
+    this.addAll(sequence)
+}
+
+/**
+ * Removes a single instance of the specified [element] from this mutable collection.
+ */
+public fun <T> MutableCollection<in T>.minusAssign(element: T) {
+    this.remove(element)
+}
+
+/**
+ * Removes all elements contained in the given [collection] from this mutable collection.
+ */
+public fun <T> MutableCollection<in T>.minusAssign(collection: Iterable<T>) {
+    this.removeAll(collection)
+}
+
+/**
+ * Removes all elements contained in the given [array] from this mutable collection.
+ */
+public fun <T> MutableCollection<in T>.minusAssign(array: Array<T>) {
+    this.removeAll(array)
+}
+
+/**
+ * Removes all elements contained in the given [sequence] from this mutable collection.
+ */
+public fun <T> MutableCollection<in T>.minusAssign(sequence: Sequence<T>) {
+    this.removeAll(sequence)
+}
+
 /**
  * Adds all elements of the given [iterable] to this [MutableCollection].
  */
@@ -21,46 +77,60 @@ public fun <T> MutableCollection<in T>.addAll(sequence: Sequence<T>) {
  * Adds all elements of the given [array] to this [MutableCollection].
  */
 public fun <T> MutableCollection<in T>.addAll(array: Array<out T>) {
-    for (item in array) add(item)
+    addAll(array.asList())
 }
 
 /**
- * Removes all elements of the given [iterable] from this [MutableCollection].
+ * Removes all elements from this [MutableCollection] that are also contained in the given [iterable].
  */
 public fun <T> MutableCollection<in T>.removeAll(iterable: Iterable<T>) {
-    when (iterable) {
-        is Collection -> removeAll(iterable)
-        else -> for (item in iterable) remove(item)
-    }
+    removeAll(iterable.convertToSetForSetOperationWith(this))
 }
 
 /**
- * Removes all elements of the given [sequence] from this [MutableCollection].
+ * Removes all elements from this [MutableCollection] that are also contained in the given [sequence].
  */
 public fun <T> MutableCollection<in T>.removeAll(sequence: Sequence<T>) {
-    for (item in sequence) remove(item)
+    val set = sequence.toHashSet()
+    if (set.isNotEmpty())
+        removeAll(set)
 }
 
 /**
- * Removes all elements of the given [array] from this [MutableCollection].
+ * Removes all elements from this [MutableCollection] that are also contained in the given [array].
  */
 public fun <T> MutableCollection<in T>.removeAll(array: Array<out T>) {
-    for (item in array) remove(item)
+    if (array.isNotEmpty())
+        removeAll(array.toHashSet())
+//    else
+//        removeAll(emptyList())
 }
 
 /**
- * Retains only elements of the given [iterable] in this [MutableCollection].
+ * Retains only elements of this [MutableCollection] that are contained in the given [iterable].
  */
 public fun <T> MutableCollection<in T>.retainAll(iterable: Iterable<T>) {
-    when (iterable) {
-        is Collection -> retainAll(iterable)
-        else -> retainAll(iterable.toSet())
-    }
+    retainAll(iterable.convertToSetForSetOperationWith(this))
 }
 
 /**
- * Retains only elements of the given [array] in this [MutableCollection].
+ * Retains only elements of this [MutableCollection] that are contained in the given [array].
  */
 public fun <T> MutableCollection<in T>.retainAll(array: Array<out T>) {
-    retainAll(array.toSet())
+    if (array.isNotEmpty())
+        retainAll(array.toHashSet())
+    else
+        clear()
+//        retainAll(emptyList())
+}
+
+/**
+ * Retains only elements of this [MutableCollection] that are contained in the given [sequence].
+ */
+public fun <T> MutableCollection<in T>.retainAll(sequence: Sequence<T>) {
+    val set = sequence.toHashSet()
+    if (set.isNotEmpty())
+        retainAll(set)
+    else
+        clear()
 }
diff --git a/libraries/stdlib/src/kotlin/concurrent/FunctionalList.kt b/libraries/stdlib/src/kotlin/concurrent/FunctionalList.kt
deleted file mode 100644
index e54a6e9e583..00000000000
--- a/libraries/stdlib/src/kotlin/concurrent/FunctionalList.kt
+++ /dev/null
@@ -1,57 +0,0 @@
-package kotlin.concurrent
-
-deprecated("This class is unfinished work. It will be removed from the standard library and replaced by a separate persistent collections library")
-public abstract class FunctionalList<T>(public val size: Int) {
-    public abstract val head: T
-    public abstract val tail: FunctionalList<T>
-
-    public val empty: Boolean
-        get() = size == 0
-
-    public fun add(element: T): FunctionalList<T> = FunctionalList.Standard(element, this)
-
-    public fun reversed(): FunctionalList<T> {
-        if(empty)
-            return this
-
-        var cur = tail
-        var new = of(head)
-
-        while(!cur.empty) {
-            new = new.add(cur.head)
-            cur = cur.tail
-        }
-        return new
-    }
-
-    public fun iterator() : Iterator<T> = object: Iterator<T> {
-        var cur = this@FunctionalList
-
-        public override fun next(): T {
-            if(cur.empty)
-                throw java.util.NoSuchElementException()
-
-            val head = cur.head
-            cur = cur.tail
-            return head
-        }
-
-        override fun hasNext(): Boolean = !cur.empty
-    }
-
-    private class Empty<T>() : FunctionalList<T>(0) {
-        override val head: T
-            get() = throw java.util.NoSuchElementException()
-        override val tail: FunctionalList<T>
-            get() = throw java.util.NoSuchElementException()
-    }
-
-    private class Standard<T>(override val head: T, override val tail: FunctionalList<T>) : FunctionalList<T>(tail.size + 1)
-
-    companion object {
-        public fun <T> emptyList(): FunctionalList<T> = Empty<T>()
-
-        public fun <T> of(element: T): FunctionalList<T> = FunctionalList.Standard<T>(element, emptyList())
-    }
-}
-
diff --git a/libraries/stdlib/src/kotlin/concurrent/FunctionalQueue.kt b/libraries/stdlib/src/kotlin/concurrent/FunctionalQueue.kt
deleted file mode 100644
index 5e51e1cbe26..00000000000
--- a/libraries/stdlib/src/kotlin/concurrent/FunctionalQueue.kt
+++ /dev/null
@@ -1,31 +0,0 @@
-package kotlin.concurrent
-
-import java.util.concurrent.Executor
-
-deprecated("This class is unfinished work. It will be removed from the standard library and replaced by a separate persistent collections library")
-public class FunctionalQueue<T> (
-        private val input: FunctionalList<T> = FunctionalList.emptyList<T>(),
-        private val output: FunctionalList<T> = FunctionalList.emptyList<T>()
-) {
-
-    public val size: Int
-        get() = input.size + output.size
-
-    public val empty: Boolean
-        get() = size == 0
-
-    public fun add(element: T): FunctionalQueue<T> = FunctionalQueue<T>(input add element, output)
-
-    public fun addFirst(element: T): FunctionalQueue<T> = FunctionalQueue<T>(input, output add element)
-
-    public fun removeFirst(): Pair<T, FunctionalQueue<T>> =
-            if (output.empty) {
-                if (input.empty)
-                    throw java.util.NoSuchElementException()
-                else
-                    FunctionalQueue<T>(FunctionalList.emptyList<T>(), input.reversed()).removeFirst()
-            }
-            else {
-                Pair(output.head, FunctionalQueue<T>(input, output.tail))
-            }
-}
diff --git a/libraries/stdlib/src/kotlin/jvm/JvmPlatformAnnotations.kt b/libraries/stdlib/src/kotlin/jvm/JvmPlatformAnnotations.kt
index aa5ebf2d062..b4f75925e36 100644
--- a/libraries/stdlib/src/kotlin/jvm/JvmPlatformAnnotations.kt
+++ b/libraries/stdlib/src/kotlin/jvm/JvmPlatformAnnotations.kt
@@ -27,3 +27,9 @@ import java.lang.annotation.RetentionPolicy
  */
 Retention(RetentionPolicy.CLASS)
 public annotation class jvmOverloads
+
+/**
+ * Instructs the Kotlin compiler to generate a public backing field for this property.
+ */
+Retention(RetentionPolicy.SOURCE)
+public annotation class publicField
\ No newline at end of file
diff --git a/libraries/stdlib/src/kotlin/text/StringsJVM.kt b/libraries/stdlib/src/kotlin/text/StringsJVM.kt
index a990d99b124..e9952c366b3 100644
--- a/libraries/stdlib/src/kotlin/text/StringsJVM.kt
+++ b/libraries/stdlib/src/kotlin/text/StringsJVM.kt
@@ -455,8 +455,8 @@ public val String.reader: StringReader
     get() = StringReader(this)
 
 /**
- * Returns a copy of this string capitalised if it is not empty or already starting with an upper case letter,
- * otherwise returns this.
+ * Returns a copy of this string having its first letter uppercased, or the original string,
+ * if it's empty or already starts with an upper case letter.
  *
  * @sample test.text.StringTest.capitalize
  */
@@ -465,8 +465,8 @@ public fun String.capitalize(): String {
 }
 
 /**
- * Returns a copy of this string with the first letter lowercased if it is not empty or already starting with
- * a lower case letter, otherwise returns this.
+ * Returns a copy of this string having its first letter lowercased, or the original string,
+ * if it's empty or already starts with a lower case letter.
  *
  * @sample test.text.StringTest.decapitalize
  */
diff --git a/libraries/stdlib/src/kotlin/util/Standard.kt b/libraries/stdlib/src/kotlin/util/Standard.kt
index 7409886605a..6155ff3407d 100644
--- a/libraries/stdlib/src/kotlin/util/Standard.kt
+++ b/libraries/stdlib/src/kotlin/util/Standard.kt
@@ -9,16 +9,26 @@ package kotlin
 public fun <A, B> A.to(that: B): Pair<A, B> = Pair(this, that)
 
 /**
- * Calls the specified function.
+ * Calls the specified function [f] and returns its result.
  */
-public inline fun <T> run(f: () -> T): T = f()
+public inline fun <R> run(f: () -> R): R = f()
 
 /**
- * Execute f with given receiver
+ * Calls the specified function [f] with `this` value as its receiver and returns its result.
+ */
+public inline fun <T, R> T.run(f: T.() -> R): R = f()
+
+/**
+ * Calls the specified function [f] with the given [receiver] as its receiver and returns its result.
  */
 public inline fun <T, R> with(receiver: T, f: T.() -> R): R = receiver.f()
 
 /**
- * Converts receiver to body parameter
+ * Calls the specified function [f] with `this` value as its receiver and returns `this` value.
+ */
+public inline fun <T> T.apply(f: T.() -> Unit): T { f(); return this }
+
+/**
+ * Calls the specified function [f] with `this` value as its argument and returns its result.
  */
 public inline fun <T, R> T.let(f: (T) -> R): R = f(this)
diff --git a/libraries/stdlib/test/AnnotationsTest.kt b/libraries/stdlib/test/AnnotationsTest.kt
index 40c45c3b3e6..cb6967f9cc4 100644
--- a/libraries/stdlib/test/AnnotationsTest.kt
+++ b/libraries/stdlib/test/AnnotationsTest.kt
@@ -3,11 +3,8 @@ package test.annotations
 import kotlin.*
 import kotlin.test.assertTrue
 import org.junit.Test as test
-import java.lang.annotation.*
 
-
-Retention(RetentionPolicy.RUNTIME)
-annotation class MyAnno
+annotation(retention = AnnotationRetention.RUNTIME) class MyAnno
 
 MyAnno
 Deprecated
diff --git a/libraries/stdlib/test/OldStdlibTest.kt b/libraries/stdlib/test/OldStdlibTest.kt
index ea2a88713ad..60b911d99fa 100644
--- a/libraries/stdlib/test/OldStdlibTest.kt
+++ b/libraries/stdlib/test/OldStdlibTest.kt
@@ -27,7 +27,7 @@ class OldStdlibTest() {
             x [index] = index.toByte()
         }
 
-        for(b in x.inputStream) {
+        for(b in x.inputStream()) {
             println(b)
         }
     }
diff --git a/libraries/stdlib/test/collections/ArraysJVMTest.kt b/libraries/stdlib/test/collections/ArraysJVMTest.kt
index 6605aa45b5a..b4892a7457f 100644
--- a/libraries/stdlib/test/collections/ArraysJVMTest.kt
+++ b/libraries/stdlib/test/collections/ArraysJVMTest.kt
@@ -13,190 +13,6 @@ class ArraysJVMTest {
             expect(b[i]) { a[i] }
     }
 
-    test fun copyOf() {
-        checkContent(booleanArrayOf(true, false, true, false, true, false).copyOf().iterator(), 6) { it % 2 == 0 }
-        checkContent(byteArrayOf(0, 1, 2, 3, 4, 5).copyOf().iterator(), 6) { it.toByte() }
-        checkContent(shortArrayOf(0, 1, 2, 3, 4, 5).copyOf().iterator(), 6) { it.toShort() }
-        checkContent(intArrayOf(0, 1, 2, 3, 4, 5).copyOf().iterator(), 6) { it }
-        checkContent(longArrayOf(0, 1, 2, 3, 4, 5).copyOf().iterator(), 6) { it.toLong() }
-        checkContent(floatArrayOf(0.toFloat(), 1.toFloat(), 2.toFloat(), 3.toFloat()).copyOf().iterator(), 4) { it.toFloat() }
-        checkContent(doubleArrayOf(0.0, 1.0, 2.0, 3.0, 4.0, 5.0).copyOf().iterator(), 6) { it.toDouble() }
-        checkContent(charArrayOf('0', '1', '2', '3', '4', '5').copyOf().iterator(), 6) { (it + '0').toChar() }
-    }
-
-    test fun copyOfRange() {
-        checkContent(booleanArrayOf(true, false, true, false, true, false).copyOfRange(0, 3).iterator(), 3) { it % 2 == 0 }
-        checkContent(byteArrayOf(0, 1, 2, 3, 4, 5).copyOfRange(0, 3).iterator(), 3) { it.toByte() }
-        checkContent(shortArrayOf(0, 1, 2, 3, 4, 5).copyOfRange(0, 3).iterator(), 3) { it.toShort() }
-        checkContent(intArrayOf(0, 1, 2, 3, 4, 5).copyOfRange(0, 3).iterator(), 3) { it }
-        checkContent(longArrayOf(0, 1, 2, 3, 4, 5).copyOfRange(0, 3).iterator(), 3) { it.toLong() }
-        checkContent(floatArrayOf(0.toFloat(), 1.toFloat(), 2.toFloat(), 3.toFloat()).copyOfRange(0, 3).iterator(), 3) { it.toFloat() }
-        checkContent(doubleArrayOf(0.0, 1.0, 2.0, 3.0, 4.0, 5.0).copyOfRange(0, 3).iterator(), 3) { it.toDouble() }
-        checkContent(charArrayOf('0', '1', '2', '3', '4', '5').copyOfRange(0, 3).iterator(), 3) { (it + '0').toChar() }
-    }
-
-    test fun reduce() {
-        expect(-4) { intArrayOf(1, 2, 3) reduce { a, b -> a - b } }
-        expect(-4.toLong()) { longArrayOf(1, 2, 3) reduce { a, b -> a - b } }
-        expect(-4.toFloat()) { floatArrayOf(1.toFloat(), 2.toFloat(), 3.toFloat()) reduce { a, b -> a - b } }
-        expect(-4.0) { doubleArrayOf(1.0, 2.0, 3.0) reduce { a, b -> a - b } }
-        expect('3') { charArrayOf('1', '3', '2') reduce { a, b -> if (a > b) a else b } }
-        expect(false) { booleanArrayOf(true, true, false) reduce { a, b -> a && b } }
-        expect(true) { booleanArrayOf(true, true) reduce { a, b -> a && b } }
-        expect(0.toByte()) { byteArrayOf(3, 2, 1) reduce { a, b -> (a - b).toByte() } }
-        expect(0.toShort()) { shortArrayOf(3, 2, 1) reduce { a, b -> (a - b).toShort() } }
-
-        failsWith (javaClass<UnsupportedOperationException>()) {
-            intArrayOf().reduce { a, b -> a + b }
-        }
-    }
-
-    test fun reduceRight() {
-        expect(2) { intArrayOf(1, 2, 3) reduceRight { a, b -> a - b } }
-        expect(2.toLong()) { longArrayOf(1, 2, 3) reduceRight { a, b -> a - b } }
-        expect(2.toFloat()) { floatArrayOf(1.toFloat(), 2.toFloat(), 3.toFloat()) reduceRight { a, b -> a - b } }
-        expect(2.0) { doubleArrayOf(1.0, 2.0, 3.0) reduceRight { a, b -> a - b } }
-        expect('3') { charArrayOf('1', '3', '2') reduceRight { a, b -> if (a > b) a else b } }
-        expect(false) { booleanArrayOf(true, true, false) reduceRight { a, b -> a && b } }
-        expect(true) { booleanArrayOf(true, true) reduceRight { a, b -> a && b } }
-        expect(2.toByte()) { byteArrayOf(1, 2, 3) reduceRight { a, b -> (a - b).toByte() } }
-        expect(2.toShort()) { shortArrayOf(1, 2, 3) reduceRight { a, b -> (a - b).toShort() } }
-
-        failsWith (javaClass<UnsupportedOperationException>()) {
-            intArrayOf().reduceRight { a, b -> a + b }
-        }
-    }
-
-    test fun indexOf() {
-        expect(-1) { byteArrayOf(1, 2, 3) indexOf 0 }
-        expect(0) { byteArrayOf(1, 2, 3) indexOf 1 }
-        expect(1) { byteArrayOf(1, 2, 3) indexOf 2 }
-        expect(2) { byteArrayOf(1, 2, 3) indexOf 3 }
-
-        expect(-1) { shortArrayOf(1, 2, 3) indexOf 0 }
-        expect(0) { shortArrayOf(1, 2, 3) indexOf 1 }
-        expect(1) { shortArrayOf(1, 2, 3) indexOf 2 }
-        expect(2) { shortArrayOf(1, 2, 3) indexOf 3 }
-
-        expect(-1) { intArrayOf(1, 2, 3) indexOf 0 }
-        expect(0) { intArrayOf(1, 2, 3) indexOf 1 }
-        expect(1) { intArrayOf(1, 2, 3) indexOf 2 }
-        expect(2) { intArrayOf(1, 2, 3) indexOf 3 }
-
-        expect(-1) { longArrayOf(1, 2, 3) indexOf 0 }
-        expect(0) { longArrayOf(1, 2, 3) indexOf 1 }
-        expect(1) { longArrayOf(1, 2, 3) indexOf 2 }
-        expect(2) { longArrayOf(1, 2, 3) indexOf 3 }
-
-        expect(-1) { floatArrayOf(1.0f, 2.0f, 3.0f) indexOf 0f }
-        expect(0) { floatArrayOf(1.0f, 2.0f, 3.0f) indexOf 1.0f }
-        expect(1) { floatArrayOf(1.0f, 2.0f, 3.0f) indexOf 2.0f }
-        expect(2) { floatArrayOf(1.0f, 2.0f, 3.0f) indexOf 3.0f }
-
-        expect(-1) { doubleArrayOf(1.0, 2.0, 3.0) indexOf 0.0 }
-        expect(0) { doubleArrayOf(1.0, 2.0, 3.0) indexOf 1.0 }
-        expect(1) { doubleArrayOf(1.0, 2.0, 3.0) indexOf 2.0 }
-        expect(2) { doubleArrayOf(1.0, 2.0, 3.0) indexOf 3.0 }
-
-        expect(-1) { charArrayOf('a', 'b', 'c') indexOf 'z' }
-        expect(0) { charArrayOf('a', 'b', 'c') indexOf 'a' }
-        expect(1) { charArrayOf('a', 'b', 'c') indexOf 'b' }
-        expect(2) { charArrayOf('a', 'b', 'c') indexOf 'c' }
-
-        expect(0) { booleanArrayOf(true, false) indexOf true }
-        expect(1) { booleanArrayOf(true, false) indexOf false }
-        expect(-1) { booleanArrayOf(true) indexOf false }
-    }
-
-    test fun isEmpty() {
-        assertTrue(intArrayOf().isEmpty())
-        assertFalse(intArrayOf(1).isEmpty())
-        assertTrue(byteArrayOf().isEmpty())
-        assertFalse(byteArrayOf(1).isEmpty())
-        assertTrue(shortArrayOf().isEmpty())
-        assertFalse(shortArrayOf(1).isEmpty())
-        assertTrue(longArrayOf().isEmpty())
-        assertFalse(longArrayOf(1).isEmpty())
-        assertTrue(charArrayOf().isEmpty())
-        assertFalse(charArrayOf('a').isEmpty())
-        assertTrue(floatArrayOf().isEmpty())
-        assertFalse(floatArrayOf(0.1.toFloat()).isEmpty())
-        assertTrue(doubleArrayOf().isEmpty())
-        assertFalse(doubleArrayOf(0.1).isEmpty())
-        assertTrue(booleanArrayOf().isEmpty())
-        assertFalse(booleanArrayOf(false).isEmpty())
-    }
-
-    test fun isNotEmpty() {
-        assertFalse(intArrayOf().isNotEmpty())
-        assertTrue(intArrayOf(1).isNotEmpty())
-    }
-
-    test fun min() {
-        expect(null, { intArrayOf().min() })
-        expect(1, { intArrayOf(1).min() })
-        expect(2, { intArrayOf(2, 3).min() })
-        expect(2000000000000, { longArrayOf(3000000000000, 2000000000000).min() })
-        expect(1, { byteArrayOf(1, 3, 2).min() })
-        expect(2, { shortArrayOf(3, 2).min() })
-        expect(2.0.toFloat(), { floatArrayOf(3.0.toFloat(), 2.0.toFloat()).min() })
-        expect(2.0, { doubleArrayOf(2.0, 3.0).min() })
-        expect('a', { charArrayOf('a', 'b').min() })
-    }
-
-    test fun max() {
-        expect(null, { intArrayOf().max() })
-        expect(1, { intArrayOf(1).max() })
-        expect(3, { intArrayOf(2, 3).max() })
-        expect(3000000000000, { longArrayOf(3000000000000, 2000000000000).max() })
-        expect(3, { byteArrayOf(1, 3, 2).max() })
-        expect(3, { shortArrayOf(3, 2).max() })
-        expect(3.0.toFloat(), { floatArrayOf(3.0.toFloat(), 2.0.toFloat()).max() })
-        expect(3.0, { doubleArrayOf(2.0, 3.0).max() })
-        expect('b', { charArrayOf('a', 'b').max() })
-    }
-
-    test fun minBy() {
-        expect(null, { intArrayOf().minBy { it } })
-        expect(1, { intArrayOf(1).minBy { it } })
-        expect(3, { intArrayOf(2, 3).minBy { -it } })
-        expect(2000000000000, { longArrayOf(3000000000000, 2000000000000).minBy { it + 1 } })
-        expect(1, { byteArrayOf(1, 3, 2).minBy { it * it } })
-        expect(3, { shortArrayOf(3, 2).minBy { "a" } })
-        expect(2.0.toFloat(), { floatArrayOf(3.0.toFloat(), 2.0.toFloat()).minBy { it.toString() } })
-        expect(2.0, { doubleArrayOf(2.0, 3.0).minBy { Math.sqrt(it) } })
-    }
-
-    test fun minIndex() {
-        val a = intArrayOf(1, 7, 9, -42, 54, 93)
-        expect(3, { a.indices.minBy { a[it] } })
-    }
-
-    test fun maxBy() {
-        expect(null, { intArrayOf().maxBy { it } })
-        expect(1, { intArrayOf(1).maxBy { it } })
-        expect(2, { intArrayOf(2, 3).maxBy { -it } })
-        expect(3000000000000, { longArrayOf(3000000000000, 2000000000000).maxBy { it + 1 } })
-        expect(3, { byteArrayOf(1, 3, 2).maxBy { it * it } })
-        expect(3, { shortArrayOf(3, 2).maxBy { "a" } })
-        expect(3.0.toFloat(), { floatArrayOf(3.0.toFloat(), 2.0.toFloat()).maxBy { it.toString() } })
-        expect(3.0, { doubleArrayOf(2.0, 3.0).maxBy { Math.sqrt(it) } })
-    }
-
-    test fun maxIndex() {
-        val a = intArrayOf(1, 7, 9, 239, 54, 93)
-        expect(3, { a.indices.maxBy { a[it] } })
-    }
-
-    test fun sum() {
-        expect(0) { intArrayOf().sum() }
-        expect(14) { intArrayOf(2, 3, 9).sum() }
-        expect(3.0) { doubleArrayOf(1.0, 2.0).sum() }
-        expect(200) { byteArrayOf(100, 100).sum() }
-        expect(50000) { shortArrayOf(20000, 30000).sum() }
-        expect(3000000000000) { longArrayOf(1000000000000, 2000000000000).sum() }
-        expect(3.0.toFloat()) { floatArrayOf(1.0.toFloat(), 2.0.toFloat()).sum() }
-    }
 
     test fun orEmptyNull() {
         val x: Array<String>? = null
@@ -214,229 +30,4 @@ class ArraysJVMTest {
         expect("1") { xArray[0] }
         expect("2") { xArray[1] }
     }
-
-    test fun drop() {
-        expect(listOf(1), { intArrayOf(1).drop(0) })
-        expect(listOf(), { intArrayOf().drop(1) })
-        expect(listOf(), { intArrayOf(1).drop(1) })
-        expect(listOf(3), { intArrayOf(2, 3).drop(1) })
-        expect(listOf(2000000000000), { longArrayOf(3000000000000, 2000000000000).drop(1) })
-        expect(listOf(3.toByte()), { byteArrayOf(2, 3).drop(1) })
-        expect(listOf(3.toShort()), { shortArrayOf(2, 3).drop(1) })
-        expect(listOf(3.0f), { floatArrayOf(2f, 3f).drop(1) })
-        expect(listOf(3.0), { doubleArrayOf(2.0, 3.0).drop(1) })
-        expect(listOf(false), { booleanArrayOf(true, false).drop(1) })
-        expect(listOf('b'), { charArrayOf('a', 'b').drop(1) })
-        expect(listOf("b"), { arrayOf("a", "b").drop(1) })
-        fails {
-            listOf(2).drop(-1)
-        }
-    }
-
-    test fun dropLast() {
-        expect(listOf(), { intArrayOf().dropLast(1) })
-        expect(listOf(), { intArrayOf(1).dropLast(1) })
-        expect(listOf(1), { intArrayOf(1).dropLast(0) })
-        expect(listOf(2), { intArrayOf(2, 3).dropLast(1) })
-        expect(listOf(3000000000000), { longArrayOf(3000000000000, 2000000000000).dropLast(1) })
-        expect(listOf(2.toByte()), { byteArrayOf(2, 3).dropLast(1) })
-        expect(listOf(2.toShort()), { shortArrayOf(2, 3).dropLast(1) })
-        expect(listOf(2.0f), { floatArrayOf(2f, 3f).dropLast(1) })
-        expect(listOf(2.0), { doubleArrayOf(2.0, 3.0).dropLast(1) })
-        expect(listOf(true), { booleanArrayOf(true, false).dropLast(1) })
-        expect(listOf('a'), { charArrayOf('a', 'b').dropLast(1) })
-        expect(listOf("a"), { arrayOf("a", "b").dropLast(1) })
-        fails {
-            listOf(1).dropLast(-1)
-        }
-    }
-
-    test fun dropWhile() {
-        expect(listOf(), { intArrayOf().dropWhile { it < 3 } })
-        expect(listOf(), { intArrayOf(1).dropWhile { it < 3 } })
-        expect(listOf(3, 1), { intArrayOf(2, 3, 1).dropWhile { it < 3 } })
-        expect(listOf(2000000000000), { longArrayOf(3000000000000, 2000000000000).dropWhile { it > 2000000000000 } })
-        expect(listOf(3.toByte(), 1.toByte()), { byteArrayOf(2, 3, 1).dropWhile { it < 3 } })
-        expect(listOf(3.toShort(), 1.toShort()), { shortArrayOf(2, 3, 1).dropWhile { it < 3 } })
-        expect(listOf(3f, 1f), { floatArrayOf(2f, 3f, 1f).dropWhile { it < 3 } })
-        expect(listOf(3.0, 1.0), { doubleArrayOf(2.0, 3.0, 1.0).dropWhile { it < 3 } })
-        expect(listOf(false, true), { booleanArrayOf(true, false, true).dropWhile { it } })
-        expect(listOf('b', 'a'), { charArrayOf('a', 'b', 'a').dropWhile { it < 'b' } })
-        expect(listOf("b", "a"), { arrayOf("a", "b", "a").dropWhile { it < "b" } })
-    }
-
-    test fun dropLastWhile() {
-        expect(listOf(), { intArrayOf().dropLastWhile { it < 3 } })
-        expect(listOf(), { intArrayOf(1).dropLastWhile { it < 3 } })
-        expect(listOf(2, 3), { intArrayOf(2, 3, 1).dropLastWhile { it < 3 } })
-        expect(listOf(3000000000000), { longArrayOf(3000000000000, 2000000000000).dropLastWhile { it < 3000000000000 } })
-        expect(listOf(2.toByte(), 3.toByte()), { byteArrayOf(2, 3, 1).dropLastWhile { it < 3 } })
-        expect(listOf(2.toShort(), 3.toShort()), { shortArrayOf(2, 3, 1).dropLastWhile { it < 3 } })
-        expect(listOf(2f, 3f), { floatArrayOf(2f, 3f, 1f).dropLastWhile { it < 3 } })
-        expect(listOf(2.0, 3.0), { doubleArrayOf(2.0, 3.0, 1.0).dropLastWhile { it < 3 } })
-        expect(listOf(true, false), { booleanArrayOf(true, false, true).dropLastWhile { it } })
-        expect(listOf('a', 'b'), { charArrayOf('a', 'b', 'a').dropLastWhile { it < 'b' } })
-        expect(listOf("a", "b"), { arrayOf("a", "b", "a").dropLastWhile { it < "b" } })
-    }
-
-    test fun take() {
-        expect(listOf(), { intArrayOf().take(1) })
-        expect(listOf(), { intArrayOf(1).take(0) })
-        expect(listOf(1), { intArrayOf(1).take(1) })
-        expect(listOf(2), { intArrayOf(2, 3).take(1) })
-        expect(listOf(3000000000000), { longArrayOf(3000000000000, 2000000000000).take(1) })
-        expect(listOf(2.toByte()), { byteArrayOf(2, 3).take(1) })
-        expect(listOf(2.toShort()), { shortArrayOf(2, 3).take(1) })
-        expect(listOf(2.0f), { floatArrayOf(2f, 3f).take(1) })
-        expect(listOf(2.0), { doubleArrayOf(2.0, 3.0).take(1) })
-        expect(listOf(true), { booleanArrayOf(true, false).take(1) })
-        expect(listOf('a'), { charArrayOf('a', 'b').take(1) })
-        expect(listOf("a"), { arrayOf("a", "b").take(1) })
-        fails {
-            listOf(1).take(-1)
-        }
-    }
-
-    test fun takeLast() {
-        expect(listOf(), { intArrayOf().takeLast(1) })
-        expect(listOf(), { intArrayOf(1).takeLast(0) })
-        expect(listOf(1), { intArrayOf(1).takeLast(1) })
-        expect(listOf(3), { intArrayOf(2, 3).takeLast(1) })
-        expect(listOf(2000000000000), { longArrayOf(3000000000000, 2000000000000).takeLast(1) })
-        expect(listOf(3.toByte()), { byteArrayOf(2, 3).takeLast(1) })
-        expect(listOf(3.toShort()), { shortArrayOf(2, 3).takeLast(1) })
-        expect(listOf(3.0f), { floatArrayOf(2f, 3f).takeLast(1) })
-        expect(listOf(3.0), { doubleArrayOf(2.0, 3.0).takeLast(1) })
-        expect(listOf(false), { booleanArrayOf(true, false).takeLast(1) })
-        expect(listOf('b'), { charArrayOf('a', 'b').takeLast(1) })
-        expect(listOf("b"), { arrayOf("a", "b").takeLast(1) })
-        fails {
-            listOf(1).takeLast(-1)
-        }
-    }
-
-    test fun takeWhile() {
-        expect(listOf(), { intArrayOf().takeWhile { it < 3 } })
-        expect(listOf(1), { intArrayOf(1).takeWhile { it < 3 } })
-        expect(listOf(2), { intArrayOf(2, 3, 1).takeWhile { it < 3 } })
-        expect(listOf(3000000000000), { longArrayOf(3000000000000, 2000000000000).takeWhile { it > 2000000000000 } })
-        expect(listOf(2.toByte()), { byteArrayOf(2, 3, 1).takeWhile { it < 3 } })
-        expect(listOf(2.toShort()), { shortArrayOf(2, 3, 1).takeWhile { it < 3 } })
-        expect(listOf(2f), { floatArrayOf(2f, 3f, 1f).takeWhile { it < 3 } })
-        expect(listOf(2.0), { doubleArrayOf(2.0, 3.0, 1.0).takeWhile { it < 3 } })
-        expect(listOf(true), { booleanArrayOf(true, false, true).takeWhile { it } })
-        expect(listOf('a'), { charArrayOf('a', 'c', 'b').takeWhile { it < 'c' } })
-        expect(listOf("a"), { arrayOf("a", "c", "b").takeWhile { it < "c" } })
-    }
-
-    test fun takeLastWhile() {
-        expect(listOf(), { intArrayOf().takeLastWhile { it < 3 } })
-        expect(listOf(1), { intArrayOf(1).takeLastWhile { it < 3 } })
-        expect(listOf(1), { intArrayOf(2, 3, 1).takeLastWhile { it < 3 } })
-        expect(listOf(2000000000000), { longArrayOf(3000000000000, 2000000000000).takeLastWhile { it < 3000000000000 } })
-        expect(listOf(1.toByte()), { byteArrayOf(2, 3, 1).takeLastWhile { it < 3 } })
-        expect(listOf(1.toShort()), { shortArrayOf(2, 3, 1).takeLastWhile { it < 3 } })
-        expect(listOf(1f), { floatArrayOf(2f, 3f, 1f).takeLastWhile { it < 3 } })
-        expect(listOf(1.0), { doubleArrayOf(2.0, 3.0, 1.0).takeLastWhile { it < 3 } })
-        expect(listOf(true), { booleanArrayOf(true, false, true).takeLastWhile { it } })
-        expect(listOf('b'), { charArrayOf('a', 'c', 'b').takeLastWhile { it < 'c' } })
-        expect(listOf("b"), { arrayOf("a", "c", "b").takeLastWhile { it < "c" } })
-    }
-
-    test fun filter() {
-        expect(listOf(), { intArrayOf().filter { it > 2 } })
-        expect(listOf(), { intArrayOf(1).filter { it > 2 } })
-        expect(listOf(3), { intArrayOf(2, 3).filter { it > 2 } })
-        expect(listOf(3000000000000), { longArrayOf(3000000000000, 2000000000000).filter { it > 2000000000000 } })
-        expect(listOf(3.toByte()), { byteArrayOf(2, 3).filter { it > 2 } })
-        expect(listOf(3.toShort()), { shortArrayOf(2, 3).filter { it > 2 } })
-        expect(listOf(3.0f), { floatArrayOf(2f, 3f).filter { it > 2 } })
-        expect(listOf(3.0), { doubleArrayOf(2.0, 3.0).filter { it > 2 } })
-        expect(listOf(true), { booleanArrayOf(true, false).filter { it } })
-        expect(listOf('b'), { charArrayOf('a', 'b').filter { it > 'a' } })
-        expect(listOf("b"), { arrayOf("a", "b").filter { it > "a" } })
-    }
-
-    test fun filterNot() {
-        expect(listOf(), { intArrayOf().filterNot { it > 2 } })
-        expect(listOf(1), { intArrayOf(1).filterNot { it > 2 } })
-        expect(listOf(2), { intArrayOf(2, 3).filterNot { it > 2 } })
-        expect(listOf(2000000000000), { longArrayOf(3000000000000, 2000000000000).filterNot { it > 2000000000000 } })
-        expect(listOf(2.toByte()), { byteArrayOf(2, 3).filterNot { it > 2 } })
-        expect(listOf(2.toShort()), { shortArrayOf(2, 3).filterNot { it > 2 } })
-        expect(listOf(2.0f), { floatArrayOf(2f, 3f).filterNot { it > 2 } })
-        expect(listOf(2.0), { doubleArrayOf(2.0, 3.0).filterNot { it > 2 } })
-        expect(listOf(false), { booleanArrayOf(true, false).filterNot { it } })
-        expect(listOf('a'), { charArrayOf('a', 'b').filterNot { it > 'a' } })
-        expect(listOf("a"), { arrayOf("a", "b").filterNot { it > "a" } })
-    }
-
-    test fun filterNotNull() {
-        expect(listOf("a"), { arrayOf("a", null).filterNotNull() })
-    }
-
-    test fun asListPrimitives() {
-        // Array of primitives
-        val arr = intArrayOf(1, 2, 3, 4, 2, 5)
-        val list = arr.asList()
-        assertEquals(list, arr.toList())
-
-        assertTrue(2 in list)
-        assertFalse(0 in list)
-        assertTrue(list.containsAll(listOf(5, 4, 3)))
-        assertFalse(list.containsAll(listOf(5, 6, 3)))
-
-        expect(1) { list.indexOf(2) }
-        expect(4) { list.lastIndexOf(2) }
-        expect(-1) { list.indexOf(6) }
-
-        assertEquals(list.subList(3, 5), listOf(4, 2))
-
-        val iter = list.listIterator(2)
-        expect(2) { iter.nextIndex() }
-        expect(1) { iter.previousIndex() }
-        expect(3) {
-            iter.next()
-            iter.previous()
-            iter.next()
-        }
-
-        arr[2] = 4
-        assertEquals(list, arr.toList())
-
-        assertEquals(IntArray(0).asList(), emptyList<Int>())
-    }
-
-    test fun asListObjects() {
-        val arr = arrayOf("a", "b", "c", "d", "b", "e")
-        val list = arr.asList()
-
-        assertEquals(list, arr.toList())
-
-        assertTrue("b" in list)
-        assertFalse("z" in list)
-
-        expect(1) { list.indexOf("b") }
-        expect(4) { list.lastIndexOf("b") }
-        expect(-1) { list.indexOf("x") }
-
-        assertTrue(list.containsAll(listOf("e", "d", "c")))
-        assertFalse(list.containsAll(listOf("e", "x", "c")))
-
-        assertEquals(list.subList(3, 5), listOf("d", "b"))
-
-        val iter = list.listIterator(2)
-        expect(2) { iter.nextIndex() }
-        expect(1) { iter.previousIndex() }
-        expect("c") {
-            iter.next()
-            iter.previous()
-            iter.next()
-        }
-
-        arr[2] = "xx"
-        assertEquals(list, arr.toList())
-
-        assertEquals(Array(0, { "" }).asList(), emptyList<String>())
-    }
 }
diff --git a/libraries/stdlib/test/collections/ArraysTest.kt b/libraries/stdlib/test/collections/ArraysTest.kt
index ff1dbf37519..c87e21297e6 100644
--- a/libraries/stdlib/test/collections/ArraysTest.kt
+++ b/libraries/stdlib/test/collections/ArraysTest.kt
@@ -1,20 +1,18 @@
 package test.collections
 
-import kotlin.test.assertEquals
-import kotlin.test.assertFalse
-import kotlin.test.assertTrue
-import kotlin.test.expect
+import kotlin.test.*
 import org.junit.Test as test
 
-fun <T> checkContent(iter: Iterator<T>, length: Int, value: (Int) -> T) {
-    var idx = 0
-    while (idx != length && iter.hasNext()) {
-        assertEquals(value(idx++), iter.next(), "Invalid element")
-    }
+fun <T> assertArrayNotSameButEquals(expected: Array<out T>, actual: Array<out T>, message: String = "") { assertTrue(expected !== actual, message); assertEquals(expected.toList(), actual.toList(), message) }
+fun assertArrayNotSameButEquals(expected: IntArray, actual: IntArray, message: String = "") { assertTrue(expected !== actual, message); assertEquals(expected.toList(), actual.toList(), message) }
+fun assertArrayNotSameButEquals(expected: LongArray, actual: LongArray, message: String = "") { assertTrue(expected !== actual, message); assertEquals(expected.toList(), actual.toList(), message) }
+fun assertArrayNotSameButEquals(expected: ShortArray, actual: ShortArray, message: String = "") { assertTrue(expected !== actual, message); assertEquals(expected.toList(), actual.toList(), message) }
+fun assertArrayNotSameButEquals(expected: ByteArray, actual: ByteArray, message: String = "") { assertTrue(expected !== actual, message); assertEquals(expected.toList(), actual.toList(), message) }
+fun assertArrayNotSameButEquals(expected: DoubleArray, actual: DoubleArray, message: String = "") { assertTrue(expected !== actual, message); assertEquals(expected.toList(), actual.toList(), message) }
+fun assertArrayNotSameButEquals(expected: FloatArray, actual: FloatArray, message: String = "") { assertTrue(expected !== actual, message); assertEquals(expected.toList(), actual.toList(), message) }
+fun assertArrayNotSameButEquals(expected: CharArray, actual: CharArray, message: String = "") { assertTrue(expected !== actual, message); assertEquals(expected.toList(), actual.toList(), message) }
+fun assertArrayNotSameButEquals(expected: BooleanArray, actual: BooleanArray, message: String = "") { assertTrue(expected !== actual, message); assertEquals(expected.toList(), actual.toList(), message) }
 
-    assertEquals(length, idx, "Invalid length")
-    assertFalse(iter.hasNext(), "Invalid length (hasNext())")
-}
 
 class ArraysTest {
 
@@ -74,7 +72,7 @@ class ArraysTest {
     test fun floatArray() {
         val arr = FloatArray(2)
 
-        val expected: Float = 0.0.toFloat()
+        val expected: Float = 0.0F
         assertEquals(arr.size(), 2)
         assertEquals(expected, arr[0])
         assertEquals(expected, arr[1])
@@ -113,6 +111,18 @@ class ArraysTest {
         expect("a", { arrayOf("a", "b").min() })
     }
 
+    test fun minInPrimitiveArrays() {
+        expect(null, { intArrayOf().min() })
+        expect(1, { intArrayOf(1).min() })
+        expect(2, { intArrayOf(2, 3).min() })
+        expect(2000000000000, { longArrayOf(3000000000000, 2000000000000).min() })
+        expect(1, { byteArrayOf(1, 3, 2).min() })
+        expect(2, { shortArrayOf(3, 2).min() })
+        expect(2.0F, { floatArrayOf(3.0F, 2.0F).min() })
+        expect(2.0, { doubleArrayOf(2.0, 3.0).min() })
+        expect('a', { charArrayOf('a', 'b').min() })
+    }
+
     test fun max() {
         expect(null, { arrayOf<Int>().max() })
         expect(1, { arrayOf(1).max() })
@@ -122,6 +132,18 @@ class ArraysTest {
         expect("b", { arrayOf("a", "b").max() })
     }
 
+    test fun maxInPrimitiveArrays() {
+        expect(null, { intArrayOf().max() })
+        expect(1, { intArrayOf(1).max() })
+        expect(3, { intArrayOf(2, 3).max() })
+        expect(3000000000000, { longArrayOf(3000000000000, 2000000000000).max() })
+        expect(3, { byteArrayOf(1, 3, 2).max() })
+        expect(3, { shortArrayOf(3, 2).max() })
+        expect(3.0F, { floatArrayOf(3.0F, 2.0F).max() })
+        expect(3.0, { doubleArrayOf(2.0, 3.0).max() })
+        expect('b', { charArrayOf('a', 'b').max() })
+    }
+
     test fun minBy() {
         expect(null, { arrayOf<Int>().minBy { it } })
         expect(1, { arrayOf(1).minBy { it } })
@@ -130,6 +152,17 @@ class ArraysTest {
         expect("b", { arrayOf("b", "abc").minBy { it.length() } })
     }
 
+    test fun minByInPrimitiveArrays() {
+        expect(null, { intArrayOf().minBy { it } })
+        expect(1, { intArrayOf(1).minBy { it } })
+        expect(3, { intArrayOf(2, 3).minBy { -it } })
+        expect(2000000000000, { longArrayOf(3000000000000, 2000000000000).minBy { it + 1 } })
+        expect(1, { byteArrayOf(1, 3, 2).minBy { it * it } })
+        expect(3, { shortArrayOf(3, 2).minBy { "a" } })
+        expect(2.0F, { floatArrayOf(3.0F, 2.0F).minBy { it.toString() } })
+        expect(2.0, { doubleArrayOf(2.0, 3.0).minBy { Math.sqrt(it) } })
+    }
+
     test fun maxBy() {
         expect(null, { arrayOf<Int>().maxBy { it } })
         expect(1, { arrayOf(1).maxBy { it } })
@@ -138,6 +171,27 @@ class ArraysTest {
         expect("abc", { arrayOf("b", "abc").maxBy { it.length() } })
     }
 
+    test fun maxByInPrimitiveArrays() {
+        expect(null, { intArrayOf().maxBy { it } })
+        expect(1, { intArrayOf(1).maxBy { it } })
+        expect(2, { intArrayOf(2, 3).maxBy { -it } })
+        expect(3000000000000, { longArrayOf(3000000000000, 2000000000000).maxBy { it + 1 } })
+        expect(3, { byteArrayOf(1, 3, 2).maxBy { it * it } })
+        expect(3, { shortArrayOf(3, 2).maxBy { "a" } })
+        expect(3.0F, { floatArrayOf(3.0F, 2.0F).maxBy { it.toString() } })
+        expect(3.0, { doubleArrayOf(2.0, 3.0).maxBy { Math.sqrt(it) } })
+    }
+
+    test fun minIndex() {
+        val a = intArrayOf(1, 7, 9, -42, 54, 93)
+        expect(3, { a.indices.minBy { a[it] } })
+    }
+
+    test fun maxIndex() {
+        val a = intArrayOf(1, 7, 9, 239, 54, 93)
+        expect(3, { a.indices.maxBy { a[it] } })
+    }
+
     test fun minByEvaluateOnce() {
         var c = 0
         expect(1, { arrayOf(5, 4, 3, 2, 1).minBy { c++; it * it } })
@@ -157,7 +211,17 @@ class ArraysTest {
         expect(200) { arrayOf<Byte>(100, 100).sum() }
         expect(50000) { arrayOf<Short>(20000, 30000).sum() }
         expect(3000000000000) { arrayOf<Long>(1000000000000, 2000000000000).sum() }
-        expect(3.0.toFloat()) { arrayOf<Float>(1.0.toFloat(), 2.0.toFloat()).sum() }
+        expect(3.0F) { arrayOf<Float>(1.0F, 2.0F).sum() }
+    }
+
+    test fun sumInPrimitiveArrays() {
+        expect(0) { intArrayOf().sum() }
+        expect(14) { intArrayOf(2, 3, 9).sum() }
+        expect(3.0) { doubleArrayOf(1.0, 2.0).sum() }
+        expect(200) { byteArrayOf(100, 100).sum() }
+        expect(50000) { shortArrayOf(20000, 30000).sum() }
+        expect(3000000000000) { longArrayOf(1000000000000, 2000000000000).sum() }
+        expect(3.0F) { floatArrayOf(1.0F, 2.0F).sum() }
     }
 
     test fun average() {
@@ -171,6 +235,47 @@ class ArraysTest {
         // for each arr with size > 0  arr.average() = arr.sum().toDouble() / arr.size()
     }
 
+    test fun indexOfInPrimitiveArrays() {
+        expect(-1) { byteArrayOf(1, 2, 3) indexOf 0 }
+        expect(0) { byteArrayOf(1, 2, 3) indexOf 1 }
+        expect(1) { byteArrayOf(1, 2, 3) indexOf 2 }
+        expect(2) { byteArrayOf(1, 2, 3) indexOf 3 }
+
+        expect(-1) { shortArrayOf(1, 2, 3) indexOf 0 }
+        expect(0) { shortArrayOf(1, 2, 3) indexOf 1 }
+        expect(1) { shortArrayOf(1, 2, 3) indexOf 2 }
+        expect(2) { shortArrayOf(1, 2, 3) indexOf 3 }
+
+        expect(-1) { intArrayOf(1, 2, 3) indexOf 0 }
+        expect(0) { intArrayOf(1, 2, 3) indexOf 1 }
+        expect(1) { intArrayOf(1, 2, 3) indexOf 2 }
+        expect(2) { intArrayOf(1, 2, 3) indexOf 3 }
+
+        expect(-1) { longArrayOf(1, 2, 3) indexOf 0 }
+        expect(0) { longArrayOf(1, 2, 3) indexOf 1 }
+        expect(1) { longArrayOf(1, 2, 3) indexOf 2 }
+        expect(2) { longArrayOf(1, 2, 3) indexOf 3 }
+
+        expect(-1) { floatArrayOf(1.0f, 2.0f, 3.0f) indexOf 0f }
+        expect(0) { floatArrayOf(1.0f, 2.0f, 3.0f) indexOf 1.0f }
+        expect(1) { floatArrayOf(1.0f, 2.0f, 3.0f) indexOf 2.0f }
+        expect(2) { floatArrayOf(1.0f, 2.0f, 3.0f) indexOf 3.0f }
+
+        expect(-1) { doubleArrayOf(1.0, 2.0, 3.0) indexOf 0.0 }
+        expect(0) { doubleArrayOf(1.0, 2.0, 3.0) indexOf 1.0 }
+        expect(1) { doubleArrayOf(1.0, 2.0, 3.0) indexOf 2.0 }
+        expect(2) { doubleArrayOf(1.0, 2.0, 3.0) indexOf 3.0 }
+
+        expect(-1) { charArrayOf('a', 'b', 'c') indexOf 'z' }
+        expect(0) { charArrayOf('a', 'b', 'c') indexOf 'a' }
+        expect(1) { charArrayOf('a', 'b', 'c') indexOf 'b' }
+        expect(2) { charArrayOf('a', 'b', 'c') indexOf 'c' }
+
+        expect(0) { booleanArrayOf(true, false) indexOf true }
+        expect(1) { booleanArrayOf(true, false) indexOf false }
+        expect(-1) { booleanArrayOf(true) indexOf false }
+    }
+
     test fun indexOf() {
         expect(-1) { arrayOf("cat", "dog", "bird").indexOf("mouse") }
         expect(0) { arrayOf("cat", "dog", "bird").indexOf("cat") }
@@ -209,14 +314,59 @@ class ArraysTest {
         expect(3) { sequenceOf("cat", "dog", "bird", "red").indexOfLast { it.endsWith('d') } }
     }
 
+    test fun isEmpty() {
+        assertTrue(emptyArray<String>().isEmpty())
+        assertFalse(arrayOf("").isEmpty())
+        assertTrue(intArrayOf().isEmpty())
+        assertFalse(intArrayOf(1).isEmpty())
+        assertTrue(byteArrayOf().isEmpty())
+        assertFalse(byteArrayOf(1).isEmpty())
+        assertTrue(shortArrayOf().isEmpty())
+        assertFalse(shortArrayOf(1).isEmpty())
+        assertTrue(longArrayOf().isEmpty())
+        assertFalse(longArrayOf(1).isEmpty())
+        assertTrue(charArrayOf().isEmpty())
+        assertFalse(charArrayOf('a').isEmpty())
+        assertTrue(floatArrayOf().isEmpty())
+        assertFalse(floatArrayOf(0.1F).isEmpty())
+        assertTrue(doubleArrayOf().isEmpty())
+        assertFalse(doubleArrayOf(0.1).isEmpty())
+        assertTrue(booleanArrayOf().isEmpty())
+        assertFalse(booleanArrayOf(false).isEmpty())
+    }
+
+    test fun isNotEmpty() {
+        assertFalse(intArrayOf().isNotEmpty())
+        assertTrue(intArrayOf(1).isNotEmpty())
+    }
+
     test fun plus() {
-        assertEquals(listOf("1", "2", "3", "4"), arrayOf("1", "2") + arrayOf("3", "4"))
         assertEquals(listOf("1", "2", "3", "4"), listOf("1", "2") + arrayOf("3", "4"))
+        assertArrayNotSameButEquals(arrayOf("1", "2", "3"), arrayOf("1", "2") + "3")
+        assertArrayNotSameButEquals(arrayOf("1", "2", "3", "4"), arrayOf("1", "2") + arrayOf("3", "4"))
+        assertArrayNotSameButEquals(arrayOf("1", "2", "3", "4"), arrayOf("1", "2") + listOf("3", "4"))
+        assertArrayNotSameButEquals(intArrayOf(1, 2, 3), intArrayOf(1, 2) + 3)
+        assertArrayNotSameButEquals(intArrayOf(1, 2, 3, 4), intArrayOf(1, 2) + listOf(3, 4))
+        assertArrayNotSameButEquals(intArrayOf(1, 2, 3, 4), intArrayOf(1, 2) + intArrayOf(3, 4))
     }
 
     test fun plusVararg() {
-        fun onePlus(vararg a: String) = arrayOf("1") + a
-        assertEquals(listOf("1", "2"), onePlus("2"))
+        fun stringOnePlus(vararg a: String) = arrayOf("1") + a
+        fun longOnePlus(vararg a: Long) = longArrayOf(1) + a
+        fun intOnePlus(vararg a: Int) = intArrayOf(1) + a
+
+        assertArrayNotSameButEquals(arrayOf("1", "2"), stringOnePlus("2"), "Array.plus")
+        assertArrayNotSameButEquals(intArrayOf(1, 2), intOnePlus(2), "IntArray.plus")
+        assertArrayNotSameButEquals(longArrayOf(1, 2), longOnePlus(2), "LongArray.plus")
+    }
+
+    test fun plusAssign() {
+        // lets use a mutable variable
+        var result = arrayOf("a")
+        result += "foo"
+        result += listOf("beer")
+        result += arrayOf("cheese", "wine")
+        assertArrayNotSameButEquals(arrayOf("a", "foo", "beer", "cheese", "wine"), result)
     }
 
     test fun first() {
@@ -307,52 +457,309 @@ class ArraysTest {
         assertEquals(charList, charArray.asList())
     }
 
-    /*
+    test fun copyOf() {
+        booleanArrayOf(true, false, true).let { assertArrayNotSameButEquals(it, it.copyOf()) }
+        byteArrayOf(0, 1, 2, 3, 4, 5).let { assertArrayNotSameButEquals(it, it.copyOf()) }
+        shortArrayOf(0, 1, 2, 3, 4, 5).let { assertArrayNotSameButEquals(it, it.copyOf()) }
+        intArrayOf(0, 1, 2, 3, 4, 5).let { assertArrayNotSameButEquals(it, it.copyOf()) }
+        longArrayOf(0, 1, 2, 3, 4, 5).let { assertArrayNotSameButEquals(it, it.copyOf()) }
+        floatArrayOf(0F, 1F, 2F, 3F).let { assertArrayNotSameButEquals(it, it.copyOf()) }
+        doubleArrayOf(0.0, 1.0, 2.0, 3.0, 4.0, 5.0).let { assertArrayNotSameButEquals(it, it.copyOf()) }
+        charArrayOf('0', '1', '2', '3', '4', '5').let { assertArrayNotSameButEquals(it, it.copyOf()) }
+    }
+
+    test fun copyAndResize() {
+        assertArrayNotSameButEquals(arrayOf("1", "2"), arrayOf("1", "2", "3").copyOf(2))
+        assertArrayNotSameButEquals(arrayOf("1", "2", null), arrayOf("1", "2").copyOf(3))
+
+        assertArrayNotSameButEquals(longArrayOf(1, 2), longArrayOf(1, 2, 3).copyOf(2))
+        assertArrayNotSameButEquals(longArrayOf(1, 2, 0), longArrayOf(1, 2).copyOf(3))
+
+        assertArrayNotSameButEquals(intArrayOf(1, 2), intArrayOf(1, 2, 3).copyOf(2))
+        assertArrayNotSameButEquals(intArrayOf(1, 2, 0), intArrayOf(1, 2).copyOf(3))
+
+        assertArrayNotSameButEquals(charArrayOf('A', 'B'), charArrayOf('A', 'B', 'C').copyOf(2))
+        assertArrayNotSameButEquals(charArrayOf('A', 'B', '\u0000'), charArrayOf('A', 'B').copyOf(3))
+    }
+
+    test fun copyOfRange() {
+        assertArrayNotSameButEquals(booleanArrayOf(true, false, true), booleanArrayOf(true, false, true, true).copyOfRange(0, 3))
+        assertArrayNotSameButEquals(byteArrayOf(0, 1, 2), byteArrayOf(0, 1, 2, 3, 4, 5).copyOfRange(0, 3))
+        assertArrayNotSameButEquals(shortArrayOf(0, 1, 2), shortArrayOf(0, 1, 2, 3, 4, 5).copyOfRange(0, 3))
+        assertArrayNotSameButEquals(intArrayOf(0, 1, 2), intArrayOf(0, 1, 2, 3, 4, 5).copyOfRange(0, 3))
+        assertArrayNotSameButEquals(longArrayOf(0, 1, 2), longArrayOf(0, 1, 2, 3, 4, 5).copyOfRange(0, 3))
+        assertArrayNotSameButEquals(floatArrayOf(0F, 1F, 2F), floatArrayOf(0F, 1F, 2F, 3F, 4F, 5F).copyOfRange(0, 3))
+        assertArrayNotSameButEquals(doubleArrayOf(0.0, 1.0, 2.0), doubleArrayOf(0.0, 1.0, 2.0, 3.0, 4.0, 5.0).copyOfRange(0, 3))
+        assertArrayNotSameButEquals(charArrayOf('0', '1', '2'), charArrayOf('0', '1', '2', '3', '4', '5').copyOfRange(0, 3))
+    }
+
 
-    TODO FIXME ASAP: These currently fail on JS due to missing upto() method on numbers
 
     test fun reduce() {
-        expect(-4) { intArray(1, 2, 3) reduce { a, b -> a - b } }
-        // Fails in JS: expect(-4.toLong()) { longArray(1, 2, 3) reduce { a, b -> a - b } }
-        expect(-4.toFloat()) { floatArray(1.toFloat(), 2.toFloat(), 3.toFloat()) reduce { a, b -> a - b } }
-        expect(-4.0) { doubleArray(1.0, 2.0, 3.0) reduce { a, b -> a - b } }
-        expect('3') { charArray('1', '3', '2') reduce { a, b -> if(a > b) a else b } }
-        expect(false) { booleanArray(true, true, false) reduce { a, b -> a && b } }
-        expect(true) { booleanArray(true, true) reduce { a, b -> a && b } }
-        //  Fails in JS: expect(0.toByte()) { byteArray(3, 2, 1) reduce { a, b -> (a - b).toByte() } }
-        //  Fails in JS: expect(0.toShort()) { shortArray(3, 2, 1) reduce { a, b -> (a - b).toShort() } }
+        expect(-4) { intArrayOf(1, 2, 3) reduce { a, b -> a - b } }
+        expect(-4.toLong()) { longArrayOf(1, 2, 3) reduce { a, b -> a - b } }
+        expect(-4F) { floatArrayOf(1F, 2F, 3F) reduce { a, b -> a - b } }
+        expect(-4.0) { doubleArrayOf(1.0, 2.0, 3.0) reduce { a, b -> a - b } }
+        expect('3') { charArrayOf('1', '3', '2') reduce { a, b -> if (a > b) a else b } }
+        expect(false) { booleanArrayOf(true, true, false) reduce { a, b -> a && b } }
+        expect(true) { booleanArrayOf(true, true) reduce { a, b -> a && b } }
+        expect(0.toByte()) { byteArrayOf(3, 2, 1) reduce { a, b -> (a - b).toByte() } }
+        expect(0.toShort()) { shortArrayOf(3, 2, 1) reduce { a, b -> (a - b).toShort() } }
 
-        failsWith(javaClass<UnsupportedOperationException>()) {
-            intArray().reduce { a, b -> a + b}
-        }
+        assertTrue(fails {
+            intArrayOf().reduce { a, b -> a + b }
+        } is UnsupportedOperationException)
     }
 
     test fun reduceRight() {
-        expect(2) { intArray(1, 2, 3) reduceRight { a, b -> a - b } }
-        //  Fails in JS: expect(2.toLong()) { longArray(1, 2, 3) reduceRight { a, b -> a - b } }
-        expect(2.toFloat()) { floatArray(1.toFloat(), 2.toFloat(), 3.toFloat()) reduceRight { a, b -> a - b } }
-        expect(2.0) { doubleArray(1.0, 2.0, 3.0) reduceRight { a, b -> a - b } }
-        expect('3') { charArray('1', '3', '2') reduceRight { a, b -> if(a > b) a else b } }
-        expect(false) { booleanArray(true, true, false) reduceRight { a, b -> a && b } }
-        expect(true) { booleanArray(true, true) reduceRight { a, b -> a && b } }
-        //  Fails in JS: expect(2.toByte()) { byteArray(1, 2, 3) reduceRight { a, b -> (a - b).toByte() } }
-        //  Fails in JS: expect(2.toShort()) { shortArray(1, 2, 3) reduceRight { a, b -> (a - b).toShort() } }
+        expect(2) { intArrayOf(1, 2, 3) reduceRight { a, b -> a - b } }
+        expect(2.toLong()) { longArrayOf(1, 2, 3) reduceRight { a, b -> a - b } }
+        expect(2F) { floatArrayOf(1F, 2F, 3F) reduceRight { a, b -> a - b } }
+        expect(2.0) { doubleArrayOf(1.0, 2.0, 3.0) reduceRight { a, b -> a - b } }
+        expect('3') { charArrayOf('1', '3', '2') reduceRight { a, b -> if (a > b) a else b } }
+        expect(false) { booleanArrayOf(true, true, false) reduceRight { a, b -> a && b } }
+        expect(true) { booleanArrayOf(true, true) reduceRight { a, b -> a && b } }
+        expect(2.toByte()) { byteArrayOf(1, 2, 3) reduceRight { a, b -> (a - b).toByte() } }
+        expect(2.toShort()) { shortArrayOf(1, 2, 3) reduceRight { a, b -> (a - b).toShort() } }
 
-        failsWith(javaClass<UnsupportedOperationException>()) {
-            intArray().reduceRight { a, b -> a + b}
-        }
+        assertTrue(fails {
+            intArrayOf().reduceRight { a, b -> a + b }
+        } is UnsupportedOperationException)
     }
 
     test fun reverse() {
-        expect(arrayList(3, 2, 1)) { intArray(1, 2, 3).reverse() }
-        //  Fails in JS: expect(arrayList<Byte>(3, 2, 1)) { byteArray(1, 2, 3).reverse() }
-        //  Fails in JS: expect(arrayList<Short>(3, 2, 1)) { shortArray(1, 2, 3).reverse() }
-        //  Fails in JS: expect(arrayList<Long>(3, 2, 1)) { longArray(1, 2, 3).reverse() }
-        expect(arrayList(3.toFloat(), 2.toFloat(), 1.toFloat())) { floatArray(1.toFloat(), 2.toFloat(), 3.toFloat()).reverse() }
-        expect(arrayList(3.0, 2.0, 1.0)) { doubleArray(1.0, 2.0, 3.0).reverse() }
-        expect(arrayList('3', '2', '1')) { charArray('1', '2', '3').reverse() }
-        expect(arrayList(false, false, true)) { booleanArray(true, false, false).reverse() }
+        expect(listOf(3, 2, 1)) { intArrayOf(1, 2, 3).reverse() }
+        expect(listOf<Byte>(3, 2, 1)) { byteArrayOf(1, 2, 3).reverse() }
+        expect(listOf<Short>(3, 2, 1)) { shortArrayOf(1, 2, 3).reverse() }
+        expect(listOf<Long>(3, 2, 1)) { longArrayOf(1, 2, 3).reverse() }
+        expect(listOf(3F, 2F, 1F)) { floatArrayOf(1F, 2F, 3F).reverse() }
+        expect(listOf(3.0, 2.0, 1.0)) { doubleArrayOf(1.0, 2.0, 3.0).reverse() }
+        expect(listOf('3', '2', '1')) { charArrayOf('1', '2', '3').reverse() }
+        expect(listOf(false, false, true)) { booleanArrayOf(true, false, false).reverse() }
     }
 
-    */
+    test fun drop() {
+        expect(listOf(1), { intArrayOf(1).drop(0) })
+        expect(listOf(), { intArrayOf().drop(1) })
+        expect(listOf(), { intArrayOf(1).drop(1) })
+        expect(listOf(3), { intArrayOf(2, 3).drop(1) })
+        expect(listOf(2000000000000), { longArrayOf(3000000000000, 2000000000000).drop(1) })
+        expect(listOf(3.toByte()), { byteArrayOf(2, 3).drop(1) })
+        expect(listOf(3.toShort()), { shortArrayOf(2, 3).drop(1) })
+        expect(listOf(3.0f), { floatArrayOf(2f, 3f).drop(1) })
+        expect(listOf(3.0), { doubleArrayOf(2.0, 3.0).drop(1) })
+        expect(listOf(false), { booleanArrayOf(true, false).drop(1) })
+        expect(listOf('b'), { charArrayOf('a', 'b').drop(1) })
+        expect(listOf("b"), { arrayOf("a", "b").drop(1) })
+        fails {
+            listOf(2).drop(-1)
+        }
+    }
+
+    test fun dropLast() {
+        expect(listOf(), { intArrayOf().dropLast(1) })
+        expect(listOf(), { intArrayOf(1).dropLast(1) })
+        expect(listOf(1), { intArrayOf(1).dropLast(0) })
+        expect(listOf(2), { intArrayOf(2, 3).dropLast(1) })
+        expect(listOf(3000000000000), { longArrayOf(3000000000000, 2000000000000).dropLast(1) })
+        expect(listOf(2.toByte()), { byteArrayOf(2, 3).dropLast(1) })
+        expect(listOf(2.toShort()), { shortArrayOf(2, 3).dropLast(1) })
+        expect(listOf(2.0f), { floatArrayOf(2f, 3f).dropLast(1) })
+        expect(listOf(2.0), { doubleArrayOf(2.0, 3.0).dropLast(1) })
+        expect(listOf(true), { booleanArrayOf(true, false).dropLast(1) })
+        expect(listOf('a'), { charArrayOf('a', 'b').dropLast(1) })
+        expect(listOf("a"), { arrayOf("a", "b").dropLast(1) })
+        fails {
+            listOf(1).dropLast(-1)
+        }
+    }
+
+    test fun dropWhile() {
+        expect(listOf(), { intArrayOf().dropWhile { it < 3 } })
+        expect(listOf(), { intArrayOf(1).dropWhile { it < 3 } })
+        expect(listOf(3, 1), { intArrayOf(2, 3, 1).dropWhile { it < 3 } })
+        expect(listOf(2000000000000), { longArrayOf(3000000000000, 2000000000000).dropWhile { it > 2000000000000 } })
+        expect(listOf(3.toByte(), 1.toByte()), { byteArrayOf(2, 3, 1).dropWhile { it < 3 } })
+        expect(listOf(3.toShort(), 1.toShort()), { shortArrayOf(2, 3, 1).dropWhile { it < 3 } })
+        expect(listOf(3f, 1f), { floatArrayOf(2f, 3f, 1f).dropWhile { it < 3 } })
+        expect(listOf(3.0, 1.0), { doubleArrayOf(2.0, 3.0, 1.0).dropWhile { it < 3 } })
+        expect(listOf(false, true), { booleanArrayOf(true, false, true).dropWhile { it } })
+        expect(listOf('b', 'a'), { charArrayOf('a', 'b', 'a').dropWhile { it < 'b' } })
+        expect(listOf("b", "a"), { arrayOf("a", "b", "a").dropWhile { it < "b" } })
+    }
+
+    test fun dropLastWhile() {
+        expect(listOf(), { intArrayOf().dropLastWhile { it < 3 } })
+        expect(listOf(), { intArrayOf(1).dropLastWhile { it < 3 } })
+        expect(listOf(2, 3), { intArrayOf(2, 3, 1).dropLastWhile { it < 3 } })
+        expect(listOf(3000000000000), { longArrayOf(3000000000000, 2000000000000).dropLastWhile { it < 3000000000000 } })
+        expect(listOf(2.toByte(), 3.toByte()), { byteArrayOf(2, 3, 1).dropLastWhile { it < 3 } })
+        expect(listOf(2.toShort(), 3.toShort()), { shortArrayOf(2, 3, 1).dropLastWhile { it < 3 } })
+        expect(listOf(2f, 3f), { floatArrayOf(2f, 3f, 1f).dropLastWhile { it < 3 } })
+        expect(listOf(2.0, 3.0), { doubleArrayOf(2.0, 3.0, 1.0).dropLastWhile { it < 3 } })
+        expect(listOf(true, false), { booleanArrayOf(true, false, true).dropLastWhile { it } })
+        expect(listOf('a', 'b'), { charArrayOf('a', 'b', 'a').dropLastWhile { it < 'b' } })
+        expect(listOf("a", "b"), { arrayOf("a", "b", "a").dropLastWhile { it < "b" } })
+    }
+
+    test fun take() {
+        expect(listOf(), { intArrayOf().take(1) })
+        expect(listOf(), { intArrayOf(1).take(0) })
+        expect(listOf(1), { intArrayOf(1).take(1) })
+        expect(listOf(2), { intArrayOf(2, 3).take(1) })
+        expect(listOf(3000000000000), { longArrayOf(3000000000000, 2000000000000).take(1) })
+        expect(listOf(2.toByte()), { byteArrayOf(2, 3).take(1) })
+        expect(listOf(2.toShort()), { shortArrayOf(2, 3).take(1) })
+        expect(listOf(2.0f), { floatArrayOf(2f, 3f).take(1) })
+        expect(listOf(2.0), { doubleArrayOf(2.0, 3.0).take(1) })
+        expect(listOf(true), { booleanArrayOf(true, false).take(1) })
+        expect(listOf('a'), { charArrayOf('a', 'b').take(1) })
+        expect(listOf("a"), { arrayOf("a", "b").take(1) })
+        fails {
+            listOf(1).take(-1)
+        }
+    }
+
+    test fun takeLast() {
+        expect(listOf(), { intArrayOf().takeLast(1) })
+        expect(listOf(), { intArrayOf(1).takeLast(0) })
+        expect(listOf(1), { intArrayOf(1).takeLast(1) })
+        expect(listOf(3), { intArrayOf(2, 3).takeLast(1) })
+        expect(listOf(2000000000000), { longArrayOf(3000000000000, 2000000000000).takeLast(1) })
+        expect(listOf(3.toByte()), { byteArrayOf(2, 3).takeLast(1) })
+        expect(listOf(3.toShort()), { shortArrayOf(2, 3).takeLast(1) })
+        expect(listOf(3.0f), { floatArrayOf(2f, 3f).takeLast(1) })
+        expect(listOf(3.0), { doubleArrayOf(2.0, 3.0).takeLast(1) })
+        expect(listOf(false), { booleanArrayOf(true, false).takeLast(1) })
+        expect(listOf('b'), { charArrayOf('a', 'b').takeLast(1) })
+        expect(listOf("b"), { arrayOf("a", "b").takeLast(1) })
+        fails {
+            listOf(1).takeLast(-1)
+        }
+    }
+
+    test fun takeWhile() {
+        expect(listOf(), { intArrayOf().takeWhile { it < 3 } })
+        expect(listOf(1), { intArrayOf(1).takeWhile { it < 3 } })
+        expect(listOf(2), { intArrayOf(2, 3, 1).takeWhile { it < 3 } })
+        expect(listOf(3000000000000), { longArrayOf(3000000000000, 2000000000000).takeWhile { it > 2000000000000 } })
+        expect(listOf(2.toByte()), { byteArrayOf(2, 3, 1).takeWhile { it < 3 } })
+        expect(listOf(2.toShort()), { shortArrayOf(2, 3, 1).takeWhile { it < 3 } })
+        expect(listOf(2f), { floatArrayOf(2f, 3f, 1f).takeWhile { it < 3 } })
+        expect(listOf(2.0), { doubleArrayOf(2.0, 3.0, 1.0).takeWhile { it < 3 } })
+        expect(listOf(true), { booleanArrayOf(true, false, true).takeWhile { it } })
+        expect(listOf('a'), { charArrayOf('a', 'c', 'b').takeWhile { it < 'c' } })
+        expect(listOf("a"), { arrayOf("a", "c", "b").takeWhile { it < "c" } })
+    }
+
+    test fun takeLastWhile() {
+        expect(listOf(), { intArrayOf().takeLastWhile { it < 3 } })
+        expect(listOf(1), { intArrayOf(1).takeLastWhile { it < 3 } })
+        expect(listOf(1), { intArrayOf(2, 3, 1).takeLastWhile { it < 3 } })
+        expect(listOf(2000000000000), { longArrayOf(3000000000000, 2000000000000).takeLastWhile { it < 3000000000000 } })
+        expect(listOf(1.toByte()), { byteArrayOf(2, 3, 1).takeLastWhile { it < 3 } })
+        expect(listOf(1.toShort()), { shortArrayOf(2, 3, 1).takeLastWhile { it < 3 } })
+        expect(listOf(1f), { floatArrayOf(2f, 3f, 1f).takeLastWhile { it < 3 } })
+        expect(listOf(1.0), { doubleArrayOf(2.0, 3.0, 1.0).takeLastWhile { it < 3 } })
+        expect(listOf(true), { booleanArrayOf(true, false, true).takeLastWhile { it } })
+        expect(listOf('b'), { charArrayOf('a', 'c', 'b').takeLastWhile { it < 'c' } })
+        expect(listOf("b"), { arrayOf("a", "c", "b").takeLastWhile { it < "c" } })
+    }
+
+    test fun filter() {
+        expect(listOf(), { intArrayOf().filter { it > 2 } })
+        expect(listOf(), { intArrayOf(1).filter { it > 2 } })
+        expect(listOf(3), { intArrayOf(2, 3).filter { it > 2 } })
+        expect(listOf(3000000000000), { longArrayOf(3000000000000, 2000000000000).filter { it > 2000000000000 } })
+        expect(listOf(3.toByte()), { byteArrayOf(2, 3).filter { it > 2 } })
+        expect(listOf(3.toShort()), { shortArrayOf(2, 3).filter { it > 2 } })
+        expect(listOf(3.0f), { floatArrayOf(2f, 3f).filter { it > 2 } })
+        expect(listOf(3.0), { doubleArrayOf(2.0, 3.0).filter { it > 2 } })
+        expect(listOf(true), { booleanArrayOf(true, false).filter { it } })
+        expect(listOf('b'), { charArrayOf('a', 'b').filter { it > 'a' } })
+        expect(listOf("b"), { arrayOf("a", "b").filter { it > "a" } })
+    }
+
+    test fun filterNot() {
+        expect(listOf(), { intArrayOf().filterNot { it > 2 } })
+        expect(listOf(1), { intArrayOf(1).filterNot { it > 2 } })
+        expect(listOf(2), { intArrayOf(2, 3).filterNot { it > 2 } })
+        expect(listOf(2000000000000), { longArrayOf(3000000000000, 2000000000000).filterNot { it > 2000000000000 } })
+        expect(listOf(2.toByte()), { byteArrayOf(2, 3).filterNot { it > 2 } })
+        expect(listOf(2.toShort()), { shortArrayOf(2, 3).filterNot { it > 2 } })
+        expect(listOf(2.0f), { floatArrayOf(2f, 3f).filterNot { it > 2 } })
+        expect(listOf(2.0), { doubleArrayOf(2.0, 3.0).filterNot { it > 2 } })
+        expect(listOf(false), { booleanArrayOf(true, false).filterNot { it } })
+        expect(listOf('a'), { charArrayOf('a', 'b').filterNot { it > 'a' } })
+        expect(listOf("a"), { arrayOf("a", "b").filterNot { it > "a" } })
+    }
+
+    test fun filterNotNull() {
+        expect(listOf("a"), { arrayOf("a", null).filterNotNull() })
+    }
+
+    test fun asListPrimitives() {
+        // Array of primitives
+        val arr = intArrayOf(1, 2, 3, 4, 2, 5)
+        val list = arr.asList()
+        assertEquals(list, arr.toList())
+
+        assertTrue(2 in list)
+        assertFalse(0 in list)
+        assertTrue(list.containsAll(listOf(5, 4, 3)))
+        assertFalse(list.containsAll(listOf(5, 6, 3)))
+
+        expect(1) { list.indexOf(2) }
+        expect(4) { list.lastIndexOf(2) }
+        expect(-1) { list.indexOf(6) }
+
+        assertEquals(list.subList(3, 5), listOf(4, 2))
+
+        val iter = list.listIterator(2)
+        expect(2) { iter.nextIndex() }
+        expect(1) { iter.previousIndex() }
+        expect(3) {
+            iter.next()
+            iter.previous()
+            iter.next()
+        }
+
+        arr[2] = 4
+        assertEquals(list, arr.toList())
+
+        assertEquals(IntArray(0).asList(), emptyList<Int>())
+    }
+
+    test fun asListObjects() {
+        val arr = arrayOf("a", "b", "c", "d", "b", "e")
+        val list = arr.asList()
+
+        assertEquals(list, arr.toList())
+
+        assertTrue("b" in list)
+        assertFalse("z" in list)
+
+        expect(1) { list.indexOf("b") }
+        expect(4) { list.lastIndexOf("b") }
+        expect(-1) { list.indexOf("x") }
+
+        assertTrue(list.containsAll(listOf("e", "d", "c")))
+        assertFalse(list.containsAll(listOf("e", "x", "c")))
+
+        assertEquals(list.subList(3, 5), listOf("d", "b"))
+
+        val iter = list.listIterator(2)
+        expect(2) { iter.nextIndex() }
+        expect(1) { iter.previousIndex() }
+        expect("c") {
+            iter.next()
+            iter.previous()
+            iter.next()
+        }
+
+        arr[2] = "xx"
+        assertEquals(list, arr.toList())
+
+        assertEquals(Array(0, { "" }).asList(), emptyList<String>())
+    }
 }
diff --git a/libraries/stdlib/test/collections/CollectionJVMTest.kt b/libraries/stdlib/test/collections/CollectionJVMTest.kt
index 2d7d658290d..acd154b6a14 100644
--- a/libraries/stdlib/test/collections/CollectionJVMTest.kt
+++ b/libraries/stdlib/test/collections/CollectionJVMTest.kt
@@ -12,6 +12,29 @@ import org.junit.Test as test
 
 class CollectionJVMTest {
 
+    private fun <T> identitySetOf(vararg values: T): MutableSet<T> {
+        val map = IdentityHashMap<T, String>()
+        values.forEach { map.put(it, "") }
+        return map.keySet()
+    }
+
+    private data class IdentityData(public val value: Int)
+
+    test fun removeAllWithDifferentEquality() {
+        val data = listOf(IdentityData(1), IdentityData(1))
+        val list = data.toArrayList()
+        list -= identitySetOf(data[0]) as Iterable<IdentityData>
+        assertTrue(list.single() === data[1], "Identity contains should be used")
+
+        val list2 = data.toArrayList()
+        list2 -= hashSetOf(data[0]) as Iterable<IdentityData>
+        assertTrue(list2.isEmpty(), "Equality contains should be used")
+
+        val set3: MutableSet<IdentityData> = identitySetOf(*data.toTypedArray())
+        set3 -= arrayOf(data[1])
+        assertTrue(set3.isEmpty(), "Array doesn't have contains, equality contains is used instead")
+    }
+
     test fun flatMap() {
         val data = listOf("", "foo", "bar", "x", "")
         val characters = data.flatMap { it.toCharList() }
diff --git a/libraries/stdlib/test/collections/CollectionTest.kt b/libraries/stdlib/test/collections/CollectionTest.kt
index a2496980d13..59f593718a5 100644
--- a/libraries/stdlib/test/collections/CollectionTest.kt
+++ b/libraries/stdlib/test/collections/CollectionTest.kt
@@ -197,37 +197,90 @@ class CollectionTest {
         assertEquals(listOf(2, 4, 6), range)
     }
 
-    test fun plus() {
+    fun testPlus(doPlus: (List<String>) -> List<String>) {
         val list = listOf("foo", "bar")
-        val list2 = list + "cheese"
+        val list2: List<String> = doPlus(list)
         assertEquals(listOf("foo", "bar"), list)
-        assertEquals(listOf("foo", "bar", "cheese"), list2)
-
-        // lets use a mutable variable
-        var list3 = listOf("a", "b")
-        list3 += "c"
-        assertEquals(listOf("a", "b", "c"), list3)
+        assertEquals(listOf("foo", "bar", "cheese", "wine"), list2)
     }
 
+    test fun plusElement() = testPlus { it + "cheese" + "wine" }
+    test fun plusCollection() = testPlus { it + listOf("cheese", "wine") }
+    test fun plusArray() = testPlus { it + arrayOf("cheese", "wine") }
+    test fun plusSequence() = testPlus { it + sequenceOf("cheese", "wine") }
+
     test fun plusCollectionBug() {
         val list = listOf("foo", "bar") + listOf("cheese", "wine")
         assertEquals(listOf("foo", "bar", "cheese", "wine"), list)
     }
 
-    test fun plusCollection() {
-        val a = listOf("foo", "bar")
-        val b = listOf("cheese", "wine")
-        val list = a + b
-        assertEquals(listOf("foo", "bar", "cheese", "wine"), list)
 
-        // lets use a mutable variable
-        var ml: List<String> = a
-        ml += "beer"
-        ml += b
-        ml += "z"
-        assertEquals(listOf("foo", "bar", "beer", "cheese", "wine", "z"), ml)
+    test fun plusAssign() {
+        // lets use a mutable variable of readonly list
+        var l: List<String> = listOf("cheese")
+        val lOriginal = l
+        l += "foo"
+        l += listOf("beer")
+        l += arrayOf("cheese", "wine")
+        l += sequenceOf("bar", "foo")
+        assertEquals(listOf("cheese", "foo", "beer", "cheese", "wine", "bar", "foo"), l)
+        assertTrue(l !== lOriginal)
+
+        val ml = arrayListOf("cheese")
+        ml += "foo"
+        ml += listOf("beer")
+        ml += arrayOf("cheese", "wine")
+        ml += sequenceOf("bar", "foo")
+        assertEquals(l, ml)
     }
 
+
+    private fun testMinus(expected: List<String>? = null, doMinus: (List<String>) -> List<String>) {
+        val a = listOf("foo", "bar", "bar")
+        val b: List<String> = doMinus(a)
+        val expected_ = expected ?: listOf("foo")
+        assertEquals(expected_, b.toList())
+    }
+
+    test fun minusElement() = testMinus(expected = listOf("foo", "bar")) { it - "bar" - "zoo" }
+    test fun minusCollection() = testMinus { it - listOf("bar", "zoo") }
+    test fun minusArray() = testMinus { it - arrayOf("bar", "zoo") }
+    test fun minusSequence() = testMinus { it - sequenceOf("bar", "zoo") }
+
+    test fun minusIsEager() {
+        val source = listOf("foo", "bar")
+        val list = arrayListOf<String>()
+        val result = source - list
+
+        list += "foo"
+        assertEquals(source, result)
+        list += "bar"
+        assertEquals(source, result)
+    }
+
+    test fun minusAssign() {
+        // lets use a mutable variable of readonly list
+        val data: List<String> = listOf("cheese", "foo", "beer", "cheese", "wine")
+        var l = data
+        l -= "cheese"
+        assertEquals(listOf("foo", "beer", "cheese", "wine"), l)
+        l = data
+        l -= listOf("cheese", "beer")
+        assertEquals(listOf("foo", "wine"), l)
+        l -= arrayOf("wine", "bar")
+        assertEquals(listOf("foo"), l)
+
+        val ml = arrayListOf("cheese", "cheese", "foo", "beer", "cheese", "wine")
+        ml -= "cheese"
+        assertEquals(listOf("cheese", "foo", "beer", "cheese", "wine"), ml)
+        ml -= listOf("cheese", "beer")
+        assertEquals(listOf("foo", "wine"), ml)
+        ml -= arrayOf("wine", "bar")
+        assertEquals(listOf("foo"), ml)
+    }
+
+
+
     test fun requireNoNulls() {
         val data = arrayListOf<String?>("foo", "bar")
         val notNull = data.requireNoNulls()
diff --git a/libraries/stdlib/test/collections/IterableTests.kt b/libraries/stdlib/test/collections/IterableTests.kt
index bf15b8413c4..60ea5810072 100644
--- a/libraries/stdlib/test/collections/IterableTests.kt
+++ b/libraries/stdlib/test/collections/IterableTests.kt
@@ -281,4 +281,72 @@ abstract class IterableTests<T : Iterable<String>>(val data: T, val empty: T) {
         val result = data.joinToString(separator = "-") { it.toUpperCase() }
         assertEquals("FOO-BAR", result)
     }
+
+    fun testPlus(doPlus: (Iterable<String>) -> List<String>) {
+        val result: List<String> = doPlus(data)
+        assertEquals(listOf("foo", "bar", "zoo", "g"), result)
+        assertFalse(result === data)
+    }
+
+    Test
+    fun plusElement() = testPlus { it + "zoo" + "g" }
+    Test
+    fun plusCollection() = testPlus { it + listOf("zoo", "g") }
+    Test
+    fun plusArray() = testPlus { it + arrayOf("zoo", "g") }
+    Test
+    fun plusSequence() = testPlus { it + sequenceOf("zoo", "g") }
+
+    Test
+    fun plusAssign() {
+        // lets use a mutable variable
+        var result: Iterable<String> = data
+        result += "foo"
+        result += listOf("beer")
+        result += arrayOf("cheese", "wine")
+        result += sequenceOf("zoo", "g")
+        assertEquals(listOf("foo", "bar", "foo", "beer", "cheese", "wine", "zoo", "g"), result)
+    }
+
+    Test
+    fun minusElement() {
+        val result = data - "foo" - "g"
+        assertEquals(listOf("bar"), result)
+    }
+
+    Test
+    fun minusCollection() {
+        val result = data - listOf("foo", "g")
+        assertEquals(listOf("bar"), result)
+    }
+
+    Test
+    fun minusArray() {
+        val result = data - arrayOf("foo", "g")
+        assertEquals(listOf("bar"), result)
+    }
+
+    Test
+    fun minusSequence() {
+        val result = data - sequenceOf("foo", "g")
+        assertEquals(listOf("bar"), result)
+    }
+
+    Test
+    fun minusAssign() {
+        // lets use a mutable variable
+        var result: Iterable<String> = data
+        result -= "foo"
+        assertEquals(listOf("bar"), result)
+        result = data
+        result -= listOf("beer", "bar")
+        assertEquals(listOf("foo"), result)
+        result = data
+        result -= arrayOf("bar", "foo")
+        assertEquals(emptyList<String>(), result)
+        result = data
+        result -= sequenceOf("foo", "g")
+        assertEquals(listOf("bar"), result)
+    }
+
 }
diff --git a/libraries/stdlib/test/collections/ListSpecificTest.kt b/libraries/stdlib/test/collections/ListSpecificTest.kt
index 2e136584390..b494c742724 100644
--- a/libraries/stdlib/test/collections/ListSpecificTest.kt
+++ b/libraries/stdlib/test/collections/ListSpecificTest.kt
@@ -28,6 +28,22 @@ class ListSpecificTest {
         assertEquals(listOf('C', 'A', 'D'), list.slice(iter))
     }
 
+    Test fun getOr() {
+        expect("foo") { data.get(0) }
+        expect("bar") { data.get(1) }
+        fails { data.get(2) }
+        fails { data.get(-1) }
+        fails { empty.get(0) }
+
+        expect("foo") { data.getOrElse(0, {""} )}
+        expect("zoo") { data.getOrElse(-1, { "zoo" })}
+        expect("zoo") { data.getOrElse(2, { "zoo" })}
+        expect("zoo") { empty.getOrElse(0) { "zoo" }}
+
+        expect(null) { empty.getOrNull(0) }
+
+    }
+
     Test fun lastIndex() {
         assertEquals(-1, empty.lastIndex)
         assertEquals(1, data.lastIndex)
diff --git a/libraries/stdlib/test/collections/MapTest.kt b/libraries/stdlib/test/collections/MapTest.kt
index 2a2e1c72f90..6eeec4ed7e4 100644
--- a/libraries/stdlib/test/collections/MapTest.kt
+++ b/libraries/stdlib/test/collections/MapTest.kt
@@ -268,120 +268,108 @@ class MapTest {
         assertEquals(3, filteredByValue["b"])
     }
 
-    test fun plusAssign() {
-        val extended = hashMapOf(Pair("b", 3))
-        extended += ("c" to 2)
-        assertEquals(2, extended.size())
-        assertEquals(2, extended["c"])
-        assertEquals(3, extended["b"])
+    fun testPlusAssign(doPlusAssign: (MutableMap<String, Int>) -> Unit) {
+        val map = hashMapOf("a" to 1, "b" to 2)
+        doPlusAssign(map)
+        assertEquals(3, map.size())
+        assertEquals(1, map["a"])
+        assertEquals(4, map["b"])
+        assertEquals(3, map["c"])
     }
 
-    test fun plusAssignList() {
-        val extended = hashMapOf(Pair("b", 3))
-        extended += listOf("C" to 3, "D" to 4)
+    test fun plusAssign() = testPlusAssign {
+        it += "b" to 4
+        it += "c" to 3
+    }
+
+    test fun plusAssignList() = testPlusAssign { it += listOf("c" to 3, "b" to 4) }
+
+    test fun plusAssignArray() = testPlusAssign { it += arrayOf("c" to 3, "b" to 4) }
+
+    test fun plusAssignSequence() = testPlusAssign { it += sequenceOf("c" to 3, "b" to 4) }
+
+    test fun plusAssignMap() = testPlusAssign { it += mapOf("c" to 3, "b" to 4) }
+
+    fun testPlus(doPlus: (Map<String, Int>) -> Map<String, Int>) {
+        val original = mapOf("A" to 1, "B" to 2)
+        val extended = doPlus(original)
         assertEquals(3, extended.size())
+        assertEquals(1, extended["A"])
+        assertEquals(4, extended["B"])
         assertEquals(3, extended["C"])
-        assertEquals(4, extended["D"])
     }
 
-    test fun plusAssignMap() {
-        val extended = hashMapOf(Pair("b", 3))
-        extended += mapOf("C" to 3, "D" to 4)
-        assertEquals(3, extended.size())
-        assertEquals(3, extended["C"])
-        assertEquals(4, extended["D"])
-    }
+    test fun plus() = testPlus { it + ("C" to 3) + ("B" to 4) }
 
-    test fun plus() {
+    test fun plusList() = testPlus { it + listOf("C" to 3, "B" to 4) }
+
+    test fun plusArray() = testPlus { it + arrayOf("C" to 3, "B" to 4) }
+
+    test fun plusSequence() = testPlus { it + sequenceOf("C" to 3, "B" to 4) }
+
+    test fun plusMap() = testPlus { it + mapOf("C" to 3, "B" to 4) }
+
+
+    fun testMinus(doMinus: (Map<String, Int>) -> Map<String, Int>) {
         val original = mapOf("A" to 1, "B" to 2)
-        val extended = original + ("C" to 3)
-        assertEquals(extended["A"], 1)
-        assertEquals(extended["B"], 2)
-        assertEquals(extended["C"], 3)
+        val shortened = doMinus(original)
+        assertEquals("A" to 1, shortened.entrySet().single().toPair())
     }
 
-    test fun plusList() {
-        val original = mapOf("A" to 1, "B" to 2)
-        val extended = original + listOf("C" to 3, "D" to 4)
-        assertEquals(extended["A"], 1)
-        assertEquals(extended["B"], 2)
-        assertEquals(extended["C"], 3)
-        assertEquals(extended["D"], 4)
+    test fun minus() = testMinus { it - "B" - "C" }
+
+    test fun minusList() = testMinus { it - listOf("B", "C") }
+
+    test fun minusArray() = testMinus { it - arrayOf("B", "C") }
+
+    test fun minusSequence() = testMinus { it - sequenceOf("B", "C") }
+
+    test fun minusSet() = testMinus { it - setOf("B", "C") }
+
+
+
+    fun testMinusAssign(doMinusAssign: (MutableMap<String, Int>) -> Unit) {
+        val original = hashMapOf("A" to 1, "B" to 2)
+        doMinusAssign(original)
+        assertEquals("A" to 1, original.entrySet().single().toPair())
     }
 
-    test fun plusMap() {
-        val original = mapOf("A" to 1, "B" to 2)
-        val extended = original + mapOf("C" to 3, "D" to 4)
-        assertEquals(extended["A"], 1)
-        assertEquals(extended["B"], 2)
-        assertEquals(extended["C"], 3)
-        assertEquals(extended["D"], 4)
+    test fun minusAssign() = testMinusAssign {
+        it -= "B"
+        it -= "C"
     }
 
-    test fun plusListOverload() {
+    test fun minusAssignList() = testMinusAssign { it -= listOf("B", "C") }
+
+    test fun minusAssignArray() = testMinusAssign { it -= arrayOf("B", "C") }
+
+    test fun minusAssignSequence() = testMinusAssign { it -= sequenceOf("B", "C") }
+
+
+    fun testIdempotent(operation: (Map<String, Int>) -> Map<String, Int>) {
         val original = mapOf("A" to 1, "B" to 2)
-        val extended = original + listOf("B" to 3, "C" to 4)
-        assertEquals(extended["A"], 1)
-        assertEquals(extended["B"], 3)
-        assertEquals(extended["C"], 4)
+        assertEquals(original, operation(original))
     }
 
-    test fun plusEmptyList() {
-        val original = mapOf("A" to 1, "B" to 2)
-        val extended = original + listOf()
-        assertEquals(extended["A"], 1)
-        assertEquals(extended["B"], 2)
+    fun testIdempotentAssign(operation: (MutableMap<String, Int>) -> Unit) {
+        val original = hashMapOf("A" to 1, "B" to 2)
+        val result = HashMap(original)
+        operation(result)
+        assertEquals(original, result)
     }
 
-    test fun plusEmptySet() {
-        val original = mapOf("A" to 1, "B" to 2)
-        val extended = original + setOf()
-        assertEquals(extended["A"], 1)
-        assertEquals(extended["B"], 2)
-    }
 
-    test fun minus() {
-        val original = mapOf("A" to 1, "B" to 2)
-        val shortened = original - "B"
-        assertEquals(shortened["A"], 1)
-        assertFalse(shortened.contains("B"))
-    }
+    test fun plusEmptyList() = testIdempotent { it + listOf() }
+    test fun minusEmptyList() = testIdempotent { it - listOf() }
 
-    test fun minusNotElem() {
-        val original = mapOf("A" to 1, "B" to 2)
-        val shortened = original - "C"
-        assertEquals(shortened["A"], 1)
-        assertEquals(shortened["B"], 2)
-    }
+    test fun plusEmptySet() = testIdempotent { it + setOf() }
+    test fun minusEmptySet() = testIdempotent { it - setOf() }
 
-    test fun minusList() {
-        val original = mapOf("A" to 1, "B" to 2)
-        val shortened = original - listOf("B", "C")
-        assertEquals(shortened["A"], 1)
-        assertFalse(shortened.contains("B"))
-        assertFalse(shortened.contains("C"))
-    }
+    test fun plusAssignEmptyList() = testIdempotentAssign { it += listOf() }
+    test fun minusAssignEmptyList() = testIdempotentAssign { it -= listOf() }
 
-    test fun minusListNotElem() {
-        val original = mapOf("A" to 1, "B" to 2)
-        val shortened = original - listOf("C", "D")
-        assertEquals(shortened["A"], 1)
-        assertEquals(shortened["B"], 2)
-    }
+    test fun plusAssignEmptySet() = testIdempotentAssign { it += setOf() }
+    test fun minusAssignEmptySet() = testIdempotentAssign { it -= setOf() }
 
-    test fun minusSet() {
-        val original = mapOf("A" to 1, "B" to 2)
-        val shortened = original - setOf("B", "C")
-        assertEquals(shortened["A"], 1)
-        assertFalse(shortened.contains("B"))
-        assertFalse(shortened.contains("C"))
-    }
-
-    test fun minusEmptySet() {
-        val original = mapOf("A" to 1, "B" to 2)
-        val shortened = original - setOf()
-        assertEquals(shortened["A"], 1)
-        assertEquals(shortened["B"], 2)
-    }
 
 }
diff --git a/libraries/stdlib/test/collections/MutableCollectionsTest.kt b/libraries/stdlib/test/collections/MutableCollectionsTest.kt
index aa2a1460e4d..bffe1255e3b 100644
--- a/libraries/stdlib/test/collections/MutableCollectionsTest.kt
+++ b/libraries/stdlib/test/collections/MutableCollectionsTest.kt
@@ -8,22 +8,44 @@ import org.junit.Test as test
 
 class MutableCollectionTest {
 
-    test fun fromIterable() {
-        val data: Iterable<String> = listOf("foo", "bar")
+    // TODO: Use apply scope function
 
-        val collection = ArrayList<String>()
-        collection.addAll(data)
+    test fun addAll() {
+        val data = listOf("foo", "bar")
 
-        assertEquals(data, collection)
+        fun assertAdd(f: MutableList<String>.() -> Unit) = assertEquals(data, arrayListOf<String>().let { it.f(); it })
+
+        assertAdd { addAll(data) }
+        assertAdd { addAll(data.toTypedArray()) }
+        assertAdd { addAll(data.toTypedArray().asIterable()) }
+        assertAdd { addAll(data.asSequence()) }
     }
 
-    test fun fromSequence() {
-        val list = listOf("foo", "bar")
-        val collection = ArrayList<String>()
+    test fun removeAll() {
+        val content = arrayOf("foo", "bar", "bar")
+        val data = listOf("bar")
+        val expected = listOf("foo")
 
-        collection.addAll(list.asSequence())
+        fun assertRemove(f: MutableList<String>.() -> Unit) = assertEquals(expected, arrayListOf(*content).let { it.f(); it })
 
-        assertEquals(list, collection)
+        assertRemove { removeAll(data) }
+        assertRemove { removeAll(data.toTypedArray()) }
+        assertRemove { removeAll(data.toTypedArray().asIterable()) }
+        assertRemove { removeAll(data.asSequence()) }
+    }
+
+
+    test fun retainAll() {
+        val content = arrayOf("foo", "bar", "bar")
+        val data = listOf("bar")
+        val expected = listOf("bar", "bar")
+
+        fun assertRetain(f: MutableList<String>.() -> Unit) = assertEquals(expected, arrayListOf(*content).let { it.f(); it })
+
+        assertRetain { retainAll(data) }
+        assertRetain { retainAll(data.toTypedArray()) }
+        assertRetain { retainAll(data.toTypedArray().asIterable()) }
+        assertRetain { retainAll(data.asSequence()) }
     }
 
 }
diff --git a/libraries/stdlib/test/collections/SequenceTest.kt b/libraries/stdlib/test/collections/SequenceTest.kt
index 9adbed14915..a1739f3e988 100644
--- a/libraries/stdlib/test/collections/SequenceTest.kt
+++ b/libraries/stdlib/test/collections/SequenceTest.kt
@@ -132,37 +132,72 @@ public class SequenceTest {
         assertEquals("144, 233, 377, 610, 987", fibonacci().filter { it > 100 }.takeWhile { it < 1000 }.joinToString())
     }
 
-    test fun plus() {
-        val sequence = sequenceOf("foo", "bar")
-        val sequenceCheese = sequence + "cheese"
-        assertEquals(listOf("foo", "bar", "cheese"), sequenceCheese.toList())
 
-        // lets use a mutable variable
-        var mi = sequenceOf("a", "b")
-        mi += "c"
-        assertEquals(listOf("a", "b", "c"), mi.toList())
+    fun testPlus(doPlus: (Sequence<String>) -> Sequence<String>) {
+        val seq = sequenceOf("foo", "bar")
+        val seq2: Sequence<String> = doPlus(seq)
+        assertEquals(listOf("foo", "bar"), seq.toList())
+        assertEquals(listOf("foo", "bar", "cheese", "wine"), seq2.toList())
     }
 
-    test fun plusCollection() {
-        val a = sequenceOf("foo", "bar")
-        val b = listOf("cheese", "wine")
-        val sequence = a + b
-        assertEquals(listOf("foo", "bar", "cheese", "wine"), sequence.toList())
 
+    test fun plusElement() = testPlus { it + "cheese" + "wine" }
+    test fun plusCollection() = testPlus { it + listOf("cheese", "wine") }
+    test fun plusArray() = testPlus { it + arrayOf("cheese", "wine") }
+    test fun plusSequence() = testPlus { it + sequenceOf("cheese", "wine") }
+
+    test fun plusAssign() {
         // lets use a mutable variable
-        var ml = sequenceOf("a")
-        ml += a
-        ml += "beer"
-        ml += b
-        ml += "z"
-        assertEquals(listOf("a", "foo", "bar", "beer", "cheese", "wine", "z"), ml.toList())
+        var seq = sequenceOf("a")
+        seq += "foo"
+        seq += listOf("beer")
+        seq += arrayOf("cheese", "wine")
+        seq += sequenceOf("bar", "foo")
+        assertEquals(listOf("a", "foo", "beer", "cheese", "wine", "bar", "foo"), seq.toList())
     }
 
+    private fun testMinus(expected: List<String>? = null, doMinus: (Sequence<String>) -> Sequence<String>) {
+        val a = sequenceOf("foo", "bar", "bar")
+        val b: Sequence<String> = doMinus(a)
+        val expected_ = expected ?: listOf("foo")
+        assertEquals(expected_, b.toList())
+    }
+
+    test fun minusElement() = testMinus(expected = listOf("foo", "bar")) { it - "bar" - "zoo" }
+    test fun minusCollection() = testMinus { it - listOf("bar", "zoo") }
+    test fun minusArray() = testMinus { it - arrayOf("bar", "zoo") }
+    test fun minusSequence() = testMinus { it - sequenceOf("bar", "zoo") }
+
+    test fun minusIsLazyIterated() {
+        val seq = sequenceOf("foo", "bar")
+        val list = arrayListOf<String>()
+        val result = seq - list
+
+        list += "foo"
+        assertEquals(listOf("bar"), result.toList())
+        list += "bar"
+        assertEquals(emptyList<String>(), result.toList())
+    }
+
+    test fun minusAssign() {
+        // lets use a mutable variable of readonly list
+        val data = sequenceOf("cheese", "foo", "beer", "cheese", "wine")
+        var l = data
+        l -= "cheese"
+        assertEquals(listOf("foo", "beer", "cheese", "wine"), l.toList())
+        l = data
+        l -= listOf("cheese", "beer")
+        assertEquals(listOf("foo", "wine"), l.toList())
+        l -= arrayOf("wine", "bar")
+        assertEquals(listOf("foo"), l.toList())
+    }
+
+
 
     test fun iterationOverSequence() {
         var s = ""
         for (i in sequenceOf(0, 1, 2, 3, 4, 5)) {
-            s = s + i.toString()
+            s += i.toString()
         }
         assertEquals("012345", s)
     }
diff --git a/libraries/stdlib/test/collections/SetOperationsTest.kt b/libraries/stdlib/test/collections/SetOperationsTest.kt
index 39f1dbe5518..92de7472a1a 100644
--- a/libraries/stdlib/test/collections/SetOperationsTest.kt
+++ b/libraries/stdlib/test/collections/SetOperationsTest.kt
@@ -32,4 +32,47 @@ class SetOperationsTest {
         assertEquals(listOf(1, 3, 5), listOf(1, 3, 5).intersect(listOf(1, 3, 5)).toList())
         assertTrue(listOf<Int>().intersect(listOf(1)).none())
     }
+
+    fun testPlus(doPlus: (Set<String>) -> Set<String>) {
+        val set = setOf("foo", "bar")
+        val set2: Set<String> = doPlus(set)
+        assertEquals(setOf("foo", "bar"), set)
+        assertEquals(setOf("foo", "bar", "cheese", "wine"), set2)
+    }
+
+    test fun plusElement() = testPlus { it + "bar" + "cheese" + "wine" }
+    test fun plusCollection() = testPlus { it + listOf("bar", "cheese", "wine") }
+    test fun plusArray() = testPlus { it + arrayOf("bar", "cheese", "wine") }
+    test fun plusSequence() = testPlus { it + sequenceOf("bar", "cheese", "wine") }
+
+    test fun plusAssign() {
+        // lets use a mutable variable
+        var set = setOf("a")
+        val setOriginal = set
+        set += "foo"
+        set += listOf("beer", "a")
+        set += arrayOf("cheese", "beer")
+        set += sequenceOf("bar", "foo")
+        assertEquals(setOf("a", "foo", "beer", "cheese", "bar"), set)
+        assertTrue(set !== setOriginal)
+
+        val mset = hashSetOf("a")
+        mset += "foo"
+        mset += listOf("beer", "a")
+        mset += arrayOf("cheese", "beer")
+        mset += sequenceOf("bar", "foo")
+        assertEquals(set, mset)
+    }
+
+    private fun testMinus(doMinus: (Set<String>) -> Set<String>) {
+        val a = setOf("foo", "bar")
+        val b: Set<String> = doMinus(a)
+        assertEquals(setOf("foo"), b)
+    }
+
+    test fun minusElement() = testMinus { it - "bar" - "zoo" }
+    test fun minusCollection() = testMinus { it - listOf("bar", "zoo") }
+    test fun minusArray() = testMinus { it - arrayOf("bar", "zoo") }
+    test fun minusSequence() = testMinus { it - sequenceOf("bar", "zoo") }
+
 }
\ No newline at end of file
diff --git a/libraries/stdlib/test/concurrent/FListTest.kt b/libraries/stdlib/test/concurrent/FListTest.kt
deleted file mode 100644
index fbc89746f6a..00000000000
--- a/libraries/stdlib/test/concurrent/FListTest.kt
+++ /dev/null
@@ -1,16 +0,0 @@
-package test.concurrent
-
-import kotlin.concurrent.*
-import junit.framework.*
-
-class FListTest() : TestCase() {
-    fun testEmpty() {
-        val empty = FunctionalQueue<Int> ()
-        Assert.assertTrue(empty.empty)
-    }
-
-    fun testNonEmpty() {
-//        val empty = FunctionalList.emptyList<Int> ()
-//        assertTrue(!(empty + 10).empty)
-    }
-}
diff --git a/libraries/stdlib/test/language/RangeIterationJVMTest.kt b/libraries/stdlib/test/language/RangeIterationJVMTest.kt
index 873f5f3d921..cef97c40cda 100644
--- a/libraries/stdlib/test/language/RangeIterationJVMTest.kt
+++ b/libraries/stdlib/test/language/RangeIterationJVMTest.kt
@@ -75,7 +75,7 @@ public class RangeIterationJVMTest {
         doTest((MaxS - 2).toShort()..MaxS, (MaxS - 2).toShort(), MaxS, 1, listOf((MaxS - 2).toShort(), (MaxS - 1).toShort(), MaxS))
         doTest((MaxL - 2).toLong()..MaxL, (MaxL - 2).toLong(), MaxL, 1.toLong(), listOf((MaxL - 2).toLong(), (MaxL - 1).toLong(), MaxL))
 
-        doTest((MaxC - 2).toChar()..MaxC, (MaxC - 2).toChar(), MaxC, 1, listOf((MaxC - 2).toChar(), (MaxC - 1).toChar(), MaxC))
+        doTest((MaxC - 2)..MaxC, (MaxC - 2), MaxC, 1, listOf((MaxC - 2), (MaxC - 1), MaxC))
     }
 
     test fun maxValueToMinValue() {
@@ -102,7 +102,7 @@ public class RangeIterationJVMTest {
         doTest((MaxS - 2).toShort()..MaxS step 2, (MaxS - 2).toShort(), MaxS, 2, listOf((MaxS - 2).toShort(), MaxS))
         doTest((MaxL - 2).toLong()..MaxL step 2, (MaxL - 2).toLong(), MaxL, 2.toLong(), listOf((MaxL - 2).toLong(), MaxL))
 
-        doTest((MaxC - 2).toChar()..MaxC step 2, (MaxC - 2).toChar(), MaxC, 2, listOf((MaxC - 2).toChar(), MaxC))
+        doTest((MaxC - 2)..MaxC step 2, (MaxC - 2), MaxC, 2, listOf((MaxC - 2), MaxC))
     }
 
     test fun progressionMaxValueToMinValue() {
@@ -129,7 +129,7 @@ public class RangeIterationJVMTest {
         doTest((MaxS - 5).toShort()..MaxS step 3, (MaxS - 5).toShort(), MaxS, 3, listOf((MaxS - 5).toShort(), (MaxS - 2).toShort()))
         doTest((MaxL - 5).toLong()..MaxL step 3, (MaxL - 5).toLong(), MaxL, 3.toLong(), listOf((MaxL - 5).toLong(), (MaxL - 2).toLong()))
 
-        doTest((MaxC - 5).toChar()..MaxC step 3, (MaxC - 5).toChar(), MaxC, 3, listOf((MaxC - 5).toChar(), (MaxC - 2).toChar()))
+        doTest((MaxC - 5)..MaxC step 3, (MaxC - 5), MaxC, 3, listOf((MaxC - 5), (MaxC - 2)))
     }
 
     test fun progressionDownToMinValue() {
@@ -138,7 +138,7 @@ public class RangeIterationJVMTest {
         doTest((MinS + 2).toShort() downTo MinS step 1, (MinS + 2).toShort(), MinS, -1, listOf((MinS + 2).toShort(), (MinS + 1).toShort(), MinS))
         doTest((MinL + 2).toLong() downTo MinL step 1, (MinL + 2).toLong(), MinL, -1.toLong(), listOf((MinL + 2).toLong(), (MinL + 1).toLong(), MinL))
 
-        doTest((MinC + 2).toChar() downTo MinC step 1, (MinC + 2).toChar(), MinC, -1, listOf((MinC + 2).toChar(), (MinC + 1).toChar(), MinC))
+        doTest((MinC + 2) downTo MinC step 1, (MinC + 2), MinC, -1, listOf((MinC + 2), (MinC + 1), MinC))
     }
 
     test fun inexactDownToMinValue() {
@@ -147,6 +147,6 @@ public class RangeIterationJVMTest {
         doTest((MinS + 5).toShort() downTo MinS step 3, (MinS + 5).toShort(), MinS, -3, listOf((MinS + 5).toShort(), (MinS + 2).toShort()))
         doTest((MinL + 5).toLong() downTo MinL step 3, (MinL + 5).toLong(), MinL, -3.toLong(), listOf((MinL + 5).toLong(), (MinL + 2).toLong()))
 
-        doTest((MinC + 5).toChar() downTo MinC step 3, (MinC + 5).toChar(), MinC, -3, listOf((MinC + 5).toChar(), (MinC + 2).toChar()))
+        doTest((MinC + 5) downTo MinC step 3, (MinC + 5), MinC, -3, listOf((MinC + 5), (MinC + 2)))
     }
 }
\ No newline at end of file
diff --git a/libraries/stdlib/validator/src/test/kotlin/NoInternalVisibilityInStdLibTest.kt b/libraries/stdlib/validator/src/test/kotlin/NoInternalVisibilityInStdLibTest.kt
index 97070f63ebe..729fb91036f 100644
--- a/libraries/stdlib/validator/src/test/kotlin/NoInternalVisibilityInStdLibTest.kt
+++ b/libraries/stdlib/validator/src/test/kotlin/NoInternalVisibilityInStdLibTest.kt
@@ -111,7 +111,7 @@ class NoInternalVisibilityInStdLibTest {
     }
 
     After fun tearDown() {
-        Disposer.dispose(disposable)
+        Disposer.dispose(disposable!!)
         disposable = null
     }
 
diff --git a/libraries/tools/kotlin-annotation-processing/src/main/kotlin/org/jetbrains/kotlin/annotation/AnnotationProcessorWrapper.kt b/libraries/tools/kotlin-annotation-processing/src/main/kotlin/org/jetbrains/kotlin/annotation/AnnotationProcessorWrapper.kt
index dec2c68a12c..4f38d40eb30 100644
--- a/libraries/tools/kotlin-annotation-processing/src/main/kotlin/org/jetbrains/kotlin/annotation/AnnotationProcessorWrapper.kt
+++ b/libraries/tools/kotlin-annotation-processing/src/main/kotlin/org/jetbrains/kotlin/annotation/AnnotationProcessorWrapper.kt
@@ -108,8 +108,8 @@ public abstract class AnnotationProcessorWrapper(
     override fun process(annotations: MutableSet<out TypeElement>?, roundEnv: RoundEnvironment): Boolean {
         roundCounter += 1
 
-        val annotatedKotlinElements = kotlinAnnotationsProvider.annotatedKotlinElements
-        val roundEnvironmentWrapper = RoundEnvironmentWrapper(processingEnv, roundEnv, roundCounter, annotatedKotlinElements)
+        val roundEnvironmentWrapper = RoundEnvironmentWrapper(
+                processingEnv, roundEnv, roundCounter, kotlinAnnotationsProvider)
         processor.process(annotations, roundEnvironmentWrapper)
         return false
     }
diff --git a/libraries/tools/kotlin-annotation-processing/src/main/kotlin/org/jetbrains/kotlin/annotation/KotlinAnnotationProvider.kt b/libraries/tools/kotlin-annotation-processing/src/main/kotlin/org/jetbrains/kotlin/annotation/KotlinAnnotationProvider.kt
index d4b44b19089..bd7fe065133 100644
--- a/libraries/tools/kotlin-annotation-processing/src/main/kotlin/org/jetbrains/kotlin/annotation/KotlinAnnotationProvider.kt
+++ b/libraries/tools/kotlin-annotation-processing/src/main/kotlin/org/jetbrains/kotlin/annotation/KotlinAnnotationProvider.kt
@@ -20,7 +20,6 @@ import java.io.File
 import java.io.Reader
 import java.io.StringReader
 import javax.tools.FileObject
-import kotlin.properties.Delegates
 
 public abstract class KotlinAnnotationProvider {
 
@@ -31,12 +30,22 @@ public abstract class KotlinAnnotationProvider {
 
         val SHORTENED_ANNOTATION = "a"
         val SHORTENED_PACKAGE_NAME = "p"
+
+        val CLASS_DECLARATION = "d"
     }
 
-    public val annotatedKotlinElements: Map<String, Set<AnnotatedElementDescriptor>> by Delegates.lazy {
+    public val annotatedKotlinElements: Map<String, Set<AnnotatedElementDescriptor>> by lazy {
         readAnnotations()
     }
 
+    private val kotlinClassesInternal = hashSetOf<String>()
+
+    public val kotlinClasses: Set<String>
+        get() = kotlinClassesInternal
+
+    public val supportInheritedAnnotations: Boolean
+        get() = kotlinClassesInternal.isNotEmpty()
+
     protected abstract val serializedAnnotations: Reader
 
     private fun readAnnotations(): MutableMap<String, MutableSet<AnnotatedElementDescriptor>> {
@@ -65,6 +74,10 @@ public abstract class KotlinAnnotationProvider {
                 when (type) {
                     SHORTENED_ANNOTATION -> handleShortenedName(shortenedAnnotationCache, lineParts)
                     SHORTENED_PACKAGE_NAME -> handleShortenedName(shortenedPackageNameCache, lineParts)
+                    CLASS_DECLARATION -> {
+                        val classFqName = expandClassName(lineParts[1]).replace('$', '.')
+                        kotlinClassesInternal.add(classFqName)
+                    }
 
                     ANNOTATED_CLASS, ANNOTATED_FIELD, ANNOTATED_METHOD -> {
                         val annotationName = expandAnnotation(lineParts[1])
diff --git a/libraries/tools/kotlin-annotation-processing/src/main/kotlin/org/jetbrains/kotlin/annotation/RoundEnvironmentWrapper.kt b/libraries/tools/kotlin-annotation-processing/src/main/kotlin/org/jetbrains/kotlin/annotation/RoundEnvironmentWrapper.kt
index c6571d1dc52..3c02d7d1325 100644
--- a/libraries/tools/kotlin-annotation-processing/src/main/kotlin/org/jetbrains/kotlin/annotation/RoundEnvironmentWrapper.kt
+++ b/libraries/tools/kotlin-annotation-processing/src/main/kotlin/org/jetbrains/kotlin/annotation/RoundEnvironmentWrapper.kt
@@ -1,16 +1,19 @@
 package org.jetbrains.kotlin.annotation
 
+import java.lang.annotation.Inherited
 import javax.annotation.processing.ProcessingEnvironment
 import javax.annotation.processing.RoundEnvironment
 import javax.lang.model.element.Element
 import javax.lang.model.element.ElementKind
 import javax.lang.model.element.TypeElement
+import javax.lang.model.type.NoType
+import javax.lang.model.type.TypeVisitor
 
 private class RoundEnvironmentWrapper(
         val processingEnv: ProcessingEnvironment,
         val parent: RoundEnvironment,
         val roundNumber: Int,
-        val annotatedElementDescriptors: Map<String, Set<AnnotatedElementDescriptor>>
+        val kotlinAnnotationsProvider: KotlinAnnotationProvider
 ) : RoundEnvironment {
 
     override fun getRootElements(): MutableSet<out Element>? {
@@ -45,11 +48,23 @@ private class RoundEnvironmentWrapper(
         return getAnnotationMirrors().any { annotationFqName == it.getAnnotationType().asElement().toString() }
     }
 
+    private fun TypeElement.hasInheritedAnnotation(annotationFqName: String): Boolean {
+        if (hasAnnotation(annotationFqName)) return true
+
+        val superclassMirror = getSuperclass()
+        if (superclassMirror is NoType) return false
+
+        val superClass = processingEnv.getTypeUtils().asElement(superclassMirror)
+        if (superClass !is TypeElement) return false
+
+        return superClass.hasInheritedAnnotation(annotationFqName)
+    }
+
     private fun resolveKotlinElements(annotationFqName: String): Set<Element> {
         if (roundNumber > 1) return setOf()
 
-        val descriptors = annotatedElementDescriptors.get(annotationFqName) ?: setOf()
-        return descriptors.fold(hashSetOf<Element>()) { set, descriptor ->
+        val descriptors = kotlinAnnotationsProvider.annotatedKotlinElements.get(annotationFqName) ?: setOf()
+        val descriptorsWithKotlin = descriptors.fold(hashSetOf<Element>()) { set, descriptor ->
             val clazz = processingEnv.getElementUtils().getTypeElement(descriptor.classFqName) ?: return@fold set
             when (descriptor) {
                 is AnnotatedClassDescriptor -> set.add(clazz)
@@ -68,5 +83,21 @@ private class RoundEnvironmentWrapper(
             }
             set
         }
+
+        if (kotlinAnnotationsProvider.supportInheritedAnnotations) {
+            val isInherited = processingEnv.getElementUtils().getTypeElement(annotationFqName)
+                    ?.hasAnnotation(javaClass<Inherited>().getCanonicalName()) ?: false
+
+            if (isInherited) {
+                kotlinAnnotationsProvider.kotlinClasses.forEach { classFqName ->
+                    val clazz = processingEnv.getElementUtils().getTypeElement(classFqName) ?: return@forEach
+                    if (clazz.hasInheritedAnnotation(annotationFqName)) {
+                        descriptorsWithKotlin.add(clazz)
+                    }
+                }
+            }
+        }
+
+        return descriptorsWithKotlin
     }
 }
diff --git a/libraries/tools/kotlin-annotation-processing/src/test/kotlin/org/jetbrains/kotlin/annotation/AnnotationListParseTest.kt b/libraries/tools/kotlin-annotation-processing/src/test/kotlin/org/jetbrains/kotlin/annotation/AnnotationListParseTest.kt
index b7565f2628b..906c3c6d2a9 100644
--- a/libraries/tools/kotlin-annotation-processing/src/test/kotlin/org/jetbrains/kotlin/annotation/AnnotationListParseTest.kt
+++ b/libraries/tools/kotlin-annotation-processing/src/test/kotlin/org/jetbrains/kotlin/annotation/AnnotationListParseTest.kt
@@ -32,6 +32,8 @@ public class AnnotationListParseTest {
 
     Test fun testSimple() = doTest("simple")
 
+    Test fun testDeclarations() = doTest("classDeclarations")
+
 
     private val resourcesRootFile = File("src/test/resources/parse")
 
@@ -59,10 +61,11 @@ public class AnnotationListParseTest {
             }
         }
 
-        val actualAnnotationsSorted = actualAnnotations.toString()
-                .lines().filter { it.isNotEmpty() }.sort().joinToString("\n")
+        val actualAnnotationsSorted = actualAnnotations.toString().lines().filter { it.isNotEmpty() }.sort()
+        val classDeclarationsSorted = annotationProvider.kotlinClasses.sort()
 
-        assertEqualsToFile(expectedFile, actualAnnotationsSorted)
+        val fileContents = (actualAnnotationsSorted + classDeclarationsSorted).joinToString("\n")
+        assertEqualsToFile(expectedFile, fileContents)
     }
 
     // JetTestUtils.assertEqualsToFile() is not reachable from here
diff --git a/libraries/tools/kotlin-annotation-processing/src/test/resources/parse/classDeclarations/annotations.txt b/libraries/tools/kotlin-annotation-processing/src/test/resources/parse/classDeclarations/annotations.txt
new file mode 100644
index 00000000000..583f2226280
--- /dev/null
+++ b/libraries/tools/kotlin-annotation-processing/src/test/resources/parse/classDeclarations/annotations.txt
@@ -0,0 +1,5 @@
+p example 0
+d 0/TestClass
+a example.ExampleAnnotation 0
+c 0 0/TestClass
+d 0/AncestorClass
\ No newline at end of file
diff --git a/libraries/tools/kotlin-annotation-processing/src/test/resources/parse/classDeclarations/parsed.txt b/libraries/tools/kotlin-annotation-processing/src/test/resources/parse/classDeclarations/parsed.txt
new file mode 100644
index 00000000000..a8f1156e72a
--- /dev/null
+++ b/libraries/tools/kotlin-annotation-processing/src/test/resources/parse/classDeclarations/parsed.txt
@@ -0,0 +1,3 @@
+example.ExampleAnnotation example.TestClass
+example.AncestorClass
+example.TestClass
\ No newline at end of file
diff --git a/libraries/tools/kotlin-annotation-processing/src/test/resources/parse/nestedClasses/annotations.txt b/libraries/tools/kotlin-annotation-processing/src/test/resources/parse/nestedClasses/annotations.txt
index 06d233ba572..c8d587fc057 100644
--- a/libraries/tools/kotlin-annotation-processing/src/test/resources/parse/nestedClasses/annotations.txt
+++ b/libraries/tools/kotlin-annotation-processing/src/test/resources/parse/nestedClasses/annotations.txt
@@ -6,5 +6,3 @@ m 1 0/SomeClass$Companion access$init$0
 c 0 0/SomeClass$SomeInnerObject
 c 0 0/SomeClass$InnerClass
 c 0 0/SomeClass$NestedClass
-a java.lang.Deprecated 2
-f 2 0/SomeClass OBJECT$
diff --git a/libraries/tools/kotlin-annotation-processing/src/test/resources/parse/nestedClasses/parsed.txt b/libraries/tools/kotlin-annotation-processing/src/test/resources/parse/nestedClasses/parsed.txt
index 5611a2ca5d2..c22f8eb4807 100644
--- a/libraries/tools/kotlin-annotation-processing/src/test/resources/parse/nestedClasses/parsed.txt
+++ b/libraries/tools/kotlin-annotation-processing/src/test/resources/parse/nestedClasses/parsed.txt
@@ -1,4 +1,3 @@
-java.lang.Deprecated org.test.SomeClass OBJECT$
 javax.inject.Named org.test.SomeClass.Companion
 javax.inject.Named org.test.SomeClass.InnerClass
 javax.inject.Named org.test.SomeClass.NestedClass
diff --git a/libraries/tools/kotlin-annotation-processing/src/test/resources/parse/platformStatic/annotations.txt b/libraries/tools/kotlin-annotation-processing/src/test/resources/parse/platformStatic/annotations.txt
index 4d9c66f1134..8ba2076e654 100644
--- a/libraries/tools/kotlin-annotation-processing/src/test/resources/parse/platformStatic/annotations.txt
+++ b/libraries/tools/kotlin-annotation-processing/src/test/resources/parse/platformStatic/annotations.txt
@@ -5,7 +5,5 @@ a kotlin.inline 1
 m 1 0/SomeClass$Companion a
 a org.jetbrains.annotations.NotNull 2
 m 2 0/SomeClass$Companion access$init$0
-a java.lang.Deprecated 3
-f 3 0/SomeClass OBJECT$
 m 0 0/SomeClass a
 m 1 0/SomeClass a
diff --git a/libraries/tools/kotlin-annotation-processing/src/test/resources/parse/platformStatic/parsed.txt b/libraries/tools/kotlin-annotation-processing/src/test/resources/parse/platformStatic/parsed.txt
index 0cb4a1b4bed..004d4e6ea11 100644
--- a/libraries/tools/kotlin-annotation-processing/src/test/resources/parse/platformStatic/parsed.txt
+++ b/libraries/tools/kotlin-annotation-processing/src/test/resources/parse/platformStatic/parsed.txt
@@ -1,4 +1,3 @@
-java.lang.Deprecated org.test.SomeClass OBJECT$
 kotlin.inline org.test.SomeClass.Companion a
 kotlin.platform.platformStatic org.test.SomeClass.Companion a
 org.jetbrains.annotations.NotNull org.test.SomeClass.Companion access$init$0
\ No newline at end of file
diff --git a/libraries/tools/kotlin-gradle-plugin-core/pom.xml b/libraries/tools/kotlin-gradle-plugin-core/pom.xml
index feab21cc14c..8636d5d7c2a 100644
--- a/libraries/tools/kotlin-gradle-plugin-core/pom.xml
+++ b/libraries/tools/kotlin-gradle-plugin-core/pom.xml
@@ -52,11 +52,6 @@
             <artifactId>kotlin-jdk-annotations</artifactId>
             <version>${project.version}</version>
         </dependency>
-        <dependency>
-            <groupId>org.jetbrains.kotlin</groupId>
-            <artifactId>kdoc</artifactId>
-            <version>${project.version}</version>
-        </dependency>
         <dependency>
             <groupId>org.jetbrains.kotlin</groupId>
             <artifactId>kotlin-stdlib</artifactId>
diff --git a/libraries/tools/kotlin-gradle-plugin-core/src/main/kotlin/org/jetbrains/kotlin/gradle/tasks/Tasks.kt b/libraries/tools/kotlin-gradle-plugin-core/src/main/kotlin/org/jetbrains/kotlin/gradle/tasks/Tasks.kt
index a82506ecb22..7c1a6e4fb7d 100644
--- a/libraries/tools/kotlin-gradle-plugin-core/src/main/kotlin/org/jetbrains/kotlin/gradle/tasks/Tasks.kt
+++ b/libraries/tools/kotlin-gradle-plugin-core/src/main/kotlin/org/jetbrains/kotlin/gradle/tasks/Tasks.kt
@@ -5,9 +5,7 @@ import java.io.File
 import org.gradle.api.GradleException
 import org.jetbrains.kotlin.cli.common.ExitCode
 import org.gradle.api.tasks.SourceTask
-import org.jetbrains.kotlin.doc.KDocArguments
 import java.util.HashSet
-import org.jetbrains.kotlin.doc.KDocCompiler
 import org.gradle.api.tasks.TaskAction
 import org.gradle.api.file.SourceDirectorySet
 import org.jetbrains.kotlin.cli.jvm.K2JVMCompiler
@@ -131,17 +129,7 @@ public open class KotlinCompile() : AbstractKotlinCompile<K2JVMCompilerArguments
         val basePluginOptions = extraProperties.getOrNull<Array<String>>("compilerPluginArguments") ?: arrayOf()
 
         val pluginOptions = arrayListOf(*basePluginOptions)
-
-        val kaptAnnotationsFile = extraProperties.getOrNull<File>("kaptAnnotationsFile")
-        if (kaptAnnotationsFile != null) {
-            if (kaptAnnotationsFile.exists()) kaptAnnotationsFile.delete()
-            pluginOptions.add("plugin:$ANNOTATIONS_PLUGIN_NAME:output=" + kaptAnnotationsFile)
-        }
-
-        val kaptClassFileStubsDir = extraProperties.getOrNull<File>("stubsDir")
-        if (kaptClassFileStubsDir != null) {
-            pluginOptions.add("plugin:$ANNOTATIONS_PLUGIN_NAME:stubs=" + kaptClassFileStubsDir)
-        }
+        handleKaptProperties(extraProperties, pluginOptions)
 
         args.pluginOptions = pluginOptions.toTypedArray()
         getLogger().kotlinDebug("args.pluginOptions = ${args.pluginOptions.joinToString(File.pathSeparator)}")
@@ -162,6 +150,24 @@ public open class KotlinCompile() : AbstractKotlinCompile<K2JVMCompilerArguments
         args.noParamAssertions = kotlinOptions.noParamAssertions
     }
 
+    private fun handleKaptProperties(extraProperties: ExtraPropertiesExtension, pluginOptions: MutableList<String>) {
+        val kaptAnnotationsFile = extraProperties.getOrNull<File>("kaptAnnotationsFile")
+        if (kaptAnnotationsFile != null) {
+            if (kaptAnnotationsFile.exists()) kaptAnnotationsFile.delete()
+            pluginOptions.add("plugin:$ANNOTATIONS_PLUGIN_NAME:output=" + kaptAnnotationsFile)
+        }
+
+        val kaptClassFileStubsDir = extraProperties.getOrNull<File>("kaptStubsDir")
+        if (kaptClassFileStubsDir != null) {
+            pluginOptions.add("plugin:$ANNOTATIONS_PLUGIN_NAME:stubs=" + kaptClassFileStubsDir)
+        }
+
+        val supportInheritedAnnotations = extraProperties.getOrNull<Boolean>("kaptInheritedAnnotations")
+        if (supportInheritedAnnotations != null && supportInheritedAnnotations) {
+            pluginOptions.add("plugin:$ANNOTATIONS_PLUGIN_NAME:inherited=true")
+        }
+    }
+
     private fun getJavaSourceRoots(): Set<File> =
             getSource()
             .filter { it.isJavaFile() }
@@ -222,7 +228,7 @@ public open class Kotlin2JsCompile() : AbstractKotlinCompile<K2JSCompilerArgumen
     }
 
     public fun addLibraryFiles(vararg fs: String) {
-        kotlinOptions.libraryFiles = (kotlinOptions.libraryFiles + (fs as Array<String>)).copyToArray()
+        kotlinOptions.libraryFiles += fs
     }
 
     public fun addLibraryFiles(vararg fs: File) {
@@ -255,7 +261,7 @@ public open class Kotlin2JsCompile() : AbstractKotlinCompile<K2JSCompilerArgumen
                         .filter { LibraryUtils.isKotlinJavascriptLibrary(it) }
                         .map { it.getAbsolutePath() }
 
-        args.libraryFiles = (kotlinOptions.libraryFiles + kotlinJsLibsFromDependencies).copyToArray()
+        args.libraryFiles = kotlinOptions.libraryFiles + kotlinJsLibsFromDependencies
         args.target = kotlinOptions.target
         args.sourceMap = kotlinOptions.sourceMap
 
@@ -276,69 +282,6 @@ public open class Kotlin2JsCompile() : AbstractKotlinCompile<K2JSCompilerArgumen
     }
 }
 
-public open class KDoc() : SourceTask() {
-
-    private val logger = Logging.getLogger(this.javaClass)
-    override fun getLogger() = logger
-
-    public var kdocArgs: KDocArguments = KDocArguments()
-
-    public var destinationDir: File? = null
-
-    init {
-        // by default, output dir is not defined in options
-        kdocArgs.docConfig.docOutputDir = ""
-    }
-
-    TaskAction fun generateDocs() {
-        val args = KDocArguments()
-        val cfg = args.docConfig
-
-        val kdocOptions = kdocArgs.docConfig
-
-        cfg.docOutputDir = if ((kdocOptions.docOutputDir.length() == 0) && (destinationDir != null)) {
-            destinationDir!!.path
-        } else {
-            kdocOptions.docOutputDir
-        }
-        cfg.title = kdocOptions.title
-        cfg.sourceRootHref = kdocOptions.sourceRootHref
-        cfg.projectRootDir = kdocOptions.projectRootDir
-        cfg.warnNoComments = kdocOptions.warnNoComments
-
-        cfg.packagePrefixToUrls.putAll(kdocOptions.packagePrefixToUrls)
-        cfg.ignorePackages.addAll(kdocOptions.ignorePackages)
-        cfg.packageDescriptionFiles.putAll(kdocOptions.packageDescriptionFiles)
-        cfg.packageSummaryText.putAll(kdocOptions.packageSummaryText)
-
-        // KDoc compiler does not accept list of files as input. Try to pass directories instead.
-        args.freeArgs = getSource().map { it.getParentFile()!!.getAbsolutePath() }
-        // Drop compiled sources to temp. Why KDoc compiles anything after all?!
-        args.destination = getTemporaryDir()?.getAbsolutePath()
-
-        getLogger().warn(args.freeArgs.toString())
-        val embeddedAnnotations = getAnnotations(getProject(), getLogger())
-        val userAnnotations = (kdocArgs.annotations ?: "").split(File.pathSeparatorChar).toList()
-        val allAnnotations = if (kdocArgs.noJdkAnnotations) userAnnotations else userAnnotations.plus(embeddedAnnotations.map { it.getPath() })
-        args.annotations = allAnnotations.joinToString(File.pathSeparator)
-
-        args.noStdlib = true
-        args.noJdkAnnotations = true
-
-
-        val compiler = KDocCompiler()
-
-        val messageCollector = GradleMessageCollector(getLogger())
-        val exitCode = compiler.exec(messageCollector, Services.EMPTY, args)
-
-        when (exitCode) {
-            ExitCode.COMPILATION_ERROR -> throw GradleException("Failed to generate kdoc. See log for more details")
-            ExitCode.INTERNAL_ERROR -> throw GradleException("Internal generation error. See log for more details")
-        }
-
-    }
-}
-
 private fun <T: Any> ExtraPropertiesExtension.getOrNull(id: String): T? {
     try {
         @suppress("UNCHECKED_CAST")
diff --git a/libraries/tools/kotlin-gradle-plugin/pom.xml b/libraries/tools/kotlin-gradle-plugin/pom.xml
index 35b74e84c00..9252c989dd8 100644
--- a/libraries/tools/kotlin-gradle-plugin/pom.xml
+++ b/libraries/tools/kotlin-gradle-plugin/pom.xml
@@ -37,12 +37,6 @@
           <version>2.2</version>
           <scope>provided</scope>
         </dependency>
-        <dependency>
-            <groupId>org.jetbrains.kotlin</groupId>
-            <artifactId>kdoc</artifactId>
-            <version>${project.version}</version>
-            <scope>test</scope>
-        </dependency>
         <dependency>
             <groupId>org.jetbrains.kotlin</groupId>
             <artifactId>kotlin-gradle-plugin-core</artifactId>
diff --git a/libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/plugin/KaptExtension.kt b/libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/plugin/KaptExtension.kt
index 024feeb6ed6..6dda5469d6c 100644
--- a/libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/plugin/KaptExtension.kt
+++ b/libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/plugin/KaptExtension.kt
@@ -23,6 +23,8 @@ public open class KaptExtension {
 
     public open var generateStubs: Boolean = false
 
+    public open var inheritedAnnotations: Boolean = true
+
     private var closure: Closure<*>? = null
 
     public open fun arguments(closure: Closure<*>) {
diff --git a/libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/plugin/KotlinPlugin.kt b/libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/plugin/KotlinPlugin.kt
index 55de4ff3b47..5d3f5da4ba1 100644
--- a/libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/plugin/KotlinPlugin.kt
+++ b/libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/plugin/KotlinPlugin.kt
@@ -247,7 +247,6 @@ abstract class AbstractKotlinPlugin @Inject constructor(val scriptHandler: Scrip
         project.getPlugins().apply(javaClass<JavaPlugin>())
 
         configureSourceSetDefaults(project as ProjectInternal, javaBasePlugin, javaPluginConvention)
-        configureKDoc(project, javaPluginConvention)
 
         val gradleUtils = GradleUtils(scriptHandler, project)
         project.getExtensions().add(DEFAULT_ANNOTATIONS, gradleUtils.resolveKotlinPluginDependency("kotlin-jdk-annotations"))
@@ -262,23 +261,6 @@ abstract class AbstractKotlinPlugin @Inject constructor(val scriptHandler: Scrip
             }
         })
     }
-
-    open protected fun configureKDoc(project: Project, javaPluginConvention: JavaPluginConvention) {
-        val mainSourceSet = javaPluginConvention.getSourceSets()?.findByName(SourceSet.MAIN_SOURCE_SET_NAME) as HasConvention?
-
-        if (mainSourceSet != null) {
-
-            val kdoc = tasksProvider.createKDocTask(project, KDOC_TASK_NAME)
-
-            kdoc.setDescription("Generates KDoc API documentation for the main source code.")
-            kdoc.setGroup(JavaBasePlugin.DOCUMENTATION_GROUP)
-            kdoc.setSource(mainSourceSet.getConvention().getExtensionsAsDynamicObject().getProperty("kotlin"))
-        }
-
-        project.getTasks().withType(tasksProvider.kDocTaskClass) { it!!.setProperty("destinationDir", File(javaPluginConvention.getDocsDir(), "kdoc")) }
-    }
-
-    public val KDOC_TASK_NAME: String = "kdoc"
 }
 
 
@@ -536,7 +518,7 @@ private class SubpluginEnvironment(
             }
         }
 
-        val extraProperties = compileTask.getExtensions().getExtraProperties()
+        val extraProperties = compileTask.extraProperties
         extraProperties.set("compilerPluginClasspaths", realPluginClasspaths.toTypedArray())
         extraProperties.set("compilerPluginArguments", pluginArguments.toTypedArray())
     }
@@ -563,7 +545,7 @@ open class GradleUtils(val scriptHandler: ScriptHandler, val project: ProjectInt
 }
 
 private fun AbstractCompile.storeKaptAnnotationsFile(kapt: AnnotationProcessingManager) {
-    getExtensions().getExtraProperties().set("kaptAnnotationsFile", kapt.getAnnotationFile())
+    extraProperties.set("kaptAnnotationsFile", kapt.getAnnotationFile())
 }
 
 private fun Project.getAptDirsForSourceSet(kotlinTask: AbstractCompile, sourceSetName: String): Pair<File, File> {
@@ -607,7 +589,7 @@ private fun Project.initKapt(
         kotlinTask.getLogger().kotlinDebug("kapt: Using class file stubs")
 
         val stubsDir = File(getBuildDir(), "tmp/kapt/$variantName/classFileStubs")
-        kotlinTask.getExtensions().getExtraProperties().set("stubsDir", stubsDir)
+        kotlinTask.extraProperties.set("kaptStubsDir", stubsDir)
 
         javaTask.setClasspath(javaTask.getClasspath() + files(stubsDir))
 
@@ -621,6 +603,10 @@ private fun Project.initKapt(
         kotlinTask.getLogger().kotlinDebug("kapt: Class file stubs are not used")
     }
 
+    if (kaptExtension.inheritedAnnotations) {
+        kotlinTask.extraProperties.set("kaptInheritedAnnotations", true)
+    }
+
     kotlinTask.doFirst {
         kaptManager.generateJavaHackFile()
     }
@@ -682,6 +668,9 @@ private fun loadAndroidPluginVersion(): String? {
     }
 }
 
+private val AbstractCompile.extraProperties: ExtraPropertiesExtension
+    get() = getExtensions().getExtraProperties()
+
 //Copied from StringUtil.compareVersionNumbers
 private fun compareVersionNumbers(v1: String?, v2: String?): Int {
     if (v1 == null && v2 == null) {
diff --git a/libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/tasks/TasksProvider.kt b/libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/tasks/TasksProvider.kt
index 26aeff3dbc1..a739f60ec0c 100644
--- a/libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/tasks/TasksProvider.kt
+++ b/libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/tasks/TasksProvider.kt
@@ -19,9 +19,6 @@ public open class KotlinTasksProvider(val tasksLoader: ClassLoader) {
     val kotlinJSCompileTaskClass: Class<AbstractCompile> =
             tasksLoader.loadClass("org.jetbrains.kotlin.gradle.tasks.Kotlin2JsCompile") as Class<AbstractCompile>
 
-    val kDocTaskClass: Class<SourceTask> =
-            tasksLoader.loadClass("org.jetbrains.kotlin.gradle.tasks.KDoc") as Class<SourceTask>
-
     val kotlinJVMOptionsClass: Class<Any> =
             tasksLoader.loadClass("org.jetbrains.kotlin.cli.common.arguments.K2JVMCompilerArguments") as Class<Any>
 
@@ -33,8 +30,4 @@ public open class KotlinTasksProvider(val tasksLoader: ClassLoader) {
     public fun createKotlinJSTask(project: Project, name: String): AbstractCompile {
         return project.getTasks().create(name, kotlinJSCompileTaskClass)
     }
-
-    public fun createKDocTask(project: Project, name: String): SourceTask {
-        return project.getTasks().create(name, kDocTaskClass)
-    }
 }
diff --git a/libraries/tools/kotlin-gradle-plugin/src/test/kotlin/org/jetbrains/kotlin/gradle/BaseGradleIT.kt b/libraries/tools/kotlin-gradle-plugin/src/test/kotlin/org/jetbrains/kotlin/gradle/BaseGradleIT.kt
index 62206eedb5b..dd43023985e 100644
--- a/libraries/tools/kotlin-gradle-plugin/src/test/kotlin/org/jetbrains/kotlin/gradle/BaseGradleIT.kt
+++ b/libraries/tools/kotlin-gradle-plugin/src/test/kotlin/org/jetbrains/kotlin/gradle/BaseGradleIT.kt
@@ -96,7 +96,7 @@ abstract class BaseGradleIT {
 
     private fun Project.createCommand(params: Array<out String>): List<String> {
         val pathToKotlinPlugin = "-PpathToKotlinPlugin=" + File("local-repo").getAbsolutePath()
-        val tailParameters = params +
+        val tailParameters = params.asList() +
                 listOf(pathToKotlinPlugin, "--no-daemon", "--${minLogLevel.name().toLowerCase()}", "-Pkotlin.gradle.test=true")
 
         return if (isWindows())
diff --git a/libraries/tools/kotlin-gradle-plugin/src/test/kotlin/org/jetbrains/kotlin/gradle/BasicKotlinGradlePluginIT.kt b/libraries/tools/kotlin-gradle-plugin/src/test/kotlin/org/jetbrains/kotlin/gradle/BasicKotlinGradlePluginIT.kt
index 02855e22d77..f4eba9f4a71 100644
--- a/libraries/tools/kotlin-gradle-plugin/src/test/kotlin/org/jetbrains/kotlin/gradle/BasicKotlinGradlePluginIT.kt
+++ b/libraries/tools/kotlin-gradle-plugin/src/test/kotlin/org/jetbrains/kotlin/gradle/BasicKotlinGradlePluginIT.kt
@@ -66,14 +66,6 @@ class SimpleKotlinGradleIT : BaseGradleIT() {
         }
     }
 
-    Test fun testSimpleKDoc() {
-        Project("kdocProject", "1.6").build("kdoc") {
-            assertSuccessful()
-            assertReportExists("build/docs/kdoc/demo/MyClass.html")
-            assertContains(":kdoc", "Generating kdoc to")
-        }
-    }
-
     Test fun testKotlinExtraJavaSrc() {
         Project("additionalJavaSrc", "1.6").build("build") {
             assertSuccessful()
diff --git a/libraries/tools/kotlin-gradle-plugin/src/test/kotlin/org/jetbrains/kotlin/gradle/KotlinGradlePluginIT.kt b/libraries/tools/kotlin-gradle-plugin/src/test/kotlin/org/jetbrains/kotlin/gradle/KotlinGradlePluginIT.kt
index ae73ce254b4..037f19fe7db 100644
--- a/libraries/tools/kotlin-gradle-plugin/src/test/kotlin/org/jetbrains/kotlin/gradle/KotlinGradlePluginIT.kt
+++ b/libraries/tools/kotlin-gradle-plugin/src/test/kotlin/org/jetbrains/kotlin/gradle/KotlinGradlePluginIT.kt
@@ -98,4 +98,14 @@ class KotlinGradleIT: BaseGradleIT() {
         }
     }
 
+    Test fun testKaptInheritedAnnotations() {
+        Project("kaptInheritedAnnotations", "1.12").build("build") {
+            assertSuccessful()
+            assertFileExists("build/generated/source/kapt/main/TestClassGenerated.java")
+            assertFileExists("build/generated/source/kapt/main/AncestorClassGenerated.java")
+            assertFileExists("build/classes/main/example/TestClassGenerated.class")
+            assertFileExists("build/classes/main/example/AncestorClassGenerated.class")
+        }
+    }
+
 }
\ No newline at end of file
diff --git a/libraries/tools/kotlin-gradle-plugin/src/test/resources/testProject/kaptInheritedAnnotations/build.gradle b/libraries/tools/kotlin-gradle-plugin/src/test/resources/testProject/kaptInheritedAnnotations/build.gradle
new file mode 100644
index 00000000000..78b978e9dd7
--- /dev/null
+++ b/libraries/tools/kotlin-gradle-plugin/src/test/resources/testProject/kaptInheritedAnnotations/build.gradle
@@ -0,0 +1,35 @@
+buildscript {
+    repositories {
+        mavenCentral()
+        maven {
+            url 'file://' + pathToKotlinPlugin
+        }
+    }
+    dependencies {
+        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:0.1-SNAPSHOT"
+    }
+}
+
+apply plugin: "java"
+apply plugin: "kotlin"
+
+repositories {
+    maven {
+        url 'file://' + pathToKotlinPlugin
+    }
+    mavenCentral()
+}
+
+dependencies {
+    compile "org.jetbrains.kotlin:kotlin-stdlib:0.1-SNAPSHOT"
+    compile "org.jetbrains.kotlin:annotation-processor-example:0.1-SNAPSHOT"
+    kapt "org.jetbrains.kotlin:annotation-processor-example:0.1-SNAPSHOT"
+}
+
+task show << {
+    buildscript.configurations.classpath.each { println it }
+}
+
+task wrapper(type: Wrapper) {
+    gradleVersion="1.12"
+}
\ No newline at end of file
diff --git a/libraries/tools/kotlin-gradle-plugin/src/test/resources/testProject/kaptInheritedAnnotations/src/main/java/test.kt b/libraries/tools/kotlin-gradle-plugin/src/test/resources/testProject/kaptInheritedAnnotations/src/main/java/test.kt
new file mode 100644
index 00000000000..7eff7b126c0
--- /dev/null
+++ b/libraries/tools/kotlin-gradle-plugin/src/test/resources/testProject/kaptInheritedAnnotations/src/main/java/test.kt
@@ -0,0 +1,22 @@
+/*
+ * Copyright 2010-2015 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 example
+
+@example.ExampleAnnotation
+public open class TestClass
+
+public class AncestorClass : TestClass()
\ No newline at end of file
diff --git a/libraries/tools/kotlin-gradle-plugin/src/test/resources/testProject/kdocProject/build.gradle b/libraries/tools/kotlin-gradle-plugin/src/test/resources/testProject/kdocProject/build.gradle
deleted file mode 100644
index a5193474c83..00000000000
--- a/libraries/tools/kotlin-gradle-plugin/src/test/resources/testProject/kdocProject/build.gradle
+++ /dev/null
@@ -1,40 +0,0 @@
-buildscript {
-  repositories {
-    mavenCentral()
-    maven {
-        url 'file://' + pathToKotlinPlugin
-    }
-  }
-  dependencies {
-    classpath 'org.jetbrains.kotlin:kotlin-gradle-plugin:0.1-SNAPSHOT'
-  }
-}
-
-
-
-apply plugin: "kotlin"
-
-repositories {
-  maven {
-     url 'file://' + pathToKotlinPlugin
-  }
-  mavenCentral()
-}
-
-dependencies {
-    testCompile  'org.testng:testng:6.8'
-    compile  'org.jetbrains.kotlin:kotlin-stdlib:0.1-SNAPSHOT'
-}
-
-test {
-    useTestNG()
-}
-
-compileKotlin {
-    kotlinOptions.annotations = "externalAnnotations"
-}
-
-
-task wrapper(type: Wrapper) {
-  gradleVersion="1.4"
-}
\ No newline at end of file
diff --git a/libraries/tools/kotlin-gradle-plugin/src/test/resources/testProject/kdocProject/externalAnnotations/com/google/common/base/annotations.xml b/libraries/tools/kotlin-gradle-plugin/src/test/resources/testProject/kdocProject/externalAnnotations/com/google/common/base/annotations.xml
deleted file mode 100644
index fd541a7e6e5..00000000000
--- a/libraries/tools/kotlin-gradle-plugin/src/test/resources/testProject/kdocProject/externalAnnotations/com/google/common/base/annotations.xml
+++ /dev/null
@@ -1,11 +0,0 @@
-<root>
-    <item name='com.google.common.base.Joiner com.google.common.base.Joiner on(java.lang.String)'>
-        <annotation name="org.jetbrains.annotations.NotNull" />
-    </item>
-    <item name='com.google.common.base.Joiner com.google.common.base.Joiner.MapJoiner withKeyValueSeparator(java.lang.String)'>
-        <annotation name="org.jetbrains.annotations.NotNull" />
-    </item>
-    <item name='com.google.common.base.Joiner com.google.common.base.Joiner skipNulls()'>
-        <annotation name="org.jetbrains.annotations.NotNull" />
-    </item>
-</root>
\ No newline at end of file
diff --git a/libraries/tools/kotlin-gradle-plugin/src/test/resources/testProject/kdocProject/src/main/kotlin/helloWorld.kt b/libraries/tools/kotlin-gradle-plugin/src/test/resources/testProject/kdocProject/src/main/kotlin/helloWorld.kt
deleted file mode 100644
index a844b9fe15d..00000000000
--- a/libraries/tools/kotlin-gradle-plugin/src/test/resources/testProject/kdocProject/src/main/kotlin/helloWorld.kt
+++ /dev/null
@@ -1,15 +0,0 @@
-package demo
-
-/**
- * This is **bold**
- *
- * New paragraph using newlines.
- *
- * We can also support wiki links notation
- * for example [[List]] and [[Collection]] and [[java.util.Collection.size()]] will
- * generate hypertext links to classes
- */
-public class MyClass() {
-    val i: Int = 0
-}
-
diff --git a/libraries/tools/kotlin-stdlib-gen/src/generators/GenerateStandardLib.kt b/libraries/tools/kotlin-stdlib-gen/src/generators/GenerateStandardLib.kt
index 09e58ca95a2..692ecc0087c 100644
--- a/libraries/tools/kotlin-stdlib-gen/src/generators/GenerateStandardLib.kt
+++ b/libraries/tools/kotlin-stdlib-gen/src/generators/GenerateStandardLib.kt
@@ -17,7 +17,7 @@ private val COMMON_AUTOGENERATED_WARNING: String = """//
  * at runtime.
  */
 fun main(args: Array<String>) {
-    require(args.size == 1, "Expecting Kotlin project home path as an argument")
+    require(args.size() == 1, "Expecting Kotlin project home path as an argument")
 
     val outDir = File(File(args[0]), "libraries/stdlib/src/generated")
     require(outDir.exists(), "${outDir.getPath()} doesn't exist!")
@@ -31,8 +31,6 @@ fun main(args: Array<String>) {
     generateDownTos(File(outDir, "_DownTo.kt"), "package kotlin")
 }
 
-fun String.flat() = this.replaceAll(" ", "")
-
 fun List<GenericFunction>.writeTo(file: File, builder: GenericFunction.() -> String) {
     println("Generating file: ${file.getPath()}")
     val its = FileWriter(file)
diff --git a/libraries/tools/kotlin-stdlib-gen/src/templates/Comparables.kt b/libraries/tools/kotlin-stdlib-gen/src/templates/Comparables.kt
index fda97e8d062..f6a3b8eb67e 100644
--- a/libraries/tools/kotlin-stdlib-gen/src/templates/Comparables.kt
+++ b/libraries/tools/kotlin-stdlib-gen/src/templates/Comparables.kt
@@ -7,7 +7,7 @@ fun comparables(): List<GenericFunction> {
 
     templates add f("coerceAtLeast(minimumValue: SELF)") {
         only(Primitives, Generic)
-        only(*numericPrimitives)
+        only(numericPrimitives)
         returns("SELF")
         typeParam("T: Comparable<T>")
         doc {
@@ -27,7 +27,7 @@ fun comparables(): List<GenericFunction> {
 
     templates add f("coerceAtMost(maximumValue: SELF)") {
         only(Primitives, Generic)
-        only(*numericPrimitives)
+        only(numericPrimitives)
         returns("SELF")
         typeParam("T: Comparable<T>")
         doc {
@@ -46,7 +46,7 @@ fun comparables(): List<GenericFunction> {
 
     templates add f("coerceIn(range: TRange)") {
         only(Primitives, Generic)
-        only(*numericPrimitives)
+        only(numericPrimitives)
         returns("SELF")
         typeParam("T: Comparable<T>")
         doc {
@@ -66,7 +66,7 @@ fun comparables(): List<GenericFunction> {
 
     templates add f("coerceIn(minimumValue: SELF?, maximumValue: SELF?)") {
         only(Primitives, Generic)
-        only(*numericPrimitives)
+        only(numericPrimitives)
         returns("SELF")
         typeParam("T: Comparable<T>")
         doc {
diff --git a/libraries/tools/kotlin-stdlib-gen/src/templates/Elements.kt b/libraries/tools/kotlin-stdlib-gen/src/templates/Elements.kt
index 1a1553ee019..00a5bf4519b 100644
--- a/libraries/tools/kotlin-stdlib-gen/src/templates/Elements.kt
+++ b/libraries/tools/kotlin-stdlib-gen/src/templates/Elements.kt
@@ -202,11 +202,10 @@ fun elements(): List<GenericFunction> {
     templates add f("elementAtOrElse(index: Int, defaultValue: (Int) -> T)") {
         doc { "Returns an element at the given [index] or the result of calling the [defaultValue] function if the [index] is out of bounds of this collection." }
         returns("T")
-        inline(true)
         body {
             """
             if (this is List<T>)
-                return this.elementAtOrElse(index, defaultValue)
+                return this.getOrElse(index, defaultValue)
             if (index < 0)
                 return defaultValue(index)
             val iterator = iterator()
@@ -233,6 +232,7 @@ fun elements(): List<GenericFunction> {
             return defaultValue(index)
             """
         }
+        inline(true, Strings, Lists, ArraysOfObjects, ArraysOfPrimitives)
         body(Strings, Lists, ArraysOfObjects, ArraysOfPrimitives) {
             """
             return if (index >= 0 && index <= lastIndex) get(index) else defaultValue(index)
@@ -240,6 +240,18 @@ fun elements(): List<GenericFunction> {
         }
     }
 
+    templates add f("getOrElse(index: Int, defaultValue: (Int) -> T)") {
+        doc { "Returns an element at the given [index] or the result of calling the [defaultValue] function if the [index] is out of bounds of this collection." }
+        returns("T")
+        inline(true)
+        only(Strings, Lists, ArraysOfObjects, ArraysOfPrimitives)
+        body {
+            """
+            return if (index >= 0 && index <= lastIndex) get(index) else defaultValue(index)
+            """
+        }
+    }
+
 
     templates add f("elementAtOrNull(index: Int)") {
         doc { "Returns an element at the given [index] or `null` if the [index] is out of bounds of this collection." }
@@ -247,7 +259,7 @@ fun elements(): List<GenericFunction> {
         body {
             """
             if (this is List<T>)
-                return this.elementAtOrNull(index)
+                return this.getOrNull(index)
             if (index < 0)
                 return null
             val iterator = iterator()
@@ -281,6 +293,18 @@ fun elements(): List<GenericFunction> {
         }
     }
 
+    templates add f("getOrNull(index: Int)") {
+        doc { "Returns an element at the given [index] or `null` if the [index] is out of bounds of this collection." }
+        returns("T?")
+        only(Strings, Lists, ArraysOfObjects, ArraysOfPrimitives)
+        body {
+            """
+            return if (index >= 0 && index <= lastIndex) get(index) else null
+            """
+        }
+    }
+
+
     templates add f("first()") {
         doc { """Returns first element.
         @throws [NoSuchElementException] if the collection is empty.
@@ -680,40 +704,21 @@ fun elements(): List<GenericFunction> {
         }
     }
 
-    templates add f("component1()") {
-        inline(true)
-        doc { "Returns 1st *element* from the collection." }
-        returns("T")
-        body { "return get(0)" }
-        only(Lists, ArraysOfObjects, ArraysOfPrimitives)
-    }
-    templates add f("component2()") {
-        inline(true)
-        doc { "Returns 2nd *element* from the collection." }
-        returns("T")
-        body { "return get(1)" }
-        only(Lists, ArraysOfObjects, ArraysOfPrimitives)
-    }
-    templates add f("component3()") {
-        inline(true)
-        doc { "Returns 3rd *element* from the collection." }
-        returns("T")
-        body { "return get(2)" }
-        only(Lists, ArraysOfObjects, ArraysOfPrimitives)
-    }
-    templates add f("component4()") {
-        inline(true)
-        doc { "Returns 4th *element* from the collection." }
-        returns("T")
-        body { "return get(3)" }
-        only(Lists, ArraysOfObjects, ArraysOfPrimitives)
-    }
-    templates add f("component5()") {
-        inline(true)
-        doc { "Returns 5th *element* from the collection." }
-        returns("T")
-        body { "return get(4)" }
-        only(Lists, ArraysOfObjects, ArraysOfPrimitives)
+    templates addAll (1..5).map { n ->
+        f("component$n()") {
+            inline(true)
+            annotations("""suppress("NOTHING_TO_INLINE")""")
+            fun getOrdinal(n: Int) = n.toString() + when (n) {
+                1 -> "st"
+                2 -> "nd"
+                3 -> "rd"
+                else -> "th"
+            }
+            doc { "Returns ${getOrdinal(n)} *element* from the collection." }
+            returns("T")
+            body { "return get(${n-1})" }
+            only(Lists, ArraysOfObjects, ArraysOfPrimitives)
+        }
     }
 
     return templates
diff --git a/libraries/tools/kotlin-stdlib-gen/src/templates/Engine.kt b/libraries/tools/kotlin-stdlib-gen/src/templates/Engine.kt
index d271af9f2a5..f53107a214d 100644
--- a/libraries/tools/kotlin-stdlib-gen/src/templates/Engine.kt
+++ b/libraries/tools/kotlin-stdlib-gen/src/templates/Engine.kt
@@ -12,26 +12,40 @@ enum class Family {
     Collections,
     Lists,
     Maps,
+    Sets,
     ArraysOfObjects,
     ArraysOfPrimitives,
+    InvariantArraysOfObjects,
     Strings,
     RangesOfPrimitives,
     ProgressionsOfPrimitives,
     Primitives,
     Generic;
 
-    val isPrimitiveSpecialization: Boolean by Delegates.lazy { this in listOf(ArraysOfPrimitives, RangesOfPrimitives, ProgressionsOfPrimitives, Primitives) }
+    val isPrimitiveSpecialization: Boolean by lazy { this in primitiveSpecializations }
+
+    companion object {
+        val primitiveSpecializations = setOf(ArraysOfPrimitives, RangesOfPrimitives, ProgressionsOfPrimitives, Primitives)
+        val defaultFamilies = setOf(Iterables, Sequences, ArraysOfObjects, ArraysOfPrimitives, Strings)
+    }
 }
 
-enum class PrimitiveType(val name: String) {
-    Boolean("Boolean"),
-    Byte("Byte"),
-    Char("Char"),
-    Short("Short"),
-    Int("Int"),
-    Long("Long"),
-    Float("Float"),
-    Double("Double")
+enum class PrimitiveType {
+    Boolean,
+    Byte,
+    Char,
+    Short,
+    Int,
+    Long,
+    Float,
+    Double;
+
+    val name: String get() = this.name()
+
+    companion object {
+        val defaultPrimitives = PrimitiveType.values().toSet()
+        val numericPrimitives = setOf(PrimitiveType.Int, PrimitiveType.Long, PrimitiveType.Byte, PrimitiveType.Short, PrimitiveType.Double, PrimitiveType.Float)
+    }
 }
 
 
@@ -63,17 +77,18 @@ class GenericFunction(val signature: String, val keyword: String = "fun") : Comp
     open class PrimitiveProperty<TValue: Any>() : SpecializedProperty<PrimitiveType, TValue>()
 
 
-    val defaultFamilies = array(Iterables, Sequences, ArraysOfObjects, ArraysOfPrimitives, Strings)
-    val defaultPrimitives = PrimitiveType.values()
-    val numericPrimitives = array(PrimitiveType.Int, PrimitiveType.Long, PrimitiveType.Byte, PrimitiveType.Short, PrimitiveType.Double, PrimitiveType.Float)
+    val defaultFamilies = Family.defaultFamilies
+    val defaultPrimitives = PrimitiveType.defaultPrimitives
+    val numericPrimitives = PrimitiveType.numericPrimitives
 
     var toNullableT: Boolean = false
 
     var receiverAsterisk = false
 
-    val buildFamilies = LinkedHashSet(defaultFamilies.toList())
-    val buildPrimitives = LinkedHashSet(defaultPrimitives.toList())
+    val buildFamilies = LinkedHashSet(defaultFamilies)
+    val buildPrimitives = LinkedHashSet(defaultPrimitives)
 
+    val customSignature = FamilyProperty<String>()
     val deprecate = FamilyProperty<String>()
     val deprecateReplacement = FamilyProperty<String>()
     val doc = FamilyProperty<String>()
@@ -112,8 +127,12 @@ class GenericFunction(val signature: String, val keyword: String = "fun") : Comp
     }
 
     fun only(vararg primitives: PrimitiveType) {
+        only(primitives.asList())
+    }
+
+    fun only(primitives: Collection<PrimitiveType>) {
         buildPrimitives.clear()
-        buildPrimitives.addAll(primitives.toList())
+        buildPrimitives.addAll(primitives)
     }
 
     fun include(vararg families: Family) {
@@ -156,15 +175,16 @@ class GenericFunction(val signature: String, val keyword: String = "fun") : Comp
             Collections -> "Collection<$isAsteriskOrT>"
             Lists -> "List<$isAsteriskOrT>"
             Maps -> "Map<K, V>"
+            Sets -> "Set<$isAsteriskOrT>"
             Sequences -> "Sequence<$isAsteriskOrT>"
-            ArraysOfObjects -> "Array<$isAsteriskOrT>"
+            InvariantArraysOfObjects -> "Array<T>"
+            ArraysOfObjects -> "Array<${isAsteriskOrT.replace("T", "out T")}>"
             Strings -> "String"
             ArraysOfPrimitives -> primitive?.let { it.name() + "Array" } ?: throw IllegalArgumentException("Primitive array should specify primitive type")
             RangesOfPrimitives -> primitive?.let { it.name() + "Range" } ?: throw IllegalArgumentException("Primitive range should specify primitive type")
             ProgressionsOfPrimitives -> primitive?.let { it.name() + "Progression" } ?: throw IllegalArgumentException("Primitive progression should specify primitive type")
             Primitives -> primitive?.let { it.name } ?: throw IllegalArgumentException("Primitive should specify primitive type")
             Generic -> "T"
-            else -> throw IllegalStateException("Invalid family")
         }
 
 
@@ -175,7 +195,7 @@ class GenericFunction(val signature: String, val keyword: String = "fun") : Comp
             while (t.hasMoreTokens()) {
                 val token = t.nextToken()
                 answer.append(when (token) {
-                                  "SELF" -> if (receiver == "Array<T>") "Array<out T>" else receiver
+                                  "SELF" -> receiver
                                   "PRIMITIVE" -> primitive?.name() ?: token
                                   "SUM" -> {
                                       when (primitive) {
@@ -186,18 +206,19 @@ class GenericFunction(val signature: String, val keyword: String = "fun") : Comp
                                   "ZERO" -> when (primitive) {
                                       PrimitiveType.Double -> "0.0"
                                       PrimitiveType.Float -> "0.0f"
+                                      PrimitiveType.Long -> "0L"
                                       else -> "0"
                                   }
                                   "ONE" -> when (primitive) {
                                       PrimitiveType.Double -> "1.0"
                                       PrimitiveType.Float -> "1.0f"
-                                      PrimitiveType.Long -> "1.toLong()"
+                                      PrimitiveType.Long -> "1L"
                                       else -> "1"
                                   }
                                   "-ONE" -> when (primitive) {
                                       PrimitiveType.Double -> "-1.0"
                                       PrimitiveType.Float -> "-1.0f"
-                                      PrimitiveType.Long -> "-1.toLong()"
+                                      PrimitiveType.Long -> "-1L"
                                       else -> "-1"
                                   }
                                   "TCollection" -> {
@@ -244,7 +265,8 @@ class GenericFunction(val signature: String, val keyword: String = "fun") : Comp
                 return types
             }
             else if (primitive == null && f != Strings) {
-                val implicitTypeParameters = receiver.dropWhile { it != '<' }.drop(1).filterNot { it == ' ' }.takeWhile { it != '>' }.split(",")
+                val implicitTypeParameters = receiver.dropWhile { it != '<' }.drop(1).takeWhile { it != '>' }.split(",")
+                        .map { it.removePrefix("out").removePrefix("in").trim() }
                 for (implicit in implicitTypeParameters.reverse()) {
                     if (implicit != "*" && !types.any { it.startsWith(implicit) || it.startsWith("reified " + implicit) }) {
                         types.add(0, implicit)
@@ -293,14 +315,10 @@ class GenericFunction(val signature: String, val keyword: String = "fun") : Comp
             builder.append(types.join(separator = ", ", prefix = "<", postfix = "> ").renderType())
         }
 
-        val receiverType = (when (receiver) {
-            "Array<T>" -> if (toNullableT) "Array<out T?>" else "Array<out T>"
-            else -> if (toNullableT) receiver.replace("T>", "T?>") else receiver
-        }).renderType()
-
+        val receiverType = (if (toNullableT) receiver.replace("T>", "T?>") else receiver).renderType()
 
         builder.append(receiverType)
-        builder.append(".${signature.renderType()}: ${returnType.renderType()}")
+        builder.append(".${(customSignature[f] ?: signature).renderType()}: ${returnType.renderType()}")
         if (keyword == "fun") builder.append(" {")
 
         val body = (customPrimitiveBodies[f to primitive] ?: body[f] ?: throw RuntimeException("No body specified for $signature for ${f to primitive}")).trim('\n')
diff --git a/libraries/tools/kotlin-stdlib-gen/src/templates/Generators.kt b/libraries/tools/kotlin-stdlib-gen/src/templates/Generators.kt
index 915fd8e0775..8e2a0f7f31b 100644
--- a/libraries/tools/kotlin-stdlib-gen/src/templates/Generators.kt
+++ b/libraries/tools/kotlin-stdlib-gen/src/templates/Generators.kt
@@ -6,28 +6,41 @@ fun generators(): List<GenericFunction> {
     val templates = arrayListOf<GenericFunction>()
 
     templates add f("plus(element: T)") {
-        exclude(Strings)
-        doc { "Returns a list containing all elements of original collection and then the given [element]." }
+        only(Iterables, Collections, Sets, Sequences)
+        doc { "Returns a list containing all elements of the original collection and then the given [element]." }
         returns("List<T>")
         body {
             """
-            val answer = ArrayList<T>(collectionSizeOrNull()?.let { it + 1 } ?: 10)
-            for (thisElement in this) answer.add(thisElement)
-            answer.add(element)
-            return answer
+            if (this is Collection) return this.plus(element)
+            val result = ArrayList<T>()
+            result.addAll(this)
+            result.add(element)
+            return result
             """
         }
-        body(ArraysOfObjects, ArraysOfPrimitives) {
+        body(Collections) {
             """
-            val answer = ArrayList<T>(size()+1)
-            for (thisElement in this) answer.add(thisElement)
-            answer.add(element)
-            return answer
+            val result = ArrayList<T>(size() + 1)
+            result.addAll(this)
+            result.add(element)
+            return result
             """
         }
 
-        doc(Sequences) { "Returns a sequence containing all elements of original sequence and then the given [element]." }
-        returns(Sequences) { "Sequence<T>" }
+        // TODO: use build scope function when available
+        // TODO: use immutable sets when available
+        returns("SELF", Sets, Sequences)
+        doc(Sets) { "Returns a set containing all elements of the original set and then the given [element]." }
+        body(Sets) {
+            """
+            val result = LinkedHashSet<T>(mapCapacity(size() + 1))
+            result.addAll(this)
+            result.add(element)
+            return result
+            """
+        }
+
+        doc(Sequences) { "Returns a sequence containing all elements of the original sequence and then the given [element]." }
         body(Sequences) {
             """
             return sequenceOf(this, sequenceOf(element)).flatten()
@@ -36,78 +49,339 @@ fun generators(): List<GenericFunction> {
     }
 
     templates add f("plus(collection: Iterable<T>)") {
-        exclude(Strings, Sequences)
-        doc { "Returns a list containing all elements of original collection and then all elements of the given [collection]." }
+        only(Iterables, Collections, Sets, Sequences)
+        doc { "Returns a list containing all elements of the original collection and then all elements of the given [collection]." }
         returns("List<T>")
+        returns("SELF", Sets, Sequences)
         body {
             """
-            val answer = ArrayList<T>(collectionSizeOrDefault(10) + collection.collectionSizeOrDefault(10))
-            for (thisElement in this) answer.add(thisElement)
-            answer.addAll(collection)
-            return answer
+            if (this is Collection) return this.plus(collection)
+            val result = ArrayList<T>()
+            result.addAll(this)
+            result.addAll(collection)
+            return result
+            """
+        }
+        body(Collections) {
+            """
+            if (collection is Collection) {
+                val result = ArrayList<T>(this.size() + collection.size())
+                result.addAll(this)
+                result.addAll(collection)
+                return result
+            } else {
+                val result = ArrayList<T>(this)
+                result.addAll(collection)
+                return result
+            }
             """
         }
 
-        body(ArraysOfObjects, ArraysOfPrimitives) {
+        // TODO: use immutable set builder when available
+        doc(Sets) { "Returns a set containing all elements both of the original set and the given [collection]." }
+        body(Sets) {
             """
-            val answer = ArrayList<T>(size() + collection.collectionSizeOrDefault(10))
-            for (thisElement in this) answer.add(thisElement)
-            answer.addAll(collection)
-            return answer
+            val result = LinkedHashSet<T>(mapCapacity(collection.collectionSizeOrNull()?.let { this.size() + it } ?: this.size() * 2))
+            result.addAll(this)
+            result.addAll(collection)
+            return result
             """
         }
-    }
 
-    templates add f("plus(array: Array<out T>)") {
-        exclude(Strings, Sequences)
-        doc { "Returns a list containing all elements of original collection and then all elements of the given [array]." }
-        returns("List<T>")
-        body {
+        doc(Sequences) {
             """
-            val answer = ArrayList<T>(collectionSizeOrDefault(10) + array.size())
-            for (thisElement in this) answer.add(thisElement)
-            answer.addAll(array)
-            return answer
-            """
-        }
-        body(ArraysOfObjects, ArraysOfPrimitives) {
-            """
-            val answer = ArrayList<T>(size() + array.size())
-            for (thisElement in this) answer.add(thisElement)
-            answer.addAll(array)
-            return answer
-            """
-        }
-    }
+            Returns a sequence containing all elements of original sequence and then all elements of the given [collection].
 
-    templates add f("plus(collection: Iterable<T>)") {
-        only(Sequences)
-        doc { "Returns a sequence containing all elements of original sequence and then all elements of the given [collection]." }
-        returns("Sequence<T>")
-        body {
+            Note that the source sequence and the collection being added are iterated only when an `iterator` is requested from
+            the resulting sequence. Changing any of them between successive calls to `iterator` may affect the result.
+            """
+        }
+        body(Sequences) {
             """
             return sequenceOf(this, collection.asSequence()).flatten()
             """
         }
     }
 
-    templates add f("plus(sequence: Sequence<T>)") {
-        only(Sequences)
-        doc { "Returns a sequence containing all elements of original sequence and then all elements of the given [sequence]." }
-        returns("Sequence<T>")
+    templates add f("plus(array: Array<out T>)") {
+        only(Iterables, Collections, Sets, Sequences)
+        doc { "Returns a list containing all elements of the original collection and then all elements of the given [array]." }
+        returns("List<T>")
+        returns("SELF", Sets, Sequences)
         body {
+            """
+            if (this is Collection) return this.plus(array)
+            val result = ArrayList<T>()
+            result.addAll(this)
+            result.addAll(array)
+            return result
+            """
+        }
+        body(Collections) {
+            """
+            val result = ArrayList<T>(this.size() + array.size())
+            result.addAll(this)
+            result.addAll(array)
+            return result
+            """
+        }
+        doc(Sets) { "Returns a set containing all elements both of the original set and the given [array]." }
+        body(Sets) {
+            """
+            val result = LinkedHashSet<T>(mapCapacity(this.size() + array.size()))
+            result.addAll(this)
+            result.addAll(array)
+            return result
+            """
+        }
+        doc(Sequences) {
+            """
+            Returns a sequence containing all elements of original sequence and then all elements of the given [array].
+
+            Note that the source sequence and the array being added are iterated only when an `iterator` is requested from
+            the resulting sequence. Changing any of them between successive calls to `iterator` may affect the result.
+            """
+        }
+        body(Sequences) {
+            """
+            return this.plus(array.asList())
+            """
+        }
+    }
+
+
+    templates add f("plus(sequence: Sequence<T>)") {
+        only(Iterables, Sets, Sequences)
+        doc { "Returns a list containing all elements of the original collection and then all elements of the given [sequence]." }
+        returns("List<T>")
+        returns("SELF", Sets, Sequences)
+        body {
+            """
+            val result = ArrayList<T>()
+            result.addAll(this)
+            result.addAll(sequence)
+            return result
+            """
+        }
+        body(Collections) {
+            """
+            val result = ArrayList<T>(this.size() + 10)
+            result.addAll(this)
+            result.addAll(sequence)
+            return result
+            """
+        }
+
+        // TODO: use immutable set builder when available
+        doc(Sets) { "Returns a set containing all elements both of the original set and the given [sequence]." }
+        body(Sets) {
+            """
+            val result = LinkedHashSet<T>(mapCapacity(this.size() * 2))
+            result.addAll(this)
+            result.addAll(sequence)
+            return result
+            """
+        }
+
+        doc(Sequences) {
+            """
+            Returns a sequence containing all elements of original sequence and then all elements of the given [sequence].
+
+            Note that the source sequence and the sequence being added are iterated only when an `iterator` is requested from
+            the resulting sequence. Changing any of them between successive calls to `iterator` may affect the result.
+            """
+        }
+        body(Sequences) {
             """
             return sequenceOf(this, sequence).flatten()
             """
         }
     }
 
+    templates add f("minus(element: T)") {
+        only(Iterables, Sets, Sequences)
+        doc { "Returns a list containing all elements of the original collection without the first occurrence of the given [element]." }
+        returns("List<T>")
+        body {
+            """
+            val result = ArrayList<T>(collectionSizeOrDefault(10))
+            var removed = false
+            return this.filterTo(result) { if (!removed && it == element) { removed = true; false } else true }
+            """
+        }
+
+        returns("SELF", Sets, Sequences)
+        doc(Sets) { "Returns a set containing all elements of the original set except the given [element]." }
+        body(Sets) {
+            """
+            val result = LinkedHashSet<T>(mapCapacity(size()))
+            var removed = false
+            return this.filterTo(result) { if (!removed && it == element) { removed = true; false } else true }
+            """
+        }
+
+
+        doc(Sequences) { "Returns a sequence containing all elements of the original sequence without the first occurrence of the given [element]." }
+        body(Sequences) {
+            """
+            return object: Sequence<T> {
+                override fun iterator(): Iterator<T> {
+                    var removed = false
+                    return this@minus.filter { if (!removed && it == element) { removed = true; false } else true }.iterator()
+                }
+            }
+            """
+        }
+    }
+
+
+    templates add f("minus(collection: Iterable<T>)") {
+        only(Iterables, Sets, Sequences)
+        doc { "Returns a list containing all elements of the original collection except the elements contained in the given [collection]." }
+        returns("List<T>")
+        returns("SELF", Sets, Sequences)
+        body {
+            """
+            val other = collection.convertToSetForSetOperationWith(this)
+            if (other.isEmpty())
+                return this.toList()
+
+            return this.filterNot { it in other }
+            """
+        }
+
+        doc(Sets) { "Returns a set containing all elements of the original set except the elements contained in the given [collection]." }
+        body(Sets) {
+            """
+            val other = collection.convertToSetForSetOperationWith(this)
+            if (other.isEmpty())
+                return this.toSet()
+            if (other is Set)
+                return this.filterNotTo(LinkedHashSet<T>()) { it in other }
+
+            val result = LinkedHashSet<T>(this)
+            result.removeAll(other)
+            return result
+            """
+        }
+
+        doc(Sequences) {
+            """
+            Returns a sequence containing all elements of original sequence except the elements contained in the given [collection].
+
+            Note that the source sequence and the collection being subtracted are iterated only when an `iterator` is requested from
+            the resulting sequence. Changing any of them between successive calls to `iterator` may affect the result.
+            """
+        }
+        body(Sequences) {
+            """
+            return object: Sequence<T> {
+                override fun iterator(): Iterator<T> {
+                    val other = collection.convertToSetForSetOperation()
+                    if (other.isEmpty())
+                        return this@minus.iterator()
+                    else
+                        return this@minus.filterNot { it in other }.iterator()
+                }
+            }
+            """
+        }
+    }
+
+    templates add f("minus(array: Array<out T>)") {
+        only(Iterables, Sets, Sequences)
+        doc { "Returns a list containing all elements of the original collection except the elements contained in the given [array]." }
+        returns("List<T>")
+        returns("SELF", Sets, Sequences)
+        body {
+            """
+            if (array.isEmpty()) return this.toList()
+            val other = array.toHashSet()
+            return this.filterNot { it in other }
+            """
+        }
+        doc(Sets) { "Returns a set containing all elements of the original set except the elements contained in the given [array]." }
+        body(Sets) {
+            """
+            val result = LinkedHashSet<T>(this)
+            result.removeAll(array)
+            return result
+            """
+        }
+
+        doc(Sequences) {
+            """
+            Returns a sequence containing all elements of original sequence except the elements contained in the given [array].
+
+            Note that the source sequence and the array being subtracted are iterated only when an `iterator` is requested from
+            the resulting sequence. Changing any of them between successive calls to `iterator` may affect the result.
+            """
+        }
+        body(Sequences) {
+            """
+            if (array.isEmpty()) return this
+            return object: Sequence<T> {
+                override fun iterator(): Iterator<T> {
+                    val other = array.toHashSet()
+                    return this@minus.filterNot { it in other }.iterator()
+                }
+            }
+            """
+        }
+    }
+
+    templates add f("minus(sequence: Sequence<T>)") {
+        only(Iterables, Sets)
+        doc { "Returns a list containing all elements of the original collection except the elements contained in the given [sequence]." }
+        returns("List<T>")
+        returns("SELF", Sets, Sequences)
+        body {
+            """
+            val other = sequence.toHashSet()
+            if (other.isEmpty())
+                return this.toList()
+
+            return this.filterNot { it in other }
+            """
+        }
+        doc(Sets) { "Returns a set containing all elements of the original set except the elements contained in the given [sequence]." }
+        body(Sets) {
+            """
+            val result = LinkedHashSet<T>(this)
+            result.removeAll(sequence)
+            return result
+            """
+        }
+
+        doc(Sequences) {
+            """
+            Returns a sequence containing all elements of original sequence except the elements contained in the given [sequence].
+
+            Note that the source sequence and the sequence being subtracted are iterated only when an `iterator` is requested from
+            the resulting sequence. Changing any of them between successive calls to `iterator` may affect the result.
+            """
+        }
+        body(Sequences) {
+            """
+            return object: Sequence<T> {
+                override fun iterator(): Iterator<T> {
+                    val other = sequence.toHashSet()
+                    if (other.isEmpty())
+                        return this@minus.iterator()
+                    else
+                        return this@minus.filterNot { it in other }.iterator()
+                }
+            }
+            """
+        }
+    }
+
     templates add f("partition(predicate: (T) -> Boolean)") {
         inline(true)
 
         doc {
             """
-            Splits original collection into pair of collections,
+            Splits the original collection into pair of collections,
             where *first* collection contains elements for which [predicate] yielded `true`,
             while *second* collection contains elements for which [predicate] yielded `false`.
             """
@@ -129,6 +403,13 @@ fun generators(): List<GenericFunction> {
             """
         }
 
+        doc(Strings) {
+            """
+            Splits the original string into pair of strings,
+            where *first* string contains characters for which [predicate] yielded `true`,
+            while *second* string contains characters for which [predicate] yielded `false`.
+            """
+        }
         returns(Strings) { "Pair<String, String>" }
         body(Strings) {
             """
@@ -161,7 +442,7 @@ fun generators(): List<GenericFunction> {
             """
             val first = iterator()
             val second = other.iterator()
-            val list = ArrayList<V>(collectionSizeOrDefault(10))
+            val list = ArrayList<V>(Math.min(collectionSizeOrDefault(10), other.collectionSizeOrDefault(10)))
             while (first.hasNext() && second.hasNext()) {
                 list.add(transform(first.next(), second.next()))
             }
@@ -170,11 +451,12 @@ fun generators(): List<GenericFunction> {
         }
         body(ArraysOfObjects, ArraysOfPrimitives) {
             """
-            val first = iterator()
-            val second = other.iterator()
-            val list = ArrayList<V>(size())
-            while (first.hasNext() && second.hasNext()) {
-                list.add(transform(first.next(), second.next()))
+            val arraySize = size()
+            val list = ArrayList<V>(Math.min(other.collectionSizeOrDefault(10), arraySize))
+            var i = 0
+            for (element in other) {
+                if (i >= arraySize) break
+                list.add(transform(this[i++], element))
             }
             return list
             """
@@ -194,22 +476,22 @@ fun generators(): List<GenericFunction> {
         inline(true)
         body {
             """
-            val first = iterator()
-            val second = array.iterator()
-            val list = ArrayList<V>(collectionSizeOrDefault(10))
-            while (first.hasNext() && second.hasNext()) {
-                list.add(transform(first.next(), second.next()))
+            val arraySize = array.size()
+            val list = ArrayList<V>(Math.min(collectionSizeOrDefault(10), arraySize))
+            var i = 0
+            for (element in this) {
+                if (i >= arraySize) break
+                list.add(transform(element, array[i++]))
             }
             return list
             """
         }
         body(ArraysOfObjects, ArraysOfPrimitives) {
             """
-            val first = iterator()
-            val second = array.iterator()
-            val list = ArrayList<V>(Math.min(size(), array.size()))
-            while (first.hasNext() && second.hasNext()) {
-                list.add(transform(first.next(), second.next()))
+            val size = Math.min(size(), array.size())
+            val list = ArrayList<V>(size)
+            for (i in 0..size-1) {
+                list.add(transform(this[i], array[i]))
             }
             return list
             """
@@ -230,11 +512,10 @@ fun generators(): List<GenericFunction> {
         inline(true)
         body() {
             """
-            val first = iterator()
-            val second = array.iterator()
-            val list = ArrayList<V>(Math.min(size(), array.size()))
-            while (first.hasNext() && second.hasNext()) {
-                list.add(transform(first.next(), second.next()))
+            val size = Math.min(size(), array.size())
+            val list = ArrayList<V>(size)
+            for (i in 0..size-1) {
+                list.add(transform(this[i], array[i]))
             }
             return list
             """
diff --git a/libraries/tools/kotlin-stdlib-gen/src/templates/Sequence.kt b/libraries/tools/kotlin-stdlib-gen/src/templates/Sequence.kt
index 8f25dbb53cb..6fb929dc583 100644
--- a/libraries/tools/kotlin-stdlib-gen/src/templates/Sequence.kt
+++ b/libraries/tools/kotlin-stdlib-gen/src/templates/Sequence.kt
@@ -26,7 +26,6 @@ fun sequences(): List<GenericFunction> {
     }
     templates add f("asSequence()") {
         include(Maps)
-        exclude(Sequences)
         doc { "Returns a sequence from the given collection." }
         returns("Sequence<T>")
         body {
@@ -39,6 +38,17 @@ fun sequences(): List<GenericFunction> {
             """
         }
 
+        body(ArraysOfObjects, ArraysOfPrimitives, Strings) {
+            """
+            if (isEmpty()) return emptySequence()
+            return object : Sequence<T> {
+                override fun iterator(): Iterator<T> {
+                    return this@asSequence.iterator()
+                }
+            }
+            """
+        }
+
         body(Sequences) {
             """
             return this
diff --git a/libraries/tools/kotlin-stdlib-gen/src/templates/SpecialJS.kt b/libraries/tools/kotlin-stdlib-gen/src/templates/SpecialJS.kt
index 7caf0eae313..829ec53a024 100644
--- a/libraries/tools/kotlin-stdlib-gen/src/templates/SpecialJS.kt
+++ b/libraries/tools/kotlin-stdlib-gen/src/templates/SpecialJS.kt
@@ -21,5 +21,101 @@ fun specialJS(): List<GenericFunction> {
         body(ArraysOfPrimitives) {"""return (this as Array<T>).asList()"""}
     }
 
+    templates add f("copyOfRange(from: Int, to: Int)") {
+        // TODO: Arguments checking as in java?
+        only(ArraysOfObjects, ArraysOfPrimitives)
+        doc { "Returns new array which is a copy of range of original array." }
+        inline(true)
+        annotations("""suppress("NOTHING_TO_INLINE")""")
+        returns("SELF")
+        returns(ArraysOfObjects) { "Array<T>" }
+        body {
+            "return (this: dynamic).slice(from, to)"
+        }
+    }
+
+    templates add f("copyOf()") {
+        only(ArraysOfObjects, ArraysOfPrimitives)
+        doc { "Returns new array which is a copy of the original array." }
+        inline(true)
+        annotations("""suppress("NOTHING_TO_INLINE")""")
+        returns("SELF")
+        returns(ArraysOfObjects) { "Array<T>" }
+        body {
+            "return (this: dynamic).slice(0)"
+        }
+    }
+
+    val allArrays = PrimitiveType.defaultPrimitives.map { ArraysOfPrimitives to it } + (ArraysOfObjects to null)
+    templates addAll allArrays.map {
+            val (family, primitive) = it
+            f("copyOf(newSize: Int)") {
+                only(family)
+                val defaultValue: String
+                if (primitive != null) {
+                    returns("SELF")
+                    only(primitive)
+                    defaultValue = when (primitive) {
+                        PrimitiveType.Boolean -> false.toString()
+                        PrimitiveType.Char -> "'\\u0000'"
+                        else -> "ZERO"
+                    }
+                } else {
+                    returns(ArraysOfObjects) { "Array<T?>" }
+                    defaultValue = "null"
+                }
+                doc { "Returns new array which is a copy of the original array." }
+                body {
+                    """
+                    return arrayCopyResize(this, newSize, $defaultValue)
+                    """
+                }
+            }
+        }
+
+
+    templates add f("plus(element: T)") {
+        only(ArraysOfObjects, ArraysOfPrimitives)
+        returns("SELF")
+        returns(ArraysOfObjects) { "Array<T>" }
+        inline(true)
+        annotations("""suppress("NOTHING_TO_INLINE")""")
+        doc { "Returns an array containing all elements of the original array and then the given [element]." }
+        body() {
+            """
+            return (this: dynamic).concat(arrayOf(element))
+            """
+        }
+    }
+
+    templates add f("plus(collection: Collection<T>)") {
+        only(ArraysOfObjects, ArraysOfPrimitives)
+        returns("SELF")
+        returns(ArraysOfObjects) { "Array<T>" }
+        doc { "Returns an array containing all elements of the original array and then all elements of the given [collection]." }
+        body {
+            """
+            return arrayPlusCollection(this, collection)
+            """
+        }
+    }
+
+    // This overload can cause nulls if array size is expanding, hence different return overload
+    templates add f("plus(array: SELF)") {
+        only(ArraysOfObjects, ArraysOfPrimitives)
+        doc { "Returns an array containing all elements of the original array and then all elements of the given [array]." }
+        inline(true)
+        annotations("""suppress("NOTHING_TO_INLINE")""")
+        returns("SELF")
+        returns(ArraysOfObjects) { "Array<T>" }
+        body {
+            """
+            return (this: dynamic).concat(array)
+            """
+        }
+    }
+
+
+
     return templates
 }
\ No newline at end of file
diff --git a/libraries/tools/kotlin-stdlib-gen/src/templates/SpecialJVM.kt b/libraries/tools/kotlin-stdlib-gen/src/templates/SpecialJVM.kt
index 4af239daa08..fc7c95dfe33 100644
--- a/libraries/tools/kotlin-stdlib-gen/src/templates/SpecialJVM.kt
+++ b/libraries/tools/kotlin-stdlib-gen/src/templates/SpecialJVM.kt
@@ -5,48 +5,88 @@ import templates.Family.*
 fun specialJVM(): List<GenericFunction> {
     val templates = arrayListOf<GenericFunction>()
 
+    templates add f("plus(element: T)") {
+        only(InvariantArraysOfObjects, ArraysOfPrimitives)
+        returns("SELF")
+        doc { "Returns an array containing all elements of the original array and then the given [element]." }
+        body() {
+            """
+            val index = size()
+            val result = Arrays.copyOf(this, index + 1)
+            result[index] = element
+            return result
+            """
+        }
+    }
+
+    templates add f("plus(collection: Collection<T>)") {
+        only(InvariantArraysOfObjects, ArraysOfPrimitives)
+        returns("SELF")
+        doc { "Returns an array containing all elements of the original array and then all elements of the given [collection]." }
+        body {
+            """
+            var index = size()
+            val result = Arrays.copyOf(this, index + collection.size())
+            for (element in collection) result[index++] = element
+            return result
+            """
+        }
+    }
+
+    templates add f("plus(array: SELF)") {
+        only(InvariantArraysOfObjects, ArraysOfPrimitives)
+        customSignature(InvariantArraysOfObjects) { "plus(array: Array<out T>)" }
+        doc { "Returns an array containing all elements of the original array and then all elements of the given [array]." }
+        returns("SELF")
+        body {
+            """
+            val thisSize = size()
+            val arraySize = array.size()
+            val result = Arrays.copyOf(this, thisSize + arraySize)
+            System.arraycopy(array, 0, result, thisSize, arraySize)
+            return result
+            """
+        }
+    }
+
+
     templates add f("copyOfRange(from: Int, to: Int)") {
-        only(ArraysOfObjects, ArraysOfPrimitives)
+        only(ArraysOfObjects, InvariantArraysOfObjects, ArraysOfPrimitives)
         doc { "Returns new array which is a copy of range of original array." }
         returns("SELF")
-        returns(ArraysOfObjects) { "Array<T>" }
+        annotations(InvariantArraysOfObjects) { """platformName("mutableCopyOfRange")"""}
         body {
             "return Arrays.copyOfRange(this, from, to)"
         }
     }
 
     templates add f("copyOf()") {
-        only(ArraysOfObjects, ArraysOfPrimitives)
+        only(ArraysOfObjects, InvariantArraysOfObjects, ArraysOfPrimitives)
         doc { "Returns new array which is a copy of the original array." }
         returns("SELF")
-        returns(ArraysOfObjects) { "Array<T>" }
+        annotations(InvariantArraysOfObjects) { """platformName("mutableCopyOf")"""}
         body {
             "return Arrays.copyOf(this, size())"
         }
-        body(ArraysOfObjects) {
-            "return Arrays.copyOf(this, size()) as Array<T>"
-        }
     }
 
     // This overload can cause nulls if array size is expanding, hence different return overload
     templates add f("copyOf(newSize: Int)") {
-        only(ArraysOfObjects, ArraysOfPrimitives)
+        only(ArraysOfObjects, InvariantArraysOfObjects, ArraysOfPrimitives)
         doc { "Returns new array which is a copy of the original array." }
         returns("SELF")
         body {
             "return Arrays.copyOf(this, newSize)"
         }
-        returns(ArraysOfObjects) { "Array<T?>" }
-        body(ArraysOfObjects) {
-            "return Arrays.copyOf(this, newSize) as Array<T?>"
-        }
+        returns(ArraysOfObjects) { "Array<out T?>" }
+        returns(InvariantArraysOfObjects) { "Array<T?>" }
+        annotations(InvariantArraysOfObjects) { """platformName("mutableCopyOf")"""}
     }
 
     templates add f("fill(element: T)") {
-        only(ArraysOfObjects, ArraysOfPrimitives)
+        only(InvariantArraysOfObjects, ArraysOfPrimitives)
         doc { "Fills original array with the provided value." }
         returns { "SELF" }
-        returns(ArraysOfObjects) { "Array<out T>" }
         body {
             """
             Arrays.fill(this, element)
@@ -167,7 +207,7 @@ fun specialJVM(): List<GenericFunction> {
                 override fun size(): Int = this@asList.size()
                 override fun isEmpty(): Boolean = this@asList.isEmpty()
                 override fun contains(o: Any?): Boolean = this@asList.contains(o as T)
-                override fun iterator(): Iterator<T> = this@asList.iterator()
+                override fun iterator(): MutableIterator<T> = this@asList.iterator() as MutableIterator<T>
                 override fun get(index: Int): T = this@asList[index]
                 override fun indexOf(o: Any?): Int = this@asList.indexOf(o as T)
                 override fun lastIndexOf(o: Any?): Int = this@asList.lastIndexOf(o as T)
diff --git a/plugins/android-compiler-plugin/src/AndroidComponentRegistrar.kt b/plugins/android-compiler-plugin/src/AndroidComponentRegistrar.kt
index dd80d5eebe9..7ed48ec76b8 100644
--- a/plugins/android-compiler-plugin/src/AndroidComponentRegistrar.kt
+++ b/plugins/android-compiler-plugin/src/AndroidComponentRegistrar.kt
@@ -68,7 +68,7 @@ public class AndroidCommandLineProcessor : CommandLineProcessor {
 
 public class CliAndroidDeclarationsProvider(private val project: Project) : ExternalDeclarationsProvider {
     override fun getExternalDeclarations(moduleInfo: ModuleInfo?): Collection<JetFile> {
-        val parser = ServiceManager.getService<AndroidUIXmlProcessor>(project, javaClass<AndroidUIXmlProcessor>())
+        val parser = ServiceManager.getService(project, javaClass<AndroidUIXmlProcessor>())
         return parser.parseToPsi() ?: listOf()
     }
 }
diff --git a/plugins/android-compiler-plugin/src/AndroidExpressionCodegenExtension.kt b/plugins/android-compiler-plugin/src/AndroidExpressionCodegenExtension.kt
index b73a963c725..8230cbc22ba 100644
--- a/plugins/android-compiler-plugin/src/AndroidExpressionCodegenExtension.kt
+++ b/plugins/android-compiler-plugin/src/AndroidExpressionCodegenExtension.kt
@@ -199,7 +199,7 @@ public class AndroidExpressionCodegenExtension : ExpressionCodegenExtension {
     }
 
     private fun CallableDescriptor.getAndroidPackage(): String? {
-        return DescriptorToSourceUtils.getContainingFile(this)?.getUserData<String>(AndroidConst.ANDROID_USER_PACKAGE)
+        return DescriptorToSourceUtils.getContainingFile(this)?.getUserData(AndroidConst.ANDROID_USER_PACKAGE)
     }
 
     private fun ResolvedCall<*>.getReceiverDeclarationDescriptor(): ClassifierDescriptor? {
@@ -337,6 +337,7 @@ public class AndroidExpressionCodegenExtension : ExpressionCodegenExtension {
                 loadId()
                 iv.invokevirtual("android/view/View", "findViewById", "(I)Landroid/view/View;", false)
             }
+            else -> throw IllegalStateException("Can't generate code for $androidClassType")
         }
         iv.store(2, viewType)
 
diff --git a/plugins/android-compiler-plugin/src/org/jetbrains/kotlin/lang/resolve/android/AndroidResourceManager.kt b/plugins/android-compiler-plugin/src/org/jetbrains/kotlin/lang/resolve/android/AndroidResourceManager.kt
index 665ccd8c44d..666b0c43e21 100644
--- a/plugins/android-compiler-plugin/src/org/jetbrains/kotlin/lang/resolve/android/AndroidResourceManager.kt
+++ b/plugins/android-compiler-plugin/src/org/jetbrains/kotlin/lang/resolve/android/AndroidResourceManager.kt
@@ -35,8 +35,7 @@ public abstract class AndroidResourceManager(val project: Project) {
     public open fun propertyToXmlAttributes(property: JetProperty): List<PsiElement> = listOf()
 
     public fun getLayoutXmlFiles(): Map<String, List<PsiFile>> {
-        val info = androidModuleInfo
-        if (info == null) return mapOf()
+        val info = androidModuleInfo ?: return mapOf()
 
         val psiManager = PsiManager.getInstance(project)
         val fileManager = VirtualFileManager.getInstance()
@@ -63,13 +62,13 @@ public abstract class AndroidResourceManager(val project: Project) {
                 .map { psiManager.findFile(it) }
                 .filterNotNull()
                 .groupBy { it.getName().substringBeforeLast('.') }
-                .mapValues { it.getValue().sortBy { it.getParent().getName().length() } }
+                .mapValues { it.getValue().sortBy { it.getParent()!!.getName().length() } }
     }
 
     companion object {
         public fun getInstance(module: Module): AndroidResourceManager {
-            val service = ModuleServiceManager.getService<AndroidResourceManager>(module, javaClass<AndroidResourceManager>())
-            return service ?: module.getComponent<AndroidResourceManager>(javaClass<AndroidResourceManager>())
+            val service = ModuleServiceManager.getService(module, javaClass<AndroidResourceManager>())
+            return service ?: module.getComponent(javaClass<AndroidResourceManager>())
         }
     }
 
diff --git a/plugins/android-compiler-plugin/src/org/jetbrains/kotlin/lang/resolve/android/AndroidUIXmlProcessor.kt b/plugins/android-compiler-plugin/src/org/jetbrains/kotlin/lang/resolve/android/AndroidUIXmlProcessor.kt
index 88dc05ef219..139163e9770 100644
--- a/plugins/android-compiler-plugin/src/org/jetbrains/kotlin/lang/resolve/android/AndroidUIXmlProcessor.kt
+++ b/plugins/android-compiler-plugin/src/org/jetbrains/kotlin/lang/resolve/android/AndroidUIXmlProcessor.kt
@@ -193,7 +193,7 @@ public abstract class AndroidUIXmlProcessor(protected val project: Project) {
 
         for (res in resources) {
             if (resourceMap.contains(res.id)) {
-                val existing = resourceMap[res.id]
+                val existing = resourceMap[res.id]!!
 
                 if (!res.sameClass(existing)) {
                     resourcesToExclude.add(res.id)
diff --git a/plugins/android-compiler-plugin/src/org/jetbrains/kotlin/lang/resolve/android/AndroidXmlHandler.kt b/plugins/android-compiler-plugin/src/org/jetbrains/kotlin/lang/resolve/android/AndroidXmlHandler.kt
index fce7c656a79..c057ff00f57 100644
--- a/plugins/android-compiler-plugin/src/org/jetbrains/kotlin/lang/resolve/android/AndroidXmlHandler.kt
+++ b/plugins/android-compiler-plugin/src/org/jetbrains/kotlin/lang/resolve/android/AndroidXmlHandler.kt
@@ -35,7 +35,7 @@ class AndroidXmlHandler(private val elementCallback: (String, String) -> Unit) :
         val attributesMap = attributes.toMap()
         val idAttribute = attributesMap[AndroidConst.ID_ATTRIBUTE_NO_NAMESPACE]
         val widgetType = attributesMap[AndroidConst.CLASS_ATTRIBUTE_NO_NAMESPACE] ?: localName
-        val name = idAttribute?.let { idToName(idAttribute) }
+        val name = idAttribute?.let { idToName(idAttribute!!) }
         if (name != null) elementCallback(name, widgetType)
     }
 
diff --git a/plugins/android-compiler-plugin/src/org/jetbrains/kotlin/lang/resolve/android/KotlinWriter.kt b/plugins/android-compiler-plugin/src/org/jetbrains/kotlin/lang/resolve/android/KotlinWriter.kt
index 3d6f6705a65..0156959f0ab 100644
--- a/plugins/android-compiler-plugin/src/org/jetbrains/kotlin/lang/resolve/android/KotlinWriter.kt
+++ b/plugins/android-compiler-plugin/src/org/jetbrains/kotlin/lang/resolve/android/KotlinWriter.kt
@@ -16,7 +16,7 @@
 
 package org.jetbrains.kotlin.lang.resolve.android
 
-trait KotlinWriter {
+interface KotlinWriter {
     fun toStringBuffer(): StringBuffer
 }
 
diff --git a/plugins/android-compiler-plugin/tests/org/jetbrains/kotlin/lang/resolve/android/test/CompilerTestUtils.kt b/plugins/android-compiler-plugin/tests/org/jetbrains/kotlin/lang/resolve/android/test/CompilerTestUtils.kt
index 9af61fbf437..af853702ed9 100644
--- a/plugins/android-compiler-plugin/tests/org/jetbrains/kotlin/lang/resolve/android/test/CompilerTestUtils.kt
+++ b/plugins/android-compiler-plugin/tests/org/jetbrains/kotlin/lang/resolve/android/test/CompilerTestUtils.kt
@@ -53,10 +53,14 @@ fun UsefulTestCase.createAndroidTestEnvironment(
 ): KotlinCoreEnvironment {
     configuration.put(AndroidConfigurationKeys.ANDROID_RES_PATH, resPaths)
     configuration.put(AndroidConfigurationKeys.ANDROID_MANIFEST, manifestPath)
+
     val myEnvironment = KotlinCoreEnvironment.createForTests(getTestRootDisposable()!!, configuration, EnvironmentConfigFiles.JVM_CONFIG_FILES)
     val project = myEnvironment.project
-    ExternalDeclarationsProvider.registerExtension(project, AndroidTestExternalDeclarationsProvider(project, resPaths, manifestPath, supportV4))
+
+    val declarationsProvider = AndroidTestExternalDeclarationsProvider(project, resPaths, manifestPath, supportV4)
+    ExternalDeclarationsProvider.registerExtension(project, declarationsProvider)
     ExpressionCodegenExtension.registerExtension(project, AndroidExpressionCodegenExtension())
+
     return myEnvironment
 }
 
diff --git a/plugins/android-idea-plugin/src/org/jetbrains/kotlin/plugin/android/AndroidPsiTreeChangePreprocessor.kt b/plugins/android-idea-plugin/src/org/jetbrains/kotlin/plugin/android/AndroidPsiTreeChangePreprocessor.kt
index 8704a38363e..59d1f21c1d6 100644
--- a/plugins/android-idea-plugin/src/org/jetbrains/kotlin/plugin/android/AndroidPsiTreeChangePreprocessor.kt
+++ b/plugins/android-idea-plugin/src/org/jetbrains/kotlin/plugin/android/AndroidPsiTreeChangePreprocessor.kt
@@ -61,10 +61,10 @@ public class AndroidPsiTreeChangePreprocessor : PsiTreeChangePreprocessor, Simpl
     }
 
     private fun AndroidResourceManager.getModuleResDirectories(): List<VirtualFile> {
-        val info = androidModuleInfo
-        if (info == null) return listOf()
+        val info = androidModuleInfo ?: return listOf()
+
         val fileManager = VirtualFileManager.getInstance()
-        return info.resDirectories.map { fileManager.findFileByUrl("file://" + it) }
+        return info.resDirectories.map { fileManager.findFileByUrl("file://" + it)!! }
     }
 
     private fun PsiFile.isLayoutXmlFile(): Boolean {
diff --git a/plugins/android-idea-plugin/src/org/jetbrains/kotlin/plugin/android/AndroidRenameProcessor.kt b/plugins/android-idea-plugin/src/org/jetbrains/kotlin/plugin/android/AndroidRenameProcessor.kt
index e47aaa450e0..0df89ffb2bc 100644
--- a/plugins/android-idea-plugin/src/org/jetbrains/kotlin/plugin/android/AndroidRenameProcessor.kt
+++ b/plugins/android-idea-plugin/src/org/jetbrains/kotlin/plugin/android/AndroidRenameProcessor.kt
@@ -91,8 +91,7 @@ public class AndroidRenameProcessor : RenamePsiElementProcessor() {
             newName: String,
             allRenames: MutableMap<PsiElement, String>
     ) {
-        val module = jetProperty.getModule()
-        if (module == null) return
+        val module = jetProperty.getModule() ?: return
 
         val processor = ModuleServiceManager.getService(module, javaClass<AndroidUIXmlProcessor>())
         val resourceManager = processor.resourceManager
@@ -119,8 +118,7 @@ public class AndroidRenameProcessor : RenamePsiElementProcessor() {
     ) {
         val element = LazyValueResourceElementWrapper.computeLazyElement(attribute)
         val module = attribute.getModule() ?: ModuleUtilCore.findModuleForFile(
-                attribute.getContainingFile().getVirtualFile(), attribute.getProject())
-        if (module == null) return
+                attribute.getContainingFile().getVirtualFile(), attribute.getProject()) ?: return
 
         val processor = ModuleServiceManager.getService(module, javaClass<AndroidUIXmlProcessor>())
         if (element == null) return
@@ -149,7 +147,7 @@ public class AndroidRenameProcessor : RenamePsiElementProcessor() {
             newName: String,
             allRenames: MutableMap<PsiElement, String>
     ) {
-        val oldName = field.getName()
+        val oldName = field.getName()!!
         val processor = ServiceManager.getService(field.getProject(), javaClass<AndroidUIXmlProcessor>())
         renameSyntheticProperties(allRenames, newName, oldName, processor)
     }
diff --git a/plugins/android-idea-plugin/src/org/jetbrains/kotlin/plugin/android/AndroidSimpleNameReferenceExtension.kt b/plugins/android-idea-plugin/src/org/jetbrains/kotlin/plugin/android/AndroidSimpleNameReferenceExtension.kt
index 440be54c065..2e51648ce12 100644
--- a/plugins/android-idea-plugin/src/org/jetbrains/kotlin/plugin/android/AndroidSimpleNameReferenceExtension.kt
+++ b/plugins/android-idea-plugin/src/org/jetbrains/kotlin/plugin/android/AndroidSimpleNameReferenceExtension.kt
@@ -26,10 +26,8 @@ import org.jetbrains.kotlin.lang.resolve.android.isAndroidSyntheticElement
 
 public class AndroidSimpleNameReferenceExtension : SimpleNameReferenceExtension {
     override fun isReferenceTo(reference: JetSimpleNameReference, element: PsiElement): Boolean? {
-        val resolvedElement = reference.resolve()
-        if (resolvedElement == null) {
-            return null
-        }
+        val resolvedElement = reference.resolve() ?: return null
+
         if (isAndroidSyntheticElement(resolvedElement)) {
             if (element is ValueResourceElementWrapper) {
                 val resource = element.getValue()
diff --git a/plugins/android-idea-plugin/src/org/jetbrains/kotlin/plugin/android/IDEAndroidExternalDeclarationsProvider.kt b/plugins/android-idea-plugin/src/org/jetbrains/kotlin/plugin/android/IDEAndroidExternalDeclarationsProvider.kt
index e776c7ba05f..bdf62868896 100644
--- a/plugins/android-idea-plugin/src/org/jetbrains/kotlin/plugin/android/IDEAndroidExternalDeclarationsProvider.kt
+++ b/plugins/android-idea-plugin/src/org/jetbrains/kotlin/plugin/android/IDEAndroidExternalDeclarationsProvider.kt
@@ -30,7 +30,7 @@ public class IDEAndroidExternalDeclarationsProvider(private val project: Project
         if (moduleInfo !is ModuleSourceInfo) return listOf()
 
         val module = moduleInfo.module
-        val parser = ModuleServiceManager.getService<AndroidUIXmlProcessor>(module, javaClass<AndroidUIXmlProcessor>())
+        val parser = ModuleServiceManager.getService(module, javaClass<AndroidUIXmlProcessor>())
         val syntheticFiles = parser.parseToPsi()
         syntheticFiles?.forEach { it.moduleInfo = moduleInfo }
 
diff --git a/plugins/android-idea-plugin/tests/org/jetbrains/kotlin/android/AbstractAndroidCompletionTest.kt b/plugins/android-idea-plugin/tests/org/jetbrains/kotlin/android/AbstractAndroidCompletionTest.kt
index 5ac0dba4912..dd81e0194f2 100644
--- a/plugins/android-idea-plugin/tests/org/jetbrains/kotlin/android/AbstractAndroidCompletionTest.kt
+++ b/plugins/android-idea-plugin/tests/org/jetbrains/kotlin/android/AbstractAndroidCompletionTest.kt
@@ -34,6 +34,7 @@ public abstract class AbstractAndroidCompletionTest : KotlinAndroidTestCase() {
         codeCompletionOldValue = settings.AUTOCOMPLETE_ON_CODE_COMPLETION
         smartTypeCompletionOldValue = settings.AUTOCOMPLETE_ON_SMART_TYPE_COMPLETION
 
+        @suppress("NON_EXHAUSTIVE_WHEN")
         when (completionType()) {
             CompletionType.SMART -> settings.AUTOCOMPLETE_ON_SMART_TYPE_COMPLETION = false
             CompletionType.BASIC -> settings.AUTOCOMPLETE_ON_CODE_COMPLETION = false
diff --git a/plugins/android-idea-plugin/tests/org/jetbrains/kotlin/android/AbstractAndroidRenameTest.kt b/plugins/android-idea-plugin/tests/org/jetbrains/kotlin/android/AbstractAndroidRenameTest.kt
index d4e8c93a44c..b39d268762e 100644
--- a/plugins/android-idea-plugin/tests/org/jetbrains/kotlin/android/AbstractAndroidRenameTest.kt
+++ b/plugins/android-idea-plugin/tests/org/jetbrains/kotlin/android/AbstractAndroidRenameTest.kt
@@ -37,8 +37,8 @@ public abstract class AbstractAndroidRenameTest : KotlinAndroidTestCase() {
         val editor = f.getEditor()
         val file = f.getFile()
         val completionEditor = InjectedLanguageUtil.getEditorForInjectedLanguageNoCommit(editor, file)
-        val element = TargetElementUtilBase.findTargetElement(completionEditor,
-                                                              TargetElementUtilBase.REFERENCED_ELEMENT_ACCEPTED or TargetElementUtilBase.ELEMENT_NAME_ACCEPTED)
+        val element = TargetElementUtilBase.findTargetElement(
+                completionEditor, TargetElementUtilBase.REFERENCED_ELEMENT_ACCEPTED or TargetElementUtilBase.ELEMENT_NAME_ACCEPTED)
 
         assert(element != null)
         assertTrue(element is JetProperty)
diff --git a/plugins/android-idea-plugin/tests/org/jetbrains/kotlin/android/KotlinAndroidTestCase.java b/plugins/android-idea-plugin/tests/org/jetbrains/kotlin/android/KotlinAndroidTestCase.java
index e98b51c45a7..bfdd7207c22 100644
--- a/plugins/android-idea-plugin/tests/org/jetbrains/kotlin/android/KotlinAndroidTestCase.java
+++ b/plugins/android-idea-plugin/tests/org/jetbrains/kotlin/android/KotlinAndroidTestCase.java
@@ -18,6 +18,7 @@ package org.jetbrains.kotlin.android;
 
 import com.android.SdkConstants;
 import com.android.ide.common.rendering.RenderSecurityManager;
+import com.android.tools.idea.rendering.PsiProjectListener;
 import com.intellij.facet.FacetManager;
 import com.intellij.facet.ModifiableFacetModel;
 import com.intellij.ide.startup.impl.StartupManagerImpl;
@@ -43,8 +44,10 @@ import org.jetbrains.kotlin.test.JetTestUtils;
 import java.io.File;
 import java.io.FileFilter;
 import java.io.IOException;
+import java.lang.reflect.Field;
 import java.util.ArrayList;
 import java.util.List;
+import java.util.Map;
 
 
 @SuppressWarnings({"JUnitTestCaseWithNonTrivialConstructors"})
@@ -80,6 +83,8 @@ public abstract class KotlinAndroidTestCase extends KotlinAndroidTestCaseBase {
         System.setProperty(KotlinAndroidTestCaseBase.SDK_PATH_PROPERTY, PathManager.getHomePath() + "/../dependencies/androidSDK");
         System.setProperty(KotlinAndroidTestCaseBase.PLATFORM_DIR_PROPERTY, "android-21");
 
+        VfsRootAccess.allowRootAccess(JetTestUtils.getHomeDirectory());
+
         super.setUp();
 
         // this will throw an exception if we don't have a full Android SDK, so we need to do this first thing before any other setup
@@ -142,7 +147,6 @@ public abstract class KotlinAndroidTestCase extends KotlinAndroidTestCaseBase {
         }
 
         ((StartupManagerImpl) StartupManager.getInstance(getProject())).runPostStartupActivities();
-        VfsRootAccess.allowRootAccess(JetTestUtils.getHomeDirectory());
 
         kotlinInternalModeOriginalValue = KotlinInternalMode.Instance.getEnabled();
         KotlinInternalMode.Instance.setEnabled(true);
@@ -177,7 +181,8 @@ public abstract class KotlinAndroidTestCase extends KotlinAndroidTestCaseBase {
     }
 
     protected void createManifest() throws IOException {
-        myFixture.copyFileToProject("plugins/android-idea-plugin/testData/android/AndroidManifest.xml", SdkConstants.FN_ANDROID_MANIFEST_XML);
+        myFixture.copyFileToProject("plugins/android-idea-plugin/testData/android/AndroidManifest.xml",
+                                    SdkConstants.FN_ANDROID_MANIFEST_XML);
     }
 
     protected void deleteManifest() throws IOException {
@@ -207,15 +212,22 @@ public abstract class KotlinAndroidTestCase extends KotlinAndroidTestCaseBase {
     @Override
     public void tearDown() throws Exception {
         KotlinInternalMode.Instance.setEnabled(kotlinInternalModeOriginalValue);
-        VfsRootAccess.disallowRootAccess(JetTestUtils.getHomeDirectory());
 
         super.tearDown();
 
+        Field listenersField = PsiProjectListener.class.getDeclaredField("ourListeners");
+        listenersField.setAccessible(true);
+        Map listeners = (Map)listenersField.get(null);
+        listeners.clear();
+
+        VfsRootAccess.disallowRootAccess(JetTestUtils.getHomeDirectory());
+
         myModule = null;
         myAdditionalModules = null;
         myFixture.tearDown();
         myFixture = null;
         myFacet = null;
+
         if (RenderSecurityManager.RESTRICT_READS) {
             RenderSecurityManager.sEnabled = true;
         }
diff --git a/plugins/android-idea-plugin/tests/org/jetbrains/kotlin/android/KotlinAndroidTestCaseBase.java b/plugins/android-idea-plugin/tests/org/jetbrains/kotlin/android/KotlinAndroidTestCaseBase.java
index 6dbd0a83db9..4e7eb4885ef 100644
--- a/plugins/android-idea-plugin/tests/org/jetbrains/kotlin/android/KotlinAndroidTestCaseBase.java
+++ b/plugins/android-idea-plugin/tests/org/jetbrains/kotlin/android/KotlinAndroidTestCaseBase.java
@@ -76,6 +76,8 @@ public abstract class KotlinAndroidTestCaseBase extends UsefulTestCase {
             @Override
             public void run() throws Exception {
                 KotlinAndroidTestCaseBase.super.tearDown();
+                androidJar = null;
+                androidSdk = null;
             }
         });
     }
diff --git a/plugins/android-jps-plugin/src/KotlinAndroidJpsPlugin.kt b/plugins/android-jps-plugin/src/KotlinAndroidJpsPlugin.kt
index 66945231713..a4ec2391754 100644
--- a/plugins/android-jps-plugin/src/KotlinAndroidJpsPlugin.kt
+++ b/plugins/android-jps-plugin/src/KotlinAndroidJpsPlugin.kt
@@ -72,15 +72,13 @@ public class KotlinAndroidJpsPlugin : KotlinJpsCompilerArgumentsProvider {
     }
 
     private fun getAndroidResPath(module: JpsModule): String? {
-        val extension = AndroidJpsUtil.getExtension(module)
-        if (extension == null) return null
+        val extension = AndroidJpsUtil.getExtension(module) ?: return null
         val path = AndroidJpsUtil.getResourceDirForCompilationPath(extension)
         return File(path!!.getAbsolutePath() + "/layout").getAbsolutePath()
     }
 
     private fun getAndroidManifest(module: JpsModule): String? {
-        val extension = AndroidJpsUtil.getExtension(module)
-        if (extension == null) return null
+        val extension = AndroidJpsUtil.getExtension(module) ?: return null
         return AndroidJpsUtil.getManifestFileForCompilationPath(extension)!!.getAbsolutePath()
     }
 
diff --git a/plugins/android-jps-plugin/tests/org/jetbrains/kotlin/jps/build/android/AbstractAndroidJpsTestCase.kt b/plugins/android-jps-plugin/tests/org/jetbrains/kotlin/jps/build/android/AbstractAndroidJpsTestCase.kt
index 1319e7a45a6..6a13411fffc 100644
--- a/plugins/android-jps-plugin/tests/org/jetbrains/kotlin/jps/build/android/AbstractAndroidJpsTestCase.kt
+++ b/plugins/android-jps-plugin/tests/org/jetbrains/kotlin/jps/build/android/AbstractAndroidJpsTestCase.kt
@@ -44,7 +44,7 @@ public abstract class AbstractAndroidJpsTestCase : JpsBuildTestCase() {
 
     public fun deleteDirectory(path: File): Boolean {
         if (path.exists() && path.isDirectory()) {
-            val files = path.listFiles()!!
+            val files = path.listFiles()
             for (i in files.indices) {
                 if (files[i].isDirectory()) {
                     deleteDirectory(files[i])
@@ -62,9 +62,8 @@ public abstract class AbstractAndroidJpsTestCase : JpsBuildTestCase() {
         addJdk(jdkName)
         val properties = JpsAndroidSdkProperties("android-21", jdkName)
         val sdkPath = getHomePath() + "/../dependencies/androidSDK"
-        val library = myModel!!.getGlobal().addSdk<JpsSimpleElement<JpsAndroidSdkProperties>>(SDK_NAME, sdkPath, "",
-                JpsAndroidSdkType.INSTANCE, JpsSimpleElementImpl(properties))
-        library!!.addRoot(File(sdkPath + "/platforms/android-21/android.jar"), JpsOrderRootType.COMPILED)
+        val library = myModel.getGlobal().addSdk(SDK_NAME, sdkPath, "", JpsAndroidSdkType.INSTANCE, JpsSimpleElementImpl(properties))
+        library.addRoot(File(sdkPath + "/platforms/android-21/android.jar"), JpsOrderRootType.COMPILED)
         return library.getProperties()
     }
 }
diff --git a/plugins/annotation-collector/src/org/jetbrains/kotlin/annotation/AnnotationCollectorExtension.kt b/plugins/annotation-collector/src/org/jetbrains/kotlin/annotation/AnnotationCollectorExtension.kt
index 0fc57f6dfbe..b49e063f65b 100644
--- a/plugins/annotation-collector/src/org/jetbrains/kotlin/annotation/AnnotationCollectorExtension.kt
+++ b/plugins/annotation-collector/src/org/jetbrains/kotlin/annotation/AnnotationCollectorExtension.kt
@@ -33,7 +33,7 @@ import java.util.regex.Pattern
 import java.util.regex.PatternSyntaxException
 import kotlin.properties.Delegates
 
-public abstract class AnnotationCollectorExtensionBase() : ClassBuilderInterceptorExtension {
+public abstract class AnnotationCollectorExtensionBase(val supportInheritedAnnotations: Boolean) : ClassBuilderInterceptorExtension {
 
     private object RecordTypes {
         val ANNOTATED_CLASS = "c"
@@ -42,6 +42,8 @@ public abstract class AnnotationCollectorExtensionBase() : ClassBuilderIntercept
 
         val SHORTENED_ANNOTATION = "a"
         val SHORTENED_PACKAGE_NAME = "p"
+
+        val CLASS_DECLARATION = "d"
     }
 
     protected abstract val annotationFilterList: List<String>?
@@ -126,8 +128,15 @@ public abstract class AnnotationCollectorExtensionBase() : ClassBuilderIntercept
                 superName: String,
                 interfaces: Array<out String>
         ) {
-            currentClassSimpleName = name.substringAfterLast('/')
-            currentPackageName = name.substringBeforeLast('/', "").replace('/', '.')
+            val currentClassSimpleName = name.substringAfterLast('/')
+            val currentPackageName = name.substringBeforeLast('/', "").replace('/', '.')
+
+            this.currentClassSimpleName = currentClassSimpleName
+            this.currentPackageName = currentPackageName
+
+            if (supportInheritedAnnotations) {
+                recordClass(currentPackageName, currentClassSimpleName)
+            }
 
             super.defineClass(origin, version, access, name, signature, superName, interfaces)
         }
@@ -170,6 +179,15 @@ public abstract class AnnotationCollectorExtensionBase() : ClassBuilderIntercept
             else !annotationFqName.startsWith("kotlin.jvm.internal.") //apply to all
         }
 
+        private fun recordClass(packageName: String, className: String) {
+            val packageNameId = if (!packageName.isEmpty())
+                shortenedPackageNameCache.save(packageName, writer)
+            else null
+
+            val outputClassName = getOutputClassName(packageNameId, className)
+            writer.write("${RecordTypes.CLASS_DECLARATION} $outputClassName\n")
+        }
+
         private fun recordAnnotation(name: String?, type: String, annotationDesc: String) {
             val annotationFqName = Type.getType(annotationDesc).getClassName()
             if (!isAnnotationHandled(annotationFqName)) return
@@ -183,7 +201,7 @@ public abstract class AnnotationCollectorExtensionBase() : ClassBuilderIntercept
                 else null
 
                 val className = this.currentClassSimpleName!!
-                val outputClassName = if (packageNameId == null) className else "$packageNameId/$className"
+                val outputClassName = getOutputClassName(packageNameId, className)
                 val elementName = if (name != null) " $name" else ""
 
                 writer.write("$type $annotationId $outputClassName$elementName\n")
@@ -193,6 +211,10 @@ public abstract class AnnotationCollectorExtensionBase() : ClassBuilderIntercept
             }
         }
 
+        private fun getOutputClassName(packageNameId: String?, className: String): String {
+            return if (packageNameId == null) className else "$packageNameId/$className"
+        }
+
         private fun String.compilePatternOpt(): Pattern? {
             return try {
                 Pattern.compile(this)
@@ -220,8 +242,9 @@ public abstract class AnnotationCollectorExtensionBase() : ClassBuilderIntercept
 
 public class AnnotationCollectorExtension(
         override val annotationFilterList: List<String>? = null,
-        val outputFilename: String? = null
-) : AnnotationCollectorExtensionBase() {
+        val outputFilename: String? = null,
+        supportInheritedAnnotations: Boolean
+) : AnnotationCollectorExtensionBase(supportInheritedAnnotations) {
 
     private var writerInternal: Writer? = null
 
diff --git a/plugins/annotation-collector/src/org/jetbrains/kotlin/annotation/AnnotationCollectorPlugin.kt b/plugins/annotation-collector/src/org/jetbrains/kotlin/annotation/AnnotationCollectorPlugin.kt
index 8043e90d8bb..76f13614d0f 100644
--- a/plugins/annotation-collector/src/org/jetbrains/kotlin/annotation/AnnotationCollectorPlugin.kt
+++ b/plugins/annotation-collector/src/org/jetbrains/kotlin/annotation/AnnotationCollectorPlugin.kt
@@ -51,6 +51,8 @@ public object AnnotationCollectorConfigurationKeys {
             CompilerConfigurationKey.create<String>("annotation file name")
     public val STUBS_PATH: CompilerConfigurationKey<String> =
             CompilerConfigurationKey.create<String>("stubs output directory")
+    public val INHERITED: CompilerConfigurationKey<String> =
+            CompilerConfigurationKey.create<String>("support inherited annotations")
 }
 
 public class AnnotationCollectorCommandLineProcessor : CommandLineProcessor {
@@ -64,12 +66,17 @@ public class AnnotationCollectorCommandLineProcessor : CommandLineProcessor {
                 CliOption("output", "<path>", "File in which annotated declarations will be placed", required = false)
 
         public val STUBS_PATH_OPTION: CliOption =
-                CliOption("stubs", "<path>", "Output path for stubs.", required = false)
+                CliOption("stubs", "<path>", "Output path for stubs", required = false)
+
+        public val INHERITED_ANNOTATIONS_OPTION: CliOption =
+                CliOption("inherited", "<true/false>",
+                          "True if collecting Kotlin class names for inherited annotations is needed", required = false)
     }
 
     override val pluginId: String = ANNOTATION_COLLECTOR_COMPILER_PLUGIN_ID
 
-    override val pluginOptions: Collection<CliOption> = listOf(ANNOTATION_FILTER_LIST_OPTION, OUTPUT_FILENAME_OPTION, STUBS_PATH_OPTION)
+    override val pluginOptions: Collection<CliOption> =
+            listOf(ANNOTATION_FILTER_LIST_OPTION, OUTPUT_FILENAME_OPTION, STUBS_PATH_OPTION, INHERITED_ANNOTATIONS_OPTION)
 
     override fun processOption(option: CliOption, value: String, configuration: CompilerConfiguration) {
         when (option) {
@@ -79,6 +86,7 @@ public class AnnotationCollectorCommandLineProcessor : CommandLineProcessor {
             }
             OUTPUT_FILENAME_OPTION -> configuration.put(AnnotationCollectorConfigurationKeys.OUTPUT_FILENAME, value)
             STUBS_PATH_OPTION -> configuration.put(AnnotationCollectorConfigurationKeys.STUBS_PATH, value)
+            INHERITED_ANNOTATIONS_OPTION -> configuration.put(AnnotationCollectorConfigurationKeys.INHERITED, value)
             else -> throw CliOptionProcessingException("Unknown option: ${option.name}")
         }
     }
@@ -86,10 +94,12 @@ public class AnnotationCollectorCommandLineProcessor : CommandLineProcessor {
 
 public class AnnotationCollectorComponentRegistrar : ComponentRegistrar {
     public override fun registerProjectComponents(project: MockProject, configuration: CompilerConfiguration) {
+        val supportInheritedAnnotations = "true" == (configuration.get(AnnotationCollectorConfigurationKeys.INHERITED) ?: "true")
+
         val annotationFilterList = configuration.get(AnnotationCollectorConfigurationKeys.ANNOTATION_FILTER_LIST)
         val outputFilename = configuration.get(AnnotationCollectorConfigurationKeys.OUTPUT_FILENAME)
         if (outputFilename != null) {
-            val collectorExtension = AnnotationCollectorExtension(annotationFilterList, outputFilename)
+            val collectorExtension = AnnotationCollectorExtension(annotationFilterList, outputFilename, supportInheritedAnnotations)
             ClassBuilderInterceptorExtension.registerExtension(project, collectorExtension)
         }
 
diff --git a/plugins/annotation-collector/test/org/jetbrains/kotlin/annotation/AbstractAnnotationProcessorBoxTest.kt b/plugins/annotation-collector/test/org/jetbrains/kotlin/annotation/AbstractAnnotationProcessorBoxTest.kt
index 8c6acf8fb14..493eb875114 100644
--- a/plugins/annotation-collector/test/org/jetbrains/kotlin/annotation/AbstractAnnotationProcessorBoxTest.kt
+++ b/plugins/annotation-collector/test/org/jetbrains/kotlin/annotation/AbstractAnnotationProcessorBoxTest.kt
@@ -35,12 +35,15 @@ import org.junit.Assert.*
 public abstract class AbstractAnnotationProcessorBoxTest : CodegenTestCase() {
 
     public fun doTest(path: String) {
-        val fileName = path + getTestName(true) + ".kt"
-        val collectorExtension = createTestEnvironment()
+        val testName = getTestName(true)
+        val fileName = path + testName + ".kt"
+        val supportInheritedAnnotations = testName.startsWith("inherited")
+
+        val collectorExtension = createTestEnvironment(supportInheritedAnnotations)
         loadFileByFullPath(fileName)
         CodegenTestUtil.generateFiles(myEnvironment, myFiles)
 
-        val actualAnnotations = collectorExtension.stringWriter.toString()
+        val actualAnnotations = JetTestUtils.replaceHashWithStar(collectorExtension.stringWriter.toString())
         val expectedAnnotationsFile = File(path + "annotations.txt")
 
         JetTestUtils.assertEqualsToFile(expectedAnnotationsFile, actualAnnotations)
@@ -50,12 +53,12 @@ public abstract class AbstractAnnotationProcessorBoxTest : CodegenTestCase() {
         return "plugins/annotation-collector/testData/codegen/"
     }
 
-    fun createTestEnvironment(): AnnotationCollectorExtensionForTests {
+    fun createTestEnvironment(supportInheritedAnnotations: Boolean): AnnotationCollectorExtensionForTests {
         val configuration = JetTestUtils.compilerConfigurationForTests(ConfigurationKind.ALL, TestJdkKind.MOCK_JDK)
         val environment = KotlinCoreEnvironment.createForTests(getTestRootDisposable()!!, configuration, EnvironmentConfigFiles.JVM_CONFIG_FILES)
         val project = environment.project
 
-        val collectorExtension = AnnotationCollectorExtensionForTests()
+        val collectorExtension = AnnotationCollectorExtensionForTests(supportInheritedAnnotations)
         ClassBuilderInterceptorExtension.registerExtension(project, collectorExtension)
 
         myEnvironment = environment
@@ -63,7 +66,9 @@ public abstract class AbstractAnnotationProcessorBoxTest : CodegenTestCase() {
         return collectorExtension
     }
 
-    private class AnnotationCollectorExtensionForTests : AnnotationCollectorExtensionBase() {
+    private class AnnotationCollectorExtensionForTests(
+            supportInheritedAnnotations: Boolean
+    ) : AnnotationCollectorExtensionBase(supportInheritedAnnotations) {
         val stringWriter = StringWriter()
 
         override fun getWriter(diagnostic: DiagnosticSink) = stringWriter
diff --git a/plugins/annotation-collector/test/org/jetbrains/kotlin/annotation/AnnotationProcessorBoxTestGenerated.java b/plugins/annotation-collector/test/org/jetbrains/kotlin/annotation/AnnotationProcessorBoxTestGenerated.java
index 4a793f4facd..32982d7ac5c 100644
--- a/plugins/annotation-collector/test/org/jetbrains/kotlin/annotation/AnnotationProcessorBoxTestGenerated.java
+++ b/plugins/annotation-collector/test/org/jetbrains/kotlin/annotation/AnnotationProcessorBoxTestGenerated.java
@@ -77,6 +77,18 @@ public class AnnotationProcessorBoxTestGenerated extends AbstractAnnotationProce
         doTest(fileName);
     }
 
+    @TestMetadata("inheritedSimple")
+    public void testInheritedSimple() throws Exception {
+        String fileName = JetTestUtils.navigationMetadata("plugins/annotation-collector/testData/collectToFile/inheritedSimple/");
+        doTest(fileName);
+    }
+
+    @TestMetadata("inheritedTopLevel")
+    public void testInheritedTopLevel() throws Exception {
+        String fileName = JetTestUtils.navigationMetadata("plugins/annotation-collector/testData/collectToFile/inheritedTopLevel/");
+        doTest(fileName);
+    }
+
     @TestMetadata("localClasses")
     public void testLocalClasses() throws Exception {
         String fileName = JetTestUtils.navigationMetadata("plugins/annotation-collector/testData/collectToFile/localClasses/");
diff --git a/plugins/annotation-collector/testData/collectToFile/annotationInSameFile/annotationInSameFile.kt b/plugins/annotation-collector/testData/collectToFile/annotationInSameFile/annotationInSameFile.kt
index 6d4608fa2ac..238f42450cc 100644
--- a/plugins/annotation-collector/testData/collectToFile/annotationInSameFile/annotationInSameFile.kt
+++ b/plugins/annotation-collector/testData/collectToFile/annotationInSameFile/annotationInSameFile.kt
@@ -1,6 +1,6 @@
 package org.test
 
-public annotation class SomeAnnotation
+public annotation(retention = AnnotationRetention.BINARY) class SomeAnnotation
 
 SomeAnnotation public class SomeClass {
 
diff --git a/plugins/annotation-collector/testData/collectToFile/annotationInSameFile/annotations.txt b/plugins/annotation-collector/testData/collectToFile/annotationInSameFile/annotations.txt
index 89c154ea586..45399e7808f 100644
--- a/plugins/annotation-collector/testData/collectToFile/annotationInSameFile/annotations.txt
+++ b/plugins/annotation-collector/testData/collectToFile/annotationInSameFile/annotations.txt
@@ -1,4 +1,8 @@
-a org.test.SomeAnnotation 0
+a kotlin.annotation.annotation 0
 p org.test 0
-c 0 0/SomeClass
-m 0 0/SomeClass annotatedFunction
+c 0 0/SomeAnnotation
+a java.lang.annotation.Retention 1
+c 1 0/SomeAnnotation
+a org.test.SomeAnnotation 2
+c 2 0/SomeClass
+m 2 0/SomeClass annotatedFunction
diff --git a/plugins/annotation-collector/testData/collectToFile/inheritedSimple/annotations.txt b/plugins/annotation-collector/testData/collectToFile/inheritedSimple/annotations.txt
new file mode 100644
index 00000000000..72c4041b2e2
--- /dev/null
+++ b/plugins/annotation-collector/testData/collectToFile/inheritedSimple/annotations.txt
@@ -0,0 +1,4 @@
+p org.test 0
+d 0/SomeInterface
+d 0/SomeInterface$$TImpl
+d 0/SomeClass
diff --git a/plugins/annotation-collector/testData/collectToFile/inheritedSimple/inheritedSimple.kt b/plugins/annotation-collector/testData/collectToFile/inheritedSimple/inheritedSimple.kt
new file mode 100644
index 00000000000..4ffaa0a8b8b
--- /dev/null
+++ b/plugins/annotation-collector/testData/collectToFile/inheritedSimple/inheritedSimple.kt
@@ -0,0 +1,5 @@
+package org.test
+
+public interface SomeInterface
+
+public class SomeClass
\ No newline at end of file
diff --git a/plugins/annotation-collector/testData/collectToFile/inheritedTopLevel/annotations.txt b/plugins/annotation-collector/testData/collectToFile/inheritedTopLevel/annotations.txt
new file mode 100644
index 00000000000..f74c7345e7e
--- /dev/null
+++ b/plugins/annotation-collector/testData/collectToFile/inheritedTopLevel/annotations.txt
@@ -0,0 +1,6 @@
+p org.test 0
+d 0/TestPackage$inheritedTopLevel$*
+a org.jetbrains.annotations.NotNull 0
+m 0 0/TestPackage$inheritedTopLevel$* getTopLevelProperty
+d 0/TestPackage
+m 0 0/TestPackage getTopLevelProperty
diff --git a/plugins/annotation-collector/testData/collectToFile/inheritedTopLevel/inheritedTopLevel.kt b/plugins/annotation-collector/testData/collectToFile/inheritedTopLevel/inheritedTopLevel.kt
new file mode 100644
index 00000000000..56923d97754
--- /dev/null
+++ b/plugins/annotation-collector/testData/collectToFile/inheritedTopLevel/inheritedTopLevel.kt
@@ -0,0 +1,8 @@
+package org.test
+
+fun topLevelFunction() {
+
+}
+
+val topLevelProperty: String
+    get() = "text"
\ No newline at end of file
diff --git a/plugins/annotation-collector/testData/collectToFile/nestedClasses/annotations.txt b/plugins/annotation-collector/testData/collectToFile/nestedClasses/annotations.txt
index 4183ec87fa3..036ab4d5eb6 100644
--- a/plugins/annotation-collector/testData/collectToFile/nestedClasses/annotations.txt
+++ b/plugins/annotation-collector/testData/collectToFile/nestedClasses/annotations.txt
@@ -5,4 +5,3 @@ c 0 0/SomeClass$SomeInnerObject
 c 0 0/SomeClass$InnerClass
 c 0 0/SomeClass$InnerClass$InnerClassInInnerClass
 c 0 0/SomeClass$NestedClass
-f 0 0/SomeClass OBJECT$
diff --git a/plugins/annotation-collector/testData/collectToFile/platformStatic/annotations.txt b/plugins/annotation-collector/testData/collectToFile/platformStatic/annotations.txt
index b8d64a800d4..51b1222d98d 100644
--- a/plugins/annotation-collector/testData/collectToFile/platformStatic/annotations.txt
+++ b/plugins/annotation-collector/testData/collectToFile/platformStatic/annotations.txt
@@ -3,7 +3,5 @@ p org.test 0
 m 0 0/SomeClass$Companion a
 a kotlin.inline 1
 m 1 0/SomeClass$Companion a
-a java.lang.Deprecated 2
-f 2 0/SomeClass OBJECT$
 m 0 0/SomeClass a
 m 1 0/SomeClass a
diff --git a/spec-docs/flexible-java-types.md b/spec-docs/flexible-java-types.md
index 232206c920d..12b23399515 100644
--- a/spec-docs/flexible-java-types.md
+++ b/spec-docs/flexible-java-types.md
@@ -139,4 +139,309 @@ The compiler issues warnings specific to `@Nullable`/`@NotNull` in the following
  - a `@Nullable` value is assigned to a not-null location (including passing parameters and receivers to functions/properties);
  - a nullable value is assigned to a `@NotNull` location;
  - a `@NotNull` value is dereferenced with a safe call (`?.`), used in `!!` or on the left-hand side of an elvis operator `?:`;
- - a `@NotNull` value is compared with `null` through `==`, `!=`, `===` or `!==`
\ No newline at end of file
+ - a `@NotNull` value is compared with `null` through `==`, `!=`, `===` or `!==`
+
+## More precise type information from annotations
+
+Goals:
+ - Catch more errors related to nullability in case of Java interop
+ - Keep all class hierarchies consistent at all times (no hierarchy errors related to incorrect annotations)
+ - (!) If the code compiled with annotations, it should always compile without annotations (because external annotations may disappear)
+
+ This process never results in errors. On any mismatch, a bare platform signature is used (and a warning issued).
+
+### Annotations recognized by the compiler
+
+- `org.jetbrains.annotations.Nullable` - value may be null/accepts nulls
+- `org.jetbrains.annotations.NotNull` - value can not be null/passing null leads to an exception
+- `org.jetbrains.annotations.ReadOnly` - only non-mutating methods can be used on this collection/iterable/iterator
+- `org.jetbrains.annotations.Mutable` - mutating methods can be used on this collection/iterable/iterator
+- `kotlin.jvm.KotlinSignature(str)` - `str` is a string representation of a more precise signature
+
+See [appendix](#appendix) for more details
+
+### Enhancing signatures with annotated declarations
+
+NOTE: the intention is that if the enhanced signature is not compatible with the overridden signatures from superclasses,
+it is discarded, and a warning is issued. We also would like to discard only the mismatching parts of the signature, and thus keep as
+much information as possible.
+
+Example:
+
+``` java
+class Super {
+    void foo(@NotNull String p) {...}
+}
+
+class Sub extends Super {
+    @Override
+    void foo(@Nullable String p) {...} // Warning: Signature does not match the one in the superclass, discarded
+}
+```
+
+#### @KotlinSignature
+
+``` java
+package kotlin.jvm;
+
+@Target({ElementType.METHOD, ElementType.TYPE, ElementType.CONSTRUCTOR, ElementType.FIELD})
+public @interface KotlinSignature {
+    String value();
+}
+```
+
+Usage:
+
+``` java
+class C {
+    @KotlinSignature("fun foo(): MutableList<String?>")
+    List<String> foo() { ... }
+}
+
+```
+
+Name resolution: `@KotlinSignature` can use short names from types, because full names are already specified in respective positions in
+the Java signature.
+
+- If there's a `@KotlinSignature` annotation, other annotations are ignored
+- If erasure of the signature specified by `@KotlinSignature` differs from the actual erased signature,
+  a warning is reported and the `@KotlinSignature` annotation is ignored
+- Otherwise, the signature from `@KotlinSignature` is used.
+
+#### @Nullable, @NotNull, @ReadOnly, @Mutable
+
+What can be annotated:
+ - field: annotation applies to its type
+ - method: annotation applies to its return type
+ - parameter: annotation applies to its type
+ - type (in Java 8): annotation applies to this type
+
+Consider a type `(L..U?)`. Nullability annotations enhance it in the following way:
+ - `@Nullable`: `(L?..U?)`
+ - `@NotNull`: `(L..U)`
+
+Note that if upper and lower bound of a flexible type are the same, it is replaced by the bounds (e.g. `(T?..T?) => T?`)
+
+Consider a collection type `(MC<T>..C<T>?)` (upper bound may be nullable or not). Mutability annotations enhance it in the following way:
+ - `@ReadOnly`: `(C<T>..C<T>?)`
+ - `@Mutable`: `(MC<T>..MC<T>?)`
+
+Nullability annotations are applied after mutability annotations.
+
+Examples:
+
+| Java | Kotlin|
+|------|-------|
+| `Foo` | `Foo!` |
+| `@Nullable Foo` | `Foo?` |
+| `@NotNull Foo` | `Foo` |
+| `List<T>` | `(Mutable)List<T!>!` |
+| `@ReadOnly List<T>` | `List<T!>!` |
+| `@Mutable List<T>` | `MutableList<T!>!` |
+| `@NotNull @Mutable List<T>` | `MutableList<T!>` |
+| `@Nullable @ReadOnly List<T>` | `List<T!>?` |
+
+*NOTE*: array types are never flattened: `@NotNull Object[]` becomes `(Array<Any!>..Array<out Any!>)`.
+
+### Propagating type information from superclasses
+
+A signature is represented as a list of its parts:
+ - upper bounds of type parameters
+ - value parameter types
+ - return type
+
+Enhancement rules (the result of their application is called a *propagated signature*) for each part:
+ - collect annotations from all supertypes and the override in the subclass
+ - for parts other than return type (which may be covariantly overridden) if there are conflicts (`@Nullable` together with `@NotNull` or
+   `@ReadOnly` together with `@Mutable`), discard the respective annotations and issue appropriate warnings
+ - for return types (full if the type from override is `~~`-equivalent to all from supertypes, and only 0-index (see below) otherwise)):
+     - fist, take annotations from supertypes, and among them: if there's `@NotNull`, discard `@Nullable`, if there's `@Mutable` discard `@ReadOnly`
+     - then if in the subtype there's `@Nullable` and in the supertype there's `@NotNull`, discard the nullability annotations (analogously,
+       for mutability annotations)
+ - apply the annotations and check compatibility with all parts from supertypes, if there's any incompatibility, issue a warning and take
+   a platform type
+
+> NOTE: Only flexible types are enhanced, because we want to avoid cases like this
+``` java
+          void foo(@Nullable int x) {...}
+```
+this code is incorrect, but Java does not reject it, so if we see this as a Kotlin declaration
+``` kotlin
+          fun foo(x: Int?)
+```
+we can't even call it properly (this, in theory, can be worked around by storing pure Java signatures alongside Kotlin ones).
+
+Detecting annotations on parts from supertypes:
+ - consider all types have the form of `(L..U)`, where an inflexible type `T` is written `(T..T)`
+ - if `L` is nullable, say that `@Nullable` annotation is present
+ - if `U` is not-null, say that `@NotNull` is present
+ - if `L` is a read-only collection/iterable/iterator type, say that `@ReadOnly` is present
+ - if `U` is a mutable collection/iterable/iterator type, say that `@Mutable` is present
+
+Examples:
+
+``` java
+interface A {
+  @NotNull
+  String foo(@NotNull String p);
+}
+
+interface B {
+  @Nullable
+  String foo(@Nullable String p);
+}
+
+interface C extends A, B {
+  // this is an override in Java, but would not be an override in Kotlin because of a conflict in parameter types: String vs String?
+  // Thus, the resulting descriptor is
+  //    fun foo(p: String!): String
+  // return type is covariantly enhanced to not-null,
+  // a warning issued about the parameter
+
+  @Override
+  String foo(String p);
+}
+```
+
+Other cases:
+
+```
+R foo(@NotNull P p) // super A
+R foo(P p) // super B
+R foo(P p) // subclass C
+
+// Result:
+fun foo(p: P): R! // parameter type propagated from A
+```
+
+```
+R foo(@NotNull P p) // super A
+R foo(P p) // super B
+R foo(@Nullable P p) // subclass C
+
+// Result:
+fun foo(p: P!): R! // conflict on parameter between A and C
+```
+
+```
+R foo(P p) // super A
+R foo(P p) // super B
+R foo(@NotNull P p) // subclass C
+
+// Result:
+fun foo(p: P): R! // parameter type specified in C, no conflict with superclasses
+```
+
+```
+@NotNull
+R foo(P p) // super A
+R foo(P p) // super B
+@Nullable
+R foo(P p) // subclass C
+
+// Result:
+fun foo(p: P!): R! // conflict on return type: subtype wants a nullable, but not-null already promised
+```
+
+```
+R foo(@NotNull @ReadOnly List<T> p) // super A
+R foo(@Nullable @ReadOnly List<T> p) // subclass B
+
+// Result:
+fun foo(p: List<T>!): R! // conflict on nullability, no conflict on mutability
+```
+
+```
+fun foo(MutableList<T> p): R // super A, written in Kotlin or has @KotlinSignature
+@Nullable
+R foo(List<T> p) // subclass B
+
+// Result:
+fun foo(MutableList<T> p): R! // parameter propagated from superclass (@Mutable, @NotNull), conflict on return type
+```
+
+*NOTE*: nullability warnings should still be reported in the Kotlin code in case of discarding the enhancing information due to conflicts.
+
+**Propagation into generic arguments**. Since annotations have to be propagated to type arguments as well as the head type constructor,
+the following procedure is used. First, every sub-tree of the type is assigned an index which is its zero-based position in the textual
+representation of the type (`0` is root). Example: for `A<B, C<D, E>>`, indices go as follows: `0 - A<...>, 1 - B, 2 - C<D, E>, 3 - D, 4 - E`,
+which corresponds to the left-to-right breadth-first walk of the tree representation of the type. For flexible types, both bounds are indexed
+in the same way: `(A<B>..C<D>)` gives `0 - (A<B>..C<D>), 1 - B and D`. 
+
+Now, in the aforementioned procedure, annotations are collected and considered *at each index* for types other than return types. Return types
+are co-variant, thus the overriding type may not match the overridden ones in its shape (e.g. we can have `Foo<Bar>` from super, 
+and `Baz<One, Two<Three>>` in the override, where `Baz` extends `Foo<Bar>`). This makes it impossible sometimes to propagate data into 
+covariant overrides, and in such cases we resort to only looking at the head constructor (index == 0). The safe cases are detected by checking
+that the overriding type is `~~`-equivalent to all the overridden ones, which guarantees that their shapes match. For example, the overriding 
+type may be `(Mutable)List<Foo!>!` while the overridden ones may be `List<Foo>` and `List<Foo?>`, the equivalence holds and we can safely 
+assume the enhanced return type to be `List<Foo>` (subtype of both overridden ones).
+
+Example:
+ - `Mutable(List)<A!>!`
+ - `Mutable(List)<A?>!`
+ - 0: `Mutable(List)<A>!`, `Mutable(List)<A?>!`
+ - 1: `A!`, `A!`, `A?`, `A?`
+
+NOTE: if the set of descriptors overridden by the resulting enhanced signature differs from the set overridden by the platform signature,
+the enhanced signature must be discarded and a warning issued.
+
+Checklist:
+   - any platform signature should override any enhanced/propagated signature created for the same member or one of its overridden.
+
+### Problematic cases of Java inheritance
+
+**Case 1**. Fake override for conflicting signatures with the same erasure:
+
+```
+// Kotlin
+trait A {
+    fun foo(x: String)
+}
+
+trait B {
+    fun foo(x: String?)
+}
+
+// Java
+interface JC extends A, B {}
+
+// Kotlin
+
+class D : JC {
+    // how to override both foo(String) and foo(String?) in this class?
+}
+```
+
+Possible solution: make fake overrides generated for Java class have platform signatures and perform normal enhancement for them
+ 
+**Case 2**. Inheriting a property through a Java class
+ 
+It may be overridden by a Java function, for example
+ 
+**Case 3**. Inheriting an extension function/property through a Java class
+ 
+Explicit override(s) may also interfere.  
+
+**Case 4**. Raw types interfering with override-compatibility of Java signatures with Kotlin ones
+
+**Case 5**. Order of type parameters in Java methods matters only partly
+
+The first parameter matters, others may come in any order.
+
+See also: [KT-7496](https://youtrack.jetbrains.com/issue/KT-7496)
+
+### Appendix
+
+We can also support the following annotations out-of-the-box:
+* [`android.support.annotation`](https://developer.android.com/reference/android/support/annotation/package-summary.html)
+ * [`android.support.annotation.Nullable`](https://developer.android.com/reference/android/support/annotation/Nullable.html)
+ * [`android.support.annotation.NonNull`](https://developer.android.com/reference/android/support/annotation/NonNull.html)
+* From [FindBugs](http://findbugs.sourceforge.net/manual/annotations.html) and [`javax.annotation`](https://code.google.com/p/jsr-305/source/browse/trunk/ri/src/main/java/javax/annotation/)
+ * `*.annotations.CheckForNull`
+ * `*.NonNull`
+ * `*.Nullable`
+* [`javax.validation.constraints`](http://docs.oracle.com/javaee/6/api/javax/validation/constraints/package-summary.html)
+ * `NotNull` and `NotNull.List`
+* [Project Lombok](http://projectlombok.org/features/NonNull.html)
+* [`org.eclipse.jdt.annotation`](https://wiki.eclipse.org/JDT_Core/Null_Analysis)
+* [`org.checkerframework.checker.nullness.qual`](http://types.cs.washington.edu/checker-framework/current/checker-framework-manual.html#nullness-checker)
diff --git a/update_dependencies.xml b/update_dependencies.xml
index 2c0d60b5712..3c79eb3682b 100644
--- a/update_dependencies.xml
+++ b/update_dependencies.xml
@@ -1,5 +1,5 @@
 <project name="Update Dependencies" default="update">
-    <property name="ideaVersion" value="142.2670.3"/>
+    <property name="ideaVersion" value="142.3230.1"/>
 
     <property name="kotlin.bootstrap.locator" value="buildType:bt345,tag:bootstrap,status:SUCCESS"/>
     <property name="kotlin.bootstrap.locator.force" value="false"/>
@@ -652,6 +652,23 @@
                         </else>
                     </if>
 
+                    <!--
+                         This one needs to be deleted because otherwise it gets onto the classpath
+                         together with junit-4.10.jar and the classloading goes crazy that breaks
+                         many nice features of IDEA including diffs in the test console.
+                    -->
+                    <delete file="@{idea.dir}/lib/junit.jar"/>
+
+                    <!--
+                    Plugin depends on newer runtime and reflect jar from our bootstrap compiler.
+                    Avoid depending on old runtime during build phase but attach original runtime when idea starts.
+                    -->
+                    <mkdir dir="@{idea.dir}/idea-kotlin-runtime"/>
+                    <move file="@{idea.dir}/lib/kotlin-runtime.jar" todir="@{idea.dir}/idea-kotlin-runtime"/>
+                    <move file="@{idea.dir}/lib/kotlin-reflect.jar" todir="@{idea.dir}/idea-kotlin-runtime"/>
+
+                    <delete dir="@{idea.dir}/plugins/Kotlin"/>
+
                     <echo message="@{download.dir.intellij-core}/intellij-core-analysis.jar"/>
 
                     <mkdir dir="@{core-analysis}"/>
@@ -675,6 +692,7 @@
                             <file file="@{idea.dir}/lib/xpp3-1.1.4-min.jar"/>
                             <file file="@{idea.dir}/lib/jsr166e.jar"/>
                             <file file="@{idea.dir}/lib/asm-all.jar"/>
+                            <file file="@{idea.dir}/lib/snappy-in-java-0.3.1.jar"/>
 
                             <!-- TODO temporary workaround since util-rt is not packaged into intellij-core.jar -->
                             <file file="@{idea.dir}/lib/util.jar"/>
@@ -705,13 +723,6 @@
 
                     <mkdir dir="@{sources}"/>
                     <copy file="@{download.file.archive.sources}" tofile="@{sources}/sources.zip" overwrite="true"/>
-
-                    <!--
-                         This one needs to be deleted because otherwise it gets onto the classpath
-                         together with junit-4.10.jar and the classloading goes crazy that breaks
-                         many nice features of IDEA including diffs in the test console.
-                    -->
-                    <delete file="@{idea.dir}/lib/junit.jar"/>
                 </then>
             </if>