Merge remote-tracking branch 'origin/master'

compiler/frontend/src/org/jetbrains/jet/lang/resolve/constants/CompileTimeConstantResolver.java

@@ -181,7 +181,7 @@ public class CompileTimeConstantResolver {
             if (text.length() == 1) {
                 return new CharValue(text.charAt(0));
             }
-            return new ErrorValue("Too many characters in a character literal" + text);
+            return new ErrorValue("Too many characters in a character literal '" + text + "'");
         }
         return escapedStringToCharValue(text);
     }

stdlib/ktSrc/JavaIterablesSpecial.kt

@@ -0,0 +1,85 @@
+package std.util
+// Number of extension function for ava.lang.Iterable that shouldn't participate in auto generation
+
+import java.util.Collection
+import java.util.List
+import java.util.AbstractList
+
+/**
+ * Count the number of elements in collection.
+ *
+ * If base collection implements Collection<T> interface method Collection<T>#size() will be used.
+ * Otherwise, this method determines the count by iterating through the all items.
+ */
+fun <T> java.lang.Iterable<T>.count() : Int {
+  if (this is Collection<T>) {
+    return this.size()
+  }
+
+  var number : Int = 0
+  for (elem in this) {
+    ++number
+  }
+  return number
+}
+
+/**
+ * Get the first element in the collection.
+ *
+ * Will throw an exception if there are no elements
+ * TODO: Specify type of the exception
+ */
+inline fun <T> java.lang.Iterable<T>.first() : T {
+  if (this is AbstractList<T>) {
+    return this.get(0)
+  }
+
+  return this.iterator().sure().next()
+}
+
+/**
+ * Get the last element in the collection.
+ *
+ * If base collection implements List<T> interface, the combination of size() and get()
+ * methods will be used for getting last element. Otherwise, this method determines the
+ * last item by iterating through the all items.
+ *
+ * Will throw an exception if there are no elements.
+ * TODO: Specify type of the exception
+ */
+fun <T> java.lang.Iterable<T>.last() : T {
+  if (this is List<T>) {
+    return this.get(this.size() - 1);
+  }
+
+  val iterator = this.iterator().sure()
+  var last : T = iterator.next()
+
+  while (iterator.hasNext()) {
+    last = iterator.next()
+  }
+
+  return last;
+}
+
+/**
+ * Checks if collection contains given item.
+ *
+ * Method checks equality of the objects with T.equals method.
+ * If collection implements java.util.AbstractCollection an overridden implementation of the contains
+ * method will be used.
+ */
+fun <T> java.lang.Iterable<T>.contains(item : T) : Boolean {
+  std.io.println("!!!!!")
+  if (this is java.util.AbstractCollection<T>) {
+    return this.contains(item);
+  }
+
+  for (var elem in this) {
+    if (elem.equals(item)) {
+      return true
+    }
+  }
+
+  return false
+}

testlib/src/Test.kt

@@ -81,6 +81,14 @@ fun assert(actual: Boolean, message: String) {
   println("Answer: ${actual} for ${message}")
 }
 
+fun assertTrue(actual: Boolean, message: String = "") {
+  return assertEquals(true, actual, message)
+}
+
+fun assertFalse(actual: Boolean, message: String = "") {
+    return assertEquals(false, actual, message)
+}
+
 fun assertEquals(expected: Any, actual: Any?, message: String = "") {
   Assert.assertEquals(message, expected, actual)
 }

testlib/test/CollectionTest.kt

@@ -9,6 +9,16 @@ import std.test.*
 import java.util.*
 
 class CollectionTest() : TestSupport() {
+
+  class IterableWrapper<T>(collection : java.lang.Iterable<T>) : java.lang.Iterable<T> {
+    private val collection = collection
+
+    override fun iterator(): java.util.Iterator<T> {
+      return collection.iterator().sure()
+    }
+  }
+
+
   val data = arrayList("foo", "bar")
 
   fun testAny() {
@@ -177,4 +187,39 @@ class CollectionTest() : TestSupport() {
       }
     }
   }
+
+  fun testSimpleCount() {
+    assertEquals(2, data.count())
+    assertEquals(3, hashSet(12, 14, 15).count())
+    assertEquals(0, ArrayList<Double>().count())
+  }
+
+  fun testLast() {
+    assertEquals("bar", data.last())
+    assertEquals(25, arrayList(15, 19, 20, 25).last())
+    // assertEquals(19, TreeSet(arrayList(90, 47, 19)).first())
+    assertEquals('a', linkedList('a').last())
+  }
+
+  fun testLastException() {
+    fails { arrayList<Int>().last() }
+    fails { linkedList<String>().last() }
+    fails { hashSet<Char>().last() }
+  }
+
+  fun testContains() {
+    assertTrue(data.contains("foo"))
+    assertTrue(data.contains("bar"))
+    assertFalse(data.contains("some"))
+
+    // TODO: Problems with generation
+//    assertTrue(IterableWrapper(data).contains("bar"))
+//    assertFalse(IterableWrapper(data).contains("some"))
+
+    assertFalse(hashSet<Int>().contains(12))
+    assertTrue(linkedList(15, 19, 20).contains(15))
+
+//    assertTrue(IterableWrapper(hashSet(45, 14, 13)).contains(14))
+//    assertFalse(IterableWrapper(linkedList<Int>()).contains(15))
+  }
 }