Comments for review

Fixes #KT-19167

.idea/artifacts/KotlinPlugin.xml

@@ -61,7 +61,6 @@
           <element id="module-output" name="ir.psi2ir" />
           <element id="module-output" name="annotation-based-compiler-plugins-ide-support" />
           <element id="module-output" name="frontend.script" />
-          <element id="extracted-dir" path="$PROJECT_DIR$/dependencies/json-org.jar" path-in-jar="/" />
         </element>
         <element id="library" level="project" name="javax.inject" />
         <element id="directory" name="jps">

.idea/dictionaries/yan.xml

@@ -1,10 +1,8 @@
 <component name="ProjectDictionaryState">
   <dictionary name="yan">
     <words>
-      <w>deserializes</w>
       <w>impls</w>
       <w>kapt</w>
-      <w>parceler</w>
       <w>uast</w>
     </words>
   </dictionary>

.idea/libraries/intellij_core.xml

@@ -18,12 +18,14 @@
       <root url="jar://$PROJECT_DIR$/ideaSDK/core/util.jar!/" />
       <root url="jar://$PROJECT_DIR$/ideaSDK/core/xpp3-1.1.4-min.jar!/" />
       <root url="jar://$PROJECT_DIR$/ideaSDK/core/xstream-1.4.8.jar!/" />
+      <root url="jar://$PROJECT_DIR$/ideaSDK/lib/jsr305.jar!/" />
     </CLASSES>
     <JAVADOC />
     <SOURCES>
       <root url="jar://$PROJECT_DIR$/dependencies/guava-19.0-sources.jar!/" />
       <root url="jar://$PROJECT_DIR$/ideaSDK/sources/sources.jar!/" />
       <root url="jar://$PROJECT_DIR$/dependencies/asm-src.zip!/" />
+      <root url="jar://$PROJECT_DIR$/ideaSDK/lib/jsr305.jar!/" />
     </SOURCES>
   </library>
 </component>

.idea/libraries/robolectric.xml

@@ -1,59 +0,0 @@
-<component name="libraryTable">
-  <library name="robolectric">
-    <CLASSES>
-      <root url="jar://$PROJECT_DIR$/dependencies/robolectric/accessibility-test-framework-2.1.jar!/" />
-      <root url="jar://$PROJECT_DIR$/dependencies/robolectric/ant-1.8.0.jar!/" />
-      <root url="jar://$PROJECT_DIR$/dependencies/robolectric/ant-launcher-1.8.0.jar!/" />
-      <root url="jar://$PROJECT_DIR$/dependencies/robolectric/asm-5.0.1.jar!/" />
-      <root url="jar://$PROJECT_DIR$/dependencies/robolectric/asm-commons-5.0.1.jar!/" />
-      <root url="jar://$PROJECT_DIR$/dependencies/robolectric/asm-tree-5.0.1.jar!/" />
-      <root url="jar://$PROJECT_DIR$/dependencies/robolectric/assertj-core-2.6.0.jar!/" />
-      <root url="jar://$PROJECT_DIR$/dependencies/robolectric/backport-util-concurrent-3.1.jar!/" />
-      <root url="jar://$PROJECT_DIR$/dependencies/robolectric/bcprov-jdk16-1.46.jar!/" />
-      <root url="jar://$PROJECT_DIR$/dependencies/robolectric/classworlds-1.1-alpha-2.jar!/" />
-      <root url="jar://$PROJECT_DIR$/dependencies/robolectric/guava-20.0.jar!/" />
-      <root url="jar://$PROJECT_DIR$/dependencies/robolectric/hamcrest-core-1.3.jar!/" />
-      <root url="jar://$PROJECT_DIR$/dependencies/robolectric/hamcrest-library-1.3.jar!/" />
-      <root url="jar://$PROJECT_DIR$/dependencies/robolectric/icu4j-53.1.jar!/" />
-      <root url="jar://$PROJECT_DIR$/dependencies/robolectric/maven-ant-tasks-2.1.3.jar!/" />
-      <root url="jar://$PROJECT_DIR$/dependencies/robolectric/maven-artifact-2.2.1.jar!/" />
-      <root url="jar://$PROJECT_DIR$/dependencies/robolectric/maven-artifact-manager-2.2.1.jar!/" />
-      <root url="jar://$PROJECT_DIR$/dependencies/robolectric/maven-error-diagnostics-2.2.1.jar!/" />
-      <root url="jar://$PROJECT_DIR$/dependencies/robolectric/maven-model-2.2.1.jar!/" />
-      <root url="jar://$PROJECT_DIR$/dependencies/robolectric/maven-plugin-registry-2.2.1.jar!/" />
-      <root url="jar://$PROJECT_DIR$/dependencies/robolectric/maven-profile-2.2.1.jar!/" />
-      <root url="jar://$PROJECT_DIR$/dependencies/robolectric/maven-project-2.2.1.jar!/" />
-      <root url="jar://$PROJECT_DIR$/dependencies/robolectric/maven-repository-metadata-2.2.1.jar!/" />
-      <root url="jar://$PROJECT_DIR$/dependencies/robolectric/maven-settings-2.2.1.jar!/" />
-      <root url="jar://$PROJECT_DIR$/dependencies/robolectric/nekohtml-1.9.6.2.jar!/" />
-      <root url="jar://$PROJECT_DIR$/dependencies/robolectric/plexus-container-default-1.0-alpha-9-stable-1.jar!/" />
-      <root url="jar://$PROJECT_DIR$/dependencies/robolectric/plexus-interpolation-1.11.jar!/" />
-      <root url="jar://$PROJECT_DIR$/dependencies/robolectric/plexus-utils-1.5.15.jar!/" />
-      <root url="jar://$PROJECT_DIR$/dependencies/robolectric/protobuf-java-2.6.1.jar!/" />
-      <root url="jar://$PROJECT_DIR$/dependencies/robolectric/robolectric-3.3.2.jar!/" />
-      <root url="jar://$PROJECT_DIR$/dependencies/robolectric/robolectric-annotations-3.3.2.jar!/" />
-      <root url="jar://$PROJECT_DIR$/dependencies/robolectric/robolectric-junit-3.3.2.jar!/" />
-      <root url="jar://$PROJECT_DIR$/dependencies/robolectric/robolectric-resources-3.3.2.jar!/" />
-      <root url="jar://$PROJECT_DIR$/dependencies/robolectric/robolectric-sandbox-3.3.2.jar!/" />
-      <root url="jar://$PROJECT_DIR$/dependencies/robolectric/robolectric-utils-3.3.2.jar!/" />
-      <root url="jar://$PROJECT_DIR$/dependencies/robolectric/shadow-api-3.3.2.jar!/" />
-      <root url="jar://$PROJECT_DIR$/dependencies/robolectric/shadows-core-3.3.2.jar!/" />
-      <root url="jar://$PROJECT_DIR$/dependencies/robolectric/sqlite4java-0.282.jar!/" />
-      <root url="jar://$PROJECT_DIR$/dependencies/robolectric/wagon-file-1.0-beta-6.jar!/" />
-      <root url="jar://$PROJECT_DIR$/dependencies/robolectric/wagon-http-lightweight-1.0-beta-6.jar!/" />
-      <root url="jar://$PROJECT_DIR$/dependencies/robolectric/wagon-http-shared-1.0-beta-6.jar!/" />
-      <root url="jar://$PROJECT_DIR$/dependencies/robolectric/wagon-provider-api-1.0-beta-6.jar!/" />
-      <root url="jar://$PROJECT_DIR$/dependencies/robolectric/xercesMinimal-1.9.6.2.jar!/" />
-      <root url="jar://$PROJECT_DIR$/dependencies/robolectric/xmlpull-1.1.3.1.jar!/" />
-      <root url="jar://$PROJECT_DIR$/dependencies/robolectric/xpp3_min-1.1.4c.jar!/" />
-      <root url="jar://$PROJECT_DIR$/dependencies/robolectric/xstream-1.4.8.jar!/" />
-    </CLASSES>
-    <JAVADOC>
-      <root url="jar://$PROJECT_DIR$/dependencies/robolectric/robolectric-3.3.2-javadoc.jar!/" />
-    </JAVADOC>
-    <SOURCES>
-      <root url="jar://$PROJECT_DIR$/dependencies/robolectric/robolectric-3.3.2-sources-source.jar!/" />
-      <root url="jar://$PROJECT_DIR$/dependencies/robolectric/robolectric-3.3.2-sources.jar!/" />
-    </SOURCES>
-  </library>
-</component>

build-common/test/org/jetbrains/kotlin/serialization/DebugProtoBuf.java

