Refactor external overidability conditions

Before this change they could only negatively affect on result
Now they may force success result

Also refine overridavility condition for java fields:
two java fields having the same name are seen as overrides even
if they have different type

compiler/frontend.java/src/org/jetbrains/kotlin/load/java/sam/SamAdapterOverridabilityCondition.java

@@ -28,20 +28,21 @@ import org.jetbrains.kotlin.types.TypeUtils;
 import java.util.List;
 
 public class SamAdapterOverridabilityCondition implements ExternalOverridabilityCondition {
+    @NotNull
     @Override
-    public boolean isOverridable(@NotNull CallableDescriptor superDescriptor, @NotNull CallableDescriptor subDescriptor) {
-        if (!(subDescriptor instanceof SimpleFunctionDescriptor)) {
-            return true;
+    public Result isOverridable(@NotNull CallableDescriptor superDescriptor, @NotNull CallableDescriptor subDescriptor) {
+        if (!(subDescriptor instanceof SimpleFunctionDescriptor) || !(superDescriptor instanceof SimpleFunctionDescriptor)) {
+            return Result.UNKNOWN;
         }
 
         SimpleFunctionDescriptor superOriginal = getOriginalOfSamAdapterFunction((SimpleFunctionDescriptor) superDescriptor);
         SimpleFunctionDescriptor subOriginal = getOriginalOfSamAdapterFunction((SimpleFunctionDescriptor) subDescriptor);
         if (superOriginal == null || subOriginal == null) { // super or sub is/overrides DECLARATION
-            return subOriginal == null; // DECLARATION can override anything
+            return subOriginal == null ? Result.UNKNOWN : Result.INCOMPATIBLE; // DECLARATION can override anything
         }
 
         // inheritor if SYNTHESIZED can override inheritor of SYNTHESIZED if their originals have same erasure
-        return equalErasure(superOriginal, subOriginal);
+        return equalErasure(superOriginal, subOriginal) ? Result.UNKNOWN : Result.INCOMPATIBLE;
     }
 
     private static boolean equalErasure(@NotNull FunctionDescriptor fun1, @NotNull FunctionDescriptor fun2) {

compiler/testData/diagnostics/tests/j+k/fieldOverridesFieldOfDifferentType.kt

@@ -0,0 +1,19 @@
+// !CHECK_TYPE
+
+// FILE: A.java
+
+public class A {
+    public int size = 1;
+}
+
+// FILE: B.java
+
+public class B extends A {
+    public String size = 1;
+}
+
+// FILE: main.kt
+
+fun foo() {
+    B().size.checkType { _<String>() }
+}

compiler/testData/diagnostics/tests/j+k/fieldOverridesFieldOfDifferentType.txt

@@ -0,0 +1,19 @@
+package
+
+public fun foo(): kotlin.Unit
+
+public open class A {
+    public constructor A()
+    public final var size: kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public open class B : A {
+    public constructor B()
+    public final override /*1*/ var size: 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
+}

compiler/tests/org/jetbrains/kotlin/checkers/DiagnosticsTestGenerated.java

@@ -9282,6 +9282,12 @@ public class DiagnosticsTestGenerated extends AbstractDiagnosticsTest {
                 doTest(fileName);
             }
 
+            @TestMetadata("fieldOverridesFieldOfDifferentType.kt")
+            public void testFieldOverridesFieldOfDifferentType() throws Exception {
+                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/fieldOverridesFieldOfDifferentType.kt");
+                doTest(fileName);
+            }
+
             @TestMetadata("fieldOverridesNothing.kt")
             public void testFieldOverridesNothing() throws Exception {
                 String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/fieldOverridesNothing.kt");

core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/FieldOverridabilityCondition.kt

@@ -20,11 +20,16 @@ import org.jetbrains.kotlin.descriptors.CallableDescriptor
 import org.jetbrains.kotlin.descriptors.PropertyDescriptor
 import org.jetbrains.kotlin.load.java.lazy.descriptors.isJavaField
 import org.jetbrains.kotlin.resolve.ExternalOverridabilityCondition
+import org.jetbrains.kotlin.resolve.ExternalOverridabilityCondition.Result
 
 class FieldOverridabilityCondition : ExternalOverridabilityCondition {
-    override fun isOverridable(superDescriptor: CallableDescriptor, subDescriptor: CallableDescriptor): Boolean {
-        if (subDescriptor !is PropertyDescriptor || superDescriptor !is PropertyDescriptor) return true
+    override fun isOverridable(superDescriptor: CallableDescriptor, subDescriptor: CallableDescriptor): Result {
+        if (subDescriptor !is PropertyDescriptor || superDescriptor !is PropertyDescriptor) return Result.UNKNOWN
+        if (subDescriptor.name != superDescriptor.name) return Result.UNKNOWN
 
-        return subDescriptor.isJavaField == superDescriptor.isJavaField
+        if (subDescriptor.isJavaField && superDescriptor.isJavaField) return Result.OVERRIDABLE
+        if (subDescriptor.isJavaField || superDescriptor.isJavaField) return Result.INCOMPATIBLE
+
+        return Result.UNKNOWN
     }
 }

core/descriptors/src/org/jetbrains/kotlin/resolve/ExternalOverridabilityCondition.java

@@ -20,5 +20,10 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.descriptors.CallableDescriptor;
 
 public interface ExternalOverridabilityCondition {
-    boolean isOverridable(@NotNull CallableDescriptor superDescriptor, @NotNull CallableDescriptor subDescriptor);
+    enum Result {
+        OVERRIDABLE, CONFLICT, INCOMPATIBLE, UNKNOWN
+    }
+
+    @NotNull
+    Result isOverridable(@NotNull CallableDescriptor superDescriptor, @NotNull CallableDescriptor subDescriptor);
 }

core/descriptors/src/org/jetbrains/kotlin/resolve/OverridingUtil.java

@@ -34,6 +34,7 @@ import org.jetbrains.kotlin.types.checker.KotlinTypeChecker;
 import java.util.*;
 
 import static org.jetbrains.kotlin.resolve.OverridingUtil.OverrideCompatibilityInfo.Result.*;
+import static org.jetbrains.kotlin.resolve.OverridingUtil.OverrideCompatibilityInfo.Result.INCOMPATIBLE;
 
 public class OverridingUtil {
 
@@ -76,6 +77,30 @@ public class OverridingUtil {
             @NotNull CallableDescriptor superDescriptor,
             @NotNull CallableDescriptor subDescriptor,
             boolean checkReturnType
+    ) {
+        for (ExternalOverridabilityCondition externalCondition : EXTERNAL_CONDITIONS) {
+            ExternalOverridabilityCondition.Result result = externalCondition.isOverridable(superDescriptor, subDescriptor);
+            switch (result) {
+                case OVERRIDABLE:
+                    return OverrideCompatibilityInfo.success();
+                case CONFLICT:
+                    return OverrideCompatibilityInfo.conflict("External condition failed");
+                case INCOMPATIBLE:
+                    return OverrideCompatibilityInfo.incompatible("External condition");
+                case UNKNOWN:
+                    // do nothing
+                    // go to the next external condition or default override check
+            }
+        }
+
+        return isOverridableByWithoutExternalConditions(superDescriptor, subDescriptor, checkReturnType);
+    }
+
+    @NotNull
+    public OverrideCompatibilityInfo isOverridableByWithoutExternalConditions(
+            @NotNull CallableDescriptor superDescriptor,
+            @NotNull CallableDescriptor subDescriptor,
+            boolean checkReturnType
     ) {
         if (superDescriptor instanceof FunctionDescriptor && !(subDescriptor instanceof FunctionDescriptor) ||
             superDescriptor instanceof PropertyDescriptor && !(subDescriptor instanceof PropertyDescriptor)) {
@@ -138,12 +163,6 @@ public class OverridingUtil {
             }
         }
 
-        for (ExternalOverridabilityCondition externalCondition : EXTERNAL_CONDITIONS) {
-            if (!externalCondition.isOverridable(superDescriptor, subDescriptor)) {
-                return OverrideCompatibilityInfo.incompatible("External condition failed");
-            }
-        }
-
         return OverrideCompatibilityInfo.success();
     }