Intrinsic default objects implementation: tests

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

@@ -0,0 +1,107 @@
+package foo
+
+fun box(): String {
+    try {
+        testDefaultObjectAccess()
+        testInCall()
+        testDoubleConstants()
+        testFloatConstants()
+        testCallInterface()
+        testLocalFun()
+        testTopLevelFun()
+        testVarTopField()
+    }
+    catch (e: Throwable) {
+        return "Error: \n" + e
+    }
+
+    return "OK"
+}
+
+fun testDefaultObjectAccess() {
+    val i = Int
+    val d = Double
+    val f = Float
+    val l = Long
+    val sh = Short
+    val b = Byte
+    val st = String
+    val en = Enum
+}
+
+fun testInCall() {
+    test(Int)
+    test(Double)
+    test(Float)
+    test(Long)
+    test(Short)
+    test(Byte)
+    test(String)
+    test(Enum)
+}
+
+fun testDoubleConstants() {
+    val pi = Double.POSITIVE_INFINITY
+    val ni = Double.NEGATIVE_INFINITY
+    val nan = Double.NaN
+
+    myAssertEquals(pi, Double.POSITIVE_INFINITY)
+    myAssertEquals(ni, Double.NEGATIVE_INFINITY)
+}
+
+fun testFloatConstants() {
+    val pi = Float.POSITIVE_INFINITY
+    val ni = Float.NEGATIVE_INFINITY
+    val nan = Float.NaN
+
+    myAssertEquals(pi, Float.POSITIVE_INFINITY)
+    myAssertEquals(ni, Float.NEGATIVE_INFINITY)
+}
+
+fun testCallInterface() {
+    fun <T> floatPointConstants(a: FloatingPointConstants<T>) {
+        val pi = a.POSITIVE_INFINITY
+        val ni = a.NEGATIVE_INFINITY
+        val nan = a.NaN
+
+        myAssertEquals(pi, a.POSITIVE_INFINITY)
+        myAssertEquals(ni, a.NEGATIVE_INFINITY)
+    }
+
+    floatPointConstants(Double)
+    floatPointConstants(Float)
+}
+
+fun testLocalFun() {
+    fun Int.Default.LocalFun() : String = "LocalFun"
+    myAssertEquals("LocalFun", Int.LocalFun())
+}
+
+fun testTopLevelFun() {
+    myAssertEquals("TopFun", Int.TopFun())
+}
+
+fun testVarTopField() {
+    myAssertEquals(0, Int.TopField)
+
+    Int.TopField++
+    myAssertEquals(1, Int.TopField)
+
+    Int.TopField += 5
+    myAssertEquals(6, Int.TopField)
+}
+
+fun test(a: Any) {}
+
+var _field: Int = 0
+var Int.Default.TopField : Int
+    get() = _field
+    set(value) { _field = value };
+
+fun Int.Default.TopFun() : String = "TopFun"
+
+fun myAssertEquals<T>(a: T, b: T) {
+    if (a != b) throw Exception("$a != $b")
+}
+
+

compiler/testData/codegen/boxWithStdlib/intrinsics/defaultObjectMapping.kt

@@ -0,0 +1,15 @@
+import kotlin.test.assertEquals
+
+fun box(): String {
+    assertEquals(java.lang.Integer.MIN_VALUE, Int.MIN_VALUE)
+    assertEquals(java.lang.Byte.MAX_VALUE, Byte.MAX_VALUE)
+
+    assertEquals("MIN_VALUE", (Int.Default::MIN_VALUE).name)
+    assertEquals("MAX_VALUE", (Double.Default::MAX_VALUE).name)
+    assertEquals("MIN_VALUE", (Float.Default::MIN_VALUE).name)
+    assertEquals("MAX_VALUE", (Long.Default::MAX_VALUE).name)
+    assertEquals("MIN_VALUE", (Short.Default::MIN_VALUE).name)
+    assertEquals("MAX_VALUE", (Byte.Default::MAX_VALUE).name)
+
+    return "OK"
+}

compiler/testData/diagnostics/tests/classObjects/builtInClassObjects.kt