@@ -22202,8 +22202,8 @@ public final class DebugProtoBuf {
      * <code>optional int32 flags = 1 [default = 0];</code>
      *
      * <pre>
-     *declaresDefault
      *hasAnnotations
+     *declaresDefault
      *isCrossinline
      *isNoinline
      * </pre>
@@ -22213,8 +22213,8 @@ public final class DebugProtoBuf {
      * <code>optional int32 flags = 1 [default = 0];</code>
      *
      * <pre>
-     *declaresDefault
      *hasAnnotations
+     *declaresDefault
      *isCrossinline
      *isNoinline
      * </pre>
@@ -22419,8 +22419,8 @@ public final class DebugProtoBuf {
      * <code>optional int32 flags = 1 [default = 0];</code>
      *
      * <pre>
-     *declaresDefault
      *hasAnnotations
+     *declaresDefault
      *isCrossinline
      *isNoinline
      * </pre>
@@ -22432,8 +22432,8 @@ public final class DebugProtoBuf {
      * <code>optional int32 flags = 1 [default = 0];</code>
      *
      * <pre>
-     *declaresDefault
      *hasAnnotations
+     *declaresDefault
      *isCrossinline
      *isNoinline
      * </pre>
@@ -22913,8 +22913,8 @@ public final class DebugProtoBuf {
        * <code>optional int32 flags = 1 [default = 0];</code>
        *
        * <pre>
-       *declaresDefault
        *hasAnnotations
+       *declaresDefault
        *isCrossinline
        *isNoinline
        * </pre>
@@ -22926,8 +22926,8 @@ public final class DebugProtoBuf {
        * <code>optional int32 flags = 1 [default = 0];</code>
        *
        * <pre>
-       *declaresDefault
        *hasAnnotations
+       *declaresDefault
        *isCrossinline
        *isNoinline
        * </pre>
@@ -22939,8 +22939,8 @@ public final class DebugProtoBuf {
        * <code>optional int32 flags = 1 [default = 0];</code>
        *
        * <pre>
-       *declaresDefault
        *hasAnnotations
+       *declaresDefault
        *isCrossinline
        *isNoinline
        * </pre>
@@ -22955,8 +22955,8 @@ public final class DebugProtoBuf {
        * <code>optional int32 flags = 1 [default = 0];</code>
        *
        * <pre>
-       *declaresDefault
        *hasAnnotations
+       *declaresDefault
        *isCrossinline
        *isNoinline
        * </pre>

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

@@ -16,6 +16,7 @@
 
 package org.jetbrains.kotlin.codegen;
 
+import kotlin.collections.CollectionsKt;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.codegen.annotation.WrappedAnnotated;
@@ -25,6 +26,7 @@ import org.jetbrains.kotlin.descriptors.annotations.*;
 import org.jetbrains.kotlin.descriptors.impl.AnonymousFunctionDescriptor;
 import org.jetbrains.kotlin.load.java.JvmAnnotationNames;
 import org.jetbrains.kotlin.name.FqName;
+import org.jetbrains.kotlin.name.Name;
 import org.jetbrains.kotlin.resolve.AnnotationChecker;
 import org.jetbrains.kotlin.resolve.constants.*;
 import org.jetbrains.kotlin.resolve.descriptorUtil.DescriptorUtilsKt;
@@ -291,32 +293,27 @@ public abstract class AnnotationCodegen {
 
     @Nullable
     private String genAnnotation(@NotNull AnnotationDescriptor annotationDescriptor) {
-        ClassifierDescriptor classifierDescriptor = getAnnotationClass(annotationDescriptor);
-        assert classifierDescriptor != null : "Annotation descriptor has no class: " + annotationDescriptor;
-        RetentionPolicy rp = getRetentionPolicy(classifierDescriptor);
+        ClassDescriptor classDescriptor = getAnnotationClass(annotationDescriptor);
+        assert classDescriptor != null : "Annotation descriptor has no class: " + annotationDescriptor;
+        RetentionPolicy rp = getRetentionPolicy(classDescriptor);
         if (rp == RetentionPolicy.SOURCE && !typeMapper.getClassBuilderMode().generateSourceRetentionAnnotations) {
             return null;
         }
 
-        String descriptor = typeMapper.mapType(annotationDescriptor.getType()).getDescriptor();
+        innerClassConsumer.addInnerClassInfoFromAnnotation(classDescriptor);
 
-        if (classifierDescriptor instanceof ClassDescriptor) {
-            innerClassConsumer.addInnerClassInfoFromAnnotation(((ClassDescriptor) classifierDescriptor));
-        }
-
-        AnnotationVisitor annotationVisitor = visitAnnotation(descriptor, rp == RetentionPolicy.RUNTIME);
+        String asmTypeDescriptor = typeMapper.mapType(annotationDescriptor.getType()).getDescriptor();
+        AnnotationVisitor annotationVisitor = visitAnnotation(asmTypeDescriptor, rp == RetentionPolicy.RUNTIME);
 
         genAnnotationArguments(annotationDescriptor, annotationVisitor);
         annotationVisitor.visitEnd();
 
-        return descriptor;
+        return asmTypeDescriptor;
     }
 
     private void genAnnotationArguments(AnnotationDescriptor annotationDescriptor, AnnotationVisitor annotationVisitor) {
-        for (Map.Entry<ValueParameterDescriptor, ConstantValue<?>> entry : annotationDescriptor.getAllValueArguments().entrySet()) {
-            ValueParameterDescriptor descriptor = entry.getKey();
-            String name = descriptor.getName().asString();
-            genCompileTimeValue(name, entry.getValue(), annotationVisitor);
+        for (Map.Entry<Name, ConstantValue<?>> entry : annotationDescriptor.getAllValueArguments().entrySet()) {
+            genCompileTimeValue(entry.getKey().asString(), entry.getValue(), annotationVisitor);
         }
     }
 
@@ -475,16 +472,13 @@ public abstract class AnnotationCodegen {
         }
         AnnotationDescriptor retentionAnnotation = descriptor.getAnnotations().findAnnotation(new FqName(Retention.class.getName()));
         if (retentionAnnotation != null) {
-            Collection<ConstantValue<?>> valueArguments = retentionAnnotation.getAllValueArguments().values();
-            if (!valueArguments.isEmpty()) {
-                ConstantValue<?> compileTimeConstant = valueArguments.iterator().next();
-                if (compileTimeConstant instanceof EnumValue) {
-                    ClassDescriptor enumEntry = ((EnumValue) compileTimeConstant).getValue();
-                    KotlinType classObjectType = DescriptorUtilsKt.getClassValueType(enumEntry);
-                    if (classObjectType != null) {
-                        if ("java/lang/annotation/RetentionPolicy".equals(typeMapper.mapType(classObjectType).getInternalName())) {
-                            return RetentionPolicy.valueOf(enumEntry.getName().asString());
-                        }
+            ConstantValue<?> compileTimeConstant = CollectionsKt.firstOrNull(retentionAnnotation.getAllValueArguments().values());
+            if (compileTimeConstant instanceof EnumValue) {
+                ClassDescriptor enumEntry = ((EnumValue) compileTimeConstant).getValue();
+                KotlinType classObjectType = DescriptorUtilsKt.getClassValueType(enumEntry);
+                if (classObjectType != null) {
+                    if ("java/lang/annotation/RetentionPolicy".equals(typeMapper.mapType(classObjectType).getInternalName())) {
+                        return RetentionPolicy.valueOf(enumEntry.getName().asString());
                     }
                 }
             }

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

@@ -140,10 +140,18 @@ public class AsmUtil {
         return primitiveTypeByBoxedType.get(boxedType);
     }
 
+    public static boolean isBoxedTypeOf(@NotNull Type boxedType, @NotNull Type unboxedType) {
+        return unboxPrimitiveTypeOrNull(boxedType) == unboxedType;
+    }
+
     public static boolean isIntPrimitive(Type type) {
         return type == Type.INT_TYPE || type == Type.SHORT_TYPE || type == Type.BYTE_TYPE || type == Type.CHAR_TYPE;
     }
 
+    public static boolean isIntOrLongPrimitive(Type type) {
+        return isIntPrimitive(type) || type == Type.LONG_TYPE;
+    }
+
     public static boolean isNumberPrimitiveOrBoolean(Type type) {
         return isNumberPrimitive(type) || type.getSort() == Type.BOOLEAN;
     }
@@ -709,7 +717,7 @@ public class AsmUtil {
                 if (innerType.getSort() == Type.OBJECT || innerType.getSort() == Type.ARRAY) {
                     v.dup();
                     v.visitLdcInsn(runtimeAssertionInfo.getMessage());
-                    v.invokestatic("kotlin/jvm/internal/Intrinsics", "checkExpressionValueIsNotNull",
+                    v.invokestatic(IntrinsicMethods.INTRINSICS_CLASS_NAME, "checkExpressionValueIsNotNull",
                                    "(Ljava/lang/Object;Ljava/lang/String;)V", false);
                 }
                 StackValue.coerce(innerType, type, v);
@@ -799,6 +807,16 @@ public class AsmUtil {
         }
     }
 
+    public static void pop2(@NotNull MethodVisitor v, @NotNull Type type) {
+        if (type.getSize() == 2) {
+            v.visitInsn(Opcodes.POP2);
+            v.visitInsn(Opcodes.POP2);
+        }
+        else {
+            v.visitInsn(Opcodes.POP2);
+        }
+    }
+
     public static void dup(@NotNull InstructionAdapter v, @NotNull Type type) {
         dup(v, type.getSize());
     }
@@ -815,6 +833,22 @@ public class AsmUtil {
         }
     }
 
+    public static void dupx(@NotNull InstructionAdapter v, @NotNull Type type) {
+        dupx(v, type.getSize());
+    }
+
+    private static void dupx(@NotNull InstructionAdapter v, int size) {
+        if (size == 2) {
+            v.dup2X2();
+        }
+        else if (size == 1) {
+            v.dupX1();
+        }
+        else {
+            throw new UnsupportedOperationException();
+        }
+    }
+
     public static void dup(@NotNull InstructionAdapter v, @NotNull Type topOfStack, @NotNull Type afterTop) {
         if (topOfStack.getSize() == 0 && afterTop.getSize() == 0) {
             return;

compiler/backend/src/org/jetbrains/kotlin/codegen/BoxedVsPrimitiveBranchedValues.kt

@@ -0,0 +1,308 @@
+/*
+ * Copyright 2010-2017 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 com.intellij.psi.tree.IElementType
+import org.jetbrains.kotlin.lexer.KtTokens
+import org.jetbrains.org.objectweb.asm.Label
+import org.jetbrains.org.objectweb.asm.Type
+import org.jetbrains.org.objectweb.asm.commons.InstructionAdapter
+
+abstract class NumberLikeCompare(
+        left: StackValue,
+        right: StackValue,
+        operandType: Type,
+        private val opToken: IElementType
+) : BranchedValue(left, right, operandType, NumberCompare.getNumberCompareOpcode(opToken)) {
+    override fun patchOpcode(opcode: Int, v: InstructionAdapter): Int =
+            NumberCompare.patchOpcode(opcode, v, opToken, operandType)
+}
+
+abstract class SafeCallFusedWithPrimitiveEqualityBase(
+        opToken: IElementType,
+        operandType: Type,
+        left: StackValue,
+        right: StackValue
+) : NumberLikeCompare(left, right, operandType, opToken) {
+    private val trueIfEqual = opToken == KtTokens.EQEQ || opToken == KtTokens.EQEQEQ
+
+    protected abstract fun cleanupOnNullReceiver(v: InstructionAdapter)
+
+    override fun condJump(jumpLabel: Label, v: InstructionAdapter, jumpIfFalse: Boolean) {
+        val endLabel = Label()
+
+        arg1.put(operandType, v)
+        arg2!!.put(operandType, v)
+        v.visitJumpInsn(patchOpcode(if (jumpIfFalse) opcode else negatedOperations[opcode]!!, v), jumpLabel)
+        v.goTo(endLabel)
+
+        cleanupOnNullReceiver(v)
+        if (jumpIfFalse == trueIfEqual) {
+            v.goTo(jumpLabel)
+        }
+
+        v.mark(endLabel)
+    }
+
+    override fun putSelector(type: Type, v: InstructionAdapter) {
+        val falseLabel = Label()
+        val endLabel = Label()
+
+        arg1.put(operandType, v)
+        arg2!!.put(operandType, v)
+        v.visitJumpInsn(patchOpcode(opcode, v), falseLabel)
+
+        if (!trueIfEqual) {
+            val trueLabel = Label()
+            v.goTo(trueLabel)
+            cleanupOnNullReceiver(v)
+            v.mark(trueLabel)
+        }
+
+        v.iconst(1)
+        v.goTo(endLabel)
+
+        if (trueIfEqual) {
+            cleanupOnNullReceiver(v)
+        }
+
+        v.mark(falseLabel)
+        v.iconst(0)
+
+        v.mark(endLabel)
+        coerceTo(type, v)
+    }
+}
+
+
+class SafeCallToPrimitiveEquality(
+        opToken: IElementType,
+        operandType: Type,
+        left: StackValue,
+        right: StackValue,
+        private val safeReceiverType: Type,
+        private val safeReceiverIsNull: Label
+) : SafeCallFusedWithPrimitiveEqualityBase(opToken, operandType, left, right) {
+    override fun cleanupOnNullReceiver(v: InstructionAdapter) {
+        v.mark(safeReceiverIsNull)
+        AsmUtil.pop(v, safeReceiverType)
+    }
+}
+
+
+class PrimitiveToSafeCallEquality(
+        opToken: IElementType,
+        operandType: Type,
+        left: StackValue,
+        right: StackValue,
+        private val safeReceiverType: Type,
+        private val safeReceiverIsNull: Label
+) : SafeCallFusedWithPrimitiveEqualityBase(opToken, operandType, left, right) {
+    override fun cleanupOnNullReceiver(v: InstructionAdapter) {
+        v.mark(safeReceiverIsNull)
+        AsmUtil.pop(v, safeReceiverType)
+        AsmUtil.pop(v, arg1.type)
+    }
+}
+
+
+class BoxedToPrimitiveEquality private constructor(
+        leftBoxed: StackValue,
+        rightPrimitive: StackValue,
+        primitiveType: Type,
+        private val frameMap: FrameMap
+) : NumberLikeCompare(leftBoxed, rightPrimitive, primitiveType, KtTokens.EQEQ) {
+    private val boxedType = arg1.type
+
+    override fun condJump(jumpLabel: Label, v: InstructionAdapter, jumpIfFalse: Boolean) {
+        if (arg2!!.canHaveSideEffects()) {
+            val tmp = frameMap.enterTemp(operandType)
+            doJump(
+                    v, jumpLabel, jumpIfFalse,
+                    {
+                        arg1.put(boxedType, v)
+                        arg2.put(operandType, v)
+                        v.store(tmp, operandType)
+                    },
+                    { v.load(tmp, operandType) }
+            )
+            frameMap.leaveTemp(operandType)
+        }
+        else {
+            doJump(
+                    v, jumpLabel, jumpIfFalse,
+                    { arg1.put(boxedType, v) },
+                    { arg2.put(operandType, v) }
+            )
+        }
+    }
+
+    private inline fun doJump(
+            v: InstructionAdapter,
+            jumpLabel: Label,
+            jumpIfFalse: Boolean,
+            putArg1: () -> Unit,
+            putArg2: () -> Unit
+    ) {
+        val notNullLabel = Label()
+        val endLabel = Label()
+
+        putArg1()
+        AsmUtil.dup(v, boxedType)
+        v.ifnonnull(notNullLabel)
+
+        AsmUtil.pop(v, boxedType)
+        if (jumpIfFalse) v.goTo(jumpLabel) else v.goTo(endLabel)
+
+        v.mark(notNullLabel)
+        coerce(boxedType, operandType, v)
+        putArg2()
+        v.visitJumpInsn(patchOpcode(if (jumpIfFalse) opcode else negatedOperations[opcode]!!, v), jumpLabel)
+
+        v.mark(endLabel)
+    }
+
+    companion object {
+        @JvmStatic
+        fun create(
+                opToken: IElementType,
+                left: StackValue,
+                leftType: Type,
+                right: StackValue,
+                rightType: Type,
+                frameMap: FrameMap
+        ): BranchedValue =
+                if (!isApplicable(opToken, leftType, rightType))
+                    throw IllegalArgumentException("Not applicable for $opToken, $leftType, $rightType")
+                else when (opToken) {
+                    KtTokens.EQEQ -> BoxedToPrimitiveEquality(left, right, rightType, frameMap)
+                    KtTokens.EXCLEQ -> Invert(BoxedToPrimitiveEquality(left, right, rightType, frameMap))
+                    else -> throw AssertionError("Unexpected opToken: $opToken")
+                }
+
+        @JvmStatic
+        fun isApplicable(opToken: IElementType, leftType: Type, rightType: Type) =
+                (opToken == KtTokens.EQEQ || opToken == KtTokens.EXCLEQ) &&
+                AsmUtil.isIntOrLongPrimitive(rightType) &&
+                AsmUtil.isBoxedTypeOf(leftType, rightType)
+    }
+}
+
+abstract class PrimitiveToSomethingEquality
+protected constructor(
+        leftPrimitive: StackValue,
+        right: StackValue,
+        primitiveType: Type
+) : NumberLikeCompare(leftPrimitive, right, primitiveType, KtTokens.EQEQ) {
+    protected val primitiveType = leftPrimitive.type
+    protected val rightType = right.type
+
+    override fun condJump(jumpLabel: Label, v: InstructionAdapter, jumpIfFalse: Boolean) {
+        val notNullLabel = Label()
+        val endLabel = Label()
+
+        arg1.put(primitiveType, v)
+        arg2!!.put(rightType, v)
+        AsmUtil.dup(v, rightType)
+        jumpIfCanCompareTopWithPrimitive(v, notNullLabel)
+
+        AsmUtil.pop(v, rightType)
+        AsmUtil.pop(v, primitiveType)
+        if (jumpIfFalse) v.goTo(jumpLabel) else v.goTo(endLabel)
+
+        v.mark(notNullLabel)
+        coerceRightToPrimitive(v)
+        v.visitJumpInsn(patchOpcode(if (jumpIfFalse) opcode else negatedOperations[opcode]!!, v), jumpLabel)
+
+        v.mark(endLabel)
+    }
+
+    protected abstract fun jumpIfCanCompareTopWithPrimitive(v: InstructionAdapter, label: Label)
+    protected abstract fun coerceRightToPrimitive(v: InstructionAdapter)
+}
+
+
+class PrimitiveToBoxedEquality private constructor(
+        leftPrimitive: StackValue,
+        rightBoxed: StackValue,
+        primitiveType: Type
+) : PrimitiveToSomethingEquality(leftPrimitive, rightBoxed, primitiveType) {
+    private val boxedType = rightBoxed.type
+
+    override fun jumpIfCanCompareTopWithPrimitive(v: InstructionAdapter, label: Label) {
+        v.ifnonnull(label)
+    }
+
+    override fun coerceRightToPrimitive(v: InstructionAdapter) {
+        coerce(boxedType, primitiveType, v)
+    }
+
+    companion object {
+        @JvmStatic
+        fun create(opToken: IElementType, left: StackValue, leftType: Type, right: StackValue, rightType: Type): BranchedValue =
+                if (!isApplicable(opToken, leftType, rightType))
+                    throw IllegalArgumentException("Not applicable for $opToken, $leftType, $rightType")
+                else when (opToken) {
+                    KtTokens.EQEQ -> PrimitiveToBoxedEquality(left, right, leftType)
+                    KtTokens.EXCLEQ -> Invert(PrimitiveToBoxedEquality(left, right, leftType))
+                    else -> throw AssertionError("Unexpected opToken: $opToken")
+                }
+
+        @JvmStatic
+        fun isApplicable(opToken: IElementType, leftType: Type, rightType: Type) =
+                (opToken == KtTokens.EQEQ || opToken == KtTokens.EXCLEQ) &&
+                AsmUtil.isIntOrLongPrimitive(leftType) &&
+                AsmUtil.isBoxedTypeOf(rightType, leftType)
+    }
+}
+
+
+class PrimitiveToObjectEquality private constructor(
+        leftPrimitive: StackValue,
+        rightObject: StackValue,
+        primitiveType: Type
+) : PrimitiveToSomethingEquality(leftPrimitive, rightObject, primitiveType) {
+    private val boxedType = AsmUtil.boxType(primitiveType)
+
+    override fun jumpIfCanCompareTopWithPrimitive(v: InstructionAdapter, label: Label) {
+        v.instanceOf(boxedType)
+        v.ifne(label)
+    }
+
+    override fun coerceRightToPrimitive(v: InstructionAdapter) {
+        coerce(rightType, boxedType, v)
+        coerce(boxedType, primitiveType, v)
+    }
+
+    companion object {
+        @JvmStatic
+        fun create(opToken: IElementType, left: StackValue, leftType: Type, right: StackValue, rightType: Type): BranchedValue =
+                if (!isApplicable(opToken, leftType, rightType))
+                    throw IllegalArgumentException("Not applicable for $opToken, $leftType, $rightType")
+                else when (opToken) {
+                    KtTokens.EQEQ -> PrimitiveToObjectEquality(left, right, leftType)
+                    KtTokens.EXCLEQ -> Invert(PrimitiveToObjectEquality(left, right, leftType))
+                    else -> throw AssertionError("Unexpected opToken: $opToken")
+                }
+
+        @JvmStatic
+        fun isApplicable(opToken: IElementType, leftType: Type, rightType: Type) =
+                (opToken == KtTokens.EQEQ || opToken == KtTokens.EXCLEQ) &&
+                AsmUtil.isIntOrLongPrimitive(leftType) &&
+                rightType.sort == Type.OBJECT
+    }
+}

compiler/backend/src/org/jetbrains/kotlin/codegen/BranchedValue.kt

@@ -54,9 +54,7 @@ open class BranchedValue(
         condJump(jumpLabel, v, jumpIfFalse)
     }
 
-    protected open fun patchOpcode(opcode: Int, v: InstructionAdapter): Int {
-        return opcode
-    }
+    protected open fun patchOpcode(opcode: Int, v: InstructionAdapter): Int = opcode
 
     companion object {
         val negatedOperations = hashMapOf<Int, Int>()
@@ -120,13 +118,9 @@ open class BranchedValue(
             negatedOperations.put(negatedOp, op)
         }
 
-        fun booleanConstant(value: Boolean): BranchedValue {
-            return if (value) TRUE else FALSE
-        }
+        fun booleanConstant(value: Boolean): BranchedValue = if (value) TRUE else FALSE
 
-        fun createInvertValue(argument: StackValue): StackValue {
-            return Invert(condJump(argument))
-        }
+        fun createInvertValue(argument: StackValue): StackValue = Invert(condJump(argument))
 
         fun condJump(condition: StackValue, label: Label, jumpIfFalse: Boolean, iv: InstructionAdapter) {
             condJump(condition).condJump(label, iv, jumpIfFalse)
@@ -136,14 +130,11 @@ open class BranchedValue(
             condJump(condition).loopJump(label, iv, jumpIfFalse)
         }
 
-        fun condJump(condition: StackValue): CondJump {
-            return CondJump(if (condition is BranchedValue) {
-                condition
-            }
-            else {
-                BranchedValue(condition, null, Type.BOOLEAN_TYPE, IFEQ)
-            }, IFEQ)
-        }
+        fun condJump(condition: StackValue): CondJump =
+                CondJump(
+                        condition as? BranchedValue ?: BranchedValue(condition, null, Type.BOOLEAN_TYPE, IFEQ),
+                        IFEQ
+                )
 
         fun cmp(opToken: IElementType, operandType: Type, left: StackValue, right: StackValue): StackValue =
                 if (operandType.sort == Type.OBJECT)
@@ -203,7 +194,7 @@ class CondJump(val condition: BranchedValue, op: Int) : BranchedValue(condition,
 }
 
 class NumberCompare(
-        val opToken: IElementType,
+        private val opToken: IElementType,
         operandType: Type,
         left: StackValue,
         right: StackValue
@@ -213,17 +204,15 @@ class NumberCompare(
             patchOpcode(opcode, v, opToken, operandType)
 
     companion object {
-        fun getNumberCompareOpcode(opToken: IElementType): Int {
-            return when (opToken) {
-                KtTokens.EQEQ, KtTokens.EQEQEQ -> IFNE
-                KtTokens.EXCLEQ, KtTokens.EXCLEQEQEQ -> IFEQ
-                KtTokens.GT -> IFLE
-                KtTokens.GTEQ -> IFLT
-                KtTokens.LT -> IFGE
-                KtTokens.LTEQ -> IFGT
-                else -> {
-                    throw UnsupportedOperationException("Don't know how to generate this condJump: " + opToken)
-                }
+        fun getNumberCompareOpcode(opToken: IElementType): Int = when (opToken) {
+            KtTokens.EQEQ, KtTokens.EQEQEQ -> IFNE
+            KtTokens.EXCLEQ, KtTokens.EXCLEQEQEQ -> IFEQ
+            KtTokens.GT -> IFLE
+            KtTokens.GTEQ -> IFLT
+            KtTokens.LT -> IFGE
+            KtTokens.LTEQ -> IFGT
+            else -> {
+                throw UnsupportedOperationException("Don't know how to generate this condJump: " + opToken)
             }
         }
 
@@ -258,100 +247,11 @@ class ObjectCompare(
 ) : BranchedValue(left, right, operandType, ObjectCompare.getObjectCompareOpcode(opToken)) {
 
     companion object {
-        fun getObjectCompareOpcode(opToken: IElementType): Int {
-            return when (opToken) {
-                KtTokens.EQEQEQ -> IF_ACMPNE
-                KtTokens.EXCLEQEQEQ -> IF_ACMPEQ
-                else -> throw UnsupportedOperationException("don't know how to generate this condjump")
-            }
+        fun getObjectCompareOpcode(opToken: IElementType): Int = when (opToken) {
+            KtTokens.EQEQEQ -> IF_ACMPNE
+            KtTokens.EXCLEQEQEQ -> IF_ACMPEQ
+            else -> throw UnsupportedOperationException("don't know how to generate this condjump")
         }
     }
 }
 
-abstract class SafeCallFusedWithPrimitiveEqualityBase(
-        val opToken: IElementType,
-        operandType: Type,
-        left: StackValue,
-        right: StackValue
-) : BranchedValue(left, right, operandType, NumberCompare.getNumberCompareOpcode(opToken)) {
-    private val trueIfEqual = opToken == KtTokens.EQEQ || opToken == KtTokens.EQEQEQ
-
-    protected abstract fun cleanupOnNullReceiver(v: InstructionAdapter)
-
-    override fun patchOpcode(opcode: Int, v: InstructionAdapter): Int =
-            NumberCompare.patchOpcode(opcode, v, opToken, operandType)
-
-    override fun condJump(jumpLabel: Label, v: InstructionAdapter, jumpIfFalse: Boolean) {
-        val endLabel = Label()
-
-        arg1.put(operandType, v)
-        arg2!!.put(operandType, v)
-        v.visitJumpInsn(patchOpcode(if (jumpIfFalse) opcode else negatedOperations[opcode]!!, v), jumpLabel)
-        v.goTo(endLabel)
-
-        cleanupOnNullReceiver(v)
-        if (jumpIfFalse == trueIfEqual) {
-            v.goTo(jumpLabel)
-        }
-
-        v.mark(endLabel)
-    }
-
-    override fun putSelector(type: Type, v: InstructionAdapter) {
-        val falseLabel = Label()
-        val endLabel = Label()
-
-        arg1.put(operandType, v)
-        arg2!!.put(operandType, v)
-        v.visitJumpInsn(patchOpcode(opcode, v), falseLabel)
-
-        if (!trueIfEqual) {
-            val trueLabel = Label()
-            v.goTo(trueLabel)
-            cleanupOnNullReceiver(v)
-            v.mark(trueLabel)
-        }
-
-        v.iconst(1)
-        v.goTo(endLabel)
-
-        if (trueIfEqual) {
-            cleanupOnNullReceiver(v)
-        }
-
-        v.mark(falseLabel)
-        v.iconst(0)
-
-        v.mark(endLabel)
-        coerceTo(type, v)
-    }
-}
-
-class SafeCallToPrimitiveEquality(
-        opToken: IElementType,
-        operandType: Type,
-        left: StackValue,
-        right: StackValue,
-        val safeReceiverType: Type,
-        val safeReceiverIsNull: Label
-) : SafeCallFusedWithPrimitiveEqualityBase(opToken, operandType, left, right) {
-    override fun cleanupOnNullReceiver(v: InstructionAdapter) {
-        v.mark(safeReceiverIsNull)
-        AsmUtil.pop(v, safeReceiverType)
-    }
-}
-
-class PrimitiveToSafeCallEquality(
-        opToken: IElementType,
-        operandType: Type,
-        left: StackValue,
-        right: StackValue,
-        val safeReceiverType: Type,
-        val safeReceiverIsNull: Label
-) : SafeCallFusedWithPrimitiveEqualityBase(opToken, operandType, left, right) {
-    override fun cleanupOnNullReceiver(v: InstructionAdapter) {
-        v.mark(safeReceiverIsNull)
-        AsmUtil.pop(v, safeReceiverType)
-        AsmUtil.pop(v, arg1.type)
-    }
-}

compiler/backend/src/org/jetbrains/kotlin/codegen/CallReceiver.java

@@ -0,0 +1,168 @@
+/*
+ * Copyright 2010-2017 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.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.jetbrains.kotlin.codegen.intrinsics.JavaClassProperty;
+import org.jetbrains.kotlin.codegen.state.GenerationState;
+import org.jetbrains.kotlin.codegen.state.KotlinTypeMapper;
+import org.jetbrains.kotlin.descriptors.*;
+import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall;
+import org.jetbrains.org.objectweb.asm.Type;
+import org.jetbrains.org.objectweb.asm.commons.InstructionAdapter;
+
+public class CallReceiver extends StackValue {
+    private final StackValue dispatchReceiver;
+    private final StackValue extensionReceiver;
+    private final Type secondReceiverType;
+
+    private CallReceiver(
+            @NotNull StackValue dispatchReceiver,
+            @NotNull StackValue extensionReceiver,
+            @NotNull Type type,
+            @Nullable Type secondReceiverType
+    ) {
+        super(type, dispatchReceiver.canHaveSideEffects() || extensionReceiver.canHaveSideEffects());
+        this.dispatchReceiver = dispatchReceiver;
+        this.extensionReceiver = extensionReceiver;
+        this.secondReceiverType = secondReceiverType;
+    }
+
+    public StackValue withoutReceiverArgument() {
+        return new CallReceiver(dispatchReceiver, none(), type, secondReceiverType);
+    }
+
+    public static StackValue generateCallReceiver(
+            @NotNull ResolvedCall<?> resolvedCall,
+            @NotNull ExpressionCodegen codegen,
+            @Nullable Callable callableMethod,
+            @Nullable ReceiverParameterDescriptor dispatchReceiverParameter,
+            @NotNull StackValue dispatchReceiver,
+            @Nullable ReceiverParameterDescriptor extensionReceiverParameter,
+            @NotNull StackValue extensionReceiver
+    ) {
+        KotlinTypeMapper typeMapper = codegen.typeMapper;
+        GenerationState state = codegen.getState();
+
+        Type type;
+        Type secondReceiverType = null;
+        if (extensionReceiverParameter != null) {
+            type = calcExtensionReceiverType(resolvedCall, extensionReceiverParameter, typeMapper, callableMethod, state);
+            if (dispatchReceiverParameter != null) {
+                secondReceiverType = calcDispatchReceiverType(resolvedCall, dispatchReceiverParameter, typeMapper, callableMethod);
+            }
+        }
+        else if (dispatchReceiverParameter != null) {
+            type = calcDispatchReceiverType(resolvedCall, dispatchReceiverParameter, typeMapper, callableMethod);
+        }
+        else if (isLocalFunCall(callableMethod)) {
+            type = callableMethod.getGenerateCalleeType();
+        }
+        else {
+            type = Type.VOID_TYPE;
+        }
+
+        assert type != null : "Could not map receiver type for " + resolvedCall;
+
+        return new CallReceiver(dispatchReceiver, extensionReceiver, type, secondReceiverType);
+    }
+
+    private static Type calcDispatchReceiverType(
+            @NotNull ResolvedCall<?> resolvedCall,
+            @Nullable ReceiverParameterDescriptor dispatchReceiver,
+            @NotNull KotlinTypeMapper typeMapper,
+            @Nullable Callable callableMethod
+    ) {
+        if (dispatchReceiver == null) return null;
+
+        CallableDescriptor descriptor = resolvedCall.getResultingDescriptor();
+
+        if (CodegenUtilKt.isJvmStaticInObjectOrClass(descriptor)) {
+            return Type.VOID_TYPE;
+        }
+
+        if (callableMethod != null) {
+            return callableMethod.getDispatchReceiverType();
+        }
+
+        // Extract the receiver from the resolved call, workarounding the fact that ResolvedCall#dispatchReceiver doesn't have
+        // all the needed information, for example there's no way to find out whether or not a smart cast was applied to the receiver.
+        DeclarationDescriptor container = descriptor.getContainingDeclaration();
+        if (container instanceof ClassDescriptor) {
+            return typeMapper.mapClass((ClassDescriptor) container);
+        }
+
+        return typeMapper.mapType(dispatchReceiver);
+    }
+
+    private static Type calcExtensionReceiverType(
+            @NotNull ResolvedCall<?> resolvedCall,
+            @Nullable ReceiverParameterDescriptor extensionReceiver,
+            @NotNull KotlinTypeMapper typeMapper,
+            @Nullable Callable callableMethod,
+            @NotNull GenerationState state
+    ) {
+        if (extensionReceiver == null) return null;
+
+        CallableDescriptor descriptor = resolvedCall.getCandidateDescriptor();
+
+        if (descriptor instanceof PropertyDescriptor &&
+            // hackaround: boxing changes behaviour of T.javaClass intrinsic
+            state.getIntrinsics().getIntrinsic((PropertyDescriptor) descriptor) != JavaClassProperty.INSTANCE
+        ) {
+            ReceiverParameterDescriptor receiverCandidate = descriptor.getExtensionReceiverParameter();
+            assert receiverCandidate != null;
+            return typeMapper.mapType(receiverCandidate.getType());
+        }
+
+        return callableMethod != null ? callableMethod.getExtensionReceiverType() : typeMapper.mapType(extensionReceiver.getType());
+    }
+
+    @Override
+    public void putSelector(@NotNull Type type, @NotNull InstructionAdapter v) {
+        StackValue currentExtensionReceiver = extensionReceiver;
+        boolean hasExtensionReceiver = extensionReceiver != none();
+        if (extensionReceiver instanceof SafeCall) {
+            currentExtensionReceiver.put(currentExtensionReceiver.type, v);
+            currentExtensionReceiver = StackValue.onStack(currentExtensionReceiver.type);
+        }
+
+        Type dispatchReceiverType = secondReceiverType != null ? secondReceiverType :
+                                    hasExtensionReceiver ? dispatchReceiver.type :
+                                    type;
+        dispatchReceiver.put(dispatchReceiverType, v);
+
+        currentExtensionReceiver
+                .moveToTopOfStack(hasExtensionReceiver ? type : currentExtensionReceiver.type, v, dispatchReceiverType.getSize());
+    }
+
+    @Override
+    public void dup(@NotNull InstructionAdapter v, boolean withReceiver) {
+        AsmUtil.dup(v, extensionReceiver.type, dispatchReceiver.type);
+    }
+
+    @NotNull
+    public StackValue getDispatchReceiver() {
+        return dispatchReceiver;
+    }
+
+    @NotNull
+    public StackValue getExtensionReceiver() {
+        return extensionReceiver;
+    }
+}

compiler/backend/src/org/jetbrains/kotlin/codegen/ClassBodyCodegen.java

@@ -192,6 +192,6 @@ public abstract class ClassBodyCodegen extends MemberCodegen<KtPureClassOrObject
     @Nullable
     @Override
     protected ClassDescriptor classForInnerClassRecord() {
-        return InnerClassConsumer.Companion.classForInnerClassRecord(descriptor, false);
+        return DescriptorUtils.isTopLevelDeclaration(descriptor) ? null : descriptor;
     }
 }

compiler/backend/src/org/jetbrains/kotlin/codegen/ExpressionCodegen.java

@@ -39,11 +39,12 @@ import org.jetbrains.kotlin.codegen.coroutines.CoroutineCodegenForLambda;
 import org.jetbrains.kotlin.codegen.coroutines.CoroutineCodegenUtilKt;
 import org.jetbrains.kotlin.codegen.coroutines.ResolvedCallWithRealDescriptor;
 import org.jetbrains.kotlin.codegen.extensions.ExpressionCodegenExtension;
-import org.jetbrains.kotlin.codegen.forLoop.AbstractForLoopGenerator;
-import org.jetbrains.kotlin.codegen.forLoop.ForLoopGeneratorsKt;
 import org.jetbrains.kotlin.codegen.inline.*;
 import org.jetbrains.kotlin.codegen.intrinsics.*;
 import org.jetbrains.kotlin.codegen.pseudoInsns.PseudoInsnsKt;
+import org.jetbrains.kotlin.codegen.range.RangeValue;
+import org.jetbrains.kotlin.codegen.range.RangeValuesKt;
+import org.jetbrains.kotlin.codegen.range.forLoop.ForLoopGenerator;
 import org.jetbrains.kotlin.codegen.signature.BothSignatureWriter;
 import org.jetbrains.kotlin.codegen.signature.JvmSignatureWriter;
 import org.jetbrains.kotlin.codegen.state.GenerationState;
@@ -599,7 +600,10 @@ public class ExpressionCodegen extends KtVisitor<StackValue, StackValue> impleme
     }
 
     private void generateFor(@NotNull KtForExpression forExpression) {
-        generateForLoop(ForLoopGeneratorsKt.getForLoopGenerator(this, forExpression));
+        KtExpression range = forExpression.getLoopRange();
+        assert range != null : "No loop range in for expression";
+        RangeValue rangeValue = RangeValuesKt.createRangeValueForExpression(this, range);
+        generateForLoop(rangeValue.createForLoopGenerator(this, forExpression));
     }
 
     @NotNull
@@ -623,7 +627,7 @@ public class ExpressionCodegen extends KtVisitor<StackValue, StackValue> impleme
         return context.getContextKind();
     }
 
-    private void generateForLoop(AbstractForLoopGenerator generator) {
+    private void generateForLoop(ForLoopGenerator generator) {
         Label loopExit = new Label();
         Label loopEntry = new Label();
         Label continueLabel = new Label();
@@ -2278,12 +2282,12 @@ public class ExpressionCodegen extends KtVisitor<StackValue, StackValue> impleme
             // But the problem is that we should leave the receiver itself on the stack, so we store it in a temporary variable.
             if (isSuspendCall && isSafeCallOrOnStack) {
                 boolean bothReceivers =
-                        receiver instanceof StackValue.CallReceiver
-                        && ((StackValue.CallReceiver) receiver).getDispatchReceiver().type.getSort() != Type.VOID
-                        && ((StackValue.CallReceiver) receiver).getExtensionReceiver().type.getSort() != Type.VOID;
+                        receiver instanceof CallReceiver
+                        && ((CallReceiver) receiver).getDispatchReceiver().type.getSort() != Type.VOID
+                        && ((CallReceiver) receiver).getExtensionReceiver().type.getSort() != Type.VOID;
                 Type firstReceiverType =
                         bothReceivers
-                        ? ((StackValue.CallReceiver) receiver).getDispatchReceiver().type
+                        ? ((CallReceiver) receiver).getDispatchReceiver().type
                         : receiver.type;
 
                 Type secondReceiverType = bothReceivers ? receiver.type : null;
@@ -2851,76 +2855,9 @@ public class ExpressionCodegen extends KtVisitor<StackValue, StackValue> impleme
 
     private StackValue generateIn(StackValue leftValue, KtExpression rangeExpression, KtSimpleNameExpression operationReference) {
         KtExpression deparenthesized = KtPsiUtil.deparenthesize(rangeExpression);
-
         assert deparenthesized != null : "For with empty range expression";
-        boolean isInverted = operationReference.getReferencedNameElementType() == KtTokens.NOT_IN;
-        return StackValue.operation(Type.BOOLEAN_TYPE, v -> {
-            if (RangeCodegenUtil.isPrimitiveRangeSpecializationOfType(leftValue.type, deparenthesized, bindingContext) ||
-                RangeCodegenUtil.isPrimitiveRangeToExtension(operationReference, bindingContext)) {
-                generateInPrimitiveRange(leftValue, (KtBinaryExpression) deparenthesized, isInverted);
-            }
-            else {
-                ResolvedCall<? extends CallableDescriptor> resolvedCall = CallUtilKt
-                        .getResolvedCallWithAssert(operationReference, bindingContext);
-                StackValue result = invokeFunction(resolvedCall.getCall(), resolvedCall, StackValue.none());
-                result.put(result.type, v);
-                if (isInverted) {
-                    genInvertBoolean(v);
-                }
-            }
-            return null;
-        });
-    }
-
-    /*
-     * Translates x in a..b to a <= x && x <= b
-     * and x !in a..b to a > x || x > b for any primitive type
-     */
-    private void generateInPrimitiveRange(StackValue argument, KtBinaryExpression rangeExpression, boolean isInverted) {
-        Type rangeType = argument.type;
-        int localVarIndex = myFrameMap.enterTemp(rangeType);
-        // Load left bound
-        gen(rangeExpression.getLeft(), rangeType);
-        // Load x into local variable to avoid StackValue#put side-effects
-        argument.put(rangeType, v);
-        v.store(localVarIndex, rangeType);
-        v.load(localVarIndex, rangeType);
-
-        // If (x < left) goto L1
-        Label l1 = new Label();
-        emitGreaterThan(rangeType, l1);
-
-        // If (x > right) goto L1
-        v.load(localVarIndex, rangeType);
-        gen(rangeExpression.getRight(), rangeType);
-        emitGreaterThan(rangeType, l1);
-
-        Label l2 = new Label();
-        v.iconst(isInverted ? 0 : 1);
-        v.goTo(l2);
-
-        v.mark(l1);
-        v.iconst(isInverted ? 1 : 0);
-        v.mark(l2);
-        myFrameMap.leaveTemp(rangeType);
-    }
-
-    private void emitGreaterThan(Type type, Label label) {
-        if (AsmUtil.isIntPrimitive(type)) {
-            v.ificmpgt(label);
-        }
-        else if (type == Type.LONG_TYPE) {
-            v.lcmp();
-            v.ifgt(label);
-        }
-        // '>' != 'compareTo' for NaN and +/- 0.0
-        else if (type == Type.FLOAT_TYPE || type == Type.DOUBLE_TYPE) {
-            v.cmpg(type);
-            v.ifgt(label);
-        }
-        else {
-            throw new UnsupportedOperationException("Unexpected type: " + type);
-        }
+        RangeValue rangeValue = RangeValuesKt.createRangeValueForExpression(this, deparenthesized);
+        return rangeValue.createInExpressionGenerator(this, operationReference).generate(leftValue);
     }
 
     private StackValue generateBooleanAnd(KtBinaryExpression expression) {
@@ -2958,6 +2895,20 @@ public class ExpressionCodegen extends KtVisitor<StackValue, StackValue> impleme
             return genCmpPrimitiveToSafeCall(left, leftType, (KtSafeQualifiedExpression) right, opToken);
         }
 
+        if (BoxedToPrimitiveEquality.isApplicable(opToken, leftType, rightType)) {
+            return BoxedToPrimitiveEquality.create(opToken, genLazy(left, leftType), leftType, genLazy(right, rightType), rightType,
+                                                   myFrameMap);
+        }
+
+        if (PrimitiveToBoxedEquality.isApplicable(opToken, leftType, rightType)) {
+            return PrimitiveToBoxedEquality.create(opToken, genLazy(left, leftType), leftType, genLazy(right, rightType), rightType);
+        }
+
+        if (PrimitiveToObjectEquality.isApplicable(opToken, leftType, rightType)) {
+            return PrimitiveToObjectEquality.create(opToken, genLazy(left, leftType), leftType, genLazy(right, rightType), rightType);
+        }
+
+
         if (isPrimitive(leftType) != isPrimitive(rightType)) {
             leftType = boxType(leftType);
             rightType = boxType(rightType);

compiler/backend/src/org/jetbrains/kotlin/codegen/ImplementationBodyCodegen.java

@@ -35,6 +35,7 @@ import org.jetbrains.kotlin.codegen.signature.BothSignatureWriter;
 import org.jetbrains.kotlin.codegen.signature.JvmSignatureWriter;
 import org.jetbrains.kotlin.codegen.state.GenerationState;
 import org.jetbrains.kotlin.codegen.state.KotlinTypeMapper;
+import org.jetbrains.kotlin.config.LanguageFeature;
 import org.jetbrains.kotlin.descriptors.*;
 import org.jetbrains.kotlin.incremental.components.NoLookupLocation;
 import org.jetbrains.kotlin.lexer.KtTokens;
@@ -64,10 +65,7 @@ import org.jetbrains.kotlin.resolve.scopes.receivers.ExtensionReceiver;
 import org.jetbrains.kotlin.resolve.scopes.receivers.ImplicitReceiver;
 import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue;
 import org.jetbrains.kotlin.types.KotlinType;
-import org.jetbrains.org.objectweb.asm.FieldVisitor;
-import org.jetbrains.org.objectweb.asm.Label;
-import org.jetbrains.org.objectweb.asm.MethodVisitor;
-import org.jetbrains.org.objectweb.asm.Type;
+import org.jetbrains.org.objectweb.asm.*;
 import org.jetbrains.org.objectweb.asm.commons.InstructionAdapter;
 import org.jetbrains.org.objectweb.asm.commons.Method;
 
@@ -348,9 +346,12 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
     }
 
     @Override
-    protected void generateSyntheticParts() {
+    protected void generateSyntheticPartsBeforeBody() {
         generatePropertyMetadataArrayFieldIfNeeded(classAsmType);
+    }
 
+    @Override
+    protected void generateSyntheticPartsAfterBody() {
         generateFieldForSingleton();
 
         generateCompanionObjectBackingFieldCopies();
@@ -835,9 +836,21 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
 
         @Nullable KtObjectDeclaration companionObject = CollectionsKt.firstOrNull(myClass.getCompanionObjects());
 
+        int properFieldVisibilityFlag = getVisibilityAccessFlag(companionObjectDescriptor);
+        boolean fieldShouldBeDeprecated =
+                state.getLanguageVersionSettings().supportsFeature(LanguageFeature.DeprecatedFieldForInvisibleCompanionObject) &&
+                (properFieldVisibilityFlag & (ACC_PRIVATE | ACC_PROTECTED)) != 0;
+        // TODO generate field with proper visibility in language version 1.3
+        int fieldAccessFlags = ACC_PUBLIC | ACC_STATIC | ACC_FINAL;
+        if (fieldShouldBeDeprecated) {
+            fieldAccessFlags |= ACC_DEPRECATED;
+        }
         StackValue.Field field = StackValue.singleton(companionObjectDescriptor, typeMapper);
-        v.newField(JvmDeclarationOriginKt.OtherOrigin(companionObject == null ? myClass.getPsiOrParent() : companionObject),
-                   ACC_PUBLIC | ACC_STATIC | ACC_FINAL, field.name, field.type.getDescriptor(), null, null);
+        FieldVisitor fv = v.newField(JvmDeclarationOriginKt.OtherOrigin(companionObject == null ? myClass.getPsiOrParent() : companionObject),
+                                     fieldAccessFlags, field.name, field.type.getDescriptor(), null, null);
+        if (fieldShouldBeDeprecated) {
+            AnnotationCodegen.forField(fv, this, typeMapper).visitAnnotation("Ljava/lang/Deprecated;", true).visitEnd();
+        }
     }
 
     private void generateCompanionObjectBackingFieldCopies() {

compiler/backend/src/org/jetbrains/kotlin/codegen/InnerClassConsumer.kt

@@ -17,35 +17,7 @@
 package org.jetbrains.kotlin.codegen
 
 import org.jetbrains.kotlin.descriptors.ClassDescriptor
-import org.jetbrains.kotlin.descriptors.ClassKind
-import org.jetbrains.kotlin.descriptors.Modality
-import org.jetbrains.kotlin.descriptors.SourceElement
-import org.jetbrains.kotlin.descriptors.impl.ClassDescriptorImpl
-import org.jetbrains.kotlin.load.java.JvmAbi
-import org.jetbrains.kotlin.name.Name
-import org.jetbrains.kotlin.resolve.DescriptorUtils
-import org.jetbrains.kotlin.resolve.scopes.MemberScope
-import java.util.*
 
 interface InnerClassConsumer {
     fun addInnerClassInfoFromAnnotation(classDescriptor: ClassDescriptor)
-
-    companion object {
-
-        fun classForInnerClassRecord(descriptor: ClassDescriptor, defaultImpls: Boolean): ClassDescriptor? {
-            if (defaultImpls) {
-                if (DescriptorUtils.isLocal(descriptor)) return null
-                val classDescriptorImpl = ClassDescriptorImpl(
-                        descriptor, Name.identifier(JvmAbi.DEFAULT_IMPLS_CLASS_NAME),
-                        Modality.FINAL, ClassKind.CLASS, Collections.emptyList(), SourceElement.NO_SOURCE,
-                        /* isExternal = */ false)
-
-                classDescriptorImpl.initialize(MemberScope.Empty, emptySet(), null)
-                return classDescriptorImpl
-            }
-            else {
-                return if (DescriptorUtils.isTopLevelDeclaration(descriptor)) null else descriptor
-            }
-        }
-    }
 }

compiler/backend/src/org/jetbrains/kotlin/codegen/InterfaceImplBodyCodegen.kt

@@ -60,10 +60,17 @@ class InterfaceImplBodyCodegen(
 
     override fun classForInnerClassRecord(): ClassDescriptor? {
         if (!isAnythingGenerated) return null
-        return InnerClassConsumer.classForInnerClassRecord(descriptor, true)
+        if (DescriptorUtils.isLocal(descriptor)) return null
+        val classDescriptorImpl = ClassDescriptorImpl(
+                descriptor, Name.identifier(JvmAbi.DEFAULT_IMPLS_CLASS_NAME),
+                Modality.FINAL, ClassKind.CLASS, Collections.emptyList(), SourceElement.NO_SOURCE,
+                /* isExternal = */ false)
+
+        classDescriptorImpl.initialize(MemberScope.Empty, emptySet(), null)
+        return classDescriptorImpl
     }
 
-    override fun generateSyntheticParts() {
+    override fun generateSyntheticPartsAfterBody() {
         for (memberDescriptor in descriptor.defaultType.memberScope.getContributedDescriptors()) {
             if (memberDescriptor !is CallableMemberDescriptor) continue
 

compiler/backend/src/org/jetbrains/kotlin/codegen/JvmStaticInCompanionObjectGenerator.kt

@@ -94,8 +94,7 @@ class JvmStaticInCompanionObjectGenerator(
                     CallableMemberDescriptor.Kind.SYNTHESIZED,
                     false
             )
-            val staticFunctionDescriptor = copies[descriptor]!!
-            return staticFunctionDescriptor
+            return copies[descriptor]!!
         }
     }
 }

compiler/backend/src/org/jetbrains/kotlin/codegen/MemberCodegen.java

@@ -36,6 +36,7 @@ import org.jetbrains.kotlin.codegen.state.KotlinTypeMapper;
 import org.jetbrains.kotlin.descriptors.*;
 import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget;
 import org.jetbrains.kotlin.descriptors.annotations.Annotations;
+import org.jetbrains.kotlin.descriptors.impl.LocalVariableDescriptor;
 import org.jetbrains.kotlin.descriptors.impl.SimpleFunctionDescriptorImpl;
 import org.jetbrains.kotlin.fileClasses.FileClasses;
 import org.jetbrains.kotlin.fileClasses.JvmFileClassesProvider;
@@ -49,6 +50,7 @@ import org.jetbrains.kotlin.psi.*;
 import org.jetbrains.kotlin.psi.synthetics.SyntheticClassOrObjectDescriptor;
 import org.jetbrains.kotlin.resolve.BindingContext;
 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.ConstantValue;
 import org.jetbrains.kotlin.resolve.descriptorUtil.DescriptorUtilsKt;
@@ -134,11 +136,18 @@ public abstract class MemberCodegen<T extends KtPureElement/* TODO: & KtDeclarat
     public void generate() {
         generateDeclaration();
 
+        boolean shouldGenerateSyntheticParts =
+                !(element instanceof KtClassOrObject) ||
+                state.getGenerateDeclaredClassFilter().shouldGenerateClassMembers((KtClassOrObject) element);
+
+        if (shouldGenerateSyntheticParts) {
+            generateSyntheticPartsBeforeBody();
+        }
+
         generateBody();
 
-        if (!(element instanceof KtClassOrObject) ||
-            state.getGenerateDeclaredClassFilter().shouldGenerateClassMembers((KtClassOrObject) element)) {
-            generateSyntheticParts();
+        if (shouldGenerateSyntheticParts) {
+            generateSyntheticPartsAfterBody();
         }
 
         if (state.getClassBuilderMode().generateMetadata) {
@@ -150,9 +159,12 @@ public abstract class MemberCodegen<T extends KtPureElement/* TODO: & KtDeclarat
 
     protected abstract void generateDeclaration();
 
+    protected void generateSyntheticPartsBeforeBody() {
+    }
+
     protected abstract void generateBody();
 
-    protected void generateSyntheticParts() {
+    protected void generateSyntheticPartsAfterBody() {
     }
 
     protected abstract void generateKotlinMetadataAnnotation();
@@ -332,7 +344,12 @@ public abstract class MemberCodegen<T extends KtPureElement/* TODO: & KtDeclarat
                 parentCodegen.innerClasses.add(classDescriptor);
             }
 
-            addParentsToInnerClassesIfNeeded(innerClasses);
+            for (MemberCodegen<?> codegen = this; codegen != null; codegen = codegen.getParentCodegen()) {
+                ClassDescriptor outerClass = codegen.classForInnerClassRecord();
+                if (outerClass != null) {
+                    innerClasses.add(outerClass);
+                }
+            }
         }
 
         for (ClassDescriptor innerClass : innerClasses) {
@@ -340,18 +357,6 @@ public abstract class MemberCodegen<T extends KtPureElement/* TODO: & KtDeclarat
         }
     }
 
-    protected void addParentsToInnerClassesIfNeeded(@NotNull Collection<ClassDescriptor> innerClasses) {
-        ClassDescriptor outerClass = classForInnerClassRecord();
-        if (outerClass != null) {
-            innerClasses.add(outerClass);
-        }
-
-        MemberCodegen<?> parentCodegen = getParentCodegen();
-        if (parentCodegen != null) {
-            parentCodegen.addParentsToInnerClassesIfNeeded(innerClasses);
-        }
-    }
-
     // It's necessary for proper recovering of classId by plain string JVM descriptor when loading annotations
     // See FileBasedKotlinClass.convertAnnotationVisitor
     @Override

compiler/backend/src/org/jetbrains/kotlin/codegen/MultifileClassPartCodegen.kt

@@ -189,7 +189,7 @@ class MultifileClassPartCodegen(
         }
     }
 
-    override fun generateSyntheticParts() {
+    override fun generateSyntheticPartsAfterBody() {
         generateSyntheticAccessors()
     }
 

compiler/backend/src/org/jetbrains/kotlin/codegen/PackagePartCodegen.java

@@ -132,7 +132,7 @@ public class PackagePartCodegen extends MemberCodegen<KtFile> {
     }
 
     @Override
-    protected void generateSyntheticParts() {
+    protected void generateSyntheticPartsAfterBody() {
         generateSyntheticAccessors();
     }
 }

compiler/backend/src/org/jetbrains/kotlin/codegen/RangeCodegenUtil.java

@@ -1,241 +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;
-
-import com.google.common.collect.ImmutableMap;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
-import org.jetbrains.kotlin.builtins.PrimitiveType;
-import org.jetbrains.kotlin.descriptors.*;
-import org.jetbrains.kotlin.lexer.KtTokens;
-import org.jetbrains.kotlin.name.FqName;
-import org.jetbrains.kotlin.name.FqNameUnsafe;
-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.callUtil.CallUtilKt;
-import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall;
-import org.jetbrains.kotlin.resolve.scopes.receivers.ExpressionReceiver;
-import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue;
-import org.jetbrains.kotlin.types.KotlinType;
-import org.jetbrains.org.objectweb.asm.Type;
-
-import java.util.Arrays;
-import java.util.List;
-
-import static org.jetbrains.kotlin.builtins.KotlinBuiltIns.RANGES_PACKAGE_FQ_NAME;
-import static org.jetbrains.kotlin.codegen.AsmUtil.isPrimitiveNumberClassDescriptor;
-
-public class RangeCodegenUtil {
-    private static final ImmutableMap<FqName, PrimitiveType> RANGE_TO_ELEMENT_TYPE;
-    private static final ImmutableMap<FqName, PrimitiveType> PROGRESSION_TO_ELEMENT_TYPE;
-
-    @NotNull
-    public static List<PrimitiveType> supportedRangeTypes() {
-        return Arrays.asList(PrimitiveType.CHAR, PrimitiveType.INT, PrimitiveType.LONG);
-    }
-
-    static {
-        ImmutableMap.Builder<FqName, PrimitiveType> rangeBuilder = ImmutableMap.builder();
-        ImmutableMap.Builder<FqName, PrimitiveType> progressionBuilder = ImmutableMap.builder();
-        for (PrimitiveType primitiveType : supportedRangeTypes()) {
-            FqName rangeClassFqName = RANGES_PACKAGE_FQ_NAME.child(Name.identifier(primitiveType.getTypeName() + "Range"));
-            FqName progressionClassFqName = RANGES_PACKAGE_FQ_NAME.child(Name.identifier(primitiveType.getTypeName() + "Progression"));
-            rangeBuilder.put(rangeClassFqName, primitiveType);
-            progressionBuilder.put(progressionClassFqName, primitiveType);
-        }
-        RANGE_TO_ELEMENT_TYPE = rangeBuilder.build();
-        PROGRESSION_TO_ELEMENT_TYPE = progressionBuilder.build();
-    }
-
-    private RangeCodegenUtil() {}
-
-    public static boolean isRange(KotlinType rangeType) {
-        return !rangeType.isMarkedNullable() && getPrimitiveRangeElementType(rangeType) != null;
-    }
-
-    public static boolean isProgression(KotlinType rangeType) {
-        return !rangeType.isMarkedNullable() && getPrimitiveProgressionElementType(rangeType) != null;
-    }
-
-    @Nullable
-    private static PrimitiveType getPrimitiveRangeElementType(KotlinType rangeType) {
-        return getPrimitiveRangeOrProgressionElementType(rangeType, RANGE_TO_ELEMENT_TYPE);
-    }
-
-    @Nullable
-    private static PrimitiveType getPrimitiveProgressionElementType(KotlinType rangeType) {
-        return getPrimitiveRangeOrProgressionElementType(rangeType, PROGRESSION_TO_ELEMENT_TYPE);
-    }
-
-    @Nullable
-    private static PrimitiveType getPrimitiveRangeOrProgressionElementType(
-            @NotNull KotlinType rangeOrProgression,
-            @NotNull ImmutableMap<FqName, PrimitiveType> map
-    ) {
-        ClassifierDescriptor declarationDescriptor = rangeOrProgression.getConstructor().getDeclarationDescriptor();
-        if (declarationDescriptor == null) return null;
-        FqNameUnsafe fqName = DescriptorUtils.getFqName(declarationDescriptor);
-        if (!fqName.isSafe()) return null;
-        return map.get(fqName.toSafe());
-    }
-
-    @Nullable
-    public static PrimitiveType getPrimitiveRangeOrProgressionElementType(@NotNull FqName rangeOrProgressionName) {
-        PrimitiveType result = RANGE_TO_ELEMENT_TYPE.get(rangeOrProgressionName);
-        return result != null ? result : PROGRESSION_TO_ELEMENT_TYPE.get(rangeOrProgressionName);
-    }
-
-    public static boolean isRangeOrProgression(@NotNull FqName className) {
-        return getPrimitiveRangeOrProgressionElementType(className) != null;
-    }
-
-    public static boolean isPrimitiveNumberRangeTo(CallableDescriptor rangeTo) {
-        if (!"rangeTo".equals(rangeTo.getName().asString())) return false;
-
-        if (!isPrimitiveNumberClassDescriptor(rangeTo.getContainingDeclaration())) return false;
-
-        return true;
-    }
-
-    private static boolean isPrimitiveRangeToExtension(@NotNull CallableDescriptor descriptor) {
-        if (!isTopLevelInPackage(descriptor, "rangeTo", "kotlin.ranges")) return false;
-
-        ReceiverParameterDescriptor extensionReceiver = descriptor.getExtensionReceiverParameter();
-        if (extensionReceiver == null) return false;
-
-        return KotlinBuiltIns.isPrimitiveType(extensionReceiver.getType());
-    }
-
-    public static boolean isPrimitiveNumberDownTo(@NotNull CallableDescriptor descriptor) {
-        if (!isTopLevelInPackage(descriptor, "downTo", "kotlin.ranges")) return false;
-
-        ReceiverParameterDescriptor extensionReceiver = descriptor.getExtensionReceiverParameter();
-        if (extensionReceiver == null) return false;
-        ClassifierDescriptor extensionReceiverClassifier = extensionReceiver.getType().getConstructor().getDeclarationDescriptor();
-        if (!isPrimitiveNumberClassDescriptor(extensionReceiverClassifier)) return false;
-
-        return true;
-    }
-
-    public static boolean isPrimitiveNumberUntil(@NotNull CallableDescriptor descriptor) {
-        if (!isTopLevelInPackage(descriptor, "until", "kotlin.ranges")) return false;
-
-        ReceiverParameterDescriptor extensionReceiver = descriptor.getExtensionReceiverParameter();
-        if (extensionReceiver == null) return false;
-        ClassifierDescriptor extensionReceiverClassifier = extensionReceiver.getType().getConstructor().getDeclarationDescriptor();
-        if (!isPrimitiveNumberClassDescriptor(extensionReceiverClassifier)) return false;
-
-        return true;
-    }
-
-    public static boolean isArrayOrPrimitiveArrayIndices(@NotNull CallableDescriptor descriptor) {
-        if (!isTopLevelInPackage(descriptor, "indices", "kotlin.collections")) return false;
-
-        ReceiverParameterDescriptor extensionReceiver = descriptor.getExtensionReceiverParameter();
-        if (extensionReceiver == null) return false;
-        KotlinType extensionReceiverType = extensionReceiver.getType();
-        if (!KotlinBuiltIns.isArray(extensionReceiverType) && !KotlinBuiltIns.isPrimitiveArray(extensionReceiverType)) return false;
-
-        return true;
-    }
-
-    public static boolean isCollectionIndices(@NotNull CallableDescriptor descriptor) {
-        if (!isTopLevelInPackage(descriptor, "indices", "kotlin.collections")) return false;
-
-        ReceiverParameterDescriptor extensionReceiver = descriptor.getExtensionReceiverParameter();
-        if (extensionReceiver == null) return false;
-        KotlinType extensionReceiverType = extensionReceiver.getType();
-        if (!KotlinBuiltIns.isCollectionOrNullableCollection(extensionReceiverType)) return false;
-
-        return true;
-    }
-
-    public static boolean isCharSequenceIndices(@NotNull CallableDescriptor descriptor) {
-        if (!isTopLevelInPackage(descriptor, "indices", "kotlin.text")) return false;
-
-        ReceiverParameterDescriptor extensionReceiver = descriptor.getExtensionReceiverParameter();
-        if (extensionReceiver == null) return false;
-        KotlinType extensionReceiverType = extensionReceiver.getType();
-        if (!KotlinBuiltIns.isCharSequenceOrNullableCharSequence(extensionReceiverType)) return false;
-
-        return true;
-    }
-
-    public static boolean isPrimitiveRangeToExtension(@NotNull KtSimpleNameExpression operationReference, @NotNull BindingContext bindingContext) {
-        ResolvedCall<? extends CallableDescriptor> resolvedCall = CallUtilKt
-                .getResolvedCallWithAssert(operationReference, bindingContext);
-        ReceiverValue receiver = resolvedCall.getDispatchReceiver();
-
-        /*
-         * Range is optimizable if
-         * 'in' receiver is expression 'rangeTo' from stdlib package
-         * and its argument has same primitive type as generic range parameter.
-         * For non-matching primitive types (e.g. int in double range)
-         * dispatch receiver will be null, because extension method will be called.
-         */
-        if (!(receiver instanceof ExpressionReceiver)) return false;
-        ExpressionReceiver e = (ExpressionReceiver) receiver;
-
-        ResolvedCall<? extends CallableDescriptor> resolvedReceiver =
-                CallUtilKt.getResolvedCall(e.getExpression(), bindingContext);
-        if (resolvedReceiver == null) return false;
-
-        return isPrimitiveRangeToExtension(resolvedReceiver.getResultingDescriptor());
-    }
-
-    /*
-     * Checks whether for expression 'x in a..b' a..b is primitive integral range
-     * with same type as x.
-     */
-    public static boolean isPrimitiveRangeSpecializationOfType(
-            @NotNull Type argumentType,
-            @NotNull KtExpression rangeExpression,
-            @NotNull BindingContext bindingContext
-    ) {
-        if (rangeExpression instanceof KtBinaryExpression &&
-            ((KtBinaryExpression) rangeExpression).getOperationReference().getReferencedNameElementType() == KtTokens.RANGE) {
-            KotlinType kotlinType = bindingContext.getType(rangeExpression);
-            assert kotlinType != null;
-            DeclarationDescriptor descriptor = kotlinType.getConstructor().getDeclarationDescriptor();
-            if (descriptor != null) {
-                FqNameUnsafe fqName = DescriptorUtils.getFqName(descriptor);
-                if (fqName.equals(KotlinBuiltIns.FQ_NAMES.longRange)) {
-                    return argumentType == Type.LONG_TYPE;
-                }
-                if (fqName.equals(KotlinBuiltIns.FQ_NAMES.charRange) || fqName.equals(KotlinBuiltIns.FQ_NAMES.intRange)) {
-                    return AsmUtil.isIntPrimitive(argumentType);
-                }
-            }
-        }
-
-        return false;
-    }
-
-    private static boolean isTopLevelInPackage(@NotNull CallableDescriptor descriptor, @NotNull String name, @NotNull String packageName) {
-        if (!name.equals(descriptor.getName().asString())) return false;
-
-        DeclarationDescriptor containingDeclaration = descriptor.getContainingDeclaration();
-        if (!(containingDeclaration instanceof PackageFragmentDescriptor)) return false;
-        String packageFqName = ((PackageFragmentDescriptor) containingDeclaration).getFqName().asString();
-        if (!packageName.equals(packageFqName)) return false;
-
-        return true;
-    }
-}

compiler/backend/src/org/jetbrains/kotlin/codegen/RangeCodegenUtil.kt

@@ -0,0 +1,242 @@
+/*
+ * Copyright 2010-2017 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.builtins.KotlinBuiltIns
+import org.jetbrains.kotlin.builtins.KotlinBuiltIns.RANGES_PACKAGE_FQ_NAME
+import org.jetbrains.kotlin.builtins.PrimitiveType
+import org.jetbrains.kotlin.codegen.AsmUtil.isPrimitiveNumberClassDescriptor
+import org.jetbrains.kotlin.descriptors.*
+import org.jetbrains.kotlin.name.FqName
+import org.jetbrains.kotlin.name.Name
+import org.jetbrains.kotlin.resolve.DescriptorUtils
+import org.jetbrains.kotlin.resolve.descriptorUtil.builtIns
+import org.jetbrains.kotlin.resolve.jvm.AsmTypes
+import org.jetbrains.kotlin.types.KotlinType
+import org.jetbrains.org.objectweb.asm.Type
+
+val supportedRangeTypes = listOf(PrimitiveType.CHAR, PrimitiveType.INT, PrimitiveType.LONG)
+
+private val RANGE_TO_ELEMENT_TYPE: Map<FqName, PrimitiveType> =
+        supportedRangeTypes.associateBy {
+            RANGES_PACKAGE_FQ_NAME.child(Name.identifier(it.typeName.toString() + "Range"))
+        }
+
+private val PROGRESSION_TO_ELEMENT_TYPE: Map<FqName, PrimitiveType> =
+        supportedRangeTypes.associateBy {
+            RANGES_PACKAGE_FQ_NAME.child(Name.identifier(it.typeName.toString() + "Progression"))
+        }
+
+fun isPrimitiveRange(rangeType: KotlinType) =
+        !rangeType.isMarkedNullable && getPrimitiveRangeElementType(rangeType) != null
+
+fun isPrimitiveProgression(rangeType: KotlinType) =
+        !rangeType.isMarkedNullable && getPrimitiveProgressionElementType(rangeType) != null
+
+fun getPrimitiveRangeElementType(rangeType: KotlinType): PrimitiveType? =
+        getPrimitiveRangeOrProgressionElementType(rangeType, RANGE_TO_ELEMENT_TYPE)
+
+private fun getPrimitiveProgressionElementType(rangeType: KotlinType) =
+        getPrimitiveRangeOrProgressionElementType(rangeType, PROGRESSION_TO_ELEMENT_TYPE)
+
+private fun getPrimitiveRangeOrProgressionElementType(
+        rangeOrProgression: KotlinType,
+        map: Map<FqName, PrimitiveType>
+): PrimitiveType? {
+    val declarationDescriptor = rangeOrProgression.constructor.declarationDescriptor ?: return null
+    val fqName = DescriptorUtils.getFqName(declarationDescriptor).takeIf { it.isSafe } ?: return null
+    return map[fqName.toSafe()]
+}
+
+fun getRangeOrProgressionElementType(rangeType: KotlinType): KotlinType? {
+    val rangeTypeDescriptor = rangeType.constructor.declarationDescriptor ?: return null
+    val builtIns = rangeTypeDescriptor.builtIns
+
+    return when {
+        isTopLevelInPackage(rangeTypeDescriptor, "CharRange", "kotlin.ranges") -> builtIns.charType
+        isTopLevelInPackage(rangeTypeDescriptor, "IntRange", "kotlin.ranges") -> builtIns.intType
+        isTopLevelInPackage(rangeTypeDescriptor, "LongRange", "kotlin.ranges") -> builtIns.longType
+
+        isTopLevelInPackage(rangeTypeDescriptor, "CharProgression", "kotlin.ranges") -> builtIns.charType
+        isTopLevelInPackage(rangeTypeDescriptor, "IntProgression", "kotlin.ranges") -> builtIns.intType
+        isTopLevelInPackage(rangeTypeDescriptor, "LongProgression", "kotlin.ranges") -> builtIns.longType
+
+        isTopLevelInPackage(rangeTypeDescriptor, "ClosedFloatRange", "kotlin.ranges") -> builtIns.floatType
+        isTopLevelInPackage(rangeTypeDescriptor, "ClosedDoubleRange", "kotlin.ranges") -> builtIns.doubleType
+
+        isTopLevelInPackage(rangeTypeDescriptor, "ClosedRange", "kotlin.ranges") -> rangeType.arguments.singleOrNull()?.type
+
+        isTopLevelInPackage(rangeTypeDescriptor, "ClosedFloatingPointRange", "kotlin.ranges") -> rangeType.arguments.singleOrNull()?.type
+
+        isTopLevelInPackage(rangeTypeDescriptor, "ComparableRange", "kotlin.ranges") -> rangeType.arguments.singleOrNull()?.type
+
+        else -> null
+    }
+}
+
+fun getPrimitiveRangeOrProgressionElementType(rangeOrProgressionName: FqName): PrimitiveType? =
+        RANGE_TO_ELEMENT_TYPE[rangeOrProgressionName] ?:
+        PROGRESSION_TO_ELEMENT_TYPE[rangeOrProgressionName]
+
+fun isRangeOrProgression(className: FqName) =
+        getPrimitiveRangeOrProgressionElementType(className) != null
+
+fun isPrimitiveNumberRangeTo(rangeTo: CallableDescriptor) =
+        "rangeTo" == rangeTo.name.asString() && isPrimitiveNumberClassDescriptor(rangeTo.containingDeclaration) ||
+        isPrimitiveRangeToExtension(rangeTo)
+
+private fun isPrimitiveRangeToExtension(descriptor: CallableDescriptor): Boolean {
+    if (!isTopLevelInPackage(descriptor, "rangeTo", "kotlin.ranges")) return false
+
+    val extensionReceiver = descriptor.extensionReceiverParameter ?: return false
+    return KotlinBuiltIns.isPrimitiveType(extensionReceiver.type)
+}
+
+fun isPrimitiveNumberDownTo(descriptor: CallableDescriptor): Boolean {
+    if (!isTopLevelInPackage(descriptor, "downTo", "kotlin.ranges")) return false
+
+    val extensionReceiver = descriptor.extensionReceiverParameter ?: return false
+    val extensionReceiverClassifier = extensionReceiver.type.constructor.declarationDescriptor
+    return isPrimitiveNumberClassDescriptor(extensionReceiverClassifier)
+}
+
+fun isPrimitiveNumberUntil(descriptor: CallableDescriptor): Boolean {
+    if (!isTopLevelInPackage(descriptor, "until", "kotlin.ranges")) return false
+
+    val extensionReceiver = descriptor.extensionReceiverParameter ?: return false
+    val extensionReceiverClassifier = extensionReceiver.type.constructor.declarationDescriptor
+    return isPrimitiveNumberClassDescriptor(extensionReceiverClassifier)
+}
+
+fun isArrayOrPrimitiveArrayIndices(descriptor: CallableDescriptor): Boolean {
+    if (!isTopLevelInPackage(descriptor, "indices", "kotlin.collections")) return false
+
+    val extensionReceiver = descriptor.extensionReceiverParameter ?: return false
+    val extensionReceiverType = extensionReceiver.type
+    return KotlinBuiltIns.isArray(extensionReceiverType) || KotlinBuiltIns.isPrimitiveArray(extensionReceiverType)
+}
+
+fun isCollectionIndices(descriptor: CallableDescriptor): Boolean {
+    if (!isTopLevelInPackage(descriptor, "indices", "kotlin.collections")) return false
+
+    val extensionReceiver = descriptor.extensionReceiverParameter ?: return false
+    val extensionReceiverType = extensionReceiver.type
+    return KotlinBuiltIns.isCollectionOrNullableCollection(extensionReceiverType)
+}
+
+fun isCharSequenceIndices(descriptor: CallableDescriptor): Boolean {
+    if (!isTopLevelInPackage(descriptor, "indices", "kotlin.text")) return false
+
+    val extensionReceiver = descriptor.extensionReceiverParameter ?: return false
+    val extensionReceiverType = extensionReceiver.type
+    return KotlinBuiltIns.isCharSequenceOrNullableCharSequence(extensionReceiverType)
+}
+
+fun isComparableRangeTo(descriptor: CallableDescriptor): Boolean {
+    if (!isTopLevelInPackage(descriptor, "rangeTo", "kotlin.ranges")) return false
+
+    val extensionReceiver = descriptor.original.extensionReceiverParameter ?: return false
+    val extensionReceiverTypeDescriptor = extensionReceiver.type.constructor.declarationDescriptor as? TypeParameterDescriptor ?: return false
+    val upperBoundType = extensionReceiverTypeDescriptor.upperBounds.singleOrNull() ?: return false
+    val upperBoundClassDescriptor = upperBoundType.constructor.declarationDescriptor as? ClassDescriptor ?: return false
+    if (!isTopLevelInPackage(upperBoundClassDescriptor, "Comparable", "kotlin")) return false
+
+    return true
+}
+
+fun isClosedRangeContains(descriptor: CallableDescriptor): Boolean {
+    if (descriptor.name.asString() != "contains") return false
+    val containingClassDescriptor = descriptor.containingDeclaration as? ClassDescriptor ?: return false
+    if (!isTopLevelInPackage(containingClassDescriptor, "ClosedRange", "kotlin.ranges")) return false
+
+    return true
+}
+
+fun isPrimitiveRangeContains(descriptor: CallableDescriptor): Boolean {
+    if (descriptor.name.asString() != "contains") return false
+    val dispatchReceiverType = descriptor.dispatchReceiverParameter?.type ?: return false
+    if (!isPrimitiveRange(dispatchReceiverType)) return false
+
+    return true
+}
+
+fun isPrimitiveNumberRangeExtensionContainsPrimitiveNumber(descriptor: CallableDescriptor): Boolean {
+    if (descriptor.name.asString() != "contains") return false
+
+    val extensionReceiverType = descriptor.extensionReceiverParameter?.type ?: return false
+
+    val rangeElementType = getRangeOrProgressionElementType(extensionReceiverType) ?: return false
+    if (!isPrimitiveNumberType(rangeElementType)) return false
+
+    val argumentType = descriptor.valueParameters.singleOrNull()?.type ?: return false
+    if (!isPrimitiveNumberType(argumentType)) return false
+
+    return true
+}
+
+private fun isPrimitiveNumberType(type: KotlinType) =
+        KotlinBuiltIns.isByte(type) ||
+        KotlinBuiltIns.isShort(type) ||
+        KotlinBuiltIns.isInt(type) ||
+        KotlinBuiltIns.isChar(type) ||
+        KotlinBuiltIns.isLong(type) ||
+        KotlinBuiltIns.isFloat(type) ||
+        KotlinBuiltIns.isDouble(type)
+
+fun isClosedFloatingPointRangeContains(descriptor: CallableDescriptor): Boolean {
+    if (descriptor.name.asString() != "contains") return false
+    val containingClassDescriptor = descriptor.containingDeclaration as? ClassDescriptor ?: return false
+    if (!isTopLevelInPackage(containingClassDescriptor, "ClosedFloatingPointRange", "kotlin.ranges")) return false
+
+    return true
+}
+
+fun getClosedFloatingPointRangeElementType(rangeType: KotlinType): KotlinType? {
+    val classDescriptor = rangeType.constructor.declarationDescriptor as? ClassDescriptor ?: return null
+    if (!isTopLevelInPackage(classDescriptor, "ClosedFloatingPointRange", "kotlin.ranges")) return null
+    return rangeType.arguments.singleOrNull()?.type
+}
+
+private fun isTopLevelInPackage(descriptor: DeclarationDescriptor, name: String, packageName: String): Boolean {
+    if (name != descriptor.name.asString()) return false
+
+    val containingDeclaration = descriptor.containingDeclaration as? PackageFragmentDescriptor ?: return false
+    val packageFqName = containingDeclaration.fqName.asString()
+    return packageName == packageFqName
+}
+
+fun getAsmRangeElementTypeForPrimitiveRangeOrProgression(rangeCallee: CallableDescriptor): Type {
+    val rangeType = rangeCallee.returnType!!
+
+    getPrimitiveRangeElementType(rangeType)?.let {
+        return AsmTypes.valueTypeForPrimitive(it)
+    }
+
+    getPrimitiveProgressionElementType(rangeType)?.let {
+        return AsmTypes.valueTypeForPrimitive(it)
+    }
+
+    getClosedFloatingPointRangeElementType(rangeType)?.let {
+        when {
+            KotlinBuiltIns.isDouble(it) -> return Type.DOUBLE_TYPE
+            KotlinBuiltIns.isFloat(it) -> return Type.FLOAT_TYPE
+            else -> {}
+        }
+    }
+
+    throw AssertionError("Unexpected range type: $rangeType")
+}

compiler/backend/src/org/jetbrains/kotlin/codegen/ScriptCodegen.java

@@ -105,10 +105,14 @@ public class ScriptCodegen extends MemberCodegen<KtScript> {
     }
 
     @Override
-    protected void generateSyntheticParts() {
+    protected void generateSyntheticPartsBeforeBody() {
         generatePropertyMetadataArrayFieldIfNeeded(classAsmType);
     }
 
+    @Override
+    protected void generateSyntheticPartsAfterBody() {
+    }
+
     @Override
     protected void generateKotlinMetadataAnnotation() {
         generateKotlinClassMetadataAnnotation(scriptDescriptor, true);

compiler/backend/src/org/jetbrains/kotlin/codegen/StackValue.java

@@ -19,7 +19,6 @@ package org.jetbrains.kotlin.codegen;
 import com.intellij.psi.tree.IElementType;
 import kotlin.Unit;
 import kotlin.collections.ArraysKt;
-import kotlin.collections.CollectionsKt;
 import kotlin.jvm.functions.Function1;
 import org.jetbrains.annotations.Contract;
 import org.jetbrains.annotations.NotNull;
@@ -27,8 +26,6 @@ import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
 import org.jetbrains.kotlin.builtins.PrimitiveType;
 import org.jetbrains.kotlin.codegen.intrinsics.IntrinsicMethods;
-import org.jetbrains.kotlin.codegen.intrinsics.JavaClassProperty;
-import org.jetbrains.kotlin.codegen.state.GenerationState;
 import org.jetbrains.kotlin.codegen.state.KotlinTypeMapper;
 import org.jetbrains.kotlin.descriptors.*;
 import org.jetbrains.kotlin.descriptors.impl.SyntheticFieldDescriptor;
@@ -518,9 +515,11 @@ public abstract class StackValue {
                     descriptor
             );
             StackValue extensionReceiver = genReceiver(receiver, codegen, resolvedCall, callableMethod, callExtensionReceiver, true);
-            Type type = CallReceiver.calcType(resolvedCall, dispatchReceiverParameter, extensionReceiverParameter, codegen.typeMapper, callableMethod, codegen.getState());
-            assert type != null : "Could not map receiver type for " + resolvedCall;
-            return new CallReceiver(dispatchReceiver, extensionReceiver, type);
+            return CallReceiver.generateCallReceiver(
+                    resolvedCall, codegen, callableMethod,
+                    dispatchReceiverParameter, dispatchReceiver,
+                    extensionReceiverParameter, extensionReceiver
+            );
         }
         return receiver;
     }
@@ -569,14 +568,13 @@ public abstract class StackValue {
     }
 
     @Contract("null -> false")
-    private static boolean isLocalFunCall(@Nullable Callable callableMethod) {
+    static boolean isLocalFunCall(@Nullable Callable callableMethod) {
         return callableMethod != null && callableMethod.getGenerateCalleeType() != null;
     }
 
     public static StackValue receiverWithoutReceiverArgument(StackValue receiverWithParameter) {
         if (receiverWithParameter instanceof CallReceiver) {
-            CallReceiver callReceiver = (CallReceiver) receiverWithParameter;
-            return new CallReceiver(callReceiver.dispatchReceiver, none(), callReceiver.type);
+            return ((CallReceiver) receiverWithParameter).withoutReceiverArgument();
         }
         return receiverWithParameter;
     }
@@ -1517,101 +1515,6 @@ public abstract class StackValue {
         }
     }
 
-    public static class CallReceiver extends StackValue {
-        private final StackValue dispatchReceiver;
-        private final StackValue extensionReceiver;
-
-        public CallReceiver(
-                @NotNull StackValue dispatchReceiver,
-                @NotNull StackValue extensionReceiver,
-                @NotNull Type type
-        ) {
-            super(type, dispatchReceiver.canHaveSideEffects() || extensionReceiver.canHaveSideEffects());
-            this.dispatchReceiver = dispatchReceiver;
-            this.extensionReceiver = extensionReceiver;
-        }
-
-        @Nullable
-        public static Type calcType(
-                @NotNull ResolvedCall<?> resolvedCall,
-                @Nullable ReceiverParameterDescriptor dispatchReceiver,
-                @Nullable ReceiverParameterDescriptor extensionReceiver,
-                @NotNull KotlinTypeMapper typeMapper,
-                @Nullable Callable callableMethod,
-                @NotNull GenerationState state
-        ) {
-            if (extensionReceiver != null) {
-                CallableDescriptor descriptor = resolvedCall.getCandidateDescriptor();
-
-                if (descriptor instanceof PropertyDescriptor &&
-                    // hackaround: boxing changes behaviour of T.javaClass intrinsic
-                    state.getIntrinsics().getIntrinsic((PropertyDescriptor) descriptor) != JavaClassProperty.INSTANCE
-                ) {
-                    ReceiverParameterDescriptor receiverCandidate = descriptor.getExtensionReceiverParameter();
-                    assert receiverCandidate != null;
-                    return typeMapper.mapType(receiverCandidate.getType());
-                }
-
-                return callableMethod != null ? callableMethod.getExtensionReceiverType() : typeMapper.mapType(extensionReceiver.getType());
-            }
-            else if (dispatchReceiver != null) {
-                CallableDescriptor descriptor = resolvedCall.getResultingDescriptor();
-
-                if (CodegenUtilKt.isJvmStaticInObjectOrClass(descriptor)) {
-                    return Type.VOID_TYPE;
-                }
-
-                if (callableMethod != null) {
-                    return callableMethod.getDispatchReceiverType();
-                }
-
-                // Extract the receiver from the resolved call, workarounding the fact that ResolvedCall#dispatchReceiver doesn't have
-                // all the needed information, for example there's no way to find out whether or not a smart cast was applied to the receiver.
-                DeclarationDescriptor container = descriptor.getContainingDeclaration();
-                if (container instanceof ClassDescriptor) {
-                    return typeMapper.mapClass((ClassDescriptor) container);
-                }
-
-                return typeMapper.mapType(dispatchReceiver);
-            }
-            else if (isLocalFunCall(callableMethod)) {
-                return callableMethod.getGenerateCalleeType();
-            }
-
-            return Type.VOID_TYPE;
-        }
-
-        @Override
-        public void putSelector(@NotNull Type type, @NotNull InstructionAdapter v) {
-            StackValue currentExtensionReceiver = extensionReceiver;
-            boolean hasExtensionReceiver = extensionReceiver != none();
-            if (extensionReceiver instanceof StackValue.SafeCall) {
-                currentExtensionReceiver.put(currentExtensionReceiver.type, v);
-                currentExtensionReceiver = StackValue.onStack(currentExtensionReceiver.type);
-            }
-
-            dispatchReceiver.put(hasExtensionReceiver ? dispatchReceiver.type : type, v);
-
-            currentExtensionReceiver
-                    .moveToTopOfStack(hasExtensionReceiver ? type : currentExtensionReceiver.type, v, dispatchReceiver.type.getSize());
-        }
-
-        @Override
-        public void dup(@NotNull InstructionAdapter v, boolean withReceiver) {
-            AsmUtil.dup(v, extensionReceiver.type, dispatchReceiver.type);
-        }
-
-        @NotNull
-        public StackValue getDispatchReceiver() {
-            return dispatchReceiver;
-        }
-
-        @NotNull
-        public StackValue getExtensionReceiver() {
-            return extensionReceiver;
-        }
-    }
-
     public abstract static class StackValueWithSimpleReceiver extends StackValue {
 
         public final boolean isStaticPut;

compiler/backend/src/org/jetbrains/kotlin/codegen/annotation/AnnotatedWithOnlyTargetedAnnotations.kt

@@ -20,7 +20,6 @@ import org.jetbrains.kotlin.descriptors.annotations.Annotated
 import org.jetbrains.kotlin.descriptors.annotations.AnnotatedImpl
 import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptor
 import org.jetbrains.kotlin.descriptors.annotations.Annotations
-import org.jetbrains.kotlin.name.FqName
 
 interface WrappedAnnotated : Annotated {
     val originalAnnotated: Annotated
@@ -34,10 +33,6 @@ class AnnotatedWithOnlyTargetedAnnotations(original: Annotated) : Annotated {
     private class UseSiteTargetedAnnotations(private val additionalAnnotations: Annotations) : Annotations {
         override fun isEmpty() = true
 
-        override fun findAnnotation(fqName: FqName) = null
-
-        override fun findExternalAnnotation(fqName: FqName) = null
-
         override fun getUseSiteTargetedAnnotations() = getAdditionalTargetedAnnotations()
 
         override fun getAllAnnotations() = getAdditionalTargetedAnnotations()
@@ -48,4 +43,4 @@ class AnnotatedWithOnlyTargetedAnnotations(original: Annotated) : Annotated {
     }
 }
 
-class AnnotatedSimple(annotations: Annotations) : AnnotatedImpl(annotations)
+class AnnotatedSimple(annotations: Annotations) : AnnotatedImpl(annotations)

compiler/backend/src/org/jetbrains/kotlin/codegen/codegenUtil.kt

@@ -413,4 +413,10 @@ fun extractReificationArgument(type: KotlinType): Pair<TypeParameterDescriptor,
 }
 
 fun unwrapInitialSignatureDescriptor(function: FunctionDescriptor): FunctionDescriptor =
-        function.initialSignatureDescriptor ?: function
+        function.initialSignatureDescriptor ?: function
+
+fun ExpressionCodegen.generateCallReceiver(rangeCall: ResolvedCall<out CallableDescriptor>): StackValue =
+        generateReceiverValue(rangeCall.extensionReceiver ?: rangeCall.dispatchReceiver!!, false)
+
+fun ExpressionCodegen.generateCallSingleArgument(rangeCall: ResolvedCall<out CallableDescriptor>): StackValue =
+        gen(ExpressionCodegen.getSingleArgumentExpression(rangeCall)!!)

compiler/backend/src/org/jetbrains/kotlin/codegen/coroutines/CoroutineTransformerMethodVisitor.kt

@@ -111,12 +111,11 @@ class CoroutineTransformerMethodVisitor(
         methodNode.instructions.apply {
             val startLabel = LabelNode()
             val defaultLabel = LabelNode()
-            val firstToInsertBefore = actualCoroutineStart
             val tableSwitchLabel = LabelNode()
             val lineNumber = CodegenUtil.getLineNumberForElement(element, false) ?: 0
 
             // tableswitch(this.label)
-            insertBefore(firstToInsertBefore,
+            insertBefore(actualCoroutineStart,
                          insnListOf(
                                  *withInstructionAdapter { loadCoroutineSuspendedMarker() }.toArray(),
                                  tableSwitchLabel,

compiler/backend/src/org/jetbrains/kotlin/codegen/coroutines/refinedIntTypesAnalysis.kt

@@ -144,7 +144,7 @@ internal fun performRefinedTypeAnalysis(methodNode: MethodNode, thisName: String
         }
     })
 
-    val refinedFrames = Array(basicFrames.size) {
+    return Array(basicFrames.size) {
         insnIndex ->
         val current = Frame(basicFrames[insnIndex] ?: return@Array null)
 
@@ -158,8 +158,6 @@ internal fun performRefinedTypeAnalysis(methodNode: MethodNode, thisName: String
 
         current
     }
-
-    return refinedFrames
 }
 
 private fun AbstractInsnNode.isIntLoad() = opcode == Opcodes.ILOAD

compiler/backend/src/org/jetbrains/kotlin/codegen/forLoop/ForLoopGenerators.kt

@@ -1,99 +0,0 @@
-/*
- * Copyright 2010-2017 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.forLoop
-
-import org.jetbrains.kotlin.builtins.KotlinBuiltIns
-import org.jetbrains.kotlin.codegen.ExpressionCodegen
-import org.jetbrains.kotlin.codegen.RangeCodegenUtil
-import org.jetbrains.kotlin.descriptors.CallableDescriptor
-import org.jetbrains.kotlin.name.Name
-import org.jetbrains.kotlin.psi.*
-import org.jetbrains.kotlin.resolve.BindingContext
-import org.jetbrains.kotlin.resolve.calls.callUtil.getResolvedCall
-import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall
-import org.jetbrains.kotlin.types.KotlinType
-import org.jetbrains.kotlin.types.checker.KotlinTypeChecker
-import org.jetbrains.org.objectweb.asm.Type
-
-fun ExpressionCodegen.getForLoopGenerator(forExpression: KtForExpression) : AbstractForLoopGenerator {
-    getLoopRangeResolvedCall(forExpression, bindingContext)?.let { loopRangeCall ->
-        createOptimizedForLoopGeneratorOrNull(forExpression, loopRangeCall)?.let {
-            return it
-        }
-    }
-
-    val loopRange = forExpression.loopRange!!
-    val loopRangeType = bindingContext.getType(loopRange)!!
-    val asmLoopRangeType = asmType(loopRangeType)
-
-    return when {
-        asmLoopRangeType.sort == Type.ARRAY ->
-            ForInArrayLoopGenerator(this, forExpression)
-        RangeCodegenUtil.isRange(loopRangeType) ->
-            ForInRangeInstanceLoopGenerator(this, forExpression)
-        RangeCodegenUtil.isProgression(loopRangeType) ->
-            ForInProgressionExpressionLoopGenerator(this, forExpression)
-        isSubtypeOfCharSequence(loopRangeType, state.module.builtIns) ->
-            ForInCharSequenceLoopGenerator(this, forExpression)
-        else ->
-            IteratorForLoopGenerator(this, forExpression)
-    }
-}
-
-private fun isSubtypeOfCharSequence(type: KotlinType, builtIns: KotlinBuiltIns) =
-        KotlinTypeChecker.DEFAULT.isSubtypeOf(type, builtIns.getBuiltInClassByName(Name.identifier("CharSequence")).defaultType)
-
-private fun ExpressionCodegen.createOptimizedForLoopGeneratorOrNull(
-        forExpression: KtForExpression,
-        loopRangeCall: ResolvedCall<out CallableDescriptor>
-): AbstractForLoopGenerator? {
-    val loopRangeCallee = loopRangeCall.resultingDescriptor
-
-    return when {
-        RangeCodegenUtil.isPrimitiveNumberRangeTo(loopRangeCallee) ->
-            ForInRangeLiteralLoopGenerator(this, forExpression, loopRangeCall)
-        RangeCodegenUtil.isPrimitiveNumberDownTo(loopRangeCallee) ->
-            ForInDownToProgressionLoopGenerator(this, forExpression, loopRangeCall)
-        RangeCodegenUtil.isPrimitiveNumberUntil(loopRangeCallee) ->
-            ForInUntilRangeLoopGenerator(this, forExpression, loopRangeCall)
-        RangeCodegenUtil.isArrayOrPrimitiveArrayIndices(loopRangeCallee) ->
-            ForInArrayIndicesRangeLoopGenerator(this, forExpression, loopRangeCall)
-        RangeCodegenUtil.isCollectionIndices(loopRangeCallee) ->
-            ForInCollectionIndicesRangeLoopGenerator(this, forExpression, loopRangeCall)
-        RangeCodegenUtil.isCharSequenceIndices(loopRangeCallee) ->
-            ForInCharSequenceIndicesRangeLoopGenerator(this, forExpression, loopRangeCall)
-        else -> null
-    }
-}
-
-private fun getLoopRangeResolvedCall(forExpression: KtForExpression, bindingContext: BindingContext): ResolvedCall<out CallableDescriptor>? {
-    val loopRange = KtPsiUtil.deparenthesize(forExpression.loopRange)
-
-    when (loopRange) {
-        is KtQualifiedExpression -> {
-            val qualifiedExpression = loopRange as KtQualifiedExpression?
-            val selector = qualifiedExpression!!.selectorExpression
-            if (selector is KtCallExpression || selector is KtSimpleNameExpression) {
-                return selector.getResolvedCall(bindingContext)
-            }
-        }
-        is KtSimpleNameExpression, is KtCallExpression -> return loopRange.getResolvedCall(bindingContext)
-        is KtBinaryExpression -> return loopRange.operationReference.getResolvedCall(bindingContext)
-    }
-
-    return null
-}

compiler/backend/src/org/jetbrains/kotlin/codegen/inline/InlineCodegen.kt

@@ -460,7 +460,7 @@ abstract class InlineCodegen<out T: BaseExpressionCodegen>(
             if (isBuiltInArrayIntrinsic(callableDescriptor)) {
                 val classId = classId
                 val bytes = state.inlineCache.classBytes.getOrPut(classId) { bytecode }
-                return getMethodNode(bytes, asmMethod.name, asmMethod.descriptor, AsmUtil.asmTypeByClassId(classId))
+                return getMethodNode(bytes, asmMethod.name, asmMethod.descriptor, classId.asString())
             }
 
             assert(callableDescriptor is DeserializedCallableMemberDescriptor) { "Not a deserialized function or proper: " + callableDescriptor }
@@ -474,7 +474,7 @@ abstract class InlineCodegen<out T: BaseExpressionCodegen>(
                 throw IllegalStateException("Couldn't find declaration file for " + containerId)
             }
 
-            val methodNode = getMethodNode(bytes, asmMethod.name, asmMethod.descriptor, AsmUtil.asmTypeByClassId(containerId)) ?: return null
+            val methodNode = getMethodNode(bytes, asmMethod.name, asmMethod.descriptor, containerId.asString()) ?: return null
 
             // KLUDGE: Inline suspend function built with compiler version less than 1.1.4/1.2-M1 did not contain proper
             // before/after suspension point marks, so we detect those functions here and insert the corresponding marks

compiler/backend/src/org/jetbrains/kotlin/codegen/inline/LambdaInfo.kt

@@ -135,7 +135,7 @@ class DefaultLambda(
                 classReader.b,
                 "<init>",
                 descriptor,
-                lambdaClassType)?.node
+                lambdaClassType.internalName)?.node
 
         assert(constructor != null || capturedArgs.isEmpty()) {
             "Can't find non-default constructor <init>$descriptor for default lambda $lambdaClassType"
@@ -164,7 +164,7 @@ class DefaultLambda(
                 classReader.b,
                 invokeMethod.name,
                 invokeMethod.descriptor,
-                lambdaClassType)!!
+                lambdaClassType.internalName)!!
 
         if (needReification) {
             //nested classes could also require reification

compiler/backend/src/org/jetbrains/kotlin/codegen/inline/MethodInliner.kt

@@ -619,11 +619,11 @@ class MethodInliner(
     }
 
     private fun wrapException(originalException: Throwable, node: MethodNode, errorSuffix: String): RuntimeException {
-        if (originalException is InlineException) {
-            return InlineException("$errorPrefix: $errorSuffix", originalException)
+        return if (originalException is InlineException) {
+            InlineException("$errorPrefix: $errorSuffix", originalException)
         }
         else {
-            return InlineException("$errorPrefix: $errorSuffix\nCause: ${node.nodeText}", originalException)
+            InlineException("$errorPrefix: $errorSuffix\nCause: ${node.nodeText}", originalException)
         }
     }
 
@@ -679,11 +679,11 @@ class MethodInliner(
             localReturns.add(LocalReturn(returnInsn, insertBeforeInsn, sourceValueFrame))
 
             if (returnInsn.opcode != Opcodes.RETURN) {
-                if (returnInsn.opcode == Opcodes.LRETURN || returnInsn.opcode == Opcodes.DRETURN) {
-                    returnVariableSize = 2
+                returnVariableSize = if (returnInsn.opcode == Opcodes.LRETURN || returnInsn.opcode == Opcodes.DRETURN) {
+                    2
                 }
                 else {
-                    returnVariableSize = 1
+                    1
                 }
             }
         }
@@ -716,10 +716,9 @@ class MethodInliner(
                 "Captured field template should start with $CAPTURED_FIELD_FOLD_PREFIX prefix"
             }
             val fin = FieldInsnNode(node.opcode, node.owner, node.name.substring(3), node.desc)
-            val field = fieldRemapper.findField(fin) ?: throw IllegalStateException(
+            return fieldRemapper.findField(fin) ?: throw IllegalStateException(
                     "Couldn't find captured field ${node.owner}.${node.name} in ${fieldRemapper.originalLambdaInternalName}"
             )
-            return field
         }
 
         private fun analyzeMethodNodeWithoutMandatoryTransformations(node: MethodNode): Array<Frame<SourceValue>?> {

compiler/backend/src/org/jetbrains/kotlin/codegen/inline/SMAP.kt

@@ -98,8 +98,8 @@ open class NestedSourceMapper(
     override fun mapLineNumber(lineNumber: Int): Int {
         val mappedLineNumber = visitedLines.get(lineNumber)
 
-        if (mappedLineNumber > 0) {
-            return mappedLineNumber
+        return if (mappedLineNumber > 0) {
+            mappedLineNumber
         }
         else {
             val rangeForMapping =
@@ -111,7 +111,7 @@ open class NestedSourceMapper(
                 visitedLines.put(lineNumber, newLineNumber)
             }
             lastVisitedRange = rangeForMapping
-            return newLineNumber
+            newLineNumber
         }
     }
 

compiler/backend/src/org/jetbrains/kotlin/codegen/inline/SourceCompilerForInline.kt

@@ -29,7 +29,6 @@ import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils
 import org.jetbrains.kotlin.resolve.DescriptorUtils
 import org.jetbrains.kotlin.resolve.calls.callUtil.getResolvedCallWithAssert
 import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodSignature
-import org.jetbrains.kotlin.utils.addIfNotNull
 import org.jetbrains.org.objectweb.asm.Label
 import org.jetbrains.org.objectweb.asm.MethodVisitor
 import org.jetbrains.org.objectweb.asm.Opcodes
@@ -95,8 +94,6 @@ class PsiSourceCompilerForInline(private val codegen: ExpressionCodegen, overrid
 
     private var context by Delegates.notNull<CodegenContext<*>>()
 
-    private var additionalInnerClasses = mutableListOf<ClassDescriptor>()
-
     override val lookupLocation = KotlinLookupLocation(callElement)
 
 
@@ -167,15 +164,12 @@ class PsiSourceCompilerForInline(private val codegen: ExpressionCodegen, overrid
                 if (isLambda)
                     codegen.parentCodegen.className
                 else
-                    state.typeMapper.mapImplementationOwner(descriptor).internalName,
-                if (isLambda) emptyList() else additionalInnerClasses,
-                isLambda
+                    state.typeMapper.mapImplementationOwner(descriptor).internalName
         )
 
         val strategy = when (expression) {
             is KtCallableReferenceExpression -> {
-                val callableReferenceExpression = expression
-                val receiverExpression = callableReferenceExpression.receiverExpression
+                val receiverExpression = expression.receiverExpression
                 val receiverType = if (receiverExpression != null && state.bindingContext.getType(receiverExpression) != null)
                     state.typeMapper.mapType(state.bindingContext.getType(receiverExpression)!!)
                 else
@@ -192,7 +186,7 @@ class PsiSourceCompilerForInline(private val codegen: ExpressionCodegen, overrid
                     FunctionReferenceGenerationStrategy(
                             state,
                             descriptor,
-                            callableReferenceExpression.callableReference
+                            expression.callableReference
                                     .getResolvedCallWithAssert(state.bindingContext),
                             receiverType, null,
                             true
@@ -228,9 +222,7 @@ class PsiSourceCompilerForInline(private val codegen: ExpressionCodegen, overrid
             internal val delegate: MemberCodegen<*>,
             declaration: KtElement,
             codegenContext: FieldOwnerContext<*>,
-            private val className: String,
-            private val parentAsInnerClasses: List<ClassDescriptor>,
-            private val isInlineLambdaCodegen: Boolean
+            private val className: String
     ) : MemberCodegen<KtPureElement>(delegate as MemberCodegen<KtPureElement>, declaration, codegenContext) {
 
         override fun generateDeclaration() {
@@ -254,14 +246,6 @@ class PsiSourceCompilerForInline(private val codegen: ExpressionCodegen, overrid
             return className
         }
 
-        override fun addParentsToInnerClassesIfNeeded(innerClasses: MutableCollection<ClassDescriptor>) {
-            if (isInlineLambdaCodegen) {
-                super.addParentsToInnerClassesIfNeeded(innerClasses)
-            }
-            else {
-                innerClasses.addAll(parentAsInnerClasses)
-            }
-        }
     }
 
     override fun doCreateMethodNodeFromSource(
@@ -294,9 +278,7 @@ class PsiSourceCompilerForInline(private val codegen: ExpressionCodegen, overrid
             val implementationOwner = state.typeMapper.mapImplementationOwner(callableDescriptor)
             val parentCodegen = FakeMemberCodegen(
                     codegen.parentCodegen, inliningFunction!!, methodContext.parentContext as FieldOwnerContext<*>,
-                    implementationOwner.internalName,
-                    additionalInnerClasses,
-                    false
+                    implementationOwner.internalName
             )
             if (element !is KtNamedFunction) {
                 throw IllegalStateException("Property accessors with default parameters not supported " + callableDescriptor)
@@ -407,25 +389,22 @@ class PsiSourceCompilerForInline(private val codegen: ExpressionCodegen, overrid
     }
 
     override fun initializeInlineFunctionContext(functionDescriptor: FunctionDescriptor) {
-        context = getContext(functionDescriptor, functionDescriptor, state, DescriptorToSourceUtils.descriptorToDeclaration(functionDescriptor)?.containingFile as? KtFile, additionalInnerClasses)
+        context = getContext(functionDescriptor, state, DescriptorToSourceUtils.descriptorToDeclaration(functionDescriptor)?.containingFile as? KtFile)
     }
 
     companion object {
         fun getContext(
-                descriptor: DeclarationDescriptor, innerDescriptor: DeclarationDescriptor, state: GenerationState, sourceFile: KtFile?, additionalInners: MutableList<ClassDescriptor>
+                descriptor: DeclarationDescriptor, state: GenerationState, sourceFile: KtFile?
         ): CodegenContext<*> {
             if (descriptor is PackageFragmentDescriptor) {
-                //no inners
                 return PackageContext(descriptor, state.rootContext, null, sourceFile)
             }
 
             val container = descriptor.containingDeclaration ?: error("No container for descriptor: " + descriptor)
             val parent = getContext(
                     container,
-                    descriptor,
                     state,
-                    sourceFile,
-                    additionalInners
+                    sourceFile
             )
 
             return when (descriptor) {
@@ -438,14 +417,7 @@ class PsiSourceCompilerForInline(private val codegen: ExpressionCodegen, overrid
                     )
                 }
                 is ClassDescriptor -> {
-                    val kind =
-                            if (DescriptorUtils.isInterface(descriptor) && innerDescriptor !is ClassDescriptor)
-                                OwnerKind.DEFAULT_IMPLS
-                            else OwnerKind.IMPLEMENTATION
-
-                    additionalInners.addIfNotNull(
-                            InnerClassConsumer.classForInnerClassRecord(descriptor, kind == OwnerKind.DEFAULT_IMPLS)
-                    )
+                    val kind = if (DescriptorUtils.isInterface(descriptor)) OwnerKind.DEFAULT_IMPLS else OwnerKind.IMPLEMENTATION
                     parent.intoClass(descriptor, kind, state)
                 }
                 is FunctionDescriptor -> {

compiler/backend/src/org/jetbrains/kotlin/codegen/inline/inlineCodegenUtils.kt

@@ -89,13 +89,12 @@ private const val INLINE_MARKER_FINALLY_START = "finallyStart"
 private const val INLINE_MARKER_FINALLY_END = "finallyEnd"
 private const val INLINE_MARKER_BEFORE_SUSPEND_ID = 0
 private const val INLINE_MARKER_AFTER_SUSPEND_ID = 1
-private val INTRINSIC_ARRAY_CONSTRUCTOR_TYPE = AsmUtil.asmTypeByClassId(classId)
 
 internal fun getMethodNode(
         classData: ByteArray,
         methodName: String,
         methodDescriptor: String,
-        classType: Type
+        classInternalName: String
 ): SMAPAndMethodNode? {
     val cr = ClassReader(classData)
     var node: MethodNode? = null
@@ -137,12 +136,12 @@ internal fun getMethodNode(
         return null
     }
 
-    if (INTRINSIC_ARRAY_CONSTRUCTOR_TYPE == classType) {
+    if (classId.asString() == classInternalName) {
         // Don't load source map for intrinsic array constructors
         debugInfo[0] = null
     }
 
-    val smap = SMAPParser.parseOrCreateDefault(debugInfo[1], debugInfo[0], classType.internalName, lines[0], lines[1])
+    val smap = SMAPParser.parseOrCreateDefault(debugInfo[1], debugInfo[0], classInternalName, lines[0], lines[1])
     return SMAPAndMethodNode(node!!, smap)
 }
 
@@ -287,9 +286,8 @@ internal fun getMarkedReturnLabelOrNull(returnInsn: AbstractInsnNode): String? {
     }
     val previous = returnInsn.previous
     if (previous is MethodInsnNode) {
-        val marker = previous
-        if (NON_LOCAL_RETURN == marker.owner) {
-            return marker.name
+        if (NON_LOCAL_RETURN == previous.owner) {
+            return previous.name
         }
     }
     return null
@@ -458,13 +456,12 @@ private fun isInlineMarker(insn: AbstractInsnNode, name: String?): Boolean {
         return false
     }
 
-    val methodInsnNode = insn
     return insn.getOpcode() == Opcodes.INVOKESTATIC &&
-           methodInsnNode.owner == INLINE_MARKER_CLASS_NAME &&
+           insn.owner == INLINE_MARKER_CLASS_NAME &&
            if (name != null)
-               methodInsnNode.name == name
+               insn.name == name
            else
-               methodInsnNode.name == INLINE_MARKER_BEFORE_METHOD_NAME || methodInsnNode.name == INLINE_MARKER_AFTER_METHOD_NAME
+               insn.name == INLINE_MARKER_BEFORE_METHOD_NAME || insn.name == INLINE_MARKER_AFTER_METHOD_NAME
 }
 
 internal fun isBeforeInlineMarker(insn: AbstractInsnNode): Boolean {

compiler/backend/src/org/jetbrains/kotlin/codegen/intrinsics/IntrinsicArrayConstructors.kt

@@ -40,7 +40,7 @@ private inline fun <reified T> arrayOf(vararg elements: T): Array<T> = elements
 
 private inline fun <reified T> Array(size: Int, init: (Int) -> T): Array<T> {
     val result = arrayOfNulls<T>(size)
-    for (i in 0..size - 1) {
+    for (i in result.indices) {
         result[i] = init(i)
     }
     return result as Array<T>
@@ -48,7 +48,7 @@ private inline fun <reified T> Array(size: Int, init: (Int) -> T): Array<T> {
 
 private inline fun DoubleArray(size: Int, init: (Int) -> Double): DoubleArray {
     val result = DoubleArray(size)
-    for (i in 0..size - 1) {
+    for (i in result.indices) {
         result[i] = init(i)
     }
     return result
@@ -56,7 +56,7 @@ private inline fun DoubleArray(size: Int, init: (Int) -> Double): DoubleArray {
 
 private inline fun FloatArray(size: Int, init: (Int) -> Float): FloatArray {
     val result = FloatArray(size)
-    for (i in 0..size - 1) {
+    for (i in result.indices) {
         result[i] = init(i)
     }
     return result
@@ -64,7 +64,7 @@ private inline fun FloatArray(size: Int, init: (Int) -> Float): FloatArray {
 
 private inline fun LongArray(size: Int, init: (Int) -> Long): LongArray {
     val result = LongArray(size)
-    for (i in 0..size - 1) {
+    for (i in result.indices) {
         result[i] = init(i)
     }
     return result
@@ -72,7 +72,7 @@ private inline fun LongArray(size: Int, init: (Int) -> Long): LongArray {
 
 private inline fun IntArray(size: Int, init: (Int) -> Int): IntArray {
     val result = IntArray(size)
-    for (i in 0..size - 1) {
+    for (i in result.indices) {
         result[i] = init(i)
     }
     return result
@@ -80,7 +80,7 @@ private inline fun IntArray(size: Int, init: (Int) -> Int): IntArray {
 
 private inline fun CharArray(size: Int, init: (Int) -> Char): CharArray {
     val result = CharArray(size)
-    for (i in 0..size - 1) {
+    for (i in result.indices) {
         result[i] = init(i)
     }
     return result
@@ -88,7 +88,7 @@ private inline fun CharArray(size: Int, init: (Int) -> Char): CharArray {
 
 private inline fun ShortArray(size: Int, init: (Int) -> Short): ShortArray {
     val result = ShortArray(size)
-    for (i in 0..size - 1) {
+    for (i in result.indices) {
         result[i] = init(i)
     }
     return result
@@ -96,7 +96,7 @@ private inline fun ShortArray(size: Int, init: (Int) -> Short): ShortArray {
 
 private inline fun ByteArray(size: Int, init: (Int) -> Byte): ByteArray {
     val result = ByteArray(size)
-    for (i in 0..size - 1) {
+    for (i in result.indices) {
         result[i] = init(i)
     }
     return result
@@ -104,7 +104,7 @@ private inline fun ByteArray(size: Int, init: (Int) -> Byte): ByteArray {
 
 private inline fun BooleanArray(size: Int, init: (Int) -> Boolean): BooleanArray {
     val result = BooleanArray(size)
-    for (i in 0..size - 1) {
+    for (i in result.indices) {
         result[i] = init(i)
     }
     return result

compiler/backend/src/org/jetbrains/kotlin/codegen/intrinsics/StringPlus.kt

@@ -22,7 +22,7 @@ import org.jetbrains.kotlin.codegen.CallableMethod
 class StringPlus : IntrinsicMethod() {
     override fun toCallable(method: CallableMethod): Callable =
             createIntrinsicCallable(method) {
-                it.invokestatic("kotlin/jvm/internal/Intrinsics", "stringPlus",
+                it.invokestatic(IntrinsicMethods.INTRINSICS_CLASS_NAME, "stringPlus",
                                 "(Ljava/lang/String;Ljava/lang/Object;)Ljava/lang/String;", false)
             }
 }

compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/CapturedVarsOptimizationMethodTransformer.kt

@@ -232,17 +232,15 @@ class CapturedVarsOptimizationMethodTransformer : MethodTransformer() {
         }
 
         private fun findCleanInstructions(refValue: CapturedVarDescriptor, oldVarIndex: Int, instructions: InsnList): List<VarInsnNode> {
-            val cleanInstructions =
-                InsnSequence(instructions).filterIsInstance<VarInsnNode>().filter {
-                    it.opcode == Opcodes.ASTORE && it.`var` == oldVarIndex
-                }.filter {
-                    it.previous?.opcode == Opcodes.ACONST_NULL
-                }.filter {
-                    val operationIndex = instructions.indexOf(it)
-                    val localVariableNode = refValue.localVar!!
-                    instructions.indexOf(localVariableNode.start) < operationIndex && operationIndex < instructions.indexOf(localVariableNode.end)
-                }.toList()
-            return cleanInstructions
+            return InsnSequence(instructions).filterIsInstance<VarInsnNode>().filter {
+                it.opcode == Opcodes.ASTORE && it.`var` == oldVarIndex
+            }.filter {
+                it.previous?.opcode == Opcodes.ACONST_NULL
+            }.filter {
+                val operationIndex = instructions.indexOf(it)
+                val localVariableNode = refValue.localVar!!
+                instructions.indexOf(localVariableNode.start) < operationIndex && operationIndex < instructions.indexOf(localVariableNode.end)
+            }.toList()
         }
 
         private fun rewrite() {

compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/MethodVerifier.kt

@@ -0,0 +1,32 @@
+/*
+ * Copyright 2010-2017 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.tree.MethodNode
+import org.jetbrains.org.objectweb.asm.tree.analysis.BasicVerifier
+
+class MethodVerifier(private val checkPoint: String) : MethodTransformer() {
+    override fun transform(internalClassName: String, methodNode: MethodNode) {
+        try {
+            analyze(internalClassName, methodNode, BasicVerifier())
+        }
+        catch (e: Throwable) {
+            throw AssertionError("$checkPoint: incorrect bytecode", e)
+        }
+    }
+}

compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/OptimizationMethodVisitor.kt

@@ -17,7 +17,7 @@
 package org.jetbrains.kotlin.codegen.optimization
 
 import org.jetbrains.kotlin.codegen.TransformationMethodVisitor
-import org.jetbrains.kotlin.codegen.optimization.boxing.FastPopBackwardPropagationTransformer
+import org.jetbrains.kotlin.codegen.optimization.boxing.StackPeepholeOptimizationsTransformer
 import org.jetbrains.kotlin.codegen.optimization.boxing.RedundantBoxingMethodTransformer
 import org.jetbrains.kotlin.codegen.optimization.boxing.PopBackwardPropagationTransformer
 import org.jetbrains.kotlin.codegen.optimization.common.prepareForEmitting
@@ -47,7 +47,10 @@ class OptimizationMethodVisitor(
     companion object {
         private val MEMORY_LIMIT_BY_METHOD_MB = 50
 
-        private val MANDATORY_METHOD_TRANSFORMER = FixStackWithLabelNormalizationMethodTransformer()
+        private val MANDATORY_METHOD_TRANSFORMER = CompositeMethodTransformer(
+                FixStackWithLabelNormalizationMethodTransformer(),
+                MethodVerifier("AFTER mandatory stack transformations")
+        )
 
         private val OPTIMIZATION_TRANSFORMER = CompositeMethodTransformer(
                 CapturedVarsOptimizationMethodTransformer(),
@@ -55,11 +58,12 @@ class OptimizationMethodVisitor(
                 RedundantCheckCastEliminationMethodTransformer(),
                 ConstantConditionEliminationMethodTransformer(),
                 RedundantBoxingMethodTransformer(),
-                FastPopBackwardPropagationTransformer(),
+                StackPeepholeOptimizationsTransformer(),
                 PopBackwardPropagationTransformer(),
                 DeadCodeEliminationMethodTransformer(),
                 RedundantGotoMethodTransformer(),
-                RedundantNopsCleanupMethodTransformer()
+                RedundantNopsCleanupMethodTransformer(),
+                MethodVerifier("AFTER optimizations")
         )
 
         fun canBeOptimized(node: MethodNode): Boolean {

compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/boxing/BoxingInterpreter.kt

@@ -18,8 +18,8 @@ package org.jetbrains.kotlin.codegen.optimization.boxing
 
 import com.google.common.collect.ImmutableSet
 import org.jetbrains.kotlin.codegen.AsmUtil
-import org.jetbrains.kotlin.codegen.RangeCodegenUtil
 import org.jetbrains.kotlin.codegen.intrinsics.IntrinsicMethods
+import org.jetbrains.kotlin.codegen.isRangeOrProgression
 import org.jetbrains.kotlin.codegen.optimization.common.OptimizationBasicInterpreter
 import org.jetbrains.kotlin.codegen.optimization.common.StrictBasicValue
 import org.jetbrains.kotlin.name.FqName
@@ -213,7 +213,7 @@ fun AbstractInsnNode.isIteratorMethodCallOfProgression(values: List<BasicValue>)
         }
 
 fun isProgressionClass(type: Type) =
-        RangeCodegenUtil.isRangeOrProgression(buildFqNameByInternal(type.internalName))
+        isRangeOrProgression(buildFqNameByInternal(type.internalName))
 
 fun AbstractInsnNode.isAreEqualIntrinsicForSameTypedBoxedValues(values: List<BasicValue>) =
         isAreEqualIntrinsic() && areSameTypedBoxedValues(values)

compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/boxing/FastPopBackwardPropagationTransformer.kt

@@ -1,88 +0,0 @@
-/*
- * Copyright 2010-2017 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.boxing
-
-import org.jetbrains.kotlin.codegen.optimization.transformer.MethodTransformer
-import org.jetbrains.org.objectweb.asm.Opcodes
-import org.jetbrains.org.objectweb.asm.tree.AbstractInsnNode
-import org.jetbrains.org.objectweb.asm.tree.InsnNode
-import org.jetbrains.org.objectweb.asm.tree.MethodNode
-
-class FastPopBackwardPropagationTransformer : MethodTransformer() {
-    override fun transform(internalClassName: String, methodNode: MethodNode) {
-        while (transformOnce(methodNode)) {
-        }
-    }
-
-    private fun transformOnce(methodNode: MethodNode): Boolean {
-        val toRemove = ArrayList<AbstractInsnNode>()
-        val toReplaceWithNop = ArrayList<AbstractInsnNode>()
-
-        val insns = methodNode.instructions.toArray()
-
-        for (i in 1 until insns.size) {
-            val insn = insns[i]
-            val prev = insns[i - 1]
-
-            when (insn.opcode) {
-                Opcodes.POP -> {
-                    if (prev.isEliminatedByPop()) {
-                        toReplaceWithNop.add(insn)
-                        toRemove.add(prev)
-                    }
-                }
-
-                Opcodes.POP2 -> {
-                    if (prev.isEliminatedByPop2()) {
-                        toReplaceWithNop.add(insn)
-                        toRemove.add(prev)
-                    }
-                    else if (i > 1) {
-                        val prev2 = insns[i - 2]
-                        if (prev.isEliminatedByPop() && prev2.isEliminatedByPop()) {
-                            toReplaceWithNop.add(insn)
-                            toRemove.add(prev)
-                            toRemove.add(prev2)
-                        }
-                    }
-                }
-            }
-        }
-
-        toReplaceWithNop.forEach { methodNode.instructions.set(it, InsnNode(Opcodes.NOP)) }
-        toRemove.forEach { methodNode.instructions.remove(it) }
-
-        return toReplaceWithNop.isNotEmpty() &&
-               toRemove.isNotEmpty()
-    }
-
-    private fun AbstractInsnNode.isEliminatedByPop() =
-            opcode in Opcodes.ACONST_NULL..Opcodes.FCONST_2 ||
-            opcode in Opcodes.BIPUSH..Opcodes.ILOAD ||
-            opcode == Opcodes.FLOAD ||
-            opcode == Opcodes.ALOAD ||
-            isUnitInstance() ||
-            opcode == Opcodes.DUP
-
-    private fun AbstractInsnNode.isEliminatedByPop2() =
-            opcode == Opcodes.LCONST_0 || opcode == Opcodes.LCONST_1 ||
-            opcode == Opcodes.DCONST_0 || opcode == Opcodes.DCONST_1 ||
-            opcode == Opcodes.LLOAD ||
-            opcode == Opcodes.DLOAD ||
-            opcode == Opcodes.DUP2
-}
-

compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/boxing/PopBackwardPropagationTransformer.kt

@@ -17,8 +17,10 @@
 package org.jetbrains.kotlin.codegen.optimization.boxing
 
 import org.jetbrains.kotlin.codegen.optimization.OptimizationMethodVisitor
+import org.jetbrains.kotlin.codegen.optimization.common.debugText
 import org.jetbrains.kotlin.codegen.optimization.common.isLoadOperation
 import org.jetbrains.kotlin.codegen.optimization.common.isMeaningful
+import org.jetbrains.kotlin.codegen.optimization.fixStack.peekWords
 import org.jetbrains.kotlin.codegen.optimization.fixStack.top
 import org.jetbrains.kotlin.codegen.optimization.removeNodeGetNext
 import org.jetbrains.kotlin.codegen.optimization.transformer.MethodTransformer
@@ -74,46 +76,84 @@ class PopBackwardPropagationTransformer : MethodTransformer() {
             postprocessNops()
         }
 
-        private fun analyzeMethodBody(): Array<out Frame<SourceValue>?> =
-                Analyzer<SourceValue>(object : SourceInterpreter() {
-                    override fun naryOperation(insn: AbstractInsnNode, values: MutableList<out SourceValue>): SourceValue {
-                        for (value in values) {
-                            value.insns.markAsDontTouch()
-                        }
-                        return super.naryOperation(insn, values)
-                    }
+        private fun analyzeMethodBody(): Array<out Frame<SourceValue>?> {
+            val frames = Analyzer<SourceValue>(HazardsTrackingInterpreter()).analyze("fake", methodNode)
 
-                    override fun copyOperation(insn: AbstractInsnNode, value: SourceValue): SourceValue {
-                        value.insns.markAsDontTouch()
-                        return super.copyOperation(insn, value)
-                    }
+            postprocessDupNxM(frames)
 
-                    override fun unaryOperation(insn: AbstractInsnNode, value: SourceValue): SourceValue {
-                        if (insn.opcode != Opcodes.CHECKCAST && !insn.isPrimitiveTypeConversion()) {
-                            value.insns.markAsDontTouch()
-                        }
-                        return super.unaryOperation(insn, value)
-                    }
+            return frames
+        }
 
-                    override fun binaryOperation(insn: AbstractInsnNode, value1: SourceValue, value2: SourceValue): SourceValue {
-                        value1.insns.markAsDontTouch()
-                        value2.insns.markAsDontTouch()
-                        return super.binaryOperation(insn, value1, value2)
-                    }
+        private fun postprocessDupNxM(frames: Array<out Frame<SourceValue>?>) {
+            val insns = methodNode.instructions.toArray()
+            for (i in frames.indices) {
+                val frame = frames[i] ?: continue
+                val insn = insns[i]
 
-                    override fun ternaryOperation(insn: AbstractInsnNode, value1: SourceValue, value2: SourceValue, value3: SourceValue): SourceValue {
-                        value1.insns.markAsDontTouch()
-                        value2.insns.markAsDontTouch()
-                        value3.insns.markAsDontTouch()
-                        return super.ternaryOperation(insn, value1, value2, value3)
+                when (insn.opcode) {
+                    Opcodes.DUP_X1 -> {
+                        val top2 = frame.peekWords(1, 1) ?: throwIncorrectBytecode(insn, frame)
+                        top2.forEach { it.insns.markAsDontTouch() }
                     }
+                    Opcodes.DUP2_X1 -> {
+                        val top3 = frame.peekWords(2, 1) ?: throwIncorrectBytecode(insn, frame)
+                        top3.forEach { it.insns.markAsDontTouch() }
+                    }
+                    Opcodes.DUP_X2 -> {
+                        val top3 = frame.peekWords(1, 2) ?: throwIncorrectBytecode(insn, frame)
+                        top3.forEach { it.insns.markAsDontTouch() }
+                    }
+                    Opcodes.DUP2_X2 -> {
+                        val top4 = frame.peekWords(2, 2) ?: throwIncorrectBytecode(insn, frame)
+                        top4.forEach { it.insns.markAsDontTouch() }
+                    }
+                }
+            }
+        }
 
-                    private fun Collection<AbstractInsnNode>.markAsDontTouch() {
-                        forEach {
-                            dontTouchInsnIndices[insnList.indexOf(it)] = true
-                        }
-                    }
-                }).analyze("fake", methodNode)
+        private fun throwIncorrectBytecode(insn: AbstractInsnNode?, frame: Frame<SourceValue>): Nothing {
+            throw AssertionError("Incorrect bytecode at ${methodNode.instructions.indexOf(insn)}: ${insn.debugText} $frame")
+        }
+
+        private inner class HazardsTrackingInterpreter : SourceInterpreter() {
+            override fun naryOperation(insn: AbstractInsnNode, values: MutableList<out SourceValue>): SourceValue {
+                for (value in values) {
+                    value.insns.markAsDontTouch()
+                }
+                return super.naryOperation(insn, values)
+            }
+
+            override fun copyOperation(insn: AbstractInsnNode, value: SourceValue): SourceValue {
+                value.insns.markAsDontTouch()
+                return super.copyOperation(insn, value)
+            }
+
+            override fun unaryOperation(insn: AbstractInsnNode, value: SourceValue): SourceValue {
+                if (insn.opcode != Opcodes.CHECKCAST && !insn.isPrimitiveTypeConversion()) {
+                    value.insns.markAsDontTouch()
+                }
+                return super.unaryOperation(insn, value)
+            }
+
+            override fun binaryOperation(insn: AbstractInsnNode, value1: SourceValue, value2: SourceValue): SourceValue {
+                value1.insns.markAsDontTouch()
+                value2.insns.markAsDontTouch()
+                return super.binaryOperation(insn, value1, value2)
+            }
+
+            override fun ternaryOperation(insn: AbstractInsnNode, value1: SourceValue, value2: SourceValue, value3: SourceValue): SourceValue {
+                value1.insns.markAsDontTouch()
+                value2.insns.markAsDontTouch()
+                value3.insns.markAsDontTouch()
+                return super.ternaryOperation(insn, value1, value2, value3)
+            }
+        }
+
+        private fun Collection<AbstractInsnNode>.markAsDontTouch() {
+            forEach {
+                dontTouchInsnIndices[insnList.indexOf(it)] = true
+            }
+        }
 
 
         private fun computeTransformations() {

compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/boxing/ProgressionIteratorBasicValue.java

@@ -20,7 +20,7 @@ import com.google.common.collect.ImmutableMap;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.builtins.PrimitiveType;
-import org.jetbrains.kotlin.codegen.RangeCodegenUtil;
+import org.jetbrains.kotlin.codegen.RangeCodegenUtilKt;
 import org.jetbrains.kotlin.codegen.intrinsics.IteratorNext;
 import org.jetbrains.kotlin.codegen.optimization.common.StrictBasicValue;
 import org.jetbrains.kotlin.name.FqName;
@@ -32,7 +32,7 @@ public class ProgressionIteratorBasicValue extends StrictBasicValue {
     private final static ImmutableMap<String, Type> VALUES_TYPENAME_TO_TYPE;
     static {
         ImmutableMap.Builder<String, Type> builder = ImmutableMap.builder();
-        for (PrimitiveType primitiveType : RangeCodegenUtil.supportedRangeTypes()) {
+        for (PrimitiveType primitiveType : RangeCodegenUtilKt.getSupportedRangeTypes()) {
             builder.put(primitiveType.getTypeName().asString(), Type.getType(JvmPrimitiveType.get(primitiveType).getDesc()));
         }
         VALUES_TYPENAME_TO_TYPE = builder.build();
@@ -41,7 +41,7 @@ public class ProgressionIteratorBasicValue extends StrictBasicValue {
     private static final ImmutableMap<PrimitiveType, ProgressionIteratorBasicValue> ITERATOR_VALUE_BY_ELEMENT_PRIMITIVE_TYPE;
     static {
         ImmutableMap.Builder<PrimitiveType, ProgressionIteratorBasicValue> builder = ImmutableMap.builder();
-        for (PrimitiveType elementType : RangeCodegenUtil.supportedRangeTypes()) {
+        for (PrimitiveType elementType : RangeCodegenUtilKt.getSupportedRangeTypes()) {
             builder.put(elementType, new ProgressionIteratorBasicValue(elementType.getTypeName().asString()));
         }
         ITERATOR_VALUE_BY_ELEMENT_PRIMITIVE_TYPE = builder.build();
@@ -67,7 +67,7 @@ public class ProgressionIteratorBasicValue extends StrictBasicValue {
     @Nullable
     public static ProgressionIteratorBasicValue byProgressionClassType(@NotNull Type progressionClassType) {
         FqName classFqName = new FqName(progressionClassType.getClassName());
-        PrimitiveType elementType = RangeCodegenUtil.getPrimitiveRangeOrProgressionElementType(classFqName);
+        PrimitiveType elementType = RangeCodegenUtilKt.getPrimitiveRangeOrProgressionElementType(classFqName);
         return ITERATOR_VALUE_BY_ELEMENT_PRIMITIVE_TYPE.get(elementType);
     }
 

compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/boxing/StackPeepholeOptimizationsTransformer.kt

@@ -0,0 +1,135 @@
+/*
+ * Copyright 2010-2017 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.boxing
+
+import org.jetbrains.kotlin.codegen.optimization.common.findPreviousOrNull
+import org.jetbrains.kotlin.codegen.optimization.transformer.MethodTransformer
+import org.jetbrains.org.objectweb.asm.Opcodes
+import org.jetbrains.org.objectweb.asm.tree.AbstractInsnNode
+import org.jetbrains.org.objectweb.asm.tree.InsnList
+import org.jetbrains.org.objectweb.asm.tree.InsnNode
+import org.jetbrains.org.objectweb.asm.tree.MethodNode
+
+class StackPeepholeOptimizationsTransformer : MethodTransformer() {
+    override fun transform(internalClassName: String, methodNode: MethodNode) {
+        while (transformOnce(methodNode)) {
+        }
+    }
+
+    private fun transformOnce(methodNode: MethodNode): Boolean {
+        val actions = ArrayList<(InsnList) -> Unit>()
+
+        val insns = methodNode.instructions.toArray()
+
+        forInsn@ for (i in 1 until insns.size) {
+            val insn = insns[i]
+            val prev = insn.previous
+            val prevNonNop = insn.findPreviousOrNull { it.opcode != Opcodes.NOP } ?: continue@forInsn
+
+            when (insn.opcode) {
+                Opcodes.POP -> {
+                    when {
+                        prevNonNop.isEliminatedByPop() -> actions.add {
+                            it.set(insn, InsnNode(Opcodes.NOP))
+                            it.remove(prevNonNop)
+                        }
+                        prevNonNop.opcode == Opcodes.DUP_X1 -> actions.add {
+                            it.remove(insn)
+                            it.set(prevNonNop, InsnNode(Opcodes.SWAP))
+                        }
+                    }
+                }
+
+                Opcodes.SWAP -> {
+                    val prevNonNop2 = prevNonNop.findPreviousOrNull { it.opcode != Opcodes.NOP } ?: continue@forInsn
+                    if (prevNonNop.isPurePushOfSize1() && prevNonNop2.isPurePushOfSize1()) {
+                        actions.add {
+                            it.remove(insn)
+                            it.set(prevNonNop, prevNonNop2.clone(emptyMap()))
+                            it.set(prevNonNop2, prevNonNop.clone(emptyMap()))
+                        }
+                    }
+                }
+
+                Opcodes.I2L -> {
+                    when (prevNonNop.opcode) {
+                        Opcodes.ICONST_0 -> actions.add {
+                            it.remove(insn)
+                            it.set(prevNonNop, InsnNode(Opcodes.LCONST_0))
+                        }
+                        Opcodes.ICONST_1 -> actions.add {
+                            it.remove(insn)
+                            it.set(prevNonNop, InsnNode(Opcodes.LCONST_1))
+                        }
+                    }
+                }
+
+                Opcodes.POP2 -> {
+                    if (prevNonNop.isEliminatedByPop2()) {
+                        actions.add {
+                            it.set(insn, InsnNode(Opcodes.NOP))
+                            it.remove(prevNonNop)
+                        }
+                    }
+                    else if (i > 1) {
+                        val prevNonNop2 = prevNonNop.findPreviousOrNull { it.opcode != Opcodes.NOP } ?: continue@forInsn
+                        if (prevNonNop.isEliminatedByPop() && prevNonNop2.isEliminatedByPop()) {
+                            actions.add {
+                                it.set(insn, InsnNode(Opcodes.NOP))
+                                it.remove(prevNonNop)
+                                it.remove(prevNonNop2)
+                            }
+                        }
+                    }
+                }
+
+                Opcodes.NOP ->
+                    if (prev.opcode == Opcodes.NOP) {
+                        actions.add {
+                            it.remove(prev)
+                        }
+                    }
+            }
+        }
+
+        actions.forEach { it(methodNode.instructions) }
+
+        return actions.isNotEmpty()
+    }
+
+    private fun AbstractInsnNode.isEliminatedByPop() =
+            isPurePushOfSize1() ||
+            opcode == Opcodes.DUP
+
+    private fun AbstractInsnNode.isPurePushOfSize1(): Boolean =
+            opcode in Opcodes.ACONST_NULL..Opcodes.FCONST_2 ||
+            opcode in Opcodes.BIPUSH..Opcodes.ILOAD ||
+            opcode == Opcodes.FLOAD ||
+            opcode == Opcodes.ALOAD ||
+            isUnitInstance()
+
+    private fun AbstractInsnNode.isEliminatedByPop2() =
+            isPurePushOfSize2() ||
+            opcode == Opcodes.DUP2
+
+    private fun AbstractInsnNode.isPurePushOfSize2(): Boolean =
+            opcode == Opcodes.LCONST_0 || opcode == Opcodes.LCONST_1 ||
+            opcode == Opcodes.DCONST_0 || opcode == Opcodes.DCONST_1 ||
+            opcode == Opcodes.LLOAD ||
+            opcode == Opcodes.DLOAD
+}
+

compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/fixStack/FixStackAnalyzer.kt

@@ -142,20 +142,20 @@ internal class FixStackAnalyzer(
             }
 
             override fun pop(): BasicValue {
-                if (extraStack.isNotEmpty()) {
-                    return extraStack.pop()
+                return if (extraStack.isNotEmpty()) {
+                    extraStack.pop()
                 }
                 else {
-                    return super.pop()
+                    super.pop()
                 }
             }
 
             override fun getStack(i: Int): BasicValue {
-                if (i < super.getMaxStackSize()) {
-                    return super.getStack(i)
+                return if (i < super.getMaxStackSize()) {
+                    super.getStack(i)
                 }
                 else {
-                    return extraStack[i - maxStackSize]
+                    extraStack[i - maxStackSize]
                 }
             }
         }

compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/fixStack/StackTransformationUtils.kt

@@ -28,6 +28,31 @@ fun <V : Value> Frame<V>.top(): V? =
 fun <V : Value> Frame<V>.peek(offset: Int): V? =
         if (stackSize > offset) getStack(stackSize - offset - 1) else null
 
+private fun <V : Value> Frame<V>.peekWordsTo(dest: MutableList<V>, size: Int, offset0: Int = 0): Int {
+    var offset = offset0
+    var totalSize = 0
+    while (totalSize < size) {
+        val value = peek(offset++) ?: return -1
+        dest.add(value)
+        totalSize += value.size
+    }
+    if (totalSize > size) return -1
+    return offset
+}
+
+fun <V : Value> Frame<V>.peekWords(size: Int): List<V>? {
+    val result = ArrayList<V>(size)
+    return if (peekWordsTo(result, size) < 0) null else result
+}
+
+fun <V : Value> Frame<V>.peekWords(size1: Int, size2: Int): List<V>? {
+    val result = ArrayList<V>(size1 + size2)
+    val offset = peekWordsTo(result, size1)
+    if (offset < 0) return null
+    if (peekWordsTo(result, size2, offset) < 0) return null
+    return result
+}
+
 class SavedStackDescriptor(
         val savedValues: List<BasicValue>,
         val firstLocalVarIndex: Int

compiler/backend/src/org/jetbrains/kotlin/codegen/range/AbstractBoundedValue.kt

@@ -0,0 +1,37 @@
+/*
+ * Copyright 2010-2017 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.range
+
+import org.jetbrains.kotlin.codegen.ExpressionCodegen
+import org.jetbrains.kotlin.codegen.StackValue
+import org.jetbrains.kotlin.descriptors.CallableDescriptor
+import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall
+import org.jetbrains.org.objectweb.asm.Type
+import org.jetbrains.org.objectweb.asm.commons.InstructionAdapter
+
+abstract class AbstractBoundedValue(
+        protected val codegen: ExpressionCodegen,
+        protected val rangeCall: ResolvedCall<out CallableDescriptor>,
+        override val isLowInclusive: Boolean = true,
+        override val isHighInclusive: Boolean = true
+) : BoundedValue {
+    override val instanceType: Type = codegen.asmType(rangeCall.resultingDescriptor.returnType!!)
+
+    override fun putInstance(v: InstructionAdapter, type: Type) {
+        codegen.invokeFunction(rangeCall.call, rangeCall, StackValue.none()).put(type, v)
+    }
+}

compiler/backend/src/org/jetbrains/kotlin/codegen/range/ArrayIndicesRangeValue.kt

@@ -0,0 +1,47 @@
+/*
+ * Copyright 2010-2017 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.range
+
+import org.jetbrains.kotlin.codegen.ExpressionCodegen
+import org.jetbrains.kotlin.codegen.StackValue
+import org.jetbrains.kotlin.codegen.generateCallReceiver
+import org.jetbrains.kotlin.codegen.range.forLoop.ForInArrayIndicesRangeLoopGenerator
+import org.jetbrains.kotlin.descriptors.CallableDescriptor
+import org.jetbrains.kotlin.psi.KtForExpression
+import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall
+import org.jetbrains.kotlin.types.KotlinType
+import org.jetbrains.org.objectweb.asm.Type
+import org.jetbrains.org.objectweb.asm.commons.InstructionAdapter
+
+class ArrayIndicesRangeValue(rangeCall: ResolvedCall<out CallableDescriptor>): PrimitiveNumberRangeIntrinsicRangeValue(rangeCall) {
+    private val expectedReceiverType: KotlinType = ExpressionCodegen.getExpectedReceiverType(rangeCall)
+
+    override fun getBoundedValue(codegen: ExpressionCodegen) =
+            object : AbstractBoundedValue(codegen, rangeCall, isHighInclusive = false) {
+                override fun putHighLow(v: InstructionAdapter, type: Type) {
+                    codegen.generateCallReceiver(rangeCall).put(codegen.asmType(expectedReceiverType), v)
+                    v.arraylength()
+                    StackValue.coerce(Type.INT_TYPE, type, v)
+
+                    StackValue.constant(0, asmElementType).put(type, v)
+                }
+            }
+
+    override fun createForLoopGenerator(codegen: ExpressionCodegen, forExpression: KtForExpression) =
+            ForInArrayIndicesRangeLoopGenerator(codegen, forExpression, rangeCall)
+
+}

compiler/backend/src/org/jetbrains/kotlin/codegen/range/ArrayRangeValue.kt

@@ -0,0 +1,32 @@
+/*
+ * Copyright 2010-2017 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.range
+
+import org.jetbrains.kotlin.codegen.ExpressionCodegen
+import org.jetbrains.kotlin.codegen.range.forLoop.ForInArrayLoopGenerator
+import org.jetbrains.kotlin.codegen.range.inExpression.CallBasedInExpressionGenerator
+import org.jetbrains.kotlin.codegen.range.inExpression.InExpressionGenerator
+import org.jetbrains.kotlin.psi.KtForExpression
+import org.jetbrains.kotlin.psi.KtSimpleNameExpression
+
+class ArrayRangeValue : RangeValue {
+    override fun createForLoopGenerator(codegen: ExpressionCodegen, forExpression: KtForExpression) =
+            ForInArrayLoopGenerator(codegen, forExpression)
+
+    override fun createInExpressionGenerator(codegen: ExpressionCodegen, operatorReference: KtSimpleNameExpression): InExpressionGenerator =
+            CallBasedInExpressionGenerator(codegen, operatorReference)
+}

compiler/backend/src/org/jetbrains/kotlin/codegen/range/CallIntrinsicRangeValue.kt

@@ -0,0 +1,40 @@
+/*
+ * Copyright 2010-2017 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.range
+
+import org.jetbrains.kotlin.codegen.ExpressionCodegen
+import org.jetbrains.kotlin.codegen.range.comparison.getComparisonGeneratorForRangeContainsCall
+import org.jetbrains.kotlin.codegen.range.inExpression.CallBasedInExpressionGenerator
+import org.jetbrains.kotlin.codegen.range.inExpression.InExpressionGenerator
+import org.jetbrains.kotlin.descriptors.CallableDescriptor
+import org.jetbrains.kotlin.psi.KtSimpleNameExpression
+import org.jetbrains.kotlin.resolve.calls.callUtil.getResolvedCallWithAssert
+import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall
+
+abstract class CallIntrinsicRangeValue(protected val rangeCall: ResolvedCall<out CallableDescriptor>): RangeValue {
+    protected abstract fun isIntrinsicInCall(resolvedCallForIn: ResolvedCall<out CallableDescriptor>): Boolean
+
+    protected abstract fun createIntrinsicInExpressionGenerator(codegen: ExpressionCodegen, operatorReference: KtSimpleNameExpression, resolvedCall: ResolvedCall<out CallableDescriptor>): InExpressionGenerator
+
+    override fun createInExpressionGenerator(codegen: ExpressionCodegen, operatorReference: KtSimpleNameExpression): InExpressionGenerator {
+        val resolvedCall = operatorReference.getResolvedCallWithAssert(codegen.bindingContext)
+        return if (isIntrinsicInCall(resolvedCall))
+            createIntrinsicInExpressionGenerator(codegen, operatorReference, resolvedCall)
+        else
+            CallBasedInExpressionGenerator(codegen, operatorReference)
+    }
+}

compiler/backend/src/org/jetbrains/kotlin/codegen/range/CharSequenceIndicesRangeValue.kt

@@ -0,0 +1,46 @@
+/*
+ * Copyright 2010-2017 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.range
+
+import org.jetbrains.kotlin.codegen.ExpressionCodegen
+import org.jetbrains.kotlin.codegen.StackValue
+import org.jetbrains.kotlin.codegen.generateCallReceiver
+import org.jetbrains.kotlin.codegen.range.forLoop.ForInCharSequenceIndicesRangeLoopGenerator
+import org.jetbrains.kotlin.descriptors.CallableDescriptor
+import org.jetbrains.kotlin.psi.KtForExpression
+import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall
+import org.jetbrains.kotlin.types.KotlinType
+import org.jetbrains.org.objectweb.asm.Type
+import org.jetbrains.org.objectweb.asm.commons.InstructionAdapter
+
+class CharSequenceIndicesRangeValue(rangeCall: ResolvedCall<out CallableDescriptor>): PrimitiveNumberRangeIntrinsicRangeValue(rangeCall) {
+    private val expectedReceiverType: KotlinType = ExpressionCodegen.getExpectedReceiverType(rangeCall)
+
+    override fun getBoundedValue(codegen: ExpressionCodegen) =
+            object : AbstractBoundedValue(codegen, rangeCall, isHighInclusive = false) {
+                override fun putHighLow(v: InstructionAdapter, type: Type) {
+                    codegen.generateCallReceiver(rangeCall).put(codegen.asmType(expectedReceiverType), v)
+                    v.invokeinterface("java/lang/CharSequence", "length", "()I")
+                    StackValue.coerce(Type.INT_TYPE, type, v)
+
+                    StackValue.constant(0, asmElementType).put(type, v)
+                }
+            }
+
+    override fun createForLoopGenerator(codegen: ExpressionCodegen, forExpression: KtForExpression) =
+            ForInCharSequenceIndicesRangeLoopGenerator(codegen, forExpression, rangeCall)
+}

compiler/backend/src/org/jetbrains/kotlin/codegen/range/CharSequenceRangeValue.kt

@@ -0,0 +1,32 @@
+/*
+ * Copyright 2010-2017 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.range
+
+import org.jetbrains.kotlin.codegen.ExpressionCodegen
+import org.jetbrains.kotlin.codegen.range.forLoop.ForInCharSequenceLoopGenerator
+import org.jetbrains.kotlin.codegen.range.inExpression.CallBasedInExpressionGenerator
+import org.jetbrains.kotlin.codegen.range.inExpression.InExpressionGenerator
+import org.jetbrains.kotlin.psi.KtForExpression
+import org.jetbrains.kotlin.psi.KtSimpleNameExpression
+
+class CharSequenceRangeValue : RangeValue {
+    override fun createForLoopGenerator(codegen: ExpressionCodegen, forExpression: KtForExpression) =
+            ForInCharSequenceLoopGenerator(codegen, forExpression)
+
+    override fun createInExpressionGenerator(codegen: ExpressionCodegen, operatorReference: KtSimpleNameExpression): InExpressionGenerator =
+            CallBasedInExpressionGenerator(codegen, operatorReference)
+}

compiler/backend/src/org/jetbrains/kotlin/codegen/range/CollectionIndicesRangeValue.kt

@@ -0,0 +1,46 @@
+/*
+ * Copyright 2010-2017 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.range
+
+import org.jetbrains.kotlin.codegen.ExpressionCodegen
+import org.jetbrains.kotlin.codegen.StackValue
+import org.jetbrains.kotlin.codegen.generateCallReceiver
+import org.jetbrains.kotlin.codegen.range.forLoop.ForInCollectionIndicesRangeLoopGenerator
+import org.jetbrains.kotlin.descriptors.CallableDescriptor
+import org.jetbrains.kotlin.psi.KtForExpression
+import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall
+import org.jetbrains.kotlin.types.KotlinType
+import org.jetbrains.org.objectweb.asm.Type
+import org.jetbrains.org.objectweb.asm.commons.InstructionAdapter
+
+class CollectionIndicesRangeValue(rangeCall: ResolvedCall<out CallableDescriptor>): PrimitiveNumberRangeIntrinsicRangeValue(rangeCall) {
+    private val expectedReceiverType: KotlinType = ExpressionCodegen.getExpectedReceiverType(rangeCall)
+
+    override fun getBoundedValue(codegen: ExpressionCodegen) =
+            object : AbstractBoundedValue(codegen, rangeCall, isHighInclusive = false) {
+                override fun putHighLow(v: InstructionAdapter, type: Type) {
+                    codegen.generateCallReceiver(rangeCall).put(codegen.asmType(expectedReceiverType), v)
+                    v.invokeinterface("java/util/Collection", "size", "()I")
+                    StackValue.coerce(Type.INT_TYPE, type, v)
+
+                    StackValue.constant(0, asmElementType).put(type, v)
+                }
+            }
+
+    override fun createForLoopGenerator(codegen: ExpressionCodegen, forExpression: KtForExpression) =
+            ForInCollectionIndicesRangeLoopGenerator(codegen, forExpression, rangeCall)
+}

compiler/backend/src/org/jetbrains/kotlin/codegen/range/ComparableRangeLiteralRangeValue.kt

@@ -0,0 +1,45 @@
+/*
+ * Copyright 2010-2017 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.range
+
+import org.jetbrains.kotlin.codegen.ExpressionCodegen
+import org.jetbrains.kotlin.codegen.isClosedRangeContains
+import org.jetbrains.kotlin.codegen.range.forLoop.IteratorForLoopGenerator
+import org.jetbrains.kotlin.codegen.range.inExpression.InContinuousRangeOfComparableExpressionGenerator
+import org.jetbrains.kotlin.descriptors.CallableDescriptor
+import org.jetbrains.kotlin.psi.KtForExpression
+import org.jetbrains.kotlin.psi.KtSimpleNameExpression
+import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall
+
+class ComparableRangeLiteralRangeValue(
+        codegen: ExpressionCodegen,
+        rangeCall: ResolvedCall<out CallableDescriptor>
+) : CallIntrinsicRangeValue(rangeCall) {
+    private val boundedValue = SimpleBoundedValue(codegen, rangeCall)
+
+    override fun createForLoopGenerator(codegen: ExpressionCodegen, forExpression: KtForExpression) =
+            IteratorForLoopGenerator(codegen, forExpression)
+
+    override fun isIntrinsicInCall(resolvedCallForIn: ResolvedCall<out CallableDescriptor>) =
+            isClosedRangeContains(resolvedCallForIn.resultingDescriptor)
+
+    override fun createIntrinsicInExpressionGenerator(
+            codegen: ExpressionCodegen,
+            operatorReference: KtSimpleNameExpression,
+            resolvedCall: ResolvedCall<out CallableDescriptor>
+    ) = InContinuousRangeOfComparableExpressionGenerator(operatorReference, boundedValue)
+}

compiler/backend/src/org/jetbrains/kotlin/codegen/range/DownToProgressionRangeValue.kt

@@ -0,0 +1,37 @@
+/*
+ * Copyright 2010-2017 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.range
+
+import org.jetbrains.kotlin.codegen.ExpressionCodegen
+import org.jetbrains.kotlin.codegen.generateCallReceiver
+import org.jetbrains.kotlin.codegen.generateCallSingleArgument
+import org.jetbrains.kotlin.codegen.range.forLoop.ForInDownToProgressionLoopGenerator
+import org.jetbrains.kotlin.descriptors.CallableDescriptor
+import org.jetbrains.kotlin.psi.KtForExpression
+import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall
+
+class DownToProgressionRangeValue(rangeCall: ResolvedCall<out CallableDescriptor>): PrimitiveNumberRangeIntrinsicRangeValue(rangeCall) {
+    override fun getBoundedValue(codegen: ExpressionCodegen) =
+            SimpleBoundedValue(
+                    codegen, rangeCall,
+                    lowBound = codegen.generateCallSingleArgument(rangeCall),
+                    highBound = codegen.generateCallReceiver(rangeCall)
+            )
+
+    override fun createForLoopGenerator(codegen: ExpressionCodegen, forExpression: KtForExpression) =
+            ForInDownToProgressionLoopGenerator(codegen, forExpression, rangeCall)
+}

compiler/backend/src/org/jetbrains/kotlin/codegen/range/IterableRangeValue.kt

@@ -0,0 +1,32 @@
+/*
+ * Copyright 2010-2017 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.range
+
+import org.jetbrains.kotlin.codegen.ExpressionCodegen
+import org.jetbrains.kotlin.codegen.range.forLoop.IteratorForLoopGenerator
+import org.jetbrains.kotlin.codegen.range.inExpression.CallBasedInExpressionGenerator
+import org.jetbrains.kotlin.codegen.range.inExpression.InExpressionGenerator
+import org.jetbrains.kotlin.psi.KtForExpression
+import org.jetbrains.kotlin.psi.KtSimpleNameExpression
+
+class IterableRangeValue : RangeValue {
+    override fun createForLoopGenerator(codegen: ExpressionCodegen, forExpression: KtForExpression) =
+            IteratorForLoopGenerator(codegen, forExpression)
+
+    override fun createInExpressionGenerator(codegen: ExpressionCodegen, operatorReference: KtSimpleNameExpression): InExpressionGenerator =
+            CallBasedInExpressionGenerator(codegen, operatorReference)
+}

compiler/backend/src/org/jetbrains/kotlin/codegen/range/PrimitiveNumberRangeIntrinsicRangeValue.kt

@@ -0,0 +1,51 @@
+/*
+ * Copyright 2010-2017 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.range
+
+import org.jetbrains.kotlin.codegen.*
+import org.jetbrains.kotlin.codegen.range.comparison.getComparisonGeneratorForRangeContainsCall
+import org.jetbrains.kotlin.codegen.range.inExpression.CallBasedInExpressionGenerator
+import org.jetbrains.kotlin.codegen.range.inExpression.InPrimitiveContinuousRangeExpressionGenerator
+import org.jetbrains.kotlin.codegen.range.inExpression.InExpressionGenerator
+import org.jetbrains.kotlin.descriptors.CallableDescriptor
+import org.jetbrains.kotlin.psi.KtSimpleNameExpression
+import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall
+
+abstract class PrimitiveNumberRangeIntrinsicRangeValue(rangeCall: ResolvedCall<out CallableDescriptor>): CallIntrinsicRangeValue(rangeCall) {
+    protected val asmElementType = getAsmRangeElementTypeForPrimitiveRangeOrProgression(rangeCall.resultingDescriptor)
+
+    override fun isIntrinsicInCall(resolvedCallForIn: ResolvedCall<out CallableDescriptor>) =
+            resolvedCallForIn.resultingDescriptor.let {
+                isPrimitiveRangeContains(it) ||
+                isClosedFloatingPointRangeContains(it) ||
+                isPrimitiveNumberRangeExtensionContainsPrimitiveNumber(it)
+            }
+
+    override fun createIntrinsicInExpressionGenerator(
+            codegen: ExpressionCodegen,
+            operatorReference: KtSimpleNameExpression,
+            resolvedCall: ResolvedCall<out CallableDescriptor>
+    ): InExpressionGenerator {
+        val comparisonGenerator = getComparisonGeneratorForRangeContainsCall(codegen, resolvedCall)
+        return if (comparisonGenerator != null)
+            InPrimitiveContinuousRangeExpressionGenerator(operatorReference, getBoundedValue(codegen), comparisonGenerator)
+        else
+            CallBasedInExpressionGenerator(codegen, operatorReference)
+    }
+
+    protected abstract fun getBoundedValue(codegen: ExpressionCodegen): BoundedValue
+}

compiler/backend/src/org/jetbrains/kotlin/codegen/range/PrimitiveNumberRangeLiteralRangeValue.kt

@@ -0,0 +1,31 @@
+/*
+ * Copyright 2010-2017 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.range
+
+import org.jetbrains.kotlin.codegen.ExpressionCodegen
+import org.jetbrains.kotlin.codegen.range.forLoop.ForInRangeLiteralLoopGenerator
+import org.jetbrains.kotlin.descriptors.CallableDescriptor
+import org.jetbrains.kotlin.psi.KtForExpression
+import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall
+
+class PrimitiveNumberRangeLiteralRangeValue(rangeCall: ResolvedCall<out CallableDescriptor>): PrimitiveNumberRangeIntrinsicRangeValue(rangeCall) {
+    override fun getBoundedValue(codegen: ExpressionCodegen) =
+            SimpleBoundedValue(codegen, rangeCall)
+
+    override fun createForLoopGenerator(codegen: ExpressionCodegen, forExpression: KtForExpression) =
+            ForInRangeLiteralLoopGenerator(codegen, forExpression, rangeCall)
+}

compiler/backend/src/org/jetbrains/kotlin/codegen/range/PrimitiveNumberUntilRangeValue.kt

@@ -0,0 +1,31 @@
+/*
+ * Copyright 2010-2017 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.range
+
+import org.jetbrains.kotlin.codegen.ExpressionCodegen
+import org.jetbrains.kotlin.codegen.range.forLoop.ForInUntilRangeLoopGenerator
+import org.jetbrains.kotlin.descriptors.CallableDescriptor
+import org.jetbrains.kotlin.psi.KtForExpression
+import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall
+
+class PrimitiveNumberUntilRangeValue(rangeCall: ResolvedCall<out CallableDescriptor>): PrimitiveNumberRangeIntrinsicRangeValue(rangeCall) {
+    override fun getBoundedValue(codegen: ExpressionCodegen) =
+            SimpleBoundedValue(codegen, rangeCall, isLowInclusive = true, isHighInclusive = false)
+
+    override fun createForLoopGenerator(codegen: ExpressionCodegen, forExpression: KtForExpression) =
+            ForInUntilRangeLoopGenerator(codegen, forExpression, rangeCall)
+}

compiler/backend/src/org/jetbrains/kotlin/codegen/range/PrimitiveProgressionRangeValue.kt

@@ -0,0 +1,32 @@
+/*
+ * Copyright 2010-2017 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.range
+
+import org.jetbrains.kotlin.codegen.ExpressionCodegen
+import org.jetbrains.kotlin.codegen.range.forLoop.ForInProgressionExpressionLoopGenerator
+import org.jetbrains.kotlin.codegen.range.inExpression.CallBasedInExpressionGenerator
+import org.jetbrains.kotlin.codegen.range.inExpression.InExpressionGenerator
+import org.jetbrains.kotlin.psi.KtForExpression
+import org.jetbrains.kotlin.psi.KtSimpleNameExpression
+
+class PrimitiveProgressionRangeValue : RangeValue {
+    override fun createForLoopGenerator(codegen: ExpressionCodegen, forExpression: KtForExpression) =
+            ForInProgressionExpressionLoopGenerator(codegen, forExpression)
+
+    override fun createInExpressionGenerator(codegen: ExpressionCodegen, operatorReference: KtSimpleNameExpression): InExpressionGenerator =
+            CallBasedInExpressionGenerator(codegen, operatorReference)
+}

compiler/backend/src/org/jetbrains/kotlin/codegen/range/PrimitiveRangeRangeValue.kt

@@ -0,0 +1,32 @@
+/*
+ * Copyright 2010-2017 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.range
+
+import org.jetbrains.kotlin.codegen.ExpressionCodegen
+import org.jetbrains.kotlin.codegen.range.forLoop.ForInRangeInstanceLoopGenerator
+import org.jetbrains.kotlin.codegen.range.inExpression.CallBasedInExpressionGenerator
+import org.jetbrains.kotlin.codegen.range.inExpression.InExpressionGenerator
+import org.jetbrains.kotlin.psi.KtForExpression
+import org.jetbrains.kotlin.psi.KtSimpleNameExpression
+
+class PrimitiveRangeRangeValue : RangeValue {
+    override fun createForLoopGenerator(codegen: ExpressionCodegen, forExpression: KtForExpression) =
+            ForInRangeInstanceLoopGenerator(codegen, forExpression)
+
+    override fun createInExpressionGenerator(codegen: ExpressionCodegen, operatorReference: KtSimpleNameExpression): InExpressionGenerator =
+            CallBasedInExpressionGenerator(codegen, operatorReference)
+}

compiler/backend/src/org/jetbrains/kotlin/codegen/range/RangeValue.kt

@@ -0,0 +1,53 @@
+/*
+ * Copyright 2010-2017 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.range
+
+import org.jetbrains.kotlin.codegen.ExpressionCodegen
+import org.jetbrains.kotlin.codegen.StackValue
+import org.jetbrains.kotlin.codegen.range.forLoop.ForLoopGenerator
+import org.jetbrains.kotlin.codegen.range.inExpression.InExpressionGenerator
+import org.jetbrains.kotlin.psi.KtForExpression
+import org.jetbrains.kotlin.psi.KtSimpleNameExpression
+import org.jetbrains.org.objectweb.asm.Type
+import org.jetbrains.org.objectweb.asm.commons.InstructionAdapter
+
+interface RangeValue {
+    fun createForLoopGenerator(codegen: ExpressionCodegen, forExpression: KtForExpression): ForLoopGenerator
+
+    fun createInExpressionGenerator(codegen: ExpressionCodegen, operatorReference: KtSimpleNameExpression): InExpressionGenerator
+}
+
+
+interface BoundedValue {
+    val instanceType: Type
+
+    fun putInstance(v: InstructionAdapter, type: Type)
+
+    // It is necessary to maintain the proper evaluation order as of Kotlin 1.0 and 1.1
+    // to evaluate range bounds left to right and put them on stack as 'high; low'.
+    fun putHighLow(v: InstructionAdapter, type: Type)
+
+    val isLowInclusive: Boolean
+    val isHighInclusive: Boolean
+}
+
+fun BoundedValue.asStackValue(): StackValue =
+        object : StackValue(instanceType) {
+            override fun putSelector(type: Type, v: InstructionAdapter) {
+                putInstance(v, type)
+            }
+        }

compiler/backend/src/org/jetbrains/kotlin/codegen/range/RangeValues.kt

@@ -0,0 +1,107 @@
+/*
+ * Copyright 2010-2017 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.range
+
+import org.jetbrains.kotlin.builtins.KotlinBuiltIns
+import org.jetbrains.kotlin.codegen.*
+import org.jetbrains.kotlin.descriptors.CallableDescriptor
+import org.jetbrains.kotlin.name.Name
+import org.jetbrains.kotlin.psi.*
+import org.jetbrains.kotlin.resolve.BindingContext
+import org.jetbrains.kotlin.resolve.calls.callUtil.getResolvedCall
+import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall
+import org.jetbrains.kotlin.types.KotlinType
+import org.jetbrains.kotlin.types.checker.KotlinTypeChecker
+import org.jetbrains.org.objectweb.asm.Type
+
+fun ExpressionCodegen.createRangeValueForExpression(rangeExpression: KtExpression): RangeValue {
+    // NB when you implement a new intrinsic RangeValue,
+    // also look into org.jetbrains.kotlin.generators.tests and update related testData generators
+    // (e.g., GenerateInRangeExpressionTestData).
+
+    getResolvedCallForRangeExpression(bindingContext, rangeExpression)?.let {
+        createIntrinsifiedRangeValueOrNull(it)?.let {
+            return it
+        }
+    }
+
+    val rangeType = bindingContext.getType(rangeExpression)!!
+    val asmRangeType = asmType(rangeType)
+
+    return when {
+        asmRangeType.sort == Type.ARRAY ->
+            ArrayRangeValue()
+        isPrimitiveRange(rangeType) ->
+            PrimitiveRangeRangeValue()
+        isPrimitiveProgression(rangeType) ->
+            PrimitiveProgressionRangeValue()
+        isSubtypeOfCharSequence(rangeType, state.module.builtIns) ->
+            CharSequenceRangeValue()
+        else ->
+            IterableRangeValue()
+    }
+}
+
+private fun isSubtypeOfCharSequence(type: KotlinType, builtIns: KotlinBuiltIns) =
+        KotlinTypeChecker.DEFAULT.isSubtypeOf(type, builtIns.getBuiltInClassByName(Name.identifier("CharSequence")).defaultType)
+
+private fun getResolvedCallForRangeExpression(
+        bindingContext: BindingContext,
+        rangeExpression: KtExpression
+): ResolvedCall<out CallableDescriptor>? {
+    val expression = KtPsiUtil.deparenthesize(rangeExpression) ?: return null
+
+    return when (expression) {
+        is KtQualifiedExpression ->
+            expression.selectorExpression.let { selector ->
+                if (selector is KtCallExpression || selector is KtSimpleNameExpression)
+                    selector.getResolvedCall(bindingContext)
+                else
+                    null
+            }
+
+        is KtSimpleNameExpression, is KtCallExpression ->
+            expression.getResolvedCall(bindingContext)
+        is KtBinaryExpression ->
+            expression.operationReference.getResolvedCall(bindingContext)
+        else ->
+            null
+    }
+}
+
+private fun ExpressionCodegen.createIntrinsifiedRangeValueOrNull(rangeCall: ResolvedCall<out CallableDescriptor>): RangeValue? {
+    val rangeCallee = rangeCall.resultingDescriptor
+
+    return when {
+        isPrimitiveNumberRangeTo(rangeCallee) ->
+            PrimitiveNumberRangeLiteralRangeValue(rangeCall)
+        isPrimitiveNumberDownTo(rangeCallee) ->
+            DownToProgressionRangeValue(rangeCall)
+        isPrimitiveNumberUntil(rangeCallee) ->
+            PrimitiveNumberUntilRangeValue(rangeCall)
+        isArrayOrPrimitiveArrayIndices(rangeCallee) ->
+            ArrayIndicesRangeValue(rangeCall)
+        isCollectionIndices(rangeCallee) ->
+            CollectionIndicesRangeValue(rangeCall)
+        isCharSequenceIndices(rangeCallee) ->
+            CharSequenceIndicesRangeValue(rangeCall)
+        isComparableRangeTo(rangeCallee) ->
+            ComparableRangeLiteralRangeValue(this, rangeCall)
+        else ->
+            null
+    }
+}

compiler/backend/src/org/jetbrains/kotlin/codegen/range/SimpleBoundedValue.kt

@@ -0,0 +1,65 @@
+/*
+ * Copyright 2010-2017 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.range
+
+import org.jetbrains.kotlin.codegen.*
+import org.jetbrains.kotlin.descriptors.CallableDescriptor
+import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall
+import org.jetbrains.org.objectweb.asm.Type
+import org.jetbrains.org.objectweb.asm.commons.InstructionAdapter
+
+class SimpleBoundedValue(
+        codegen: ExpressionCodegen,
+        rangeCall: ResolvedCall<out CallableDescriptor>,
+        private val lowBound: StackValue,
+        isLowInclusive: Boolean,
+        private val highBound: StackValue,
+        isHighInclusive: Boolean
+): AbstractBoundedValue(codegen, rangeCall, isLowInclusive, isHighInclusive) {
+    constructor(
+            codegen: ExpressionCodegen,
+            rangeCall: ResolvedCall<out CallableDescriptor>,
+            isLowInclusive: Boolean = true,
+            isHighInclusive: Boolean = true
+    ) : this(
+            codegen,
+            rangeCall,
+            codegen.generateCallReceiver(rangeCall),
+            isLowInclusive,
+            codegen.generateCallSingleArgument(rangeCall),
+            isHighInclusive
+    )
+
+    constructor(
+            codegen: ExpressionCodegen,
+            rangeCall: ResolvedCall<out CallableDescriptor>,
+            lowBound: StackValue,
+            highBound: StackValue
+    ) : this(codegen, rangeCall, lowBound, true, highBound, true)
+
+    override fun putHighLow(v: InstructionAdapter, type: Type) {
+        if (!lowBound.canHaveSideEffects() || !highBound.canHaveSideEffects()) {
+            highBound.put(type, v)
+            lowBound.put(type, v)
+        }
+        else {
+            lowBound.put(type, v)
+            highBound.put(type, v)
+            AsmUtil.swap(v, type, type)
+        }
+    }
+}

compiler/backend/src/org/jetbrains/kotlin/codegen/range/comparison/ComparisonGenerator.kt

@@ -0,0 +1,77 @@
+/*
+ * Copyright 2010-2017 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.range.comparison
+
+import org.jetbrains.kotlin.codegen.ExpressionCodegen
+import org.jetbrains.kotlin.codegen.getRangeOrProgressionElementType
+import org.jetbrains.kotlin.descriptors.CallableDescriptor
+import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall
+import org.jetbrains.org.objectweb.asm.Label
+import org.jetbrains.org.objectweb.asm.Type
+import org.jetbrains.org.objectweb.asm.commons.InstructionAdapter
+
+interface ComparisonGenerator {
+    val comparedType: Type
+
+    fun jumpIfGreaterOrEqual(v: InstructionAdapter, label: Label)
+    fun jumpIfLessOrEqual(v: InstructionAdapter, label: Label)
+    fun jumpIfGreater(v: InstructionAdapter, label: Label)
+    fun jumpIfLess(v: InstructionAdapter, label: Label)
+}
+
+fun getComparisonGeneratorForPrimitiveType(type: Type): ComparisonGenerator =
+        when {
+            type.isRepresentedAsPrimitiveInt() -> IntComparisonGenerator
+            type == Type.LONG_TYPE -> LongComparisonGenerator
+            type == Type.FLOAT_TYPE -> FloatComparisonGenerator
+            type == Type.DOUBLE_TYPE -> DoubleComparisonGenerator
+            else -> throw UnsupportedOperationException("Unexpected primitive type: " + type)
+        }
+
+fun getComparisonGeneratorForRangeContainsCall(codegen: ExpressionCodegen, call: ResolvedCall<out CallableDescriptor>): ComparisonGenerator? {
+    val descriptor = call.resultingDescriptor
+
+    val receiverType = descriptor.extensionReceiverParameter?.type ?: descriptor.dispatchReceiverParameter?.type ?: return null
+
+    val elementType = getRangeOrProgressionElementType(receiverType) ?: return null
+
+    val valueParameterType = descriptor.valueParameters.singleOrNull()?.type ?: return null
+
+    val asmElementType = codegen.asmType(elementType)
+    val asmValueParameterType = codegen.asmType(valueParameterType)
+
+    return when {
+        asmElementType == asmValueParameterType ->
+            getComparisonGeneratorForPrimitiveType(asmElementType)
+
+        asmElementType.isRepresentedAsPrimitiveInt() && asmValueParameterType.isRepresentedAsPrimitiveInt() ->
+            IntComparisonGenerator
+
+        asmElementType.isRepresentedAsPrimitiveInt() && asmValueParameterType == Type.LONG_TYPE ||
+        asmValueParameterType.isRepresentedAsPrimitiveInt() && asmElementType == Type.LONG_TYPE ->
+            LongComparisonGenerator
+
+        asmElementType == Type.FLOAT_TYPE && asmValueParameterType == Type.DOUBLE_TYPE ||
+        asmElementType == Type.DOUBLE_TYPE && asmValueParameterType == Type.FLOAT_TYPE ->
+            DoubleComparisonGenerator
+
+        else -> null
+    }
+}
+
+private fun Type.isRepresentedAsPrimitiveInt() =
+        this == Type.INT_TYPE || this == Type.SHORT_TYPE || this == Type.BYTE_TYPE || this == Type.CHAR_TYPE

compiler/backend/src/org/jetbrains/kotlin/codegen/range/comparison/FloatingPointComparisonGenerator.kt

@@ -0,0 +1,47 @@
+/*
+ * Copyright 2010-2017 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.range.comparison
+
+import org.jetbrains.org.objectweb.asm.Label
+import org.jetbrains.org.objectweb.asm.Type
+import org.jetbrains.org.objectweb.asm.commons.InstructionAdapter
+
+sealed class FloatingPointComparisonGenerator(override val comparedType: Type): ComparisonGenerator {
+    override fun jumpIfGreaterOrEqual(v: InstructionAdapter, label: Label) {
+        v.cmpl(comparedType)
+        v.ifge(label)
+    }
+
+    override fun jumpIfLessOrEqual(v: InstructionAdapter, label: Label) {
+        v.cmpg(comparedType)
+        v.ifle(label)
+    }
+
+    override fun jumpIfGreater(v: InstructionAdapter, label: Label) {
+        v.cmpl(comparedType)
+        v.ifgt(label)
+    }
+
+    override fun jumpIfLess(v: InstructionAdapter, label: Label) {
+        v.cmpg(comparedType)
+        v.iflt(label)
+    }
+}
+
+object FloatComparisonGenerator : FloatingPointComparisonGenerator(Type.FLOAT_TYPE)
+
+object DoubleComparisonGenerator : FloatingPointComparisonGenerator(Type.DOUBLE_TYPE)

compiler/backend/src/org/jetbrains/kotlin/codegen/range/comparison/IntComparisonGenerator.kt

@@ -0,0 +1,41 @@
+/*
+ * Copyright 2010-2017 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.range.comparison
+
+import org.jetbrains.org.objectweb.asm.Label
+import org.jetbrains.org.objectweb.asm.Type
+import org.jetbrains.org.objectweb.asm.commons.InstructionAdapter
+
+object IntComparisonGenerator : ComparisonGenerator {
+    override val comparedType: Type = Type.INT_TYPE
+
+    override fun jumpIfGreaterOrEqual(v: InstructionAdapter, label: Label) {
+        v.ificmpge(label)
+    }
+
+    override fun jumpIfLessOrEqual(v: InstructionAdapter, label: Label) {
+        v.ificmple(label)
+    }
+
+    override fun jumpIfGreater(v: InstructionAdapter, label: Label) {
+        v.ificmpgt(label)
+    }
+
+    override fun jumpIfLess(v: InstructionAdapter, label: Label) {
+        v.ificmplt(label)
+    }
+}

compiler/backend/src/org/jetbrains/kotlin/codegen/range/comparison/LongComparisonGenerator.kt

@@ -0,0 +1,45 @@
+/*
+ * Copyright 2010-2017 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.range.comparison
+
+import org.jetbrains.org.objectweb.asm.Label
+import org.jetbrains.org.objectweb.asm.Type
+import org.jetbrains.org.objectweb.asm.commons.InstructionAdapter
+
+object LongComparisonGenerator : ComparisonGenerator {
+    override val comparedType: Type = Type.LONG_TYPE
+
+    override fun jumpIfGreaterOrEqual(v: InstructionAdapter, label: Label) {
+        v.lcmp()
+        v.ifge(label)
+    }
+
+    override fun jumpIfLessOrEqual(v: InstructionAdapter, label: Label) {
+        v.lcmp()
+        v.ifle(label)
+    }
+
+    override fun jumpIfGreater(v: InstructionAdapter, label: Label) {
+        v.lcmp()
+        v.ifgt(label)
+    }
+
+    override fun jumpIfLess(v: InstructionAdapter, label: Label) {
+        v.lcmp()
+        v.iflt(label)
+    }
+}

compiler/backend/src/org/jetbrains/kotlin/codegen/range/comparison/ObjectComparisonGenerator.kt

@@ -0,0 +1,49 @@
+/*
+ * Copyright 2010-2017 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.range.comparison
+
+import org.jetbrains.org.objectweb.asm.Label
+import org.jetbrains.org.objectweb.asm.Type
+import org.jetbrains.org.objectweb.asm.commons.InstructionAdapter
+
+object ObjectComparisonGenerator : ComparisonGenerator {
+    override val comparedType: Type = Type.getObjectType("java/lang/Comparable")
+
+    override fun jumpIfGreaterOrEqual(v: InstructionAdapter, label: Label) {
+        invokeCompare(v)
+        v.ifge(label)
+    }
+
+    override fun jumpIfLessOrEqual(v: InstructionAdapter, label: Label) {
+        invokeCompare(v)
+        v.ifle(label)
+    }
+
+    override fun jumpIfGreater(v: InstructionAdapter, label: Label) {
+        invokeCompare(v)
+        v.ifgt(label)
+    }
+
+    override fun jumpIfLess(v: InstructionAdapter, label: Label) {
+        invokeCompare(v)
+        v.iflt(label)
+    }
+
+    private fun invokeCompare(v: InstructionAdapter) {
+        v.invokeinterface("java/lang/Comparable", "compareTo", "(Ljava/lang/Object;)I")
+    }
+}

compiler/backend/src/org/jetbrains/kotlin/codegen/range/forLoop/AbstractForInExclusiveRangeLoopGenerator.kt

@@ -14,10 +14,9 @@
  * limitations under the License.
  */
 
-package org.jetbrains.kotlin.codegen.forLoop
+package org.jetbrains.kotlin.codegen.range.forLoop
 
 import org.jetbrains.kotlin.codegen.ExpressionCodegen
-import org.jetbrains.kotlin.codegen.StackValue
 import org.jetbrains.kotlin.psi.KtForExpression
 import org.jetbrains.org.objectweb.asm.Label
 import org.jetbrains.org.objectweb.asm.Type
@@ -25,15 +24,7 @@ import org.jetbrains.org.objectweb.asm.Type
 abstract class AbstractForInExclusiveRangeLoopGenerator(
         codegen: ExpressionCodegen,
         forExpression: KtForExpression
-) : AbstractForInRangeLoopGenerator(codegen, forExpression) {
-    protected abstract fun generateFrom(): StackValue
-    protected abstract fun generateTo(): StackValue
-
-    override fun storeRangeStartAndEnd() {
-        loopParameter().store(generateFrom(), v)
-        StackValue.local(endVar, asmElementType).store(generateTo(), v)
-    }
-
+) : AbstractForInRangeWithGivenBoundsLoopGenerator(codegen, forExpression) {
     override fun checkEmptyLoop(loopExit: Label) {}
 
     override fun checkPreCondition(loopExit: Label) {

compiler/backend/src/org/jetbrains/kotlin/codegen/range/forLoop/AbstractForInProgressionLoopGenerator.kt

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package org.jetbrains.kotlin.codegen.forLoop
+package org.jetbrains.kotlin.codegen.range.forLoop
 
 import org.jetbrains.kotlin.codegen.ExpressionCodegen
 import org.jetbrains.kotlin.codegen.StackValue
@@ -24,38 +24,36 @@ import org.jetbrains.kotlin.psi.KtForExpression
 import org.jetbrains.org.objectweb.asm.Label
 import org.jetbrains.org.objectweb.asm.Type
 
-class ForInProgressionExpressionLoopGenerator(codegen: ExpressionCodegen, forExpression: KtForExpression)
+abstract class AbstractForInProgressionLoopGenerator(codegen: ExpressionCodegen, forExpression: KtForExpression)
     : AbstractForInProgressionOrRangeLoopGenerator(codegen, forExpression)
 {
-    private var incrementVar: Int = 0
-    private var incrementType: Type? = null
+    protected var incrementVar: Int = -1
+    protected val asmLoopRangeType: Type
+    protected val incrementType: Type
+
+    init {
+        val loopRangeType = bindingContext.getType(forExpression.loopRange!!)!!
+        asmLoopRangeType = codegen.asmType(loopRangeType)
+
+        val incrementProp = loopRangeType.memberScope.getContributedVariables(Name.identifier("step"), NoLookupLocation.FROM_BACKEND)
+        assert(incrementProp.size == 1) { loopRangeType.toString() + " " + incrementProp.size }
+        incrementType = codegen.asmType(incrementProp.iterator().next().type)
+    }
 
     override fun beforeLoop() {
         super.beforeLoop()
 
         incrementVar = createLoopTempVariable(asmElementType)
 
-        val loopRangeType = bindingContext.getType(forExpression.loopRange!!)!!
-        val asmLoopRangeType = codegen.asmType(loopRangeType)
-
-        val incrementProp = loopRangeType.memberScope.getContributedVariables(Name.identifier("step"), NoLookupLocation.FROM_BACKEND)
-        assert(incrementProp.size == 1) { loopRangeType.toString() + " " + incrementProp.size }
-        incrementType = codegen.asmType(incrementProp.iterator().next().type)
-
-        codegen.gen(forExpression.loopRange, asmLoopRangeType)
-        v.dup()
-        v.dup()
-
-        generateRangeOrProgressionProperty(asmLoopRangeType, "getFirst", asmElementType, loopParameterType,
-                                           loopParameterVar)
-        generateRangeOrProgressionProperty(asmLoopRangeType, "getLast", asmElementType, asmElementType, endVar)
-        generateRangeOrProgressionProperty(asmLoopRangeType, "getStep", incrementType!!, incrementType!!, incrementVar)
+        storeProgressionParametersToLocalVars()
     }
 
+    protected abstract fun storeProgressionParametersToLocalVars()
+
     override fun checkEmptyLoop(loopExit: Label) {
         loopParameter().put(asmElementType, v)
         v.load(endVar, asmElementType)
-        v.load(incrementVar, incrementType!!)
+        v.load(incrementVar, incrementType)
 
         val negativeIncrement = Label()
         val afterIf = Label()
@@ -106,4 +104,4 @@ class ForInProgressionExpressionLoopGenerator(codegen: ExpressionCodegen, forExp
 
         loopParameter.store(StackValue.onStack(asmElementType), v)
     }
-}
+}

compiler/backend/src/org/jetbrains/kotlin/codegen/range/forLoop/AbstractForInProgressionOrRangeLoopGenerator.kt

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package org.jetbrains.kotlin.codegen.forLoop
+package org.jetbrains.kotlin.codegen.range.forLoop
 
 import org.jetbrains.kotlin.codegen.ExpressionCodegen
 import org.jetbrains.kotlin.codegen.StackValue
@@ -25,7 +25,7 @@ import org.jetbrains.org.objectweb.asm.Type
 abstract class AbstractForInProgressionOrRangeLoopGenerator(codegen: ExpressionCodegen, forExpression: KtForExpression)
     : AbstractForLoopGenerator(codegen, forExpression)
 {
-    protected var endVar: Int = 0
+    protected var endVar: Int = -1
 
     private var loopParameter: StackValue? = null
 

compiler/backend/src/org/jetbrains/kotlin/codegen/range/forLoop/AbstractForInRangeLoopGenerator.kt

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package org.jetbrains.kotlin.codegen.forLoop
+package org.jetbrains.kotlin.codegen.range.forLoop
 
 import org.jetbrains.kotlin.psi.KtForExpression
 import org.jetbrains.org.objectweb.asm.Label

compiler/backend/src/org/jetbrains/kotlin/codegen/range/forLoop/AbstractForInRangeWithGivenBoundsLoopGenerator.kt

@@ -0,0 +1,35 @@
+/*
+ * Copyright 2010-2017 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.range.forLoop
+
+import org.jetbrains.kotlin.codegen.ExpressionCodegen
+import org.jetbrains.kotlin.codegen.StackValue
+import org.jetbrains.kotlin.psi.KtForExpression
+
+abstract class AbstractForInRangeWithGivenBoundsLoopGenerator(
+        codegen: ExpressionCodegen,
+        forExpression: KtForExpression,
+        step: Int = 1
+) : AbstractForInRangeLoopGenerator(codegen, forExpression, step) {
+    protected abstract fun generateFrom(): StackValue
+    protected abstract fun generateTo(): StackValue
+
+    override fun storeRangeStartAndEnd() {
+        loopParameter().store(generateFrom(), v)
+        StackValue.local(endVar, asmElementType).store(generateTo(), v)
+    }
+}

compiler/backend/src/org/jetbrains/kotlin/codegen/range/forLoop/AbstractForLoopGenerator.kt

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package org.jetbrains.kotlin.codegen.forLoop
+package org.jetbrains.kotlin.codegen.range.forLoop
 
 import org.jetbrains.kotlin.codegen.ExpressionCodegen
 import org.jetbrains.kotlin.codegen.StackValue
@@ -30,8 +30,8 @@ import org.jetbrains.org.objectweb.asm.Type
 
 abstract class AbstractForLoopGenerator(
         protected val codegen: ExpressionCodegen,
-        val forExpression: KtForExpression
-) {
+        override val forExpression: KtForExpression
+) : ForLoopGenerator {
     protected val bindingContext = codegen.bindingContext
     protected val v = codegen.v!!
 
@@ -42,7 +42,7 @@ abstract class AbstractForLoopGenerator(
     protected val elementType: KotlinType = bindingContext.getElementType(forExpression)
     protected val asmElementType: Type = codegen.asmType(elementType)
 
-    protected var loopParameterVar: Int = 0
+    protected var loopParameterVar: Int = -1
     protected lateinit var loopParameterType: Type
 
     private fun BindingContext.getElementType(forExpression: KtForExpression): KotlinType {
@@ -52,7 +52,7 @@ abstract class AbstractForLoopGenerator(
         return nextCall.resultingDescriptor.returnType!!
     }
 
-    open fun beforeLoop() {
+    override fun beforeLoop() {
         val loopParameter = forExpression.loopParameter ?: return
         val multiParameter = loopParameter.destructuringDeclaration
         if (multiParameter != null) {
@@ -75,11 +75,7 @@ abstract class AbstractForLoopGenerator(
         }
     }
 
-    abstract fun checkEmptyLoop(loopExit: Label)
-
-    abstract fun checkPreCondition(loopExit: Label)
-
-    fun beforeBody() {
+    override fun beforeBody() {
         assignToLoopParameter()
         v.mark(loopParameterStartLabel)
 
@@ -118,7 +114,7 @@ abstract class AbstractForLoopGenerator(
 
     protected abstract fun checkPostConditionAndIncrement(loopExit: Label)
 
-    fun body() {
+    override fun body() {
         codegen.generateLoopBody(forExpression.body)
     }
 
@@ -132,7 +128,7 @@ abstract class AbstractForLoopGenerator(
         return varIndex
     }
 
-    fun afterBody(loopExit: Label) {
+    override fun afterBody(loopExit: Label) {
         codegen.markStartLineNumber(forExpression)
 
         checkPostConditionAndIncrement(loopExit)
@@ -140,7 +136,7 @@ abstract class AbstractForLoopGenerator(
         v.mark(bodyEnd)
     }
 
-    fun afterLoop() {
+    override fun afterLoop() {
         for (task in leaveVariableTasks.asReversed()) {
             task.run()
         }

compiler/backend/src/org/jetbrains/kotlin/codegen/range/forLoop/ForInArrayIndicesRangeLoopGenerator.kt

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package org.jetbrains.kotlin.codegen.forLoop
+package org.jetbrains.kotlin.codegen.range.forLoop
 
 import org.jetbrains.kotlin.codegen.ExpressionCodegen
 import org.jetbrains.kotlin.psi.KtForExpression

compiler/backend/src/org/jetbrains/kotlin/codegen/range/forLoop/ForInArrayLoopGenerator.kt

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package org.jetbrains.kotlin.codegen.forLoop
+package org.jetbrains.kotlin.codegen.range.forLoop
 
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns
 import org.jetbrains.kotlin.psi.KtForExpression

compiler/backend/src/org/jetbrains/kotlin/codegen/range/forLoop/ForInCharSequenceIndicesRangeLoopGenerator.kt

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package org.jetbrains.kotlin.codegen.forLoop
+package org.jetbrains.kotlin.codegen.range.forLoop
 
 import org.jetbrains.kotlin.codegen.ExpressionCodegen
 import org.jetbrains.kotlin.psi.KtForExpression

compiler/backend/src/org/jetbrains/kotlin/codegen/range/forLoop/ForInCharSequenceLoopGenerator.kt

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package org.jetbrains.kotlin.codegen.forLoop
+package org.jetbrains.kotlin.codegen.range.forLoop
 
 import org.jetbrains.kotlin.codegen.ExpressionCodegen
 import org.jetbrains.kotlin.codegen.StackValue

compiler/backend/src/org/jetbrains/kotlin/codegen/range/forLoop/ForInCollectionIndicesRangeLoopGenerator.kt

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package org.jetbrains.kotlin.codegen.forLoop
+package org.jetbrains.kotlin.codegen.range.forLoop
 
 import org.jetbrains.kotlin.codegen.ExpressionCodegen
 import org.jetbrains.kotlin.psi.KtForExpression

compiler/backend/src/org/jetbrains/kotlin/codegen/range/forLoop/ForInDownToProgressionLoopGenerator.kt

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package org.jetbrains.kotlin.codegen.forLoop
+package org.jetbrains.kotlin.codegen.range.forLoop
 
 import org.jetbrains.kotlin.codegen.ExpressionCodegen
 import org.jetbrains.kotlin.codegen.StackValue
@@ -27,12 +27,11 @@ class ForInDownToProgressionLoopGenerator(
         codegen: ExpressionCodegen,
         forExpression: KtForExpression,
         loopRangeCall: ResolvedCall<*>
-) : AbstractForInRangeLoopGenerator(codegen, forExpression, -1) {
+) : AbstractForInRangeWithGivenBoundsLoopGenerator(codegen, forExpression, -1) {
     private val from: ReceiverValue = loopRangeCall.extensionReceiver!!
     private val to: KtExpression = ExpressionCodegen.getSingleArgumentExpression(loopRangeCall)!!
 
-    override fun storeRangeStartAndEnd() {
-        loopParameter().store(codegen.generateReceiverValue(from, false), v)
-        StackValue.local(endVar, asmElementType).store(codegen.gen(to), v)
-    }
+    override fun generateFrom(): StackValue = codegen.generateReceiverValue(from, false)
+
+    override fun generateTo(): StackValue = codegen.gen(to)
 }

compiler/backend/src/org/jetbrains/kotlin/codegen/range/forLoop/ForInOptimizedIndicesLoopGenerator.kt

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package org.jetbrains.kotlin.codegen.forLoop
+package org.jetbrains.kotlin.codegen.range.forLoop
 
 import org.jetbrains.kotlin.codegen.ExpressionCodegen
 import org.jetbrains.kotlin.codegen.StackValue

compiler/backend/src/org/jetbrains/kotlin/codegen/range/forLoop/ForInProgressionExpressionLoopGenerator.kt

@@ -0,0 +1,34 @@
+/*
+ * Copyright 2010-2017 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.range.forLoop
+
+import org.jetbrains.kotlin.codegen.ExpressionCodegen
+import org.jetbrains.kotlin.psi.KtForExpression
+
+class ForInProgressionExpressionLoopGenerator(codegen: ExpressionCodegen, forExpression: KtForExpression)
+    : AbstractForInProgressionLoopGenerator(codegen, forExpression)
+{
+    override fun storeProgressionParametersToLocalVars() {
+        codegen.gen(forExpression.loopRange, asmLoopRangeType)
+        v.dup()
+        v.dup()
+
+        generateRangeOrProgressionProperty(asmLoopRangeType, "getFirst", asmElementType, loopParameterType, loopParameterVar)
+        generateRangeOrProgressionProperty(asmLoopRangeType, "getLast", asmElementType, asmElementType, endVar)
+        generateRangeOrProgressionProperty(asmLoopRangeType, "getStep", incrementType, incrementType, incrementVar)
+    }
+}

compiler/backend/src/org/jetbrains/kotlin/codegen/range/forLoop/ForInRangeInstanceLoopGenerator.kt

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package org.jetbrains.kotlin.codegen.forLoop
+package org.jetbrains.kotlin.codegen.range.forLoop
 
 import org.jetbrains.kotlin.codegen.ExpressionCodegen
 import org.jetbrains.kotlin.psi.KtForExpression
@@ -31,8 +31,7 @@ class ForInRangeInstanceLoopGenerator(
         v.dup()
 
         // ranges inherit first and last from corresponding progressions
-        generateRangeOrProgressionProperty(asmLoopRangeType, "getFirst", asmElementType, loopParameterType,
-                                           loopParameterVar)
+        generateRangeOrProgressionProperty(asmLoopRangeType, "getFirst", asmElementType, loopParameterType, loopParameterVar)
         generateRangeOrProgressionProperty(asmLoopRangeType, "getLast", asmElementType, asmElementType, endVar)
     }
 }

compiler/backend/src/org/jetbrains/kotlin/codegen/range/forLoop/ForInRangeLiteralLoopGenerator.kt

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package org.jetbrains.kotlin.codegen.forLoop
+package org.jetbrains.kotlin.codegen.range.forLoop
 
 import org.jetbrains.kotlin.codegen.ExpressionCodegen
 import org.jetbrains.kotlin.codegen.StackValue
@@ -27,12 +27,16 @@ class ForInRangeLiteralLoopGenerator(
         codegen: ExpressionCodegen,
         forExpression: KtForExpression,
         loopRangeCall: ResolvedCall<*>
-) : AbstractForInRangeLoopGenerator(codegen, forExpression) {
+) : AbstractForInRangeWithGivenBoundsLoopGenerator(codegen, forExpression) {
     private val from: ReceiverValue = loopRangeCall.dispatchReceiver!!
     private val to: KtExpression = ExpressionCodegen.getSingleArgumentExpression(loopRangeCall)!!
 
+    override fun generateFrom(): StackValue = codegen.generateReceiverValue(from, false)
+
+    override fun generateTo(): StackValue = codegen.gen(to)
+
     override fun storeRangeStartAndEnd() {
-        loopParameter().store(codegen.generateReceiverValue(from, false), codegen.v)
-        StackValue.local(endVar, asmElementType).store(codegen.gen(to), codegen.v)
+        loopParameter().store(generateFrom(), v)
+        StackValue.local(endVar, asmElementType).store(generateTo(), v)
     }
 }

compiler/backend/src/org/jetbrains/kotlin/codegen/range/forLoop/ForInUntilRangeLoopGenerator.kt

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package org.jetbrains.kotlin.codegen.forLoop
+package org.jetbrains.kotlin.codegen.range.forLoop
 
 import org.jetbrains.kotlin.codegen.ExpressionCodegen
 import org.jetbrains.kotlin.codegen.StackValue

compiler/backend/src/org/jetbrains/kotlin/codegen/range/forLoop/ForLoopGenerator.kt

@@ -14,18 +14,18 @@
  * limitations under the License.
  */
 
-package kotlin.script.experimental.dependencies
+package org.jetbrains.kotlin.codegen.range.forLoop
 
-import java.io.File
+import org.jetbrains.kotlin.psi.KtForExpression
+import org.jetbrains.org.objectweb.asm.Label
 
-data class ScriptDependencies(
-        val javaHome: File? = null,
-        val classpath: List<File> = emptyList(),
-        val imports: List<String> = emptyList(),
-        val sources: List<File> = emptyList(),
-        val scripts: List<File> = emptyList()
-) {
-    companion object {
-        val Empty = ScriptDependencies()
-    }
+interface ForLoopGenerator {
+    val forExpression: KtForExpression
+    fun beforeLoop()
+    fun checkEmptyLoop(loopExit: Label)
+    fun checkPreCondition(loopExit: Label)
+    fun beforeBody()
+    fun body()
+    fun afterBody(loopExit: Label)
+    fun afterLoop()
 }

compiler/backend/src/org/jetbrains/kotlin/codegen/range/forLoop/IteratorForLoopGenerator.kt

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package org.jetbrains.kotlin.codegen.forLoop
+package org.jetbrains.kotlin.codegen.range.forLoop
 
 import org.jetbrains.kotlin.codegen.ExpressionCodegen
 import org.jetbrains.kotlin.codegen.StackValue

compiler/backend/src/org/jetbrains/kotlin/codegen/range/inExpression/CallBasedInExpressionGenerator.kt

@@ -0,0 +1,54 @@
+/*
+ * Copyright 2010-2017 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.range.inExpression
+
+import org.jetbrains.kotlin.codegen.*
+import org.jetbrains.kotlin.lexer.KtTokens
+import org.jetbrains.kotlin.psi.KtSimpleNameExpression
+import org.jetbrains.kotlin.resolve.calls.callUtil.getResolvedCallWithAssert
+import org.jetbrains.org.objectweb.asm.Label
+import org.jetbrains.org.objectweb.asm.Opcodes
+import org.jetbrains.org.objectweb.asm.Type
+import org.jetbrains.org.objectweb.asm.commons.InstructionAdapter
+
+class CallBasedInExpressionGenerator(
+        val codegen: ExpressionCodegen,
+        operatorReference: KtSimpleNameExpression
+) : InExpressionGenerator {
+    private val resolvedCall = operatorReference.getResolvedCallWithAssert(codegen.bindingContext)
+    private val isInverted =  operatorReference.getReferencedNameElementType() == KtTokens.NOT_IN
+
+    override fun generate(argument: StackValue): BranchedValue =
+            gen(argument).let { if (isInverted) Invert(it) else it }
+
+    private fun gen(argument: StackValue): BranchedValue =
+            object : BranchedValue(argument, null, argument.type, Opcodes.IFEQ) {
+                override fun putSelector(type: Type, v: InstructionAdapter) {
+                    invokeFunction(v)
+                }
+
+                override fun condJump(jumpLabel: Label, v: InstructionAdapter, jumpIfFalse: Boolean) {
+                    invokeFunction(v)
+                    v.visitJumpInsn(if (jumpIfFalse) Opcodes.IFEQ else Opcodes.IFNE, jumpLabel)
+                }
+
+                private fun invokeFunction(v: InstructionAdapter) {
+                    val result = codegen.invokeFunction(resolvedCall.call, resolvedCall, none())
+                    result.put(result.type, v)
+                }
+            }
+}

compiler/backend/src/org/jetbrains/kotlin/codegen/range/inExpression/InContinuousRangeOfComparableExpressionGenerator.kt

@@ -0,0 +1,136 @@
+/*
+ * Copyright 2010-2017 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.range.inExpression
+
+import org.jetbrains.kotlin.codegen.AsmUtil
+import org.jetbrains.kotlin.codegen.BranchedValue
+import org.jetbrains.kotlin.codegen.Invert
+import org.jetbrains.kotlin.codegen.StackValue
+import org.jetbrains.kotlin.codegen.range.BoundedValue
+import org.jetbrains.kotlin.codegen.range.comparison.ObjectComparisonGenerator
+import org.jetbrains.kotlin.lexer.KtTokens
+import org.jetbrains.kotlin.psi.KtSimpleNameExpression
+import org.jetbrains.org.objectweb.asm.Label
+import org.jetbrains.org.objectweb.asm.Opcodes
+import org.jetbrains.org.objectweb.asm.commons.InstructionAdapter
+
+class InContinuousRangeOfComparableExpressionGenerator(
+        operatorReference: KtSimpleNameExpression,
+        private val boundedValue: BoundedValue
+) : InExpressionGenerator {
+    private val isNotIn = operatorReference.getReferencedNameElementType() == KtTokens.NOT_IN
+    private val comparisonGenerator = ObjectComparisonGenerator
+
+    override fun generate(argument: StackValue): BranchedValue =
+            gen(argument).let { if (isNotIn) Invert(it) else it }
+
+    private fun gen(argument: StackValue): BranchedValue =
+            object : BranchedValue(argument, null, comparisonGenerator.comparedType, Opcodes.IFEQ) {
+                override fun condJump(jumpLabel: Label, v: InstructionAdapter, jumpIfFalse: Boolean) {
+                    if (jumpIfFalse) {
+                        genJumpIfFalse(v, jumpLabel)
+                    }
+                    else {
+                        genJumpIfTrue(v, jumpLabel)
+                    }
+                }
+
+                private fun genJumpIfTrue(v: InstructionAdapter, jumpLabel: Label) {
+                    // if (arg is in range) goto jumpLabel
+
+                    val exitLabel1 = Label()
+                    val exitLabel2 = Label()
+
+                    boundedValue.putHighLow(v, operandType)
+                    arg1.put(operandType, v)
+                    AsmUtil.dupx(v, operandType)
+
+                    // On stack: high arg low arg
+                    // if (low bound is NOT satisfied) goto exitLabel1
+                    if (boundedValue.isLowInclusive) {
+                        // arg < low
+                        v.swap()
+                        comparisonGenerator.jumpIfLess(v, exitLabel1)
+                    }
+                    else {
+                        // arg <= low
+                        v.swap()
+                        comparisonGenerator.jumpIfLessOrEqual(v, exitLabel1)
+                    }
+
+                    // On stack: high arg
+                    // if (high bound is satisfied) goto jumpLabel
+                    if (boundedValue.isHighInclusive) {
+                        // arg <= high
+                        v.swap()
+                        comparisonGenerator.jumpIfLessOrEqual(v, jumpLabel)
+                    }
+                    else {
+                        // arg < high
+                        v.swap()
+                        comparisonGenerator.jumpIfLess(v, jumpLabel)
+                    }
+                    v.goTo(exitLabel2)
+
+                    v.mark(exitLabel1)
+                    AsmUtil.pop2(v, operandType)
+
+                    v.mark(exitLabel2)
+                }
+
+                private fun genJumpIfFalse(v: InstructionAdapter, jumpLabel: Label) {
+                    // if (arg is NOT in range) goto jumpLabel
+
+                    val cmpHighLabel = Label()
+
+                    boundedValue.putHighLow(v, operandType)
+                    arg1.put(operandType, v)
+                    AsmUtil.dupx(v, operandType)
+
+                    // On stack: high arg low arg
+                    // if ([low bound is satisfied]) goto cmpHighLabel
+                    if (boundedValue.isLowInclusive) {
+                        // arg >= low
+                        v.swap()
+                        comparisonGenerator.jumpIfGreaterOrEqual(v, cmpHighLabel)
+                    }
+                    else {
+                        // arg > low
+                        v.swap()
+                        comparisonGenerator.jumpIfGreater(v, cmpHighLabel)
+                    }
+
+                    // Low bound is NOT satisfied, clear stack and goto jumpLabel
+                    AsmUtil.pop2(v, operandType)
+                    v.goTo(jumpLabel)
+
+                    v.mark(cmpHighLabel)
+                    // On stack: high arg
+                    // if ([high bound is NOT satisfied]) goto jumpLabel
+                    if (boundedValue.isHighInclusive) {
+                        // arg > high
+                        v.swap()
+                        comparisonGenerator.jumpIfGreater(v, jumpLabel)
+                    }
+                    else {
+                        // arg >= high
+                        v.swap()
+                        comparisonGenerator.jumpIfGreaterOrEqual(v, jumpLabel)
+                    }
+                }
+            }
+}

compiler/backend/src/org/jetbrains/kotlin/codegen/range/inExpression/InExpressionGenerator.kt

@@ -14,10 +14,11 @@
  * limitations under the License.
  */
 
-package org.jetbrains.kotlin.gradle.utils
+package org.jetbrains.kotlin.codegen.range.inExpression
 
-import java.util.*
+import org.jetbrains.kotlin.codegen.BranchedValue
+import org.jetbrains.kotlin.codegen.StackValue
 
-// Based on org.jetbrains.kotlin.com.intellij.openapi.util.SystemInfoRt from Intellij platform
-internal val isWindows: Boolean =
-        System.getProperty("os.name")?.toLowerCase(Locale.US)?.startsWith("windows") ?: false
+interface InExpressionGenerator {
+    fun generate(argument: StackValue): BranchedValue
+}

compiler/backend/src/org/jetbrains/kotlin/codegen/range/inExpression/InPrimitiveContinuousRangeExpressionGenerator.kt

@@ -0,0 +1,128 @@
+/*
+ * Copyright 2010-2017 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.range.inExpression
+
+import org.jetbrains.kotlin.codegen.AsmUtil
+import org.jetbrains.kotlin.codegen.BranchedValue
+import org.jetbrains.kotlin.codegen.Invert
+import org.jetbrains.kotlin.codegen.StackValue
+import org.jetbrains.kotlin.codegen.range.BoundedValue
+import org.jetbrains.kotlin.codegen.range.comparison.ComparisonGenerator
+import org.jetbrains.kotlin.lexer.KtTokens
+import org.jetbrains.kotlin.psi.KtSimpleNameExpression
+import org.jetbrains.org.objectweb.asm.Label
+import org.jetbrains.org.objectweb.asm.Opcodes
+import org.jetbrains.org.objectweb.asm.commons.InstructionAdapter
+
+class InPrimitiveContinuousRangeExpressionGenerator(
+        operatorReference: KtSimpleNameExpression,
+        private val boundedValue: BoundedValue,
+        private val comparisonGenerator: ComparisonGenerator
+) : InExpressionGenerator {
+    private val isNotIn = operatorReference.getReferencedNameElementType() == KtTokens.NOT_IN
+
+    override fun generate(argument: StackValue): BranchedValue =
+            gen(argument).let { if (isNotIn) Invert(it) else it }
+
+    private fun gen(argument: StackValue): BranchedValue =
+            object : BranchedValue(argument, null, comparisonGenerator.comparedType, Opcodes.IFEQ) {
+                override fun condJump(jumpLabel: Label, v: InstructionAdapter, jumpIfFalse: Boolean) {
+                    if (jumpIfFalse) {
+                        genJumpIfFalse(v, jumpLabel)
+                    }
+                    else {
+                        genJumpIfTrue(v, jumpLabel)
+                    }
+                }
+
+                private fun genJumpIfTrue(v: InstructionAdapter, jumpLabel: Label) {
+                    // if (arg is in range) goto jumpLabel
+
+                    val exitLabel1 = Label()
+                    val exitLabel2 = Label()
+
+                    boundedValue.putHighLow(v, operandType)
+                    arg1.put(operandType, v)
+                    AsmUtil.dupx(v, operandType)
+
+                    // On stack: high arg low arg
+                    // if (low bound is NOT satisfied) goto exitLabel1
+                    if (boundedValue.isLowInclusive) {
+                        // low > arg
+                        comparisonGenerator.jumpIfGreater(v, exitLabel1)
+                    }
+                    else {
+                        // low >= arg
+                        comparisonGenerator.jumpIfGreaterOrEqual(v, exitLabel1)
+                    }
+
+                    // On stack: high arg
+                    // if (high bound is satisfied) goto jumpLabel
+                    if (boundedValue.isHighInclusive) {
+                        // high >= arg
+                        comparisonGenerator.jumpIfGreaterOrEqual(v, jumpLabel)
+                    }
+                    else {
+                        // high > arg
+                        comparisonGenerator.jumpIfGreater(v, jumpLabel)
+                    }
+                    v.goTo(exitLabel2)
+
+                    v.mark(exitLabel1)
+                    AsmUtil.pop2(v, operandType)
+
+                    v.mark(exitLabel2)
+                }
+
+                private fun genJumpIfFalse(v: InstructionAdapter, jumpLabel: Label) {
+                    // if (arg is NOT in range) goto jumpLabel
+
+                    val cmpHighLabel = Label()
+
+                    boundedValue.putHighLow(v, operandType)
+                    arg1.put(operandType, v)
+                    AsmUtil.dupx(v, operandType)
+
+                    // On stack: high arg low arg
+                    // if ([low bound is satisfied]) goto cmpHighLabel
+                    if (boundedValue.isLowInclusive) {
+                        // low <= arg
+                        comparisonGenerator.jumpIfLessOrEqual(v, cmpHighLabel)
+                    }
+                    else {
+                        // low < arg
+                        comparisonGenerator.jumpIfLess(v, cmpHighLabel)
+                    }
+
+                    // Low bound is NOT satisfied, clear stack and goto jumpLabel
+                    AsmUtil.pop2(v, operandType)
+                    v.goTo(jumpLabel)
+
+                    v.mark(cmpHighLabel)
+                    // On stack: high arg
+                    // if ([high bound is NOT satisfied]) goto jumpLabel
+                    if (boundedValue.isHighInclusive) {
+                        // high < arg
+                        comparisonGenerator.jumpIfLess(v, jumpLabel)
+                    }
+                    else {
+                        // high <= arg
+                        comparisonGenerator.jumpIfLessOrEqual(v, jumpLabel)
+                    }
+                }
+            }
+}

compiler/backend/src/org/jetbrains/kotlin/codegen/syntheticAccessorUtil.kt

@@ -17,6 +17,7 @@
 package org.jetbrains.kotlin.codegen
 
 import org.jetbrains.kotlin.descriptors.*
+import org.jetbrains.kotlin.resolve.DescriptorUtils
 
 enum class FieldAccessorKind(val suffix: String) {
     NORMAL("p"),
@@ -26,15 +27,18 @@ enum class FieldAccessorKind(val suffix: String) {
     override fun toString() = suffix
 }
 
+private fun CallableMemberDescriptor.getJvmName() =
+        DescriptorUtils.getJvmName(this) ?: name.asString()
+
 fun getAccessorNameSuffix(descriptor: CallableMemberDescriptor, superCallDescriptor: ClassDescriptor?,
                           accessorKind: FieldAccessorKind): String {
     val suffix = when (descriptor) {
         is ConstructorDescriptor ->
             return "will be ignored"
         is SimpleFunctionDescriptor ->
-            descriptor.name.asString()
+            descriptor.getJvmName()
         is PropertyDescriptor ->
-            descriptor.name.asString() + "$" + accessorKind
+            descriptor.getJvmName() + "$" + accessorKind
         else ->
             throw UnsupportedOperationException("Do not know how to create accessor for descriptor " + descriptor)
     }

compiler/cli/cli-common/src/org/jetbrains/kotlin/cli/common/arguments/CommonCompilerArguments.java

@@ -16,13 +16,6 @@
 
 package org.jetbrains.kotlin.cli.common.arguments;
 
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.kotlin.config.AnalysisFlag;
-
-import java.util.HashMap;
-import java.util.Map;
-
-@SuppressWarnings("WeakerAccess")
 public abstract class CommonCompilerArguments extends CommonToolArguments {
     public static final long serialVersionUID = 0L;
 
@@ -96,14 +89,6 @@ public abstract class CommonCompilerArguments extends CommonToolArguments {
     public static final String ERROR = "error";
     public static final String ENABLE = "enable";
 
-    @NotNull
-    public Map<AnalysisFlag<?>, Object> configureAnalysisFlags() {
-        Map<AnalysisFlag<?>, Object> result = new HashMap<>();
-        result.put(AnalysisFlag.getSkipMetadataVersionCheck(), skipMetadataVersionCheck);
-        result.put(AnalysisFlag.getMultiPlatformDoNotCheckImpl(), noCheckImpl);
-        return result;
-    }
-
     // Used only for serialize and deserialize settings. Don't use in other places!
     public static final class DummyImpl extends CommonCompilerArguments {}
 }

compiler/cli/cli-common/src/org/jetbrains/kotlin/cli/common/arguments/K2JVMCompilerArguments.java

@@ -16,14 +16,8 @@
 
 package org.jetbrains.kotlin.cli.common.arguments;
 
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.kotlin.config.AnalysisFlag;
-import org.jetbrains.kotlin.config.Jsr305State;
 import org.jetbrains.kotlin.config.JvmTarget;
 
-import java.util.Map;
-
-@SuppressWarnings("WeakerAccess")
 public class K2JVMCompilerArguments extends CommonCompilerArguments {
     public static final long serialVersionUID = 0L;
 
@@ -163,26 +157,9 @@ public class K2JVMCompilerArguments extends CommonCompilerArguments {
             description = "Java compiler arguments")
     public String[] javacArguments;
 
-    @Argument(
-            value = "-Xjsr305-annotations",
-            valueDescription = "{ignore|enable}",
-            description = "Specify global behavior for JSR-305 nullability annotations: ignore, or treat as other supported nullability annotations"
-    )
-    public String jsr305GlobalReportLevel = Jsr305State.DEFAULT.getDescription();
+    @Argument(value = "-Xload-jsr305-annotations", description = "Load JSR-305 nullability annotations")
+    public boolean loadJsr305annotations;
 
     // Paths to output directories for friend modules.
     public String[] friendPaths;
-
-    @Override
-    @NotNull
-    public Map<AnalysisFlag<?>, Object> configureAnalysisFlags() {
-        Map<AnalysisFlag<?>, Object> result = super.configureAnalysisFlags();
-        for (Jsr305State state : Jsr305State.values()) {
-            if (state.getDescription().equals(jsr305GlobalReportLevel)) {
-                result.put(AnalysisFlag.getLoadJsr305Annotations(), state);
-                break;
-            }
-        }
-        return result;
-    }
 }

compiler/cli/cli-common/src/org/jetbrains/kotlin/cli/common/arguments/parseCommandLineArguments.kt

@@ -18,6 +18,7 @@ package org.jetbrains.kotlin.cli.common.arguments
 
 import com.intellij.util.SmartList
 import java.lang.reflect.Field
+import java.util.*
 
 annotation class Argument(
         val value: String,
@@ -53,7 +54,7 @@ data class ArgumentParseErrors(
 )
 
 // Parses arguments into the passed [result] object. Errors related to the parsing will be collected into [CommonToolArguments.errors].
-fun <A : CommonToolArguments> parseCommandLineArguments(args: List<String>, result: A) {
+fun <A : CommonToolArguments> parseCommandLineArguments(args: Array<out String>, result: A) {
     data class ArgumentField(val field: Field, val argument: Argument)
 
     val fields = result::class.java.fields.mapNotNull { field ->

compiler/cli/cli-common/src/org/jetbrains/kotlin/cli/common/repl/KotlinJsr223JvmScriptEngineBase.kt

@@ -59,14 +59,13 @@ abstract class KotlinJsr223JvmScriptEngineBase(protected val myFactory: ScriptEn
         val codeLine = nextCodeLine(context, script)
         val state = getCurrentState(context)
         val result = replEvaluator.compileAndEval(state, codeLine, scriptArgs = overrideScriptArgs(context))
-        val ret = when (result) {
+        return when (result) {
             is ReplEvalResult.ValueResult -> result.value
             is ReplEvalResult.UnitResult -> null
             is ReplEvalResult.Error -> throw ScriptException(result.message)
             is ReplEvalResult.Incomplete -> throw ScriptException("error: incomplete code")
             is ReplEvalResult.HistoryMismatch -> throw ScriptException("Repl history mismatch at line: ${result.lineNo}")
         }
-        return ret
     }
 
     open fun compile(script: String, context: ScriptContext): CompiledScript {
@@ -91,14 +90,13 @@ abstract class KotlinJsr223JvmScriptEngineBase(protected val myFactory: ScriptEn
             throw ScriptException(e)
         }
 
-        val ret = when (result) {
+        return when (result) {
             is ReplEvalResult.ValueResult -> result.value
             is ReplEvalResult.UnitResult -> null
             is ReplEvalResult.Error -> throw ScriptException(result.message)
             is ReplEvalResult.Incomplete -> throw ScriptException("error: incomplete code")
             is ReplEvalResult.HistoryMismatch -> throw ScriptException("Repl history mismatch at line: ${result.lineNo}")
         }
-        return ret
     }
 
     class CompiledKotlinScript(val engine: KotlinJsr223JvmScriptEngineBase, val codeLine: ReplCodeLine, val compiledData: ReplCompileResult.CompiledClasses) : CompiledScript() {

compiler/cli/src/org/jetbrains/kotlin/cli/common/CLICompiler.java

@@ -189,12 +189,15 @@ public abstract class CLICompiler<A extends CommonCompilerArguments> extends CLI
             extraLanguageFeatures.put(LanguageFeature.Coroutines, coroutinesState);
         }
 
-        CommonConfigurationKeysKt.setLanguageVersionSettings(configuration, new LanguageVersionSettingsImpl(
-                languageVersion,
-                ApiVersion.createByLanguageVersion(apiVersion),
-                arguments.configureAnalysisFlags(),
-                extraLanguageFeatures
-        ));
+        LanguageVersionSettingsImpl settings =
+                new LanguageVersionSettingsImpl(languageVersion, ApiVersion.createByLanguageVersion(apiVersion), extraLanguageFeatures);
+        settings.switchFlag(AnalysisFlags.getSkipMetadataVersionCheck(), arguments.skipMetadataVersionCheck);
+        settings.switchFlag(AnalysisFlags.getMultiPlatformDoNotCheckImpl(), arguments.noCheckImpl);
+        configureAnalysisFlags(settings, arguments);
+        CommonConfigurationKeysKt.setLanguageVersionSettings(configuration, settings);
+    }
+
+    protected void configureAnalysisFlags(@NotNull LanguageVersionSettingsImpl settings, @NotNull A arguments) {
     }
 
     @Nullable

compiler/cli/src/org/jetbrains/kotlin/cli/common/CLITool.kt

@@ -45,7 +45,7 @@ abstract class CLITool<A : CommonToolArguments> {
         K2JVMCompiler.resetInitStartTime()
 
         val arguments = createArguments()
-        parseCommandLineArguments(args.asList(), arguments)
+        parseCommandLineArguments(args, arguments)
         val collector = PrintingMessageCollector(errStream, messageRenderer, arguments.verbose)
 
         try {
@@ -99,7 +99,7 @@ abstract class CLITool<A : CommonToolArguments> {
 
     // Used in kotlin-maven-plugin (KotlinCompileMojoBase) and in kotlin-gradle-plugin (KotlinJvmOptionsImpl, KotlinJsOptionsImpl)
     fun parseArguments(args: Array<out String>, arguments: A) {
-        parseCommandLineArguments(args.asList(), arguments)
+        parseCommandLineArguments(args, arguments)
         val message = validateArguments(arguments.errors)
         if (message != null) {
             throw IllegalArgumentException(message)