rename error

2012-09-07 18:23:11 +04:00
parent 1dfe212844
commit cd5521d6dc
15 changed files with 29 additions and 29 deletions
@@ -84,7 +84,7 @@ public interface Errors {
    DiagnosticFactory1<JetSimpleNameExpression, DeclarationDescriptor> CANNOT_BE_IMPORTED = DiagnosticFactory1.create(ERROR);
    SimpleDiagnosticFactory<JetExpression> USELESS_HIDDEN_IMPORT = SimpleDiagnosticFactory.create(WARNING);
    SimpleDiagnosticFactory<JetExpression> USELESS_SIMPLE_IMPORT = SimpleDiagnosticFactory.create(WARNING);
-    DiagnosticFactory1<JetElement, Collection<ClassDescriptor>> CLASS_HAS_KOTLIN_ANALOG = DiagnosticFactory1.create(WARNING);
+    DiagnosticFactory1<JetElement, Collection<ClassDescriptor>> PLATFORM_CLASS_MAPPED_TO_KOTLIN = DiagnosticFactory1.create(WARNING);

    SimpleDiagnosticFactory<JetParameter> CANNOT_INFER_PARAMETER_TYPE = SimpleDiagnosticFactory.create(ERROR);

@@ -95,7 +95,7 @@ public class DefaultErrorMessages {
        MAP.put(CANNOT_BE_IMPORTED, "Cannot import ''{0}'', functions and properties can be imported only from packages", NAME);
        MAP.put(USELESS_HIDDEN_IMPORT, "Useless import, it is hidden further");
        MAP.put(USELESS_SIMPLE_IMPORT, "Useless import, does nothing");
-        MAP.put(CLASS_HAS_KOTLIN_ANALOG, "This class has Kotlin analog(s) {0} that should be used instead.", CLASS_DESCRIPTOR_LIST);
+        MAP.put(PLATFORM_CLASS_MAPPED_TO_KOTLIN, "This class shouldn't be used in Kotlin. Use {0} instead.", CLASS_DESCRIPTOR_LIST);

        MAP.put(CANNOT_INFER_PARAMETER_TYPE,
                "Cannot infer a type for this parameter. To specify it explicitly use the {(p : Type) => ...} notation");
@@ -32,7 +32,7 @@ import java.util.Collection;
 import java.util.List;
 import java.util.Map;

-import static org.jetbrains.jet.lang.diagnostics.Errors.CLASS_HAS_KOTLIN_ANALOG;
+import static org.jetbrains.jet.lang.diagnostics.Errors.PLATFORM_CLASS_MAPPED_TO_KOTLIN;
 import static org.jetbrains.jet.lang.diagnostics.Errors.USELESS_HIDDEN_IMPORT;
 import static org.jetbrains.jet.lang.diagnostics.Errors.USELESS_SIMPLE_IMPORT;

@@ -149,7 +149,7 @@ public class ImportsResolver {
        PlatformToKotlinClassMap platformToKotlinMap = configuration.getPlatformToKotlinClassMap();
        Collection<ClassDescriptor> kotlinAnalogsForClass = platformToKotlinMap.mapPlatformClass((ClassDescriptor) descriptor);
        if (!kotlinAnalogsForClass.isEmpty()) {
-            trace.report(CLASS_HAS_KOTLIN_ANALOG.on(element, kotlinAnalogsForClass));
+            trace.report(PLATFORM_CLASS_MAPPED_TO_KOTLIN.on(element, kotlinAnalogsForClass));
        }
    }

@@ -1,3 +1,3 @@
 class TestIface(r : Runnable) : Runnable by r {}

-class TestObject(o : <!CLASS_HAS_KOTLIN_ANALOG!>Object<!>) : <!CLASS_HAS_KOTLIN_ANALOG, DELEGATION_NOT_TO_TRAIT!>Object<!> by o {}
+class TestObject(o : <!PLATFORM_CLASS_MAPPED_TO_KOTLIN!>Object<!>) : <!PLATFORM_CLASS_MAPPED_TO_KOTLIN, DELEGATION_NOT_TO_TRAIT!>Object<!> by o {}
@@ -4,7 +4,7 @@
 package foobar.a
    import java.*

-    val a : <!CLASS_HAS_KOTLIN_ANALOG!>util.List<Int><!>? = null
+    val a : <!PLATFORM_CLASS_MAPPED_TO_KOTLIN!>util.List<Int><!>? = null
    val a1 : List<Int>? = null

 // FILE: b.kt
@@ -8,7 +8,7 @@ fun test() {
  val <!UNUSED_VARIABLE!>a<!> : Collection<String>? = java.util.Collections.emptyList()
 }

-fun test(<!UNUSED_PARAMETER!>a<!> : <!CLASS_HAS_KOTLIN_ANALOG!>java.lang.Comparable<Int><!>) {
+fun test(<!UNUSED_PARAMETER!>a<!> : <!PLATFORM_CLASS_MAPPED_TO_KOTLIN!>java.lang.Comparable<Int><!>) {

 }

@@ -5,15 +5,15 @@ import java.util.*
 import <!UNRESOLVED_REFERENCE!>utils<!>.*

 import java.io.PrintStream
-import <!CLASS_HAS_KOTLIN_ANALOG!>java.lang.Comparable<!> as Com
+import <!PLATFORM_CLASS_MAPPED_TO_KOTLIN!>java.lang.Comparable<!> as Com

 val l : List<in Int> = ArrayList<Int>()

-fun test(<!UNUSED_PARAMETER!>l<!> : <!CLASS_HAS_KOTLIN_ANALOG!>java.util.List<Int><!>) {
+fun test(<!UNUSED_PARAMETER!>l<!> : <!PLATFORM_CLASS_MAPPED_TO_KOTLIN!>java.util.List<Int><!>) {
  val <!UNUSED_VARIABLE!>x<!> : java.<!UNRESOLVED_REFERENCE!>List<!>
-  val <!UNUSED_VARIABLE!>y<!> : <!CLASS_HAS_KOTLIN_ANALOG!>java.util.List<Int><!>
-  val <!UNUSED_VARIABLE!>b<!> : <!CLASS_HAS_KOTLIN_ANALOG!>java.lang.Object<!>
-  val <!UNUSED_VARIABLE!>a<!> : <!CLASS_HAS_KOTLIN_ANALOG!>util.List<Int><!>
+  val <!UNUSED_VARIABLE!>y<!> : <!PLATFORM_CLASS_MAPPED_TO_KOTLIN!>java.util.List<Int><!>
+  val <!UNUSED_VARIABLE!>b<!> : <!PLATFORM_CLASS_MAPPED_TO_KOTLIN!>java.lang.Object<!>
+  val <!UNUSED_VARIABLE!>a<!> : <!PLATFORM_CLASS_MAPPED_TO_KOTLIN!>util.List<Int><!>
  val <!UNUSED_VARIABLE!>z<!> : java.<!UNRESOLVED_REFERENCE!>utils<!>.List<Int>

  val <!UNUSED_VARIABLE!>f<!> : java.io.File? = null
@@ -29,7 +29,7 @@ fun test(<!UNUSED_PARAMETER!>l<!> : <!CLASS_HAS_KOTLIN_ANALOG!>java.util.List<In
  <!UNRESOLVED_REFERENCE!>List<!><Int>


-  val <!UNUSED_VARIABLE!>o<!> = "sdf" <!CAST_NEVER_SUCCEEDS!>as<!> <!CLASS_HAS_KOTLIN_ANALOG!>Object<!>
+  val <!UNUSED_VARIABLE!>o<!> = "sdf" <!CAST_NEVER_SUCCEEDS!>as<!> <!PLATFORM_CLASS_MAPPED_TO_KOTLIN!>Object<!>

  try {
    // ...
@@ -40,9 +40,9 @@ fun test(<!UNUSED_PARAMETER!>l<!> : <!CLASS_HAS_KOTLIN_ANALOG!>java.util.List<In

  PrintStream("sdf")

-  val c : <!CLASS_HAS_KOTLIN_ANALOG!>Com<Int><!>? = null
+  val c : <!PLATFORM_CLASS_MAPPED_TO_KOTLIN!>Com<Int><!>? = null

-  c : <!CLASS_HAS_KOTLIN_ANALOG!>java.lang.Comparable<Int><!>?
+  c : <!PLATFORM_CLASS_MAPPED_TO_KOTLIN!>java.lang.Comparable<Int><!>?

 //  Collections.sort<Integer>(ArrayList<Integer>())
  xxx.<!UNRESOLVED_REFERENCE!>Class<!>()
@@ -4,7 +4,7 @@ package i
 import java.util.*

 fun <T, R> Collection<T>.map1(<!UNUSED_PARAMETER!>f<!> : (T) -> R) : List<R> {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
-fun <T, R> <!CLASS_HAS_KOTLIN_ANALOG!>java.lang.Iterable<T><!>.map1(<!UNUSED_PARAMETER!>f<!> : (T) -> R) : List<R> {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
+fun <T, R> <!PLATFORM_CLASS_MAPPED_TO_KOTLIN!>java.lang.Iterable<T><!>.map1(<!UNUSED_PARAMETER!>f<!> : (T) -> R) : List<R> {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>

 fun test(list: List<Int>) {
    val res = list.map1 { it }
@@ -13,7 +13,7 @@ fun test(list: List<Int>) {
 }

 fun <T> Collection<T>.foo() {}
-fun <T> <!CLASS_HAS_KOTLIN_ANALOG!>java.lang.Iterable<T><!>.foo() {}
+fun <T> <!PLATFORM_CLASS_MAPPED_TO_KOTLIN!>java.lang.Iterable<T><!>.foo() {}

 fun test1(list: List<Int>) {
    val res = list.foo()
@@ -5,7 +5,7 @@ import java.util.*
 import java.lang.annotation.*

 fun bar() : Iterator<Int>? {
-    val <!UNUSED_VARIABLE!>i<!> : Iterable<<!CLASS_HAS_KOTLIN_ANALOG!>Integer<!>>
+    val <!UNUSED_VARIABLE!>i<!> : Iterable<<!PLATFORM_CLASS_MAPPED_TO_KOTLIN!>Integer<!>>
    val <!UNUSED_VARIABLE!>a<!> : Annotation
    return null
 }
@@ -1,11 +1,11 @@
 //KT-2641 Warn on using j.l.Iterable in Kotlin code
 package n

-import <!CLASS_HAS_KOTLIN_ANALOG!>java.util.Iterator<!>
-import <!CLASS_HAS_KOTLIN_ANALOG!>java.lang.Comparable<!> as Comp
+import <!PLATFORM_CLASS_MAPPED_TO_KOTLIN!>java.util.Iterator<!>
+import <!PLATFORM_CLASS_MAPPED_TO_KOTLIN!>java.lang.Comparable<!> as Comp

-fun bar() : <!CLASS_HAS_KOTLIN_ANALOG!>java.lang.Iterable<Int><!>? {
-    val <!UNUSED_VARIABLE!>a<!> : <!CLASS_HAS_KOTLIN_ANALOG!>java.lang.Comparable<String><!>? = null
-    val <!UNUSED_VARIABLE!>b<!> : Iterable<<!CLASS_HAS_KOTLIN_ANALOG!>Integer<!>>
+fun bar() : <!PLATFORM_CLASS_MAPPED_TO_KOTLIN!>java.lang.Iterable<Int><!>? {
+    val <!UNUSED_VARIABLE!>a<!> : <!PLATFORM_CLASS_MAPPED_TO_KOTLIN!>java.lang.Comparable<String><!>? = null
+    val <!UNUSED_VARIABLE!>b<!> : Iterable<<!PLATFORM_CLASS_MAPPED_TO_KOTLIN!>Integer<!>>
    return null
 }
@@ -3,7 +3,7 @@ package kt1778

 fun main(args : Array<String>) {
    val x = args[0]: Any
-    if(x is <!CLASS_HAS_KOTLIN_ANALOG!>java.lang.CharSequence<!>) {
+    if(x is <!PLATFORM_CLASS_MAPPED_TO_KOTLIN!>java.lang.CharSequence<!>) {
        if ("a" == x) x.length() else x.length() // OK
        if ("a" == x || "b" == x) x.length() else x.length() // <– THEN ERROR
        if ("a" == x && "a" == x) x.length() else x.length() // <– ELSE ERROR
@@ -2,13 +2,13 @@

 import java.util.ArrayList

-abstract class Item(val room: <!CLASS_HAS_KOTLIN_ANALOG!>Object<!>) {
+abstract class Item(val room: <!PLATFORM_CLASS_MAPPED_TO_KOTLIN!>Object<!>) {
   abstract val name : String
 }

 val items: ArrayList<Item> = ArrayList<Item>()

-fun test(room : <!CLASS_HAS_KOTLIN_ANALOG!>Object<!>) {
+fun test(room : <!PLATFORM_CLASS_MAPPED_TO_KOTLIN!>Object<!>) {
  for(val item: Item? in items) {
    if (item?.room === room) {
      System.out.println("You see " + item?.name)
@@ -3,5 +3,5 @@
 class IdUnavailableException() : Exception() {}

 fun <T : Any> T.getJavaClass() : Class<T> {
-    return <!UNCHECKED_CAST!>((this <!CAST_NEVER_SUCCEEDS!>as<!> <!CLASS_HAS_KOTLIN_ANALOG!>Object<!>).getClass()) as Class<T><!> // Some error here, because of Exception() used above. ?!!!
+    return <!UNCHECKED_CAST!>((this <!CAST_NEVER_SUCCEEDS!>as<!> <!PLATFORM_CLASS_MAPPED_TO_KOTLIN!>Object<!>).getClass()) as Class<T><!> // Some error here, because of Exception() used above. ?!!!
 }
@@ -5,7 +5,7 @@ class TypeInfo<T>
 fun <T> typeinfo() : TypeInfo<T> = null <!CAST_NEVER_SUCCEEDS!>as<!> TypeInfo<T>

 fun <T> TypeInfo<T>.getJavaClass() : java.lang.Class<T> {
-    val t : <!CLASS_HAS_KOTLIN_ANALOG!>java.lang.Object<!> = this <!CAST_NEVER_SUCCEEDS!>as<!> <!CLASS_HAS_KOTLIN_ANALOG!>java.lang.Object<!>
+    val t : <!PLATFORM_CLASS_MAPPED_TO_KOTLIN!>java.lang.Object<!> = this <!CAST_NEVER_SUCCEEDS!>as<!> <!PLATFORM_CLASS_MAPPED_TO_KOTLIN!>java.lang.Object<!>
    return <!UNCHECKED_CAST!>t.getClass() as java.lang.Class<T><!> // inferred type is Object but Serializable was expected
 }

@@ -42,6 +42,6 @@ class Q {
 }

 //check that 'toString' can be invoked without specifying return type
-class NewClass : java.util.ArrayList<<!CLASS_HAS_KOTLIN_ANALOG!>Integer<!>>() {
+class NewClass : java.util.ArrayList<<!PLATFORM_CLASS_MAPPED_TO_KOTLIN!>Integer<!>>() {
    public override fun toString() = "a"
 }