@@ -0,0 +1,41 @@
+// !DIAGNOSTICS: -UNUSED_VARIABLE, -UNUSED_PARAMETER
+
+fun box(): String {
+    try {
+        // Objects
+        val i = Int
+        val d = Double
+        val f = Float
+        val l = Long
+        val sh = Short
+        val b = Byte
+        val st = String
+
+        test(Int)
+        test(Double)
+        test(Float)
+        test(Long)
+        test(Short)
+        test(Byte)
+        test(String)
+
+        // Common Double
+        Double.POSITIVE_INFINITY
+        Double.NEGATIVE_INFINITY
+        Double.NaN
+
+        // Common Float
+        Float.POSITIVE_INFINITY
+        Float.NEGATIVE_INFINITY
+        Float.NaN
+    }
+    catch (e: Throwable) {
+        return "Error: \n" + e
+    }
+
+    return "OK"
+}
+
+fun test(a: Any) {}
+
+

compiler/testData/diagnostics/tests/classObjects/builtInClassObjects.txt

@@ -0,0 +1,4 @@
+package
+
+internal fun box(): kotlin.String
+internal fun test(/*0*/ a: kotlin.Any): kotlin.Unit

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

@@ -1498,6 +1498,12 @@ public class JetDiagnosticsTestGenerated extends AbstractJetDiagnosticsTest {
                 JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/classObjects"), Pattern.compile("^(.+)\\.kt$"), true);
             }
 
+            @TestMetadata("builtInClassObjects.kt")
+            public void testBuiltInClassObjects() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/classObjects/builtInClassObjects.kt");
+                doTest(fileName);
+            }
+
             @TestMetadata("ClassObjectCannotAccessClassFields.kt")
             public void testClassObjectCannotAccessClassFields() throws Exception {
                 String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/classObjects/ClassObjectCannotAccessClassFields.kt");

compiler/tests/org/jetbrains/kotlin/codegen/generated/BlackBoxCodegenTestGenerated.java

@@ -59,6 +59,7 @@ import java.util.regex.Pattern;
         BlackBoxCodegenTestGenerated.Labels.class,
         BlackBoxCodegenTestGenerated.LocalClasses.class,
         BlackBoxCodegenTestGenerated.MultiDecl.class,
+        BlackBoxCodegenTestGenerated.ObjectIntrinsics.class,
         BlackBoxCodegenTestGenerated.Objects.class,
         BlackBoxCodegenTestGenerated.OperatorConventions.class,
         BlackBoxCodegenTestGenerated.Package.class,
@@ -4934,6 +4935,21 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest {
         }
     }
 
+    @TestMetadata("compiler/testData/codegen/box/objectIntrinsics")
+    @TestDataPath("$PROJECT_ROOT")
+    @RunWith(JUnit3RunnerWithInners.class)
+    public static class ObjectIntrinsics extends AbstractBlackBoxCodegenTest {
+        public void testAllFilesPresentInObjectIntrinsics() throws Exception {
+            JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/codegen/box/objectIntrinsics"), Pattern.compile("^(.+)\\.kt$"), true);
+        }
+
+        @TestMetadata("objects.kt")
+        public void testObjects() throws Exception {
+            String fileName = JetTestUtils.navigationMetadata("compiler/testData/codegen/box/objectIntrinsics/objects.kt");
+            doTest(fileName);
+        }
+    }
+
     @TestMetadata("compiler/testData/codegen/box/objects")
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)

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

@@ -1570,6 +1570,12 @@ public class BlackBoxWithStdlibCodegenTestGenerated extends AbstractBlackBoxCode
             JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/codegen/boxWithStdlib/intrinsics"), Pattern.compile("^(.+)\\.kt$"), true);
         }
 
+        @TestMetadata("defaultObjectMapping.kt")
+        public void testDefaultObjectMapping() throws Exception {
+            String fileName = JetTestUtils.navigationMetadata("compiler/testData/codegen/boxWithStdlib/intrinsics/defaultObjectMapping.kt");
+            doTestWithStdlib(fileName);
+        }
+
         @TestMetadata("kt5937.kt")
         public void testKt5937() throws Exception {
             String fileName = JetTestUtils.navigationMetadata("compiler/testData/codegen/boxWithStdlib/intrinsics/kt5937.kt");