Update changeling for 1.2-Beta

(cherry picked from commit ab6bc43)

Kotlin.iml

@@ -32,6 +32,8 @@
       <excludeFolder url="file://$MODULE_DIR$/libraries/kotlin.test/jvm/build" />
       <excludeFolder url="file://$MODULE_DIR$/libraries/stdlib/build" />
       <excludeFolder url="file://$MODULE_DIR$/libraries/stdlib/common/build" />
+      <excludeFolder url="file://$MODULE_DIR$/libraries/stdlib/jdk7/build" />
+      <excludeFolder url="file://$MODULE_DIR$/libraries/stdlib/jdk8/build" />
       <excludeFolder url="file://$MODULE_DIR$/libraries/stdlib/jre7/build" />
       <excludeFolder url="file://$MODULE_DIR$/libraries/stdlib/jre8/build" />
       <excludeFolder url="file://$MODULE_DIR$/libraries/stdlib/js/build" />
@@ -83,4 +85,4 @@
     <orderEntry type="inheritedJdk" />
     <orderEntry type="sourceFolder" forTests="false" />
   </component>
-</module>
+</module>

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

@@ -34,7 +34,7 @@ public class FieldInfo {
         }
 
         if (isNonCompanionObject(classDescriptor) || CompanionObjectMapping.INSTANCE.isMappedIntrinsicCompanionObject(classDescriptor)) {
-            return createSingletonViaInstance(classDescriptor, typeMapper);
+            return createSingletonViaInstance(classDescriptor, typeMapper, JvmAbi.INSTANCE_FIELD);
         }
 
         ClassDescriptor ownerDescriptor = DescriptorUtils.getParentOfType(classDescriptor, ClassDescriptor.class);
@@ -46,10 +46,11 @@ public class FieldInfo {
     @NotNull
     public static FieldInfo createSingletonViaInstance(
             @NotNull ClassDescriptor classDescriptor,
-            @NotNull KotlinTypeMapper typeMapper
+            @NotNull KotlinTypeMapper typeMapper,
+            @NotNull String name
     ) {
         Type type = typeMapper.mapType(classDescriptor);
-        return new FieldInfo(type, type, JvmAbi.INSTANCE_FIELD, true);
+        return new FieldInfo(type, type, name, true);
     }
 
     @NotNull

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

@@ -39,7 +39,6 @@ import org.jetbrains.kotlin.config.LanguageFeature;
 import org.jetbrains.kotlin.descriptors.*;
 import org.jetbrains.kotlin.incremental.components.NoLookupLocation;
 import org.jetbrains.kotlin.lexer.KtTokens;
-import org.jetbrains.kotlin.load.java.JvmAbi;
 import org.jetbrains.kotlin.load.java.descriptors.JavaClassDescriptor;
 import org.jetbrains.kotlin.load.kotlin.TypeMappingMode;
 import org.jetbrains.kotlin.name.ClassId;
@@ -77,6 +76,7 @@ import static org.jetbrains.kotlin.codegen.CodegenUtilKt.isNonGenericToArray;
 import static org.jetbrains.kotlin.codegen.JvmCodegenUtil.*;
 import static org.jetbrains.kotlin.codegen.binding.CodegenBinding.enumEntryNeedSubclass;
 import static org.jetbrains.kotlin.codegen.inline.InlineCodegenUtils2Kt.initDefaultSourceMappingIfNeeded;
+import static org.jetbrains.kotlin.load.java.JvmAbi.*;
 import static org.jetbrains.kotlin.resolve.BindingContextUtils.getDelegationConstructorCall;
 import static org.jetbrains.kotlin.resolve.BindingContextUtils.getNotNull;
 import static org.jetbrains.kotlin.resolve.DescriptorToSourceUtils.descriptorToDeclaration;
@@ -354,6 +354,8 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
     protected void generateSyntheticPartsAfterBody() {
         generateFieldForSingleton();
 
+        initializeObjects();
+
         generateCompanionObjectBackingFieldCopies();
 
         generateTraitMethods();
@@ -811,21 +813,21 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
     }
 
     private void generateFieldForSingleton() {
+        if (isCompanionObjectInInterfaceNotIntrinsic(descriptor)) {
+            StackValue.Field field = StackValue.createSingletonViaInstance(descriptor, typeMapper, HIDDEN_INSTANCE_FIELD);
+            //hidden instance in interface companion
+            v.newField(JvmDeclarationOriginKt.OtherOrigin(descriptor),
+                       ACC_SYNTHETIC | ACC_STATIC | ACC_FINAL, field.name, field.type.getDescriptor(), null, null);
+        }
+
         if (isEnumEntry(descriptor) || isCompanionObject(descriptor)) return;
 
         if (isNonCompanionObject(descriptor)) {
-            StackValue.Field field = StackValue.singletonViaInstance(descriptor, typeMapper);
+            StackValue.Field field = StackValue.createSingletonViaInstance(descriptor, typeMapper, INSTANCE_FIELD);
             v.newField(JvmDeclarationOriginKt.OtherOriginFromPure(myClass),
                        ACC_PUBLIC | ACC_STATIC | ACC_FINAL,
                        field.name, field.type.getDescriptor(), null, null);
 
-            if (!state.getClassBuilderMode().generateBodies) return;
-            // Invoke the object constructor but ignore the result because INSTANCE will be initialized in the first line of <init>
-            InstructionAdapter v = createOrGetClInitCodegen().v;
-            markLineNumberForElement(element.getPsiOrParent(), v);
-            v.anew(classAsmType);
-            v.invokespecial(classAsmType.getInternalName(), "<init>", "()V", false);
-
             return;
         }
 
@@ -853,6 +855,60 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
         }
     }
 
+    private void initializeObjects() {
+        if (!DescriptorUtils.isObject(descriptor)) return;
+        if (!state.getClassBuilderMode().generateBodies) return;
+
+        boolean isNonCompanionObject = isNonCompanionObject(descriptor);
+        boolean isInterfaceCompanion = isCompanionObjectInInterfaceNotIntrinsic(descriptor);
+        boolean isMappedIntrinsicCompanionObject = isMappedIntrinsicCompanionObject(descriptor);
+        if (isNonCompanionObject || isInterfaceCompanion || isMappedIntrinsicCompanionObject) {
+            ExpressionCodegen clInitCodegen = createOrGetClInitCodegen();
+            InstructionAdapter v = clInitCodegen.v;
+            markLineNumberForElement(element.getPsiOrParent(), v);
+            v.anew(classAsmType);
+            v.dup();
+            v.invokespecial(classAsmType.getInternalName(), "<init>", "()V", false);
+
+            //local0 emulates this in object constructor
+            int local0Index = clInitCodegen.getFrameMap().enterTemp(classAsmType);
+            assert local0Index == 0 : "Local variable with index 0 in clInit should be used only for singleton instance keeping";
+            StackValue.Local local0 = StackValue.local(0, classAsmType);
+            local0.store(StackValue.onStack(classAsmType), clInitCodegen.v);
+            StackValue.Field singleton =
+                    StackValue.createSingletonViaInstance(
+                            descriptor, typeMapper, isInterfaceCompanion ? HIDDEN_INSTANCE_FIELD : INSTANCE_FIELD
+            );
+            singleton.store(local0, clInitCodegen.v);
+
+            generateInitializers(clInitCodegen);
+
+            if (isInterfaceCompanion) {
+                //initialize singleton instance in outer by hidden instance
+                StackValue.singleton(descriptor, typeMapper).store(
+                        singleton, getParentCodegen().createOrGetClInitCodegen().v, true
+                );
+            }
+        }
+        else if (isCompanionObjectWithBackingFieldsInOuter(descriptor)) {
+            ImplementationBodyCodegen parentCodegen = (ImplementationBodyCodegen) getParentCodegen();
+            ExpressionCodegen parentClInitCodegen = parentCodegen.createOrGetClInitCodegen();
+            InstructionAdapter parentVisitor = parentClInitCodegen.v;
+
+            FunctionDescriptor constructor = (FunctionDescriptor) parentCodegen.context.accessibleDescriptor(
+                    CollectionsKt.single(descriptor.getConstructors()), /* superCallExpression = */ null
+            );
+            parentCodegen.generateMethodCallTo(constructor, null, parentVisitor);
+            StackValue instance = StackValue.onStack(parentCodegen.typeMapper.mapClass(descriptor));
+            StackValue.singleton(descriptor, parentCodegen.typeMapper).store(instance, parentVisitor, true);
+
+            generateInitializers(parentClInitCodegen);
+        }
+        else {
+            assert false : "Unknown object type: " + descriptor;
+        }
+    }
+
     private void generateCompanionObjectBackingFieldCopies() {
         if (companionObjectPropertiesToCopy == null) return;
 
@@ -900,17 +956,6 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
         field.store(property, codegen.v);
     }
 
-    private void generateCompanionObjectInitializer(@NotNull ClassDescriptor companionObject) {
-        ExpressionCodegen codegen = createOrGetClInitCodegen();
-
-        FunctionDescriptor constructor = (FunctionDescriptor) context.accessibleDescriptor(
-                CollectionsKt.single(companionObject.getConstructors()), /* superCallExpression = */ null
-        );
-        generateMethodCallTo(constructor, null, codegen.v);
-        StackValue instance = StackValue.onStack(typeMapper.mapClass(companionObject));
-        StackValue.singleton(companionObject, typeMapper).store(instance, codegen.v, true);
-    }
-
     private void generatePrimaryConstructor(DelegationFieldsInfo delegationFieldsInfo) {
         if (isInterface(descriptor) || isAnnotationClass(descriptor)) return;
 
@@ -978,10 +1023,6 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
         generateDelegatorToConstructorCall(iv, codegen, constructorDescriptor,
                                            getDelegationConstructorCall(bindingContext, constructorDescriptor));
 
-        if (isNonCompanionObject(descriptor)) {
-            StackValue.singletonViaInstance(descriptor, typeMapper).store(StackValue.LOCAL_0, iv);
-        }
-
         for (KtSuperTypeListEntry specifier : myClass.getSuperTypeListEntries()) {
             if (specifier instanceof KtDelegatedSuperTypeEntry) {
                 genCallToDelegatorByExpressionSpecifier(iv, codegen, (KtDelegatedSuperTypeEntry) specifier, fieldsInfo);
@@ -1003,18 +1044,10 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
             curParam++;
         }
 
-        if (isCompanionObject(descriptor)) {
-            ImplementationBodyCodegen parentCodegen = (ImplementationBodyCodegen) getParentCodegen();
-            parentCodegen.generateCompanionObjectInitializer(descriptor);
-        }
-
-        if (JvmAbi.isCompanionObjectWithBackingFieldsInOuter(descriptor)) {
-            generateInitializers(((ImplementationBodyCodegen) getParentCodegen())::createOrGetClInitCodegen);
-        }
-        else {
+        //object initialization was moved to initializeObjects()
+        if (!isObject(descriptor)) {
             generateInitializers(codegen);
         }
-
         iv.visitInsn(RETURN);
     }
 
@@ -1159,7 +1192,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
 
                     if (asmType == null) continue;
 
-                    result.addField((KtDelegatedSuperTypeEntry) specifier, asmType, JvmAbi.DELEGATE_SUPER_FIELD_PREFIX + n);
+                    result.addField((KtDelegatedSuperTypeEntry) specifier, asmType, DELEGATE_SUPER_FIELD_PREFIX + n);
                 }
                 n++;
             }

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

