JS: Make StringBuilder implement CharSequence and introduce secondary constructors.

js/js.libraries/src/core/javalang.kt

@@ -44,7 +44,10 @@ public interface Appendable {
 }
 
 @library
-public class StringBuilder(capacity: Int? = null) : Appendable {
+public class StringBuilder(content: String = "") : Appendable, CharSequence {
+    override val length: Int = noImpl
+    override fun get(index: Int): Char = noImpl
+    override fun subSequence(start: Int, end: Int): CharSequence = noImpl
     override fun append(c: Char): StringBuilder = noImpl
     override fun append(csq: CharSequence?): StringBuilder = noImpl
     override fun append(csq: CharSequence?, start: Int, end: Int): StringBuilder = noImpl
@@ -52,3 +55,6 @@ public class StringBuilder(capacity: Int? = null) : Appendable {
     public fun reverse(): StringBuilder = noImpl
     override fun toString(): String = noImpl
 }
+
+public inline fun StringBuilder(capacity: Int): StringBuilder = StringBuilder()
+public inline fun StringBuilder(content: CharSequence): StringBuilder = StringBuilder(content.toString())

js/js.translator/testData/kotlin_lib.js

@@ -1029,9 +1029,20 @@
 
 
     Kotlin.StringBuilder = Kotlin.createClassNow(null,
-        function () {
+        function (content) {
-            this.string = "";
+            this.string = typeof(content) == "string" ? content : "";
         }, {
+        length: {
+            get: function() {
+                return this.string.length;
+            }
+        },
+        substring: function(start, end) {
+            return this.string.substring(start, end);
+        },
+        charAt: function(index) {
+            return this.string.charAt(index);
+        },
         append: function (obj, from, to) {
             if (from == void 0 && to == void 0) {
                 this.string = this.string + obj.toString();

libraries/stdlib/test/text/StringBuilderTest.kt

@@ -25,4 +25,41 @@ class StringBuilderTest {
             append("element", 2, 4)
         })
     }
+
+    @test fun asCharSequence() {
+        val original = "Some test string"
+        val sb = StringBuilder(original)
+        val result = sb.toString()
+        val cs = sb as CharSequence
+
+        assertEquals(result.length(), cs.length())
+        assertEquals(result.length(), sb.length())
+        for (index in result.indices) {
+            assertEquals(result[index], sb[index])
+            assertEquals(result[index], cs[index])
+        }
+        assertEquals(result.substring(2, 6), cs.subSequence(2, 6).toString())
+    }
+
+    @test fun constructors() {
+        StringBuilder().let { sb ->
+            assertEquals(0, sb.length())
+            assertEquals("", sb.toString())
+        }
+
+        StringBuilder(16).let { sb ->
+            assertEquals(0, sb.length())
+            assertEquals("", sb.toString())
+        }
+
+        StringBuilder("content").let { sb ->
+            assertEquals(7, sb.length())
+            assertEquals("content", sb.toString())
+        }
+
+        StringBuilder(StringBuilder("content")).let { sb ->
+            assertEquals(7, sb.length())
+            assertEquals("content", sb.toString())
+        }
+    }
 }