@@ -608,8 +608,8 @@ public abstract class StackValue {
         return field(FieldInfo.createForSingleton(classDescriptor, typeMapper), none());
     }
 
-    public static Field singletonViaInstance(ClassDescriptor classDescriptor, KotlinTypeMapper typeMapper) {
-        return field(FieldInfo.createSingletonViaInstance(classDescriptor, typeMapper), none());
+    public static Field createSingletonViaInstance(@NotNull ClassDescriptor classDescriptor, @NotNull KotlinTypeMapper typeMapper, @NotNull String name) {
+        return field(FieldInfo.createSingletonViaInstance(classDescriptor, typeMapper, name), none());
     }
 
     public static StackValue operation(Type type, Function1<InstructionAdapter, Unit> lambda) {

compiler/builtins-serializer/src/org/jetbrains/kotlin/serialization/builtins/BuiltInsSerializer.kt

@@ -74,7 +74,8 @@ class BuiltInsSerializer(dependOnOldBuiltIns: Boolean) : MetadataSerializer(depe
     }
 
     private fun createMessageCollector() = object : GroupingMessageCollector(
-            PrintingMessageCollector(System.err, MessageRenderer.PLAIN_RELATIVE_PATHS, /* verbose = */ false)
+            PrintingMessageCollector(System.err, MessageRenderer.PLAIN_RELATIVE_PATHS, false),
+            false
     ) {
         override fun report(severity: CompilerMessageSeverity, message: String, location: CompilerMessageLocation?) {
             // Only report diagnostics without a particular location because there's plenty of errors in built-in sources

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

@@ -44,4 +44,8 @@ abstract class CommonToolArguments : Freezable(), Serializable {
     @GradleOption(DefaultValues.BooleanFalseDefault::class)
     @Argument(value = "-nowarn", description = "Generate no warnings")
     var suppressWarnings: Boolean by FreezableVar(false)
+
+    @GradleOption(DefaultValues.BooleanFalseDefault::class)
+    @Argument(value = "-Werror", description = "Report an error if there are any warnings")
+    var warningsAsErrors: Boolean by FreezableVar(false)
 }

compiler/cli/cli-common/src/org/jetbrains/kotlin/cli/common/messages/CompilerMessageSeverity.java

@@ -35,11 +35,14 @@ public enum CompilerMessageSeverity {
      */
     OUTPUT;
 
-    public static final EnumSet<CompilerMessageSeverity> ERRORS = EnumSet.of(ERROR, EXCEPTION);
     public static final EnumSet<CompilerMessageSeverity> VERBOSE = EnumSet.of(LOGGING);
 
     public boolean isError() {
-        return ERRORS.contains(this);
+        return this == EXCEPTION || this == ERROR;
+    }
+
+    public boolean isWarning() {
+        return this == STRONG_WARNING || this == WARNING;
     }
 
     @NotNull

compiler/cli/cli-common/src/org/jetbrains/kotlin/cli/common/messages/GroupingMessageCollector.java

@@ -24,16 +24,19 @@ import org.jetbrains.annotations.Nullable;
 
 import java.util.Comparator;
 import java.util.List;
+import java.util.Map;
 import java.util.Objects;
 
 public class GroupingMessageCollector implements MessageCollector {
     private final MessageCollector delegate;
+    private final boolean treatWarningsAsErrors;
 
     // Note that the key in this map can be null
     private final Multimap<CompilerMessageLocation, Message> groupedMessages = LinkedHashMultimap.create();
 
-    public GroupingMessageCollector(@NotNull MessageCollector delegate) {
+    public GroupingMessageCollector(@NotNull MessageCollector delegate, boolean treatWarningsAsErrors) {
         this.delegate = delegate;
+        this.treatWarningsAsErrors = treatWarningsAsErrors;
     }
 
     @Override
@@ -57,17 +60,29 @@ public class GroupingMessageCollector implements MessageCollector {
 
     @Override
     public boolean hasErrors() {
+        return hasExplicitErrors() || (treatWarningsAsErrors && hasWarnings());
+    }
+
+    private boolean hasExplicitErrors() {
         return groupedMessages.entries().stream().anyMatch(entry -> entry.getValue().severity.isError());
     }
 
+    private boolean hasWarnings() {
+        return groupedMessages.entries().stream().anyMatch(entry -> entry.getValue().severity.isWarning());
+    }
+
     public void flush() {
-        boolean hasErrors = hasErrors();
+        boolean hasExplicitErrors = hasExplicitErrors();
+
+        if (treatWarningsAsErrors && !hasExplicitErrors && hasWarnings()) {
+            report(CompilerMessageSeverity.ERROR, "warnings found and -Werror specified", null);
+        }
 
         List<CompilerMessageLocation> sortedKeys =
                 CollectionsKt.sortedWith(groupedMessages.keySet(), Comparator.nullsFirst(CompilerMessageLocationComparator.INSTANCE));
         for (CompilerMessageLocation location : sortedKeys) {
             for (Message message : groupedMessages.get(location)) {
-                if (!hasErrors || message.severity.isError() || message.severity == CompilerMessageSeverity.STRONG_WARNING) {
+                if (!hasExplicitErrors || message.severity.isError() || message.severity == CompilerMessageSeverity.STRONG_WARNING) {
                     delegate.report(message.severity, message.message, message.location);
                 }
             }

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

@@ -65,7 +65,7 @@ public abstract class CLICompiler<A extends CommonCompilerArguments> extends CLI
     @NotNull
     @Override
     public ExitCode execImpl(@NotNull MessageCollector messageCollector, @NotNull Services services, @NotNull A arguments) {
-        GroupingMessageCollector groupingCollector = new GroupingMessageCollector(messageCollector);
+        GroupingMessageCollector groupingCollector = new GroupingMessageCollector(messageCollector, arguments.getWarningsAsErrors());
 
         CompilerConfiguration configuration = new CompilerConfiguration();
         configuration.put(CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY, groupingCollector);

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

@@ -81,7 +81,7 @@ abstract class CLITool<A : CommonToolArguments> {
     fun exec(messageCollector: MessageCollector, services: Services, arguments: A): ExitCode {
         printVersionIfNeeded(messageCollector, arguments)
 
-        val fixedMessageCollector = if (arguments.suppressWarnings) {
+        val fixedMessageCollector = if (arguments.suppressWarnings && !arguments.warningsAsErrors) {
             FilteringMessageCollector(messageCollector, Predicate.isEqual(CompilerMessageSeverity.WARNING))
         }
         else {

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/repl/messages/ReplTerminalDiagnosticMessageHolder.kt

@@ -28,7 +28,8 @@ class ReplTerminalDiagnosticMessageHolder : MessageCollectorBasedReporter, Diagn
     private val outputStream = ByteArrayOutputStream()
 
     override val messageCollector: GroupingMessageCollector = GroupingMessageCollector(
-            PrintingMessageCollector(PrintStream(outputStream), MessageRenderer.WITHOUT_PATHS, false)
+            PrintingMessageCollector(PrintStream(outputStream), MessageRenderer.WITHOUT_PATHS, false),
+            false
     )
 
     override val renderedDiagnostics: String

compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/diagnostics/DefaultErrorMessagesJvm.java

@@ -115,7 +115,7 @@ public class DefaultErrorMessagesJvm implements DefaultErrorMessages.Extension {
                 "Please make explicit overrides (abstract or concrete) for the following non-abstract members of ''{1}'': {2}",
                 NAME, NAME, STRING);
 
-        MAP.put(DEFAULT_METHOD_CALL_FROM_JAVA6_TARGET, "Super calls to Java default methods are deprecated in JVM target 1.6. Recompile with '-jvm-target 1.8'");
+        MAP.put(DEFAULT_METHOD_CALL_FROM_JAVA6_TARGET, "Super calls to Java default methods are prohibited in JVM target 1.6. Recompile with '-jvm-target 1.8'");
         MAP.put(INTERFACE_STATIC_METHOD_CALL_FROM_JAVA6_TARGET, "Calls to static methods in Java interfaces are deprecated in JVM target 1.6. Recompile with '-jvm-target 1.8'");
 
         MAP.put(INLINE_FROM_HIGHER_PLATFORM, "Cannot inline bytecode built with {0} into bytecode that is being built with {1}. Please specify proper ''-jvm-target'' option", STRING, STRING);

compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/diagnostics/ErrorsJvm.java

@@ -96,7 +96,7 @@ public interface ErrorsJvm {
 
     DiagnosticFactory3<PsiElement, DeclarationDescriptor, DeclarationDescriptor, String> TARGET6_INTERFACE_INHERITANCE = DiagnosticFactory3.create(ERROR);
 
-    DiagnosticFactory0<PsiElement> DEFAULT_METHOD_CALL_FROM_JAVA6_TARGET = DiagnosticFactory0.create(WARNING);
+    DiagnosticFactory0<PsiElement> DEFAULT_METHOD_CALL_FROM_JAVA6_TARGET = DiagnosticFactory0.create(ERROR);
     DiagnosticFactory0<PsiElement> INTERFACE_STATIC_METHOD_CALL_FROM_JAVA6_TARGET = DiagnosticFactory0.create(WARNING);
 
     DiagnosticFactory2<PsiElement, String, String> INLINE_FROM_HIGHER_PLATFORM = DiagnosticFactory2.create(ERROR);

compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DefaultErrorMessages.java

@@ -276,7 +276,7 @@ public class DefaultErrorMessages {
         MAP.put(ACTUAL_TYPE_ALIAS_WITH_USE_SITE_VARIANCE, "Right-hand side of actual type alias cannot contain use-site variance or star projections");
         MAP.put(ACTUAL_TYPE_ALIAS_WITH_COMPLEX_SUBSTITUTION, "Type arguments in the right-hand side of actual type alias should be its type parameters in the same order, e.g. 'actual typealias Foo<A, B> = Bar<A, B>'");
 
-        MAP.put(NO_ACTUAL_FOR_EXPECT, "Expected {0} has no actual in module{1}{2}", DECLARATION_NAME_WITH_KIND,
+        MAP.put(NO_ACTUAL_FOR_EXPECT, "Expected {0} has no actual declaration in module{1}{2}", DECLARATION_NAME_WITH_KIND,
                 PLATFORM, PlatformIncompatibilityDiagnosticRenderer.TEXT);
         MAP.put(ACTUAL_WITHOUT_EXPECT, "Actual {0} has no corresponding expected declaration{1}", DECLARATION_NAME_WITH_KIND,
                 PlatformIncompatibilityDiagnosticRenderer.TEXT);

compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/PlatformIncompatibilityDiagnosticRenderer.kt

@@ -101,7 +101,7 @@ private fun StringBuilder.renderIncompatibilityInformation(
 
         if (incompatibility is Incompatible.ClassScopes) {
             append(indent)
-            append("No actuals are found for expected members listed below:")
+            append("No actual members are found for expected members listed below:")
             mode.newLine(this)
             renderIncompatibleClassScopes(incompatibility.unfulfilled, indent, context, mode)
         }

compiler/frontend/src/org/jetbrains/kotlin/resolve/BindingContext.java

@@ -258,6 +258,7 @@ public interface BindingContext {
     WritableSlice<FqNameUnsafe, ClassDescriptor> FQNAME_TO_CLASS_DESCRIPTOR = new BasicWritableSlice<>(DO_NOTHING, true);
     WritableSlice<KtFile, PackageFragmentDescriptor> FILE_TO_PACKAGE_FRAGMENT = Slices.createSimpleSlice();
     WritableSlice<FqName, Collection<KtFile>> PACKAGE_TO_FILES = Slices.createSimpleSlice();
+    WritableSlice<KtBinaryExpressionWithTypeRHS, Boolean> CAST_TYPE_USED_AS_EXPECTED_TYPE = Slices.createSimpleSlice();
 
     WritableSlice<KtFunction, KotlinResolutionCallbacksImpl.LambdaInfo> NEW_INFERENCE_LAMBDA_INFO = new BasicWritableSlice<>(DO_NOTHING);
 

compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/GenericCandidateResolver.kt

@@ -20,11 +20,16 @@ import org.jetbrains.kotlin.builtins.KotlinBuiltIns
 import org.jetbrains.kotlin.builtins.ReflectionTypes
 import org.jetbrains.kotlin.builtins.isBuiltinFunctionalTypeOrSubtype
 import org.jetbrains.kotlin.builtins.isFunctionTypeOrSubtype
+import org.jetbrains.kotlin.config.LanguageFeature
+import org.jetbrains.kotlin.config.LanguageVersionSettings
 import org.jetbrains.kotlin.descriptors.CallableDescriptor
+import org.jetbrains.kotlin.descriptors.FunctionDescriptor
 import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor
 import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor
 import org.jetbrains.kotlin.descriptors.impl.TypeAliasConstructorDescriptor
+import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.psi.*
+import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.FunctionDescriptorUtil
 import org.jetbrains.kotlin.resolve.TemporaryBindingTrace
 import org.jetbrains.kotlin.resolve.calls.callResolverUtil.*
@@ -39,6 +44,7 @@ import org.jetbrains.kotlin.resolve.calls.context.ResolutionResultsCache
 import org.jetbrains.kotlin.resolve.calls.context.TemporaryTraceAndCache
 import org.jetbrains.kotlin.resolve.calls.inference.*
 import org.jetbrains.kotlin.resolve.calls.inference.constraintPosition.ConstraintPosition
+import org.jetbrains.kotlin.resolve.calls.inference.constraintPosition.ConstraintPositionKind
 import org.jetbrains.kotlin.resolve.calls.inference.constraintPosition.ConstraintPositionKind.RECEIVER_POSITION
 import org.jetbrains.kotlin.resolve.calls.inference.constraintPosition.ConstraintPositionKind.VALUE_PARAMETER_POSITION
 import org.jetbrains.kotlin.resolve.calls.inference.constraintPosition.ValidityConstraintForConstituentType
@@ -53,12 +59,16 @@ import org.jetbrains.kotlin.types.*
 import org.jetbrains.kotlin.types.TypeUtils.DONT_CARE
 import org.jetbrains.kotlin.types.expressions.ControlStructureTypingUtils.ResolveConstruct
 import org.jetbrains.kotlin.types.expressions.ExpressionTypingUtils
+import org.jetbrains.kotlin.types.typeUtil.contains
+import org.jetbrains.kotlin.types.typeUtil.makeNullable
+import org.jetbrains.kotlin.utils.addToStdlib.safeAs
 
 private val SPECIAL_FUNCTION_NAMES = ResolveConstruct.values().map { it.specialFunctionName }.toSet()
 
 class GenericCandidateResolver(
         private val argumentTypeResolver: ArgumentTypeResolver,
-        private val coroutineInferenceSupport: CoroutineInferenceSupport
+        private val coroutineInferenceSupport: CoroutineInferenceSupport,
+        private val languageVersionSettings: LanguageVersionSettings
 ) {
     fun <D : CallableDescriptor> inferTypeArguments(context: CallCandidateResolutionContext<D>): ResolutionStatus {
         val candidateCall = context.candidateCall
@@ -116,11 +126,68 @@ class GenericCandidateResolver(
         // Solution
         val hasContradiction = constraintSystem.status.hasContradiction()
         if (!hasContradiction) {
+            addExpectedTypeForExplicitCast(context, builder)
             return INCOMPLETE_TYPE_INFERENCE
         }
         return OTHER_ERROR
     }
 
+    private fun ConstraintSystem.Builder.typeInSystem(call: Call, type: KotlinType?): KotlinType? =
+            type?.let {
+                typeVariableSubstitutors[call.toHandle()]?.substitute(it, Variance.INVARIANT)
+            }
+
+    private fun FunctionDescriptor.isFunctionForExpectTypeFromCastFeature(): Boolean {
+        val typeParameter = typeParameters.singleOrNull() ?: return false
+
+        val returnType = returnType ?: return false
+        if (returnType is DeferredType && returnType.isComputing) return false
+
+        if (returnType.constructor != typeParameter.typeConstructor) return false
+
+        fun KotlinType.isBadType() = contains { it.constructor == typeParameter.typeConstructor }
+
+        if (valueParameters.any { it.type.isBadType() } || extensionReceiverParameter?.type?.isBadType() == true) return false
+
+        return true
+    }
+
+    private fun addExpectedTypeForExplicitCast(
+            context: CallCandidateResolutionContext<*>,
+            builder: ConstraintSystem.Builder
+    ) {
+        if (!languageVersionSettings.supportsFeature(LanguageFeature.ExpectedTypeFromCast)) return
+
+        if (context.candidateCall is VariableAsFunctionResolvedCall) return
+
+        val candidateDescriptor = context.candidateCall.candidateDescriptor.safeAs<FunctionDescriptor>() ?: return
+
+        val binaryParent = getBinaryWithTypeParent(context.call.calleeExpression) ?: return
+        val operationType = binaryParent.operationReference.getReferencedNameElementType().takeIf {
+            it == KtTokens.AS_KEYWORD || it == KtTokens.AS_SAFE
+        } ?: return
+
+        val leftType = context.trace.get(BindingContext.TYPE, binaryParent.right ?: return) ?: return
+        val expectedType = if (operationType == KtTokens.AS_SAFE) leftType.makeNullable() else leftType
+
+        if (context.candidateCall.call.typeArgumentList != null || !candidateDescriptor.isFunctionForExpectTypeFromCastFeature()) return
+
+        val typeInSystem = builder.typeInSystem(context.call, candidateDescriptor.returnType ?: return) ?: return
+
+        context.trace.record(BindingContext.CAST_TYPE_USED_AS_EXPECTED_TYPE, binaryParent)
+        builder.addSubtypeConstraint(typeInSystem, expectedType, ConstraintPositionKind.SPECIAL.position())
+    }
+
+    private fun getBinaryWithTypeParent(calleeExpression: KtExpression?): KtBinaryExpressionWithTypeRHS? {
+        val callExpression = calleeExpression?.parent.safeAs<KtCallExpression>() ?: return null
+        val parent = callExpression.parent
+        return when (parent) {
+            is KtBinaryExpressionWithTypeRHS -> parent
+            is KtQualifiedExpression -> parent.parent.safeAs<KtBinaryExpressionWithTypeRHS>().takeIf { parent.selectorExpression == callExpression }
+            else -> null
+        }
+    }
+
     private fun addValidityConstraintsForConstituentTypes(builder: ConstraintSystem.Builder, type: KotlinType) {
         val typeConstructor = type.constructor
         if (typeConstructor.declarationDescriptor is TypeParameterDescriptor) return

compiler/frontend/src/org/jetbrains/kotlin/types/expressions/BasicExpressionTypingVisitor.java

@@ -366,6 +366,8 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
     ) {
         if (actualType == null || noExpectedType(targetType) || KotlinTypeKt.isError(targetType)) return;
 
+        if (Boolean.TRUE.equals(context.trace.get(BindingContext.CAST_TYPE_USED_AS_EXPECTED_TYPE, expression))) return;
+
         if (DynamicTypesKt.isDynamic(targetType)) {
             KtTypeReference right = expression.getRight();
             assert right != null : "We know target is dynamic, but RHS is missing";

compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/tower/TowerLevels.kt

@@ -23,6 +23,7 @@ import org.jetbrains.kotlin.resolve.calls.USE_NEW_INFERENCE
 import org.jetbrains.kotlin.resolve.calls.smartcasts.getReceiverValueWithSmartCast
 import org.jetbrains.kotlin.resolve.calls.util.FakeCallableDescriptorForObject
 import org.jetbrains.kotlin.resolve.calls.util.FakeCallableDescriptorForTypeAliasObject
+import org.jetbrains.kotlin.resolve.calls.util.isLowPriorityFromStdlibJre7Or8
 import org.jetbrains.kotlin.resolve.descriptorUtil.HIDES_MEMBERS_NAME_LIST
 import org.jetbrains.kotlin.resolve.descriptorUtil.hasClassValueDescriptor
 import org.jetbrains.kotlin.resolve.descriptorUtil.hasHidesMembersAnnotation
@@ -59,7 +60,9 @@ internal abstract class AbstractScopeTowerLevel(
             diagnostics.add(ErrorDescriptorDiagnostic)
         }
         else {
-            if (descriptor.hasLowPriorityInOverloadResolution()) diagnostics.add(LowPriorityDescriptorDiagnostic)
+            if (descriptor.hasLowPriorityInOverloadResolution() || descriptor.isLowPriorityFromStdlibJre7Or8()) {
+                diagnostics.add(LowPriorityDescriptorDiagnostic)
+            }
             if (dispatchReceiverSmartCastType != null) diagnostics.add(UsedSmartCastForDispatchReceiver(dispatchReceiverSmartCastType))
 
             if (!USE_NEW_INFERENCE) {

compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/util/isFromStdlibJre7Or8.kt

@@ -0,0 +1,60 @@
+/*
+ * 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.resolve.calls.util
+
+import org.jetbrains.kotlin.builtins.KotlinBuiltIns
+import org.jetbrains.kotlin.config.LanguageVersion
+import org.jetbrains.kotlin.descriptors.CallableDescriptor
+import org.jetbrains.kotlin.descriptors.PackageFragmentDescriptor
+import org.jetbrains.kotlin.name.FqName
+import org.jetbrains.kotlin.name.Name
+import org.jetbrains.kotlin.resolve.getSinceKotlinAnnotation
+
+private val kotlin: FqName = KotlinBuiltIns.BUILT_INS_PACKAGE_FQ_NAME
+private val kotlinText: FqName = KotlinBuiltIns.TEXT_PACKAGE_FQ_NAME
+private val kotlinCollections: FqName = KotlinBuiltIns.COLLECTIONS_PACKAGE_FQ_NAME
+private val kotlinStreams: FqName = kotlin.child(Name.identifier("streams"))
+
+private val use: Name = Name.identifier("use")
+private val get: Name = Name.identifier("get")
+private val getOrDefault: Name = Name.identifier("getOrDefault")
+private val remove: Name = Name.identifier("remove")
+
+// We treat all declarations in deprecated libraries kotlin-stdlib-jre7 and kotlin-stdlib-jre8 as if they were
+// annotated with @LowPriorityInOverloadResolution.
+// This is needed in order to avoid reporting "overload resolution ambiguity" in case when there's both kotlin-stdlib-jreN and
+// kotlin-stdlib-jdkN in dependencies, to allow smooth migration from the former to the latter. The ambiguity here would be incorrect
+// because there's really no ambiguity in the bytecode since all declarations in -jdk7/8 have been moved to another JVM package.
+// We locate declarations in kotlin-stdlib-jre{7,8} by FQ name and @SinceKotlin annotation value, which should be 1.1.
+fun CallableDescriptor.isLowPriorityFromStdlibJre7Or8(): Boolean {
+    val containingPackage = containingDeclaration as? PackageFragmentDescriptor ?: return false
+    val packageFqName = containingPackage.fqName
+    if (!packageFqName.startsWith(KotlinBuiltIns.BUILT_INS_PACKAGE_NAME)) return false
+
+    val isFromStdlibJre7Or8 =
+            packageFqName == kotlin && name == use ||
+            packageFqName == kotlinText && name == get ||
+            packageFqName == kotlinCollections && (name == getOrDefault || name == remove) ||
+            packageFqName == kotlinStreams
+
+    if (!isFromStdlibJre7Or8) return false
+
+    val sinceKotlin = getSinceKotlinAnnotation() ?: return false
+    val version = sinceKotlin.allValueArguments.values.singleOrNull()?.value as? String ?: return false
+
+    return version == LanguageVersion.KOTLIN_1_1.versionString
+}

compiler/resolution/src/org/jetbrains/kotlin/resolve/sinceKotlinUtil.kt

@@ -1,5 +1,5 @@
 /*
- * Copyright 2010-2016 JetBrains s.r.o.
+ * 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.
@@ -27,14 +27,14 @@ import org.jetbrains.kotlin.resolve.calls.util.FakeCallableDescriptorForTypeAlia
 private val SINCE_KOTLIN_FQ_NAME = FqName("kotlin.SinceKotlin")
 
 // TODO: use-site targeted annotations
-internal fun DeclarationDescriptor.getSinceKotlinAnnotation(): AnnotationDescriptor? =
+fun DeclarationDescriptor.getSinceKotlinAnnotation(): AnnotationDescriptor? =
         annotations.findAnnotation(SINCE_KOTLIN_FQ_NAME)
 
 /**
  * @return true if the descriptor is accessible according to [languageVersionSettings], or false otherwise. The [actionIfInaccessible]
  * callback is called with the version specified in the [SinceKotlin] annotation if the descriptor is inaccessible.
  */
-internal fun DeclarationDescriptor.checkSinceKotlinVersionAccessibility(
+fun DeclarationDescriptor.checkSinceKotlinVersionAccessibility(
         languageVersionSettings: LanguageVersionSettings,
         actionIfInaccessible: ((ApiVersion) -> Unit)? = null
 ): Boolean {

compiler/testData/cli/js-dce/dceHelp.out

@@ -8,4 +8,5 @@ where possible options include:
   -nowarn                    Generate no warnings
   -verbose                   Enable verbose logging output
   -version                   Display compiler version
+  -Werror                    Report an error if there are any warnings
 OK

compiler/testData/cli/js/jsHelp.out

@@ -26,4 +26,5 @@ where possible options include:
   -nowarn                    Generate no warnings
   -verbose                   Enable verbose logging output
   -version                   Display compiler version
+  -Werror                    Report an error if there are any warnings
 OK

compiler/testData/cli/jvm/apiVersionInvalid.out

@@ -1,3 +1,3 @@
 error: unknown API version: 239.42
-Supported API versions: 1.0, 1.1, 1.2 (EXPERIMENTAL), 1.3 (EXPERIMENTAL)
+Supported API versions: 1.0, 1.1, 1.2
 COMPILATION_ERROR

compiler/testData/cli/jvm/help.out

@@ -23,4 +23,5 @@ where possible options include:
   -nowarn                    Generate no warnings
   -verbose                   Enable verbose logging output
   -version                   Display compiler version
+  -Werror                    Report an error if there are any warnings
 OK

compiler/testData/cli/jvm/languageVersionInvalid.out

@@ -1,3 +1,3 @@
 error: unknown language version: 239.42
-Supported language versions: 1.0, 1.1, 1.2 (EXPERIMENTAL), 1.3 (EXPERIMENTAL)
+Supported language versions: 1.0, 1.1, 1.2
 COMPILATION_ERROR

compiler/testData/cli/jvm/werror.args

@@ -0,0 +1,4 @@
+$TESTDATA_DIR$/werror.kt
+-d
+$TEMP_DIR$
+-Werror

compiler/testData/cli/jvm/werror.kt

@@ -0,0 +1,4 @@
+fun foo(s: String, t: String?) {
+    s!!
+    t?.toString()
+}

compiler/testData/cli/jvm/werror.out

@@ -0,0 +1,5 @@
+error: warnings found and -Werror specified
+compiler/testData/cli/jvm/werror.kt:2:6: warning: unnecessary non-null assertion (!!) on a non-null receiver of type String
+    s!!
+     ^
+COMPILATION_ERROR

compiler/testData/cli/jvm/werrorWithExplicitError.args

@@ -0,0 +1,4 @@
+$TESTDATA_DIR$/werrorWithExplicitError.kt
+-d
+$TEMP_DIR$
+-Werror

compiler/testData/cli/jvm/werrorWithExplicitError.kt

@@ -0,0 +1,5 @@
+fun foo(s: String, t: String?) {
+    s!!
+    t?.toString()
+    t.length
+}

compiler/testData/cli/jvm/werrorWithExplicitError.out

@@ -0,0 +1,4 @@
+compiler/testData/cli/jvm/werrorWithExplicitError.kt:4:6: error: only safe (?.) or non-null asserted (!!.) calls are allowed on a nullable receiver of type String?
+    t.length
+     ^
+COMPILATION_ERROR

compiler/testData/cli/jvm/werrorWithNoWarn.args

@@ -0,0 +1,5 @@
+$TESTDATA_DIR$/werrorWithNoWarn.kt
+-d
+$TEMP_DIR$
+-Werror
+-nowarn

compiler/testData/cli/jvm/werrorWithNoWarn.kt

@@ -0,0 +1,4 @@
+fun foo(s: String, t: String?) {
+    s!!
+    t?.toString()
+}

compiler/testData/cli/jvm/werrorWithNoWarn.out

@@ -0,0 +1,5 @@
+error: warnings found and -Werror specified
+compiler/testData/cli/jvm/werrorWithNoWarn.kt:2:6: warning: unnecessary non-null assertion (!!) on a non-null receiver of type String
+    s!!
+     ^
+COMPILATION_ERROR

compiler/testData/cli/jvm/werrorWithStrongWarning.args

@@ -0,0 +1,6 @@
+$TESTDATA_DIR$/werrorWithStrongWarning.kt
+-d
+$TEMP_DIR$
+-Werror
+-cp
+non-existing-path.jar

compiler/testData/cli/jvm/werrorWithStrongWarning.kt

@@ -0,0 +1,4 @@
+fun foo(s: String, t: String?) {
+    s!!
+    t?.toString()
+}

compiler/testData/cli/jvm/werrorWithStrongWarning.out

@@ -0,0 +1,3 @@
+warning: classpath entry points to a non-existent location: non-existing-path.jar
+error: warnings found and -Werror specified
+COMPILATION_ERROR

compiler/testData/codegen/box/jvmPackageName/rootPackage.kt

@@ -0,0 +1,18 @@
+// TARGET_BACKEND: JVM
+// WITH_RUNTIME
+// LANGUAGE_VERSION: 1.2
+
+// FILE: foo.kt
+
+@file:Suppress("INVISIBLE_REFERENCE", "INVISIBLE_MEMBER")
+@file:JvmPackageName("jjj")
+
+fun f(): String = "O"
+
+val g: String? get() = "K"
+
+inline fun i(block: () -> String) = block()
+
+// FILE: bar.kt
+
+fun box(): String = i { f() + g }

compiler/testData/codegen/box/jvmPackageName/simple.kt

@@ -0,0 +1,21 @@
+// TARGET_BACKEND: JVM
+// WITH_RUNTIME
+// LANGUAGE_VERSION: 1.2
+
+// FILE: foo.kt
+
+@file:Suppress("INVISIBLE_REFERENCE", "INVISIBLE_MEMBER")
+@file:JvmPackageName("baz.foo.quux.bar")
+package foo.bar
+
+fun f(): String = "O"
+
+val g: String? get() = "K"
+
+inline fun <T> i(block: () -> T): T = block()
+
+// FILE: bar.kt
+
+import foo.bar.*
+
+fun box(): String = i { f() + g }

compiler/testData/codegen/box/jvmPackageName/withJvmName.kt

@@ -0,0 +1,19 @@
+// TARGET_BACKEND: JVM
+// WITH_RUNTIME
+// LANGUAGE_VERSION: 1.2
+
+// FILE: foo.kt
+
+@file:Suppress("INVISIBLE_REFERENCE", "INVISIBLE_MEMBER")
+@file:JvmPackageName("jjj")
+@file:JvmName("Foooo")
+
+fun f(): String = "O"
+
+val g: String? get() = "K"
+
+inline fun i(block: () -> String) = block()
+
+// FILE: bar.kt
+
+fun box(): String = i { f() + g }

compiler/testData/codegen/box/objects/classCompanion.kt

@@ -0,0 +1,19 @@
+var result = ""
+
+class A {
+
+    companion object {
+
+        val prop = test()
+
+        fun test(): String {
+            result += "OK"
+            return result
+        }
+    }
+}
+
+fun box(): String {
+    if (A.prop != "OK") return "fail ${A.prop}"
+    return result
+}

compiler/testData/codegen/box/objects/interfaceCompanion.kt

@@ -0,0 +1,19 @@
+var result = ""
+
+interface A {
+
+    companion object {
+
+        val prop = test()
+
+        fun test(): String {
+            result += "OK"
+            return result
+        }
+    }
+}
+
+fun box(): String {
+    if (A.prop != "OK") return "fail ${A.prop}"
+    return result
+}

compiler/testData/codegen/box/objects/object.kt

@@ -0,0 +1,15 @@
+var result = ""
+
+object A {
+    val prop = test()
+
+    fun test(): String {
+        result += "OK"
+        return result
+    }
+}
+
+fun box(): String {
+    if (A.prop != "OK") return "fail ${A.prop}"
+    return result
+}

compiler/testData/codegen/box/properties/lateinit/isInitializedAndDeinitialize/innerSubclass.kt

@@ -0,0 +1,35 @@
+// IGNORE_BACKEND: NATIVE
+// LANGUAGE_VERSION: 1.2
+// WITH_RUNTIME
+
+open class Foo {
+    lateinit var bar: String
+
+    private lateinit var baz: String
+
+    fun test(): String {
+        val isBarInitialized: () -> Boolean = { this::bar.isInitialized }
+        if (isBarInitialized()) return "Fail 1"
+        bar = "bar"
+        if (!isBarInitialized()) return "Fail 2"
+        baz = "baz"
+        return InnerSubclass().testInner()
+    }
+
+    inner class InnerSubclass : Foo() {
+        fun testInner(): String {
+            // This is access to InnerSubclass.bar which is inherited from Foo.bar
+            if (this::bar.isInitialized) return "Fail 3"
+            bar = "OK"
+            if (!this::bar.isInitialized) return "Fail 4"
+
+            // This is access to Foo.bar declared lexically above
+            if (!this@Foo::bar.isInitialized) return "Fail 5"
+            return "OK"
+        }
+    }
+}
+
+fun box(): String {
+    return Foo().test()
+}

compiler/testData/codegen/box/properties/lateinit/isInitializedAndDeinitialize/sideEffects.kt

@@ -0,0 +1,21 @@
+// IGNORE_BACKEND: NATIVE
+// LANGUAGE_VERSION: 1.2
+// WITH_RUNTIME
+
+class Foo {
+    lateinit var bar: String
+
+    fun test(): String {
+        var state = 0
+        if (run { state++; this }::bar.isInitialized) return "Fail 1"
+
+        bar = "A"
+        if (!run { state++; this }::bar.isInitialized) return "Fail 3"
+
+        return if (state == 2) "OK" else "Fail: state=$state"
+    }
+}
+
+fun box(): String {
+    return Foo().test()
+}

compiler/testData/codegen/box/properties/lateinit/isInitializedAndDeinitialize/simpleIsInitialized.kt

@@ -0,0 +1,36 @@
+// TARGET_BACKEND: JVM
+// LANGUAGE_VERSION: 1.2
+// WITH_RUNTIME
+
+// FILE: J.java
+
+public class J {
+    public static void deinitialize(Foo foo) {
+        foo.bar = null;
+    }
+}
+
+// FILE: main.kt
+
+class Foo {
+    lateinit var bar: String
+
+    fun test(): String {
+        if (this::bar.isInitialized) return "Fail 1"
+        J.deinitialize(this)
+        if (this::bar.isInitialized) return "Fail 2"
+
+        bar = "A"
+        if (!this::bar.isInitialized) return "Fail 3"
+        J.deinitialize(this)
+        if (this::bar.isInitialized) return "Fail 4"
+
+        bar = "OK"
+        if (!this::bar.isInitialized) return "Fail 5"
+        return bar
+    }
+}
+
+fun box(): String {
+    return Foo().test()
+}

compiler/testData/codegen/box/properties/lateinit/isInitializedAndDeinitialize/topLevelProperty.kt

@@ -0,0 +1,12 @@
+// IGNORE_BACKEND: NATIVE
+// LANGUAGE_VERSION: 1.2
+// WITH_RUNTIME
+
+lateinit var bar: String
+
+fun box(): String {
+    if (::bar.isInitialized) return "Fail 1"
+    bar = "OK"
+    if (!::bar.isInitialized) return "Fail 2"
+    return bar
+}

compiler/testData/codegen/box/reflection/enclosing/lambdaInObjectDeclaration.kt

@@ -14,7 +14,7 @@ fun box(): String {
     if (enclosingMethod != null) return "method: $enclosingMethod"
 
     val enclosingConstructor = javaClass.getEnclosingConstructor()
-    if (enclosingConstructor == null) return "no enclosing constructor"
+    if (enclosingConstructor != null) return "field should be initialized in clInit"
 
     val enclosingClass = javaClass.getEnclosingClass()
     if (enclosingClass?.getName() != "O") return "enclosing class: $enclosingClass"

compiler/testData/codegen/box/reified/expectedTypeFromCast.kt

@@ -0,0 +1,19 @@
+// IGNORE_BACKEND: JS, NATIVE
+
+// LANGUAGE_VERSION: 1.2
+// WITH_RUNTIME
+import kotlin.test.assertEquals
+
+inline fun <reified T> foo(): T {
+    return T::class.java.getName() as T
+}
+
+fun box(): String {
+    val fooCall = foo() as String
+    assertEquals("java.lang.String", fooCall)
+
+    val safeFooCall = foo() as? String
+    assertEquals("java.lang.String", safeFooCall)
+
+    return "OK"
+}

compiler/testData/codegen/boxInline/jvmPackageName/simple.kt

@@ -0,0 +1,21 @@
+// TARGET_BACKEND: JVM
+// WITH_RUNTIME
+// LANGUAGE_VERSION: 1.2
+
+// FILE: 1.kt
+
+@file:Suppress("INVISIBLE_REFERENCE", "INVISIBLE_MEMBER")
+@file:JvmPackageName("baz.foo.quux.bar")
+package foo.bar
+
+fun f(): String = "O"
+
+val g: String? get() = "K"
+
+inline fun <T> i(block: () -> T): T = block()
+
+// FILE: 2.kt
+
+import foo.bar.*
+
+fun box(): String = i { f() + g }

compiler/testData/codegen/dumpDeclarations/interfaces.json

@@ -49,7 +49,8 @@
 		"class": "PublicInterface$Companion",
 		"members": [
 			{"visibility": "private",	"declaration": "constructor Companion()", "name": "<init>", "desc": "()V"},
-			{"visibility": "private",	"declaration": "constructor Companion()", "name": "<init>", "desc": "(Lkotlin/jvm/internal/DefaultConstructorMarker;)V"}
+			{"visibility": "public",	"declaration": "companion object", "name": "$$INSTANCE", "desc": "LPublicInterface$Companion;"},
+			{"visibility": "public",	"declaration": "companion object", "name": "<clinit>", "desc": "()V"}
 		]
 	},
 	{
@@ -75,7 +76,8 @@
 		"class": "InternalInterface$Companion",
 		"members": [
 			{"visibility": "private",	"declaration": "constructor Companion()", "name": "<init>", "desc": "()V"},
-			{"visibility": "private",	"declaration": "constructor Companion()", "name": "<init>", "desc": "(Lkotlin/jvm/internal/DefaultConstructorMarker;)V"}
+			{"visibility": "public",	"declaration": "companion object", "name": "$$INSTANCE", "desc": "LInternalInterface$Companion;"},
+			{"visibility": "public",	"declaration": "companion object", "name": "<clinit>", "desc": "()V"}
 		]
 	},
 	{
@@ -101,7 +103,8 @@
 		"class": "InternalInterfacePrivateCompanion$Companion",
 		"members": [
 			{"visibility": "private",	"declaration": "constructor Companion()", "name": "<init>", "desc": "()V"},
-			{"visibility": "private",	"declaration": "constructor Companion()", "name": "<init>", "desc": "(Lkotlin/jvm/internal/DefaultConstructorMarker;)V"}
+			{"visibility": "private",	"declaration": "companion object", "name": "$$INSTANCE", "desc": "LInternalInterfacePrivateCompanion$Companion;"},
+			{"visibility": "private",	"declaration": "companion object", "name": "<clinit>", "desc": "()V"}
 		]
 	},
 	{
@@ -163,7 +166,8 @@
 		"class": "PrivateInterface$Companion",
 		"members": [
 			{"visibility": "private",	"declaration": "constructor Companion()", "name": "<init>", "desc": "()V"},
-			{"visibility": "private",	"declaration": "constructor Companion()", "name": "<init>", "desc": "(Lkotlin/jvm/internal/DefaultConstructorMarker;)V"}
+			{"visibility": "public",	"declaration": "companion object", "name": "$$INSTANCE", "desc": "LPrivateInterface$Companion;"},
+			{"visibility": "public",	"declaration": "companion object", "name": "<clinit>", "desc": "()V"}
 		]
 	},
 	{
@@ -189,7 +193,8 @@
 		"class": "PrivateInterfacePrivateCompanion$Companion",
 		"members": [
 			{"visibility": "private",	"declaration": "constructor Companion()", "name": "<init>", "desc": "()V"},
-			{"visibility": "private",	"declaration": "constructor Companion()", "name": "<init>", "desc": "(Lkotlin/jvm/internal/DefaultConstructorMarker;)V"}
+			{"visibility": "private",	"declaration": "companion object", "name": "$$INSTANCE", "desc": "LPrivateInterfacePrivateCompanion$Companion;"},
+			{"visibility": "private",	"declaration": "companion object", "name": "<clinit>", "desc": "()V"}
 		]
 	},
 	{

compiler/testData/codegen/java8/box/capturedSuperCall.kt

@@ -11,6 +11,7 @@ open class Base {
     fun foo() = "OK"
 }
 
+@kotlin.Suppress("DEFAULT_METHOD_CALL_FROM_JAVA6_TARGET")
 class C : Base(), IBase {
     val lambda1 = {
         super.foo()

compiler/testData/codegen/java8/box/inheritKotlin.kt

@@ -15,6 +15,7 @@ interface KInterface {
 }
 
 class Test : Simple {
+    @kotlin.Suppress("DEFAULT_METHOD_CALL_FROM_JAVA6_TARGET")
     fun bar(): String {
         return super.test()
     }

compiler/testData/codegen/java8/box/invokeDefaultViaSuper.kt

@@ -13,12 +13,14 @@ interface KInterface : Test {
 }
 
 class KClass : Test {
+    @kotlin.Suppress("DEFAULT_METHOD_CALL_FROM_JAVA6_TARGET")
     fun ktest(): String {
         return super.test() + test()
     }
 }
 
 class KTClass : KInterface {
+    @kotlin.Suppress("DEFAULT_METHOD_CALL_FROM_JAVA6_TARGET")
     fun ktest(): String {
         return super.test() + test()
     }
@@ -27,6 +29,7 @@ class KTClass : KInterface {
 
 fun box(): String {
     val p = object : KInterface {
+        @kotlin.Suppress("DEFAULT_METHOD_CALL_FROM_JAVA6_TARGET")
         fun ktest(): String {
             return super.test() + test()
         }

compiler/testData/codegen/java8/box/longChainOfKotlinExtendsFromJavaWithDefault.kt

@@ -15,6 +15,7 @@ interface K2 : K1
 interface K3 : K2
 
 class C : K3 {
+    @kotlin.Suppress("DEFAULT_METHOD_CALL_FROM_JAVA6_TARGET")
     override fun foo() = super.foo()
 }
 

compiler/testData/compileKotlinAgainstKotlin/jvmPackageName.kt

@@ -0,0 +1,26 @@
+// IGNORE_BACKEND: NATIVE
+// FILE: A.kt
+// LANGUAGE_VERSION: 1.2
+
+@file:Suppress("INVISIBLE_MEMBER", "INVISIBLE_REFERENCE")
+@file:JvmPackageName("bar")
+package foo
+
+fun f() = "OK"
+
+var v: Int = 1
+
+inline fun i(block: () -> Unit) = block()
+
+// FILE: B.kt
+// LANGUAGE_VERSION: 1.2
+
+import foo.*
+
+fun box(): String {
+    v = 2
+    if (v != 2) return "Fail"
+    i { v = 3 }
+    if (v != 3) return "Fail"
+    return f()
+}

compiler/testData/compileKotlinAgainstKotlin/jvmPackageNameInRootPackage.kt

@@ -0,0 +1,19 @@
+// IGNORE_BACKEND: NATIVE
+// FILE: A.kt
+// LANGUAGE_VERSION: 1.2
+
+@file:Suppress("INVISIBLE_MEMBER", "INVISIBLE_REFERENCE")
+@file:JvmPackageName("bar")
+
+fun f() = "OK"
+
+var v: Int = 1
+
+// FILE: B.kt
+// LANGUAGE_VERSION: 1.2
+
+fun box(): String {
+    v = 2
+    if (v != 2) return "Fail"
+    return f()
+}

compiler/testData/compileKotlinAgainstKotlin/jvmPackageNameWithJvmName.kt

@@ -0,0 +1,23 @@
+// IGNORE_BACKEND: NATIVE
+// FILE: A.kt
+// LANGUAGE_VERSION: 1.2
+
+@file:Suppress("INVISIBLE_MEMBER", "INVISIBLE_REFERENCE")
+@file:JvmPackageName("bar")
+@file:JvmName("Baz")
+package foo
+
+fun f() = "OK"
+
+var v: Int = 1
+
+// FILE: B.kt
+// LANGUAGE_VERSION: 1.2
+
+import foo.*
+
+fun box(): String {
+    v = 2
+    if (v != 2) return "Fail"
+    return f()
+}

compiler/testData/diagnostics/tests/inference/expectedTypeAdditionalTest.kt

@@ -0,0 +1,12 @@
+// !LANGUAGE: +ExpectedTypeFromCast
+
+fun foo() = 1
+
+fun <T> foo() = foo() <!UNCHECKED_CAST!>as T<!>
+
+fun <T> foo2(): T = TODO()
+
+val test = <!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo2<!>().<!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>plus<!>("") as String
+
+fun <T> T.bar() = this
+val barTest = "".bar() <!CAST_NEVER_SUCCEEDS!>as<!> Number

compiler/testData/diagnostics/tests/inference/expectedTypeAdditionalTest.txt

@@ -0,0 +1,8 @@
+package
+
+public val barTest: kotlin.Number
+public val test: kotlin.String
+public fun foo(): kotlin.Int
+public fun </*0*/ T> foo(): T
+public fun </*0*/ T> foo2(): T
+public fun </*0*/ T> T.bar(): T

compiler/testData/diagnostics/tests/inference/expectedTypeFromCast.kt

@@ -0,0 +1,20 @@
+// !LANGUAGE: +ExpectedTypeFromCast
+
+fun <T> foo(): T = TODO()
+
+fun <V> id(value: V) = value
+
+val asString = foo() as String
+
+val viaId = <!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>id<!>(<!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>()) as String
+
+val insideId = id(foo() as String)
+
+val asList = foo() as List<String>
+
+val asStarList = foo() as List<*>
+
+val safeAs = foo() as? String
+
+val fromIs = <!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>() is String
+val fromNoIs = <!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>() !is String

compiler/testData/diagnostics/tests/inference/expectedTypeFromCast.txt

@@ -0,0 +1,12 @@
+package
+
+public val asList: kotlin.collections.List<kotlin.String>
+public val asStarList: kotlin.collections.List<*>
+public val asString: kotlin.String
+public val fromIs: kotlin.Boolean
+public val fromNoIs: kotlin.Boolean
+public val insideId: kotlin.String
+public val safeAs: kotlin.String?
+public val viaId: kotlin.String
+public fun </*0*/ T> foo(): T
+public fun </*0*/ V> id(/*0*/ value: V): V

compiler/testData/diagnostics/tests/inference/expectedTypeFromCastComplexExpression.kt

@@ -0,0 +1,16 @@
+// !LANGUAGE: +ExpectedTypeFromCast
+
+package pp
+
+class A {
+    fun <T> foo(): T = TODO()
+
+    companion object {
+        fun <T> foo2(): T = TODO()
+    }
+}
+
+val x = A().foo() as String
+val y = A.foo2() as String
+val z = pp.A.foo2() as String
+

compiler/testData/diagnostics/tests/inference/expectedTypeFromCastComplexExpression.txt

@@ -0,0 +1,23 @@
+package
+
+package pp {
+    public val x: kotlin.String
+    public val y: kotlin.String
+    public val z: kotlin.String
+
+    public final class A {
+        public constructor A()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public final fun </*0*/ T> foo(): T
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+        public companion object Companion {
+            private constructor Companion()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public final fun </*0*/ T> foo2(): T
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+        }
+    }
+}

compiler/testData/diagnostics/tests/inference/expectedTypeWithGenerics.kt

@@ -0,0 +1,17 @@
+// !LANGUAGE: +ExpectedTypeFromCast
+
+class X<S> {
+    fun <T : S> foo(): T = TODO()
+}
+
+fun test(x: X<Number>) {
+    val <!UNUSED_VARIABLE!>y<!> = x.foo() as Int
+}
+
+fun <S, D: S> g() {
+    fun <T : S> foo(): T = TODO()
+
+    val <!UNUSED_VARIABLE!>y<!> = <!TYPE_INFERENCE_UPPER_BOUND_VIOLATED!>foo<!>() as Int
+
+    val <!UNUSED_VARIABLE!>y2<!> = foo() as D
+}

compiler/testData/diagnostics/tests/inference/expectedTypeWithGenerics.txt

@@ -0,0 +1,12 @@
+package
+
+public fun </*0*/ S, /*1*/ D : S> g(): kotlin.Unit
+public fun test(/*0*/ x: X<kotlin.Number>): kotlin.Unit
+
+public final class X</*0*/ S> {
+    public constructor X</*0*/ S>()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public final fun </*0*/ T : S> foo(): T
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}

compiler/testData/diagnostics/tests/inference/findViewById.kt

@@ -0,0 +1,58 @@
+// !LANGUAGE: +ExpectedTypeFromCast
+// !DIAGNOSTICS: -UNUSED_VARIABLE -DEBUG_INFO_LEAKING_THIS
+
+// FILE: a/View.java
+package a;
+
+public class View {
+
+}
+
+// FILE: a/Test.java
+package a;
+
+public class Test {
+    public <T extends View> T findViewById(int id);
+}
+
+// FILE: 1.kt
+package a
+
+
+class X : View()
+
+class Y<T> : View()
+
+val xExplicit: X = Test().findViewById(0)
+val xCast = Test().findViewById(0) as X
+
+val xCastExplicitType = Test().findViewById<X>(0) as X
+val xSafeCastExplicitType = Test().findViewById<X>(0) <!USELESS_CAST!>as? X<!>
+
+val yExplicit: Y<String> = Test().findViewById(0)
+val yCast = Test().findViewById(0) as Y<String>
+
+
+class TestChild : Test() {
+    val xExplicit: X = findViewById(0)
+    val xCast = findViewById(0) as X
+
+    val yExplicit: Y<String> = findViewById(0)
+    val yCast = findViewById(0) as Y<String>
+}
+
+fun test(t: Test) {
+    val xExplicit: X = t.findViewById(0)
+    val xCast = t.findViewById(0) as X
+
+    val yExplicit: Y<String> = t.findViewById(0)
+    val yCast = t.findViewById(0) as Y<String>
+}
+
+fun test2(t: Test?) {
+    val xSafeCallSafeCast = t?.findViewById(0) as? X
+    val xSafeCallSafeCastExplicitType = t?.findViewById<X>(0) <!USELESS_CAST!>as? X<!>
+
+    val xSafeCallCast = t?.findViewById(0) as X
+    val xSafeCallCastExplicitType = t<!UNNECESSARY_SAFE_CALL!>?.<!>findViewById<X>(0) as X
+}

compiler/testData/diagnostics/tests/inference/findViewById.txt

@@ -0,0 +1,53 @@
+package
+
+package a {
+    public val xCast: a.X
+    public val xCastExplicitType: a.X
+    public val xExplicit: a.X
+    public val xSafeCastExplicitType: a.X?
+    public val yCast: a.Y<kotlin.String>
+    public val yExplicit: a.Y<kotlin.String>
+    public fun test(/*0*/ t: a.Test): kotlin.Unit
+    public fun test2(/*0*/ t: a.Test?): kotlin.Unit
+
+    public open class Test {
+        public constructor Test()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open fun </*0*/ T : a.View!> findViewById(/*0*/ id: kotlin.Int): T!
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    public final class TestChild : a.Test {
+        public constructor TestChild()
+        public final val xCast: a.X
+        public final val xExplicit: a.X
+        public final val yCast: a.Y<kotlin.String>
+        public final val yExplicit: a.Y<kotlin.String>
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun </*0*/ T : a.View!> findViewById(/*0*/ id: kotlin.Int): T!
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    public open class View {
+        public constructor View()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    public final class X : a.View {
+        public constructor X()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    public final class Y</*0*/ T> : a.View {
+        public constructor Y</*0*/ T>()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+}

compiler/testData/diagnostics/testsWithStdLib/annotations/jvmPackageName/incorrectJvmPackageName.kt

@@ -0,0 +1,34 @@
+// !DIAGNOSTICS: -INVISIBLE_MEMBER -INVISIBLE_REFERENCE
+// !API_VERSION: 1.2
+
+// FILE: a.kt
+<!JVM_PACKAGE_NAME_NOT_SUPPORTED_IN_MULTIFILE_CLASSES!>@file:JvmPackageName("a")<!>
+@file:JvmMultifileClass
+package a
+fun a() {}
+
+// FILE: b.kt
+<!JVM_PACKAGE_NAME_CANNOT_BE_EMPTY!>@file:JvmPackageName("")<!>
+package b
+fun b() {}
+
+// FILE: c.kt
+<!JVM_PACKAGE_NAME_MUST_BE_VALID_NAME!>@file:JvmPackageName("invalid-fq-name")<!>
+package c
+fun c() {}
+
+// FILE: d.kt
+<!JVM_PACKAGE_NAME_NOT_SUPPORTED_IN_FILES_WITH_CLASSES!>@file:JvmPackageName("d")<!>
+package d
+class D
+fun d() {}
+
+// FILE: e.kt
+@file:JvmPackageName(<!CONSTANT_EXPECTED_TYPE_MISMATCH!>42<!>)
+package e
+fun e() {}
+
+// FILE: f.kt
+@file:JvmPackageName(<!EXPRESSION_EXPECTED_PACKAGE_FOUND!>f<!>)
+package f
+const val name = "f"

compiler/testData/diagnostics/testsWithStdLib/annotations/jvmPackageName/incorrectJvmPackageName.txt

@@ -0,0 +1,32 @@
+package
+
+package a {
+    public fun a(): kotlin.Unit
+}
+
+package b {
+    public fun b(): kotlin.Unit
+}
+
+package c {
+    public fun c(): kotlin.Unit
+}
+
+package d {
+    public fun d(): kotlin.Unit
+
+    public final class D {
+        public constructor D()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+}
+
+package e {
+    public fun e(): kotlin.Unit
+}
+
+package f {
+    public const val name: kotlin.String = "f"
+}

compiler/testData/diagnostics/testsWithStdLib/lateinit/isInitialized.kt

@@ -0,0 +1,88 @@
+// !DIAGNOSTICS: -UNUSED_VARIABLE -NOTHING_TO_INLINE
+// !API_VERSION: 1.2
+// FILE: test.kt
+
+interface Base {
+    var x: String
+}
+
+open class Foo : Base {
+    override lateinit var x: String
+    private lateinit var y: String
+
+    var nonLateInit: Int = 1
+
+    fun ok() {
+        val b: Boolean = this::x.isInitialized
+
+        val otherInstance = Foo()
+        otherInstance::x.isInitialized
+
+        (this::x).isInitialized
+        (@Suppress("ALL") (this::x)).isInitialized
+
+        object {
+            fun local() {
+                class Local {
+                    val xx = this@Foo::x.isInitialized
+                    val yy = this@Foo::y.isInitialized
+                }
+            }
+        }
+    }
+
+    fun onLiteral() {
+        val p = this::x
+        p.<!LATEINIT_INTRINSIC_CALL_ON_NON_LITERAL!>isInitialized<!>
+    }
+
+    fun onNonLateinit() {
+        this::nonLateInit.<!LATEINIT_INTRINSIC_CALL_ON_NON_LATEINIT!>isInitialized<!>
+    }
+
+    inline fun inlineFun() {
+        this::x.<!LATEINIT_INTRINSIC_CALL_IN_INLINE_FUNCTION!>isInitialized<!>
+
+        object {
+            val z = this@Foo::x.isInitialized
+        }
+    }
+
+    inner class InnerSubclass : Foo() {
+        fun innerOk() {
+            // This is access to Foo.x declared lexically above
+            this@Foo::x.isInitialized
+
+            // This is access to InnerSubclass.x which is inherited from Foo.x
+            this::x.isInitialized
+        }
+    }
+}
+
+fun onNonAccessible() {
+    Foo()::x.<!LATEINIT_INTRINSIC_CALL_ON_NON_ACCESSIBLE_PROPERTY!>isInitialized<!>
+}
+
+fun onNonLateinit() {
+    Foo()::nonLateInit.<!LATEINIT_INTRINSIC_CALL_ON_NON_LATEINIT!>isInitialized<!>
+}
+
+object Unrelated {
+    fun onNonAccessible() {
+        Foo()::x.<!LATEINIT_INTRINSIC_CALL_ON_NON_ACCESSIBLE_PROPERTY!>isInitialized<!>
+    }
+}
+
+class FooImpl : Foo() {
+    fun onNonAccessible() {
+        this::x.<!LATEINIT_INTRINSIC_CALL_ON_NON_ACCESSIBLE_PROPERTY!>isInitialized<!>
+    }
+}
+
+// FILE: other.kt
+
+class OtherFooImpl : Foo() {
+    fun onNonAccessible() {
+        this::x.<!LATEINIT_INTRINSIC_CALL_ON_NON_ACCESSIBLE_PROPERTY!>isInitialized<!>
+    }
+}

compiler/testData/diagnostics/testsWithStdLib/lateinit/isInitialized.txt

@@ -0,0 +1,78 @@
+package
+
+public fun onNonAccessible(): kotlin.Unit
+public fun onNonLateinit(): kotlin.Unit
+
+public interface Base {
+    public abstract var x: kotlin.String
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public open class Foo : Base {
+    public constructor Foo()
+    public final var nonLateInit: kotlin.Int
+    public open override /*1*/ lateinit var x: kotlin.String
+    private final lateinit var y: kotlin.String
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public final inline fun inlineFun(): kotlin.Unit
+    public final fun ok(): kotlin.Unit
+    public final fun onLiteral(): kotlin.Unit
+    public final fun onNonLateinit(): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    public final inner class InnerSubclass : Foo {
+        public constructor InnerSubclass()
+        public final override /*1*/ /*fake_override*/ var nonLateInit: kotlin.Int
+        public open override /*1*/ lateinit /*fake_override*/ var x: kotlin.String
+        invisible_fake final override /*1*/ lateinit /*fake_override*/ var y: kotlin.String
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public final inline override /*1*/ /*fake_override*/ fun inlineFun(): kotlin.Unit
+        public final fun innerOk(): kotlin.Unit
+        public final override /*1*/ /*fake_override*/ fun ok(): kotlin.Unit
+        public final override /*1*/ /*fake_override*/ fun onLiteral(): kotlin.Unit
+        public final override /*1*/ /*fake_override*/ fun onNonLateinit(): kotlin.Unit
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+}
+
+public final class FooImpl : Foo {
+    public constructor FooImpl()
+    public final override /*1*/ /*fake_override*/ var nonLateInit: kotlin.Int
+    public open override /*1*/ lateinit /*fake_override*/ var x: kotlin.String
+    invisible_fake final override /*1*/ lateinit /*fake_override*/ var y: kotlin.String
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public final inline override /*1*/ /*fake_override*/ fun inlineFun(): kotlin.Unit
+    public final override /*1*/ /*fake_override*/ fun ok(): kotlin.Unit
+    public final override /*1*/ /*fake_override*/ fun onLiteral(): kotlin.Unit
+    public final fun onNonAccessible(): kotlin.Unit
+    public final override /*1*/ /*fake_override*/ fun onNonLateinit(): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public final class OtherFooImpl : Foo {
+    public constructor OtherFooImpl()
+    public final override /*1*/ /*fake_override*/ var nonLateInit: kotlin.Int
+    public open override /*1*/ lateinit /*fake_override*/ var x: kotlin.String
+    invisible_fake final override /*1*/ lateinit /*fake_override*/ var y: kotlin.String
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public final inline override /*1*/ /*fake_override*/ fun inlineFun(): kotlin.Unit
+    public final override /*1*/ /*fake_override*/ fun ok(): kotlin.Unit
+    public final override /*1*/ /*fake_override*/ fun onLiteral(): kotlin.Unit
+    public final fun onNonAccessible(): kotlin.Unit
+    public final override /*1*/ /*fake_override*/ fun onNonLateinit(): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public object Unrelated {
+    private constructor Unrelated()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public final fun onNonAccessible(): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}

compiler/testData/integration/ant/jvm/stdlibJre78AndStdlibJdk78/build.log.expected

@@ -0,0 +1,10 @@
+OUT:
+Buildfile: [TestData]/build.xml
+
+build:
+  [kotlinc] Compiling [[TestData]/main.kt] => [[Temp]/test.jar]
+
+BUILD SUCCESSFUL
+Total time: [time]
+
+Return code: 0

compiler/testData/integration/ant/jvm/stdlibJre78AndStdlibJdk78/build.xml

@@ -0,0 +1,15 @@
+<project name="Ant Task Test" default="build">
+    <taskdef resource="org/jetbrains/kotlin/ant/antlib.xml" classpath="${kotlin.lib}/kotlin-ant.jar"/>
+
+    <target name="build">
+        <kotlinc src="${test.data}/main.kt" output="${temp}/test.jar" nowarn="true">
+            <classpath>
+                <file file="${kotlin.stdlib.jre7.jar}"/>
+                <file file="${kotlin.stdlib.jre8.jar}"/>
+                <file file="${kotlin.stdlib.jdk7.jar}"/>
+                <file file="${kotlin.stdlib.jdk8.jar}"/>
+            </classpath>
+            <compilerarg line="-jvm-target 1.8"/>
+        </kotlinc>
+    </target>
+</project>

compiler/testData/integration/ant/jvm/stdlibJre78AndStdlibJdk78/main.kt

@@ -0,0 +1,15 @@
+import java.util.stream.Stream
+import kotlin.streams.*
+
+// kotlin-stdlib-jdk7
+
+fun testUse(c: AutoCloseable) = c.use {}
+
+// kotlin-stdlib-jdk8
+
+fun testGet(c: MatchGroupCollection) = c.get("")
+
+fun testGetOrDefault(c: Map<out Number, Any>) = c.getOrDefault(42, "")
+fun testRemove(c: MutableMap<out Number, Any>) = c.remove(42, "")
+
+fun testAsSequence(c: Stream<String>) = c.asSequence()

compiler/testData/javaModules/dependencyOnReflect/usage.txt

@@ -0,0 +1 @@
+OK

compiler/testData/javaModules/dependencyOnReflect/usage/module-info.java

@@ -0,0 +1,4 @@
+module usage {
+    requires kotlin.stdlib;
+    requires kotlin.reflect;
+}

compiler/testData/javaModules/dependencyOnReflect/usage/usage.kt

@@ -0,0 +1,11 @@
+import kotlin.reflect.*
+import kotlin.reflect.jvm.*
+import kotlin.reflect.full.*
+
+class Test<T> {
+    fun test() {
+        Test::class.allSupertypes
+        Test::class.createType(listOf(KTypeProjection.STAR))
+        this::test.javaMethod
+    }
+}

compiler/testData/javaModules/dependencyOnStdlibJdk78/usage.txt

@@ -0,0 +1 @@
+OK

compiler/testData/javaModules/dependencyOnStdlibJdk78/usage/main.kt

@@ -0,0 +1,15 @@
+import java.util.stream.Stream
+import kotlin.streams.*
+
+// kotlin-stdlib-jdk7
+
+fun testUse(c: AutoCloseable) = c.use {}
+
+// kotlin-stdlib-jdk8
+
+fun testGet(c: MatchGroupCollection) = c.get("")
+
+fun testGetOrDefault(c: Map<out Number, Any>) = c.getOrDefault(42, "")
+fun testRemove(c: MutableMap<out Number, Any>) = c.remove(42, "")
+
+fun testAsSequence(c: Stream<String>) = c.asSequence()

compiler/testData/javaModules/dependencyOnStdlibJdk78/usage/module-info.java

@@ -0,0 +1,5 @@
+module usage {
+    requires kotlin.stdlib;
+    requires kotlin.stdlib.jdk7;
+    requires kotlin.stdlib.jdk8;
+}

compiler/testData/jvmPackageTable/jvmPackageName/BarAsJ.kt

@@ -0,0 +1,5 @@
+@file:Suppress("INVISIBLE_MEMBER", "INVISIBLE_REFERENCE")
+@file:JvmPackageName("j")
+package bar
+
+fun file0() {}

compiler/testData/jvmPackageTable/jvmPackageName/BarAsJJ.kt

@@ -0,0 +1,6 @@
+@file:Suppress("INVISIBLE_MEMBER", "INVISIBLE_REFERENCE")
+@file:JvmName("JJ")
+@file:JvmPackageName("jj")
+package bar
+
+fun jj() {}

compiler/testData/jvmPackageTable/jvmPackageName/Foo.kt

@@ -0,0 +1,3 @@
+package foo
+
+fun file1() {}

compiler/testData/jvmPackageTable/jvmPackageName/FooAsJJJ.kt

@@ -0,0 +1,5 @@
+@file:Suppress("INVISIBLE_MEMBER", "INVISIBLE_REFERENCE")
+@file:JvmPackageName("jjj")
+package foo
+
+fun file2() {}

compiler/testData/jvmPackageTable/jvmPackageName/FooMultiFile.kt

@@ -0,0 +1,5 @@
+@file:JvmMultifileClass
+@file:JvmName("MultiFoo")
+package foo
+
+fun multiFile1() {}

compiler/testData/jvmPackageTable/jvmPackageName/jvm-package-table.txt

@@ -0,0 +1,7 @@
+bar
+  j/BarAsJKt
+  jj/JJ
+foo
+  foo/MultiFoo__FooMultiFileKt (foo/MultiFoo)
+  foo/FooKt
+  jjj/FooAsJJJKt

compiler/testData/jvmPackageTable/jvmPackageNameLanguageVersion11/Foo.kt

@@ -0,0 +1,3 @@
+package foo
+
+fun file1() {}

compiler/testData/jvmPackageTable/jvmPackageNameLanguageVersion11/FooAsJ.kt

@@ -0,0 +1,5 @@
+@file:Suppress("INVISIBLE_MEMBER", "INVISIBLE_REFERENCE")
+@file:JvmPackageName("j")
+package foo
+
+fun file2() {}

compiler/testData/jvmPackageTable/jvmPackageNameLanguageVersion11/jvm-package-table.txt

@@ -0,0 +1,2 @@
+foo
+  foo/FooKt

compiler/testData/jvmPackageTable/jvmPackageNameManyParts/Foo1.kt

@@ -0,0 +1,5 @@
+@file:Suppress("INVISIBLE_MEMBER", "INVISIBLE_REFERENCE")
+@file:JvmPackageName("foo.jvm")
+package foo
+
+fun foo1() {}

compiler/testData/jvmPackageTable/jvmPackageNameManyParts/Foo2.kt

@@ -0,0 +1,5 @@
+@file:Suppress("INVISIBLE_MEMBER", "INVISIBLE_REFERENCE")
+@file:JvmPackageName("foo.jvm")
+package foo
+
+fun foo2() {}

compiler/testData/jvmPackageTable/jvmPackageNameManyParts/Foo3.kt

@@ -0,0 +1,5 @@
+@file:Suppress("INVISIBLE_MEMBER", "INVISIBLE_REFERENCE")
+@file:JvmPackageName("foo.jvm")
+package foo
+
+fun foo3() {}

compiler/testData/jvmPackageTable/jvmPackageNameManyParts/jvm-package-table.txt

@@ -0,0 +1,4 @@
+foo
+  foo/jvm/Foo1Kt
+  foo/jvm/Foo2Kt
+  foo/jvm/Foo3Kt

compiler/testData/multiplatform/missingOverload/output.txt

@@ -5,7 +5,7 @@ Output:
 -- JVM --
 Exit code: COMPILATION_ERROR
 Output:
-compiler/testData/multiplatform/missingOverload/common.kt:7:1: error: expected function 'g' has no actual in module
+compiler/testData/multiplatform/missingOverload/common.kt:7:1: error: expected function 'g' has no actual declaration in module
 The following declaration is incompatible because parameter types are different:
     public actual fun g(a: Any): Unit
 

compiler/tests-common/org/jetbrains/kotlin/integration/AbstractAntTaskTest.java

@@ -33,6 +33,10 @@ public abstract class AbstractAntTaskTest extends KotlinIntegrationTestBase {
                 "-Dkotlin.lib=" + KotlinIntegrationTestBase.getCompilerLib(),
                 "-Dkotlin.runtime.jar=" + ForTestCompileRuntime.runtimeJarForTests().getAbsolutePath(),
                 "-Dkotlin.reflect.jar=" + ForTestCompileRuntime.reflectJarForTests().getAbsolutePath(),
+                "-Dkotlin.stdlib.jre7.jar=" + new File("dist/kotlinc/lib/kotlin-stdlib-jre7.jar").getAbsolutePath(),
+                "-Dkotlin.stdlib.jre8.jar=" + new File("dist/kotlinc/lib/kotlin-stdlib-jre8.jar").getAbsolutePath(),
+                "-Dkotlin.stdlib.jdk7.jar=" + new File("dist/kotlinc/lib/kotlin-stdlib-jdk7.jar").getAbsolutePath(),
+                "-Dkotlin.stdlib.jdk8.jar=" + new File("dist/kotlinc/lib/kotlin-stdlib-jdk8.jar").getAbsolutePath(),
                 "-Dtest.data=" + testDataDir,
                 "-Dtemp=" + tmpdir,
                 "-f", "build.xml"

compiler/tests-ir-jvm/tests/org/jetbrains/kotlin/codegen/ir/IrBlackBoxCodegenTestGenerated.java

@@ -10407,6 +10407,33 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes
         }
     }
 
+    @TestMetadata("compiler/testData/codegen/box/jvmPackageName")
+    @TestDataPath("$PROJECT_ROOT")
+    @RunWith(JUnit3RunnerWithInners.class)
+    public static class JvmPackageName extends AbstractIrBlackBoxCodegenTest {
+        public void testAllFilesPresentInJvmPackageName() throws Exception {
+            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/codegen/box/jvmPackageName"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JVM, true);
+        }
+
+        @TestMetadata("rootPackage.kt")
+        public void testRootPackage() throws Exception {
+            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/box/jvmPackageName/rootPackage.kt");
+            doTest(fileName);
+        }
+
+        @TestMetadata("simple.kt")
+        public void testSimple() throws Exception {
+            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/box/jvmPackageName/simple.kt");
+            doTest(fileName);
+        }
+
+        @TestMetadata("withJvmName.kt")
+        public void testWithJvmName() throws Exception {
+            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/box/jvmPackageName/withJvmName.kt");
+            doTest(fileName);
+        }
+    }
+
     @TestMetadata("compiler/testData/codegen/box/jvmStatic")
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
@@ -11840,6 +11867,12 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes
             doTest(fileName);
         }
 
+        @TestMetadata("classCompanion.kt")
+        public void testClassCompanion() throws Exception {
+            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/box/objects/classCompanion.kt");
+            doTest(fileName);
+        }
+
         @TestMetadata("flist.kt")
         public void testFlist() throws Exception {
             String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/box/objects/flist.kt");
@@ -11858,6 +11891,12 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes
             doTest(fileName);
         }
 
+        @TestMetadata("interfaceCompanion.kt")
+        public void testInterfaceCompanion() throws Exception {
+            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/box/objects/interfaceCompanion.kt");
+            doTest(fileName);
+        }
+
         @TestMetadata("kt1047.kt")
         public void testKt1047() throws Exception {
             String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/box/objects/kt1047.kt");
@@ -11996,6 +12035,12 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes
             doTest(fileName);
         }
 
+        @TestMetadata("object.kt")
+        public void testObject() throws Exception {
+            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/box/objects/object.kt");
+            doTest(fileName);
+        }
+
         @TestMetadata("objectExtendsInnerAndReferencesOuterMember.kt")
         public void testObjectExtendsInnerAndReferencesOuterMember() throws Exception {
             String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/box/objects/objectExtendsInnerAndReferencesOuterMember.kt");
@@ -13612,6 +13657,39 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes
                 doTest(fileName);
             }
 
+            @TestMetadata("compiler/testData/codegen/box/properties/lateinit/isInitializedAndDeinitialize")
+            @TestDataPath("$PROJECT_ROOT")
+            @RunWith(JUnit3RunnerWithInners.class)
+            public static class IsInitializedAndDeinitialize extends AbstractIrBlackBoxCodegenTest {
+                public void testAllFilesPresentInIsInitializedAndDeinitialize() throws Exception {
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/codegen/box/properties/lateinit/isInitializedAndDeinitialize"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JVM, true);
+                }
+
+                @TestMetadata("innerSubclass.kt")
+                public void testInnerSubclass() throws Exception {
+                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/box/properties/lateinit/isInitializedAndDeinitialize/innerSubclass.kt");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("sideEffects.kt")
+                public void testSideEffects() throws Exception {
+                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/box/properties/lateinit/isInitializedAndDeinitialize/sideEffects.kt");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("simpleIsInitialized.kt")
+                public void testSimpleIsInitialized() throws Exception {
+                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/box/properties/lateinit/isInitializedAndDeinitialize/simpleIsInitialized.kt");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("topLevelProperty.kt")
+                public void testTopLevelProperty() throws Exception {
+                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/box/properties/lateinit/isInitializedAndDeinitialize/topLevelProperty.kt");
+                    doTest(fileName);
+                }
+            }
+
             @TestMetadata("compiler/testData/codegen/box/properties/lateinit/local")
             @TestDataPath("$PROJECT_ROOT")
             @RunWith(JUnit3RunnerWithInners.class)
@@ -17510,6 +17588,12 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes
             doTest(fileName);
         }
 
+        @TestMetadata("expectedTypeFromCast.kt")
+        public void testExpectedTypeFromCast() throws Exception {
+            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/box/reified/expectedTypeFromCast.kt");
+            doTest(fileName);
+        }
+
         @TestMetadata("filterIsInstance.kt")
         public void testFilterIsInstance() throws Exception {
             String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/box/reified/filterIsInstance.kt");