From 8d6d292150b2f1871f4abeb08ab0922c053295c6 Mon Sep 17 00:00:00 2001 From: Svetlana Isakova Date: Wed, 18 Apr 2012 18:52:32 +0400 Subject: [PATCH 01/10] more tests for resolve order --- .../testData/codegen/classes/resolveOrder.jet | 36 +++++++++++++++---- 1 file changed, 29 insertions(+), 7 deletions(-) diff --git a/compiler/testData/codegen/classes/resolveOrder.jet b/compiler/testData/codegen/classes/resolveOrder.jet index 563859f6e8e..3770367675d 100644 --- a/compiler/testData/codegen/classes/resolveOrder.jet +++ b/compiler/testData/codegen/classes/resolveOrder.jet @@ -1,8 +1,10 @@ fun box() : String { if (!B().test()) return "fail 1"; if (!D().test()) return "fail 2" + if (!F().test()) return "fail 3" if (!L().test()) return "fail 4" - if (!N().test()) return "fail 5" + if (!H().test()) return "fail 5" + if (!N().test()) return "fail 6" return "OK" } @@ -31,16 +33,26 @@ class D { fun test() = C().bar() == 1 } +class E +fun E.foo() = 2 -class M -fun M.foo() = 2 +class F { + fun foo() = 1 -class N { - fun M.foo() = 1 + fun E.bar() = foo() - fun M.bar() = foo() + fun test() = E().bar() == 1 +} - fun test() = M().bar() == 1 +class G +fun G.foo() = 2 + +class H { + fun G.foo() = 1 + + fun G.bar() = foo() + + fun test() = G().bar() == 1 } class K @@ -51,3 +63,13 @@ class L { } fun K.foo() = 1 fun L.foo() = 2 + +class M +class N { + fun foo() = 1 + fun M.foo() = 2 + + fun M.bar() = foo() + + fun test() = M().bar() == 1 +} From b5bf4a626cb4eb9822900da5d57cb12dc12dbb7a Mon Sep 17 00:00:00 2001 From: Svetlana Isakova Date: Wed, 18 Apr 2012 18:55:03 +0400 Subject: [PATCH 02/10] Reverted explicitly specifying visibility modifier while override --- .../codegen/classes/classObjectInterface.jet | 2 +- .../codegen/controlStructures/forUserType.jet | 14 +++++++------- .../testData/codegen/controlStructures/sync.jet | 2 +- .../testData/codegen/objects/objectLiteral.jet | 2 +- .../codegen/objects/objectLiteralInClosure.jet | 2 +- compiler/testData/codegen/regressions/kt1136.kt | 2 +- compiler/testData/codegen/regressions/kt1157.kt | 2 +- compiler/testData/codegen/regressions/kt1159.kt | 2 +- compiler/testData/codegen/regressions/kt1168.kt | 4 ++-- compiler/testData/codegen/regressions/kt299.jet | 2 +- compiler/testData/codegen/regressions/kt344.jet | 2 +- compiler/testData/codegen/regressions/kt533.kt | 6 +++--- compiler/testData/codegen/regressions/kt887.jet | 2 +- compiler/testData/codegen/regressions/kt940.kt | 4 ++-- .../codegen/super/basicmethodSuperClass.jet | 2 +- compiler/testData/codegen/traits/simple.jet | 2 +- compiler/testData/codegen/traits/stdlib.jet | 8 ++++---- .../diagnostics/tests/PrimaryConstructors.jet | 7 +++---- .../tests/extensions/GenericIterator.jet | 4 ++-- .../diagnostics/tests/regressions/kt588.jet | 2 +- libraries/kunit/src/main/kotlin/junit/JUnit.kt | 10 +++++----- libraries/stdlib/src/kotlin/Standard.kt | 4 ++-- .../stdlib/src/kotlin/concurrent/FunctionalList.kt | 6 +++--- libraries/stdlib/src/kotlin/dom/Dom.kt | 12 ++++++------ libraries/stdlib/src/kotlin/io/JIO.kt | 4 ++-- .../stdlib/src/kotlin/support/AbstractIterator.kt | 6 +++--- libraries/stdlib/test/CollectionTest.kt | 2 +- libraries/stdlib/test/CompareTest.kt | 4 ++-- libraries/stdlib/test/Test.kt | 8 ++++---- .../test/concurrent/SerialFunAndTupleTest.kt | 2 +- libraries/stdlib/test/properties/PropertiesTest.kt | 2 +- 31 files changed, 66 insertions(+), 67 deletions(-) diff --git a/compiler/testData/codegen/classes/classObjectInterface.jet b/compiler/testData/codegen/classes/classObjectInterface.jet index 0672b7f4b65..432bb37bee0 100644 --- a/compiler/testData/codegen/classes/classObjectInterface.jet +++ b/compiler/testData/codegen/classes/classObjectInterface.jet @@ -2,7 +2,7 @@ class C() { fun getInstance(): Runnable = C class object: Runnable { - public override fun run(): Unit { } + override fun run(): Unit { } } } diff --git a/compiler/testData/codegen/controlStructures/forUserType.jet b/compiler/testData/codegen/controlStructures/forUserType.jet index e08bbe4f86d..7c0a4d1203d 100644 --- a/compiler/testData/codegen/controlStructures/forUserType.jet +++ b/compiler/testData/codegen/controlStructures/forUserType.jet @@ -78,25 +78,25 @@ fun box() : String { } class MyCollection1(): java.lang.Iterable { - public override fun iterator(): java.util.Iterator = MyIterator() + override fun iterator(): java.util.Iterator = MyIterator() class MyIterator(): java.util.Iterator { var k : Int = 5 - public override fun next() : Int = k-- - public override fun hasNext() = k > 0 - public override fun remove() {} + override fun next() : Int = k-- + override fun hasNext() = k > 0 + override fun remove() {} } } class MyCollection2(): Iterable { - public override fun iterator(): Iterator = MyIterator() + override fun iterator(): Iterator = MyIterator() class MyIterator(): Iterator { var k : Int = 5 - public override fun next() : Int = k-- - public override val hasNext : Boolean + override fun next() : Int = k-- + override val hasNext : Boolean get() = k > 0 } } diff --git a/compiler/testData/codegen/controlStructures/sync.jet b/compiler/testData/codegen/controlStructures/sync.jet index dcec0d68127..317fa64a53a 100644 --- a/compiler/testData/codegen/controlStructures/sync.jet +++ b/compiler/testData/codegen/controlStructures/sync.jet @@ -3,7 +3,7 @@ import java.util.concurrent.atomic.* fun thread(block: ()->Unit ) { val thread = object: Thread() { - public override fun run() { + override fun run() { block() } } diff --git a/compiler/testData/codegen/objects/objectLiteral.jet b/compiler/testData/codegen/objects/objectLiteral.jet index d12b396b33f..ca3f96cf336 100644 --- a/compiler/testData/codegen/objects/objectLiteral.jet +++ b/compiler/testData/codegen/objects/objectLiteral.jet @@ -1,7 +1,7 @@ class C(x: Int, val y : Int) { fun initChild(var x: Int) : java.lang.Object { return object : java.lang.Object() { - public override fun toString(): String? { + override fun toString(): String? { x = x + y return "child" + x } diff --git a/compiler/testData/codegen/objects/objectLiteralInClosure.jet b/compiler/testData/codegen/objects/objectLiteralInClosure.jet index fcfb11e91b6..d63c1c879fa 100644 --- a/compiler/testData/codegen/objects/objectLiteralInClosure.jet +++ b/compiler/testData/codegen/objects/objectLiteralInClosure.jet @@ -3,7 +3,7 @@ package p class C(val y : Int) { val initChild = { -> object : java.lang.Object() { - public override fun toString(): String { + override fun toString(): String { return "child" + y } } diff --git a/compiler/testData/codegen/regressions/kt1136.kt b/compiler/testData/codegen/regressions/kt1136.kt index 293ef9781e3..e3214c521fa 100644 --- a/compiler/testData/codegen/regressions/kt1136.kt +++ b/compiler/testData/codegen/regressions/kt1136.kt @@ -2,7 +2,7 @@ import java.util.ArrayList public object SomeObject { private val workerThread = object : Thread() { - public override fun run() { + override fun run() { foo() } } diff --git a/compiler/testData/codegen/regressions/kt1157.kt b/compiler/testData/codegen/regressions/kt1157.kt index f8cc35b8f29..a053a0e54cd 100644 --- a/compiler/testData/codegen/regressions/kt1157.kt +++ b/compiler/testData/codegen/regressions/kt1157.kt @@ -2,7 +2,7 @@ public object SomeClass { var bug: Any = "" private val workerThread = object : Thread() { - public override fun run() { + override fun run() { try { foo() bug = "none" diff --git a/compiler/testData/codegen/regressions/kt1159.kt b/compiler/testData/codegen/regressions/kt1159.kt index bcc902cc21e..c8bb69a04c1 100644 --- a/compiler/testData/codegen/regressions/kt1159.kt +++ b/compiler/testData/codegen/regressions/kt1159.kt @@ -1,6 +1,6 @@ public object RefreshQueue { private val workerThread: Thread = Thread(object : Runnable { - public override fun run() { + override fun run() { workerThread.isInterrupted() } }); diff --git a/compiler/testData/codegen/regressions/kt1168.kt b/compiler/testData/codegen/regressions/kt1168.kt index bf614a7d355..fc931784687 100644 --- a/compiler/testData/codegen/regressions/kt1168.kt +++ b/compiler/testData/codegen/regressions/kt1168.kt @@ -7,9 +7,9 @@ public abstract class BaseClass() { } public class Subclass : BaseClass() { - protected override val kind : String = "Physical" + override val kind : String = "Physical" - protected override val kind2 : String = " kind2" + override val kind2 : String = " kind2" } fun box():String = if(Subclass().debug() == "Physical kind2") "OK" else "fail" diff --git a/compiler/testData/codegen/regressions/kt299.jet b/compiler/testData/codegen/regressions/kt299.jet index 3a34b3f6e5a..4aa31a44dc8 100644 --- a/compiler/testData/codegen/regressions/kt299.jet +++ b/compiler/testData/codegen/regressions/kt299.jet @@ -1,5 +1,5 @@ class MyRange1() : Range { - public override fun contains(item: Int) = true + override fun contains(item: Int) = true } class MyRange2() { diff --git a/compiler/testData/codegen/regressions/kt344.jet b/compiler/testData/codegen/regressions/kt344.jet index 8f08096b5da..1f35cb5e138 100644 --- a/compiler/testData/codegen/regressions/kt344.jet +++ b/compiler/testData/codegen/regressions/kt344.jet @@ -163,7 +163,7 @@ fun t11(var x: Int) : Int { fun t12(x: Int) : Int { var y = x val runnable = object : Runnable { - public override fun run () { + override fun run () { y = y + 1 } } diff --git a/compiler/testData/codegen/regressions/kt533.kt b/compiler/testData/codegen/regressions/kt533.kt index 7aef19da9e6..cc6cc547f6c 100644 --- a/compiler/testData/codegen/regressions/kt533.kt +++ b/compiler/testData/codegen/regressions/kt533.kt @@ -95,11 +95,11 @@ fun LinkedList.sum(f : (Int, Int) -> Int) : Int { } fun List.backwards() : Iterable = object : Iterable { - public override fun iterator() : jet.Iterator = + override fun iterator() : jet.Iterator = object : jet.Iterator { var current = size() - public override fun next() : T = get(--current) - public override val hasNext : Boolean get() = current > 0 + override fun next() : T = get(--current) + override val hasNext : Boolean get() = current > 0 } } diff --git a/compiler/testData/codegen/regressions/kt887.jet b/compiler/testData/codegen/regressions/kt887.jet index 28289154899..ee1c57ec1d3 100644 --- a/compiler/testData/codegen/regressions/kt887.jet +++ b/compiler/testData/codegen/regressions/kt887.jet @@ -1,5 +1,5 @@ class Book(val name: String) : Comparable { - public override fun compareTo(other: Book) = name.compareTo(other.name) + override fun compareTo(other: Book) = name.compareTo(other.name) } fun box() = if(Book("239").compareTo(Book("932")) != 0) "OK" else "fail" \ No newline at end of file diff --git a/compiler/testData/codegen/regressions/kt940.kt b/compiler/testData/codegen/regressions/kt940.kt index 702b6c05788..a81d971ffba 100644 --- a/compiler/testData/codegen/regressions/kt940.kt +++ b/compiler/testData/codegen/regressions/kt940.kt @@ -3,13 +3,13 @@ import java.util.* fun box() : String { val w = object : Comparator { - public override fun compare(o1 : String?, o2 : String?) : Int { + override fun compare(o1 : String?, o2 : String?) : Int { val l1 : Int = o1?.length ?: 0 val l2 = o2?.length ?: 0 return l1 - l2 } - public override fun equals(obj: Any?): Boolean = obj === this + override fun equals(obj: Any?): Boolean = obj === this } w.compare("aaa", "bbb") diff --git a/compiler/testData/codegen/super/basicmethodSuperClass.jet b/compiler/testData/codegen/super/basicmethodSuperClass.jet index 19d9ae7afcb..1b8a48bbfe9 100644 --- a/compiler/testData/codegen/super/basicmethodSuperClass.jet +++ b/compiler/testData/codegen/super/basicmethodSuperClass.jet @@ -1,7 +1,7 @@ import java.util.ArrayList class N() : ArrayList() { - public override fun add(el: Any) : Boolean { + override fun add(el: Any) : Boolean { if (!super.add(el)) { throw Exception() } diff --git a/compiler/testData/codegen/traits/simple.jet b/compiler/testData/codegen/traits/simple.jet index 537f03a6ef8..f8119547d2d 100644 --- a/compiler/testData/codegen/traits/simple.jet +++ b/compiler/testData/codegen/traits/simple.jet @@ -3,7 +3,7 @@ trait SimpleClass : java.lang.Object { } class SimpleClassImpl() : SimpleClass { - public override fun toString() = "SimpleClassImpl" + override fun toString() = "SimpleClassImpl" } fun box() : String { diff --git a/compiler/testData/codegen/traits/stdlib.jet b/compiler/testData/codegen/traits/stdlib.jet index b7b3e16b928..235263a95eb 100644 --- a/compiler/testData/codegen/traits/stdlib.jet +++ b/compiler/testData/codegen/traits/stdlib.jet @@ -3,7 +3,7 @@ trait ISized { } trait javaUtilIterator : java.util.Iterator { - public override fun remove() : Unit { + override fun remove() : Unit { throw UnsupportedOperationException() } } @@ -11,9 +11,9 @@ trait javaUtilIterator : java.util.Iterator { class MyIterator(val array : ReadOnlyArray) : javaUtilIterator { private var index = 0 - public override fun hasNext() : Boolean = index < array.size + override fun hasNext() : Boolean = index < array.size - public override fun next() : T = array.get(index++) + override fun next() : T = array.get(index++) } trait ReadOnlyArray : ISized, java.lang.Iterable { @@ -23,7 +23,7 @@ trait ReadOnlyArray : ISized, java.lang.Iterable { fun check(v: Any) = v is T } - public override fun iterator() : java.util.Iterator = MyIterator(this) + override fun iterator() : java.util.Iterator = MyIterator(this) } trait WriteOnlyArray : ISized { diff --git a/compiler/testData/diagnostics/tests/PrimaryConstructors.jet b/compiler/testData/diagnostics/tests/PrimaryConstructors.jet index cd2489ad285..250ee0d30df 100644 --- a/compiler/testData/diagnostics/tests/PrimaryConstructors.jet +++ b/compiler/testData/diagnostics/tests/PrimaryConstructors.jet @@ -1,4 +1,3 @@ - class X { val x : Int } @@ -18,12 +17,12 @@ class Z : Y() { class MyIterable : Iterable { - public override fun iterator(): Iterator = MyIterator() + override fun iterator(): Iterator = MyIterator() class MyIterator : Iterator { - public override val hasNext: Boolean = false - public override fun next(): T { + override val hasNext: Boolean = false + override fun next(): T { throw UnsupportedOperationException() } } diff --git a/compiler/testData/diagnostics/tests/extensions/GenericIterator.jet b/compiler/testData/diagnostics/tests/extensions/GenericIterator.jet index 7ffb9cf9567..e8bbda72080 100644 --- a/compiler/testData/diagnostics/tests/extensions/GenericIterator.jet +++ b/compiler/testData/diagnostics/tests/extensions/GenericIterator.jet @@ -1,10 +1,10 @@ import java.util.Enumeration inline fun java.util.Enumeration.iterator() = object: Iterator { - public override val hasNext: Boolean + override val hasNext: Boolean get() = hasMoreElements() - public override fun next() = nextElement() + override fun next() = nextElement() } fun T?.iterator() = object { diff --git a/compiler/testData/diagnostics/tests/regressions/kt588.jet b/compiler/testData/diagnostics/tests/regressions/kt588.jet index e98a4c3d989..fee5c198ebc 100644 --- a/compiler/testData/diagnostics/tests/regressions/kt588.jet +++ b/compiler/testData/diagnostics/tests/regressions/kt588.jet @@ -6,7 +6,7 @@ class Test() : Thread("Test") { } } - public override fun run() { + override fun run() { init2() // unresolved Test.init2() // ok } diff --git a/libraries/kunit/src/main/kotlin/junit/JUnit.kt b/libraries/kunit/src/main/kotlin/junit/JUnit.kt index 5af3d342a4c..ebd721e5447 100644 --- a/libraries/kunit/src/main/kotlin/junit/JUnit.kt +++ b/libraries/kunit/src/main/kotlin/junit/JUnit.kt @@ -4,23 +4,23 @@ import kotlin.test.Asserter import org.junit.Assert class JUnitAsserter : Asserter { - public override fun assertEquals(message : String, expected : Any?, actual : Any?) { + override fun assertEquals(message : String, expected : Any?, actual : Any?) { Assert.assertEquals(message, expected, actual) } - public override fun assertNotNull(message : String, actual : Any?) { + override fun assertNotNull(message : String, actual : Any?) { Assert.assertNotNull(message, actual) } - public override fun assertNull(message : String, actual : Any?) { + override fun assertNull(message : String, actual : Any?) { Assert.assertNull(message, actual) } - public override fun assertTrue(message : String, actual : Boolean) { + override fun assertTrue(message : String, actual : Boolean) { Assert.assertTrue(message, actual) } - public override fun fail(message : String) { + override fun fail(message : String) { Assert.fail(message) } } \ No newline at end of file diff --git a/libraries/stdlib/src/kotlin/Standard.kt b/libraries/stdlib/src/kotlin/Standard.kt index 5ee821b7dc5..30ae28c12e0 100644 --- a/libraries/stdlib/src/kotlin/Standard.kt +++ b/libraries/stdlib/src/kotlin/Standard.kt @@ -25,7 +25,7 @@ public inline fun java.util.Iterator.iterator() : java.util.Iterator = Helper to make java.util.Enumeration usable in for */ public fun java.util.Enumeration.iterator(): Iterator = object: Iterator { - public override val hasNext: Boolean + override val hasNext: Boolean get() = hasMoreElements() public override fun next() : T = nextElement().sure() @@ -114,4 +114,4 @@ public inline fun Throwable.printStackTrace(writer: PrintWriter): Unit { public inline fun Throwable.printStackTrace(stream: PrintStream): Unit { val jlt = this as java.lang.Throwable jlt.printStackTrace(stream) -} \ No newline at end of file +} diff --git a/libraries/stdlib/src/kotlin/concurrent/FunctionalList.kt b/libraries/stdlib/src/kotlin/concurrent/FunctionalList.kt index 0634ef3369b..d9472a20d7e 100644 --- a/libraries/stdlib/src/kotlin/concurrent/FunctionalList.kt +++ b/libraries/stdlib/src/kotlin/concurrent/FunctionalList.kt @@ -35,15 +35,15 @@ abstract class FunctionalList(public val size: Int) { return head } - public override val hasNext: Boolean + override val hasNext: Boolean get() = !cur.empty } class object { class Empty() : FunctionalList(0) { - public override val head: T + override val head: T get() = throw java.util.NoSuchElementException() - public override val tail: FunctionalList + override val tail: FunctionalList get() = throw java.util.NoSuchElementException() } diff --git a/libraries/stdlib/src/kotlin/dom/Dom.kt b/libraries/stdlib/src/kotlin/dom/Dom.kt index 19a13fd8776..37d81f17283 100644 --- a/libraries/stdlib/src/kotlin/dom/Dom.kt +++ b/libraries/stdlib/src/kotlin/dom/Dom.kt @@ -201,7 +201,7 @@ fun Node.nextSiblings() : Iterator = NextSiblingIterator(this) class NextSiblingIterator(var node: Node) : AbstractIterator() { - protected override fun computeNext(): Unit { + override fun computeNext(): Unit { val next = node.getNextSibling() if (next != null) { setNext(next) @@ -215,7 +215,7 @@ fun Node.previousSiblings() : Iterator = PreviousSiblingIterator(this) class PreviousSiblingIterator(var node: Node) : AbstractIterator() { - protected override fun computeNext(): Unit { + override fun computeNext(): Unit { val next = node.getPreviousSibling() if (next != null) { setNext(next) @@ -323,7 +323,7 @@ fun NodeList?.toXmlString(xmlDeclaration: Boolean = false): String { } class NodeListAsList(val nodeList: NodeList): AbstractList() { - public override fun get(index: Int): Node { + override fun get(index: Int): Node { val node = nodeList.item(index) if (node == null) { throw IndexOutOfBoundsException("NodeList does not contain a node at index: " + index) @@ -332,11 +332,11 @@ class NodeListAsList(val nodeList: NodeList): AbstractList() { } } - public override fun size(): Int = nodeList.getLength() + override fun size(): Int = nodeList.getLength() } class ElementListAsList(val nodeList: NodeList): AbstractList() { - public override fun get(index: Int): Element { + override fun get(index: Int): Element { val node = nodeList.item(index) if (node is Element) { return node @@ -349,7 +349,7 @@ class ElementListAsList(val nodeList: NodeList): AbstractList() { } } - public override fun size(): Int = nodeList.getLength() + override fun size(): Int = nodeList.getLength() } diff --git a/libraries/stdlib/src/kotlin/io/JIO.kt b/libraries/stdlib/src/kotlin/io/JIO.kt index 841f65d6ff7..6f5334cd723 100644 --- a/libraries/stdlib/src/kotlin/io/JIO.kt +++ b/libraries/stdlib/src/kotlin/io/JIO.kt @@ -172,7 +172,7 @@ public inline fun T.use(block: (T)-> R) : R { /** Returns an [Iterator] of bytes over an input stream */ public fun InputStream.iterator() : ByteIterator = object: ByteIterator() { - public override val hasNext : Boolean + override val hasNext : Boolean get() = available() > 0 public override fun nextByte() : Byte = read().toByte() @@ -238,7 +238,7 @@ class LineIterator(val reader: BufferedReader) : Iterator { private var nextValue: String? = null private var done = false - public override val hasNext: Boolean + override val hasNext: Boolean get() { if (nextValue == null && !done) { nextValue = reader.readLine() diff --git a/libraries/stdlib/src/kotlin/support/AbstractIterator.kt b/libraries/stdlib/src/kotlin/support/AbstractIterator.kt index cddaaa2f083..1c67ec0ad74 100644 --- a/libraries/stdlib/src/kotlin/support/AbstractIterator.kt +++ b/libraries/stdlib/src/kotlin/support/AbstractIterator.kt @@ -17,7 +17,7 @@ public abstract class AbstractIterator: java.util.Iterator { private var state: State = State.NotReady private var next: T? = null - public override fun hasNext(): Boolean { + override fun hasNext(): Boolean { require(state != State.Failed) return when (state) { State.Done -> false @@ -26,13 +26,13 @@ public abstract class AbstractIterator: java.util.Iterator { } } - public override fun next(): T { + override fun next(): T { if (!hasNext()) throw NoSuchElementException() state = State.NotReady return next.sure() } - public override fun remove() { + override fun remove() { throw UnsupportedOperationException() } diff --git a/libraries/stdlib/test/CollectionTest.kt b/libraries/stdlib/test/CollectionTest.kt index 01eb8d11c62..b3b86928ca7 100644 --- a/libraries/stdlib/test/CollectionTest.kt +++ b/libraries/stdlib/test/CollectionTest.kt @@ -389,7 +389,7 @@ class CollectionTest { class IterableWrapper(collection : java.lang.Iterable) : java.lang.Iterable { private val collection = collection - public override fun iterator(): java.util.Iterator { + override fun iterator(): java.util.Iterator { return collection.iterator().sure() } } diff --git a/libraries/stdlib/test/CompareTest.kt b/libraries/stdlib/test/CompareTest.kt index c0826f4aca2..81235609264 100644 --- a/libraries/stdlib/test/CompareTest.kt +++ b/libraries/stdlib/test/CompareTest.kt @@ -43,10 +43,10 @@ class CompareTest { Test fun sortUsingCustomComparator() { val c = object : Comparator{ - public override fun compare(o1: Item?, o2: Item?): Int { + override fun compare(o1: Item?, o2: Item?): Int { return compareBy(o1, o2, {(it: Item) -> it.name}, {(it: Item) -> it.rating}) } - public override fun equals(obj: Any?): Boolean { + override fun equals(obj: Any?): Boolean { return this == obj } } diff --git a/libraries/stdlib/test/Test.kt b/libraries/stdlib/test/Test.kt index 42cb6b755af..cb74e35f5d9 100644 --- a/libraries/stdlib/test/Test.kt +++ b/libraries/stdlib/test/Test.kt @@ -17,13 +17,13 @@ class TestBuilt(name: String, val builder: TestBuilder, val test: TestBuil get() = myState.sure() set(newState: T) { myState = newState } - public override fun countTestCases(): Int = 1 + override fun countTestCases(): Int = 1 - protected override fun setUp() = this.(builder.setUp)() + override fun setUp() = this.(builder.setUp)() - protected override fun tearDown() = this.(builder.tearDown)() + override fun tearDown() = this.(builder.tearDown)() - protected override fun runTest() = this.(test)() + override fun runTest() = this.(test)() } open class TestBuilder(name: String) { diff --git a/libraries/stdlib/test/concurrent/SerialFunAndTupleTest.kt b/libraries/stdlib/test/concurrent/SerialFunAndTupleTest.kt index c279f3564e3..498aa1095e4 100644 --- a/libraries/stdlib/test/concurrent/SerialFunAndTupleTest.kt +++ b/libraries/stdlib/test/concurrent/SerialFunAndTupleTest.kt @@ -10,7 +10,7 @@ import junit.framework.TestCase import junit.framework.Assert class Serial(val a : String) : java.lang.Object(), Serializable { - public override fun toString() = a + override fun toString() = a } class SerialTest() : TestCase() { diff --git a/libraries/stdlib/test/properties/PropertiesTest.kt b/libraries/stdlib/test/properties/PropertiesTest.kt index 9d3d197e79a..b31dab87288 100644 --- a/libraries/stdlib/test/properties/PropertiesTest.kt +++ b/libraries/stdlib/test/properties/PropertiesTest.kt @@ -28,7 +28,7 @@ class Customer() : ChangeSupport() { class MyChangeListener() : ChangeListener { val events = ArrayList() - public override fun onPropertyChange(event: ChangeEvent): Unit { + override fun onPropertyChange(event: ChangeEvent): Unit { println("Property changed: $event") events.add(event) } From 1ed79d534f5b0d0f5cce42bb9972ca7d9fc9deb6 Mon Sep 17 00:00:00 2001 From: Svetlana Isakova Date: Wed, 18 Apr 2012 19:01:26 +0400 Subject: [PATCH 03/10] KT-151 Inherit visibility when overriding #KT-151 Fixed Visibilities.INHERITED constant added (occurs only during resolve), changed after overridden descriptors resolve Fake descriptors are created for invisible properties as well (is necessary for better error reporting) --- .../resolve/java/JavaDescriptorResolver.java | 4 +- .../descriptors/FunctionDescriptorImpl.java | 4 + .../PropertyAccessorDescriptor.java | 6 +- .../lang/descriptors/PropertyDescriptor.java | 4 + .../jet/lang/descriptors/Visibilities.java | 15 +- .../jet/lang/diagnostics/Errors.java | 5 +- .../jet/lang/resolve/DeclarationResolver.java | 2 +- .../jet/lang/resolve/DescriptorResolver.java | 3 +- .../jet/lang/resolve/OverrideResolver.java | 221 +++++++++++------- .../lang/resolve/TopDownAnalysisContext.java | 15 +- ...fier.jet => VisibilityInheritModifier.jet} | 12 +- .../diagnostics/tests/scopes/kt151.jet | 40 ++++ .../modifiers/beforeVisibilityModifer2.kt | 2 +- .../beforeVisibilityModiferParameter.kt | 2 +- 14 files changed, 236 insertions(+), 99 deletions(-) rename compiler/testData/diagnostics/tests/scopes/{visibility_inherit_modifier.jet => VisibilityInheritModifier.jet} (78%) create mode 100644 compiler/testData/diagnostics/tests/scopes/kt151.jet diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaDescriptorResolver.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaDescriptorResolver.java index e53c9031ffb..b225cf81b40 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaDescriptorResolver.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaDescriptorResolver.java @@ -1394,7 +1394,7 @@ public class JavaDescriptorResolver { if (owner instanceof ClassDescriptor) { ClassDescriptor classDescriptor = (ClassDescriptor) owner; - OverrideResolver.generateOverridesInFunctionGroup(propertyName, propertiesFromSupertypes, propertiesFromCurrent, classDescriptor, new OverrideResolver.DescriptorSink() { + OverrideResolver.generateOverridesInFunctionGroup(propertyName, null, propertiesFromSupertypes, propertiesFromCurrent, classDescriptor, new OverrideResolver.DescriptorSink() { @Override public void addToScope(@NotNull CallableMemberDescriptor fakeOverride) { properties.add((PropertyDescriptor) fakeOverride); @@ -1433,7 +1433,7 @@ public class JavaDescriptorResolver { Set functionsFromSupertypes = getFunctionsFromSupertypes(scopeData, methodName); - OverrideResolver.generateOverridesInFunctionGroup(methodName, functionsFromSupertypes, functionsFromCurrent, classDescriptor, new OverrideResolver.DescriptorSink() { + OverrideResolver.generateOverridesInFunctionGroup(methodName, null, functionsFromSupertypes, functionsFromCurrent, classDescriptor, new OverrideResolver.DescriptorSink() { @Override public void addToScope(@NotNull CallableMemberDescriptor fakeOverride) { functions.add((FunctionDescriptor) fakeOverride); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/FunctionDescriptorImpl.java b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/FunctionDescriptorImpl.java index 18123e6947e..96c7cae015e 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/FunctionDescriptorImpl.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/FunctionDescriptorImpl.java @@ -106,6 +106,10 @@ public abstract class FunctionDescriptorImpl extends DeclarationDescriptorImpl i return this; } + public void setVisibility(@NotNull Visibility visibility) { + this.visibility = visibility; + } + public void setReturnType(@NotNull JetType unsubstitutedReturnType) { this.unsubstitutedReturnType = unsubstitutedReturnType; } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/PropertyAccessorDescriptor.java b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/PropertyAccessorDescriptor.java index d05a34969c1..8924fc839d9 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/PropertyAccessorDescriptor.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/PropertyAccessorDescriptor.java @@ -34,9 +34,9 @@ public abstract class PropertyAccessorDescriptor extends DeclarationDescriptorIm private final boolean hasBody; private final boolean isDefault; private final Modality modality; - private final Visibility visibility; private final PropertyDescriptor correspondingProperty; private final Kind kind; + private Visibility visibility; public PropertyAccessorDescriptor( @NotNull Modality modality, @@ -99,6 +99,10 @@ public abstract class PropertyAccessorDescriptor extends DeclarationDescriptorIm return visibility; } + public void setVisibility(Visibility visibility) { + this.visibility = visibility; + } + @NotNull public PropertyDescriptor getCorrespondingProperty() { return correspondingProperty; diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/PropertyDescriptor.java b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/PropertyDescriptor.java index c614cca9161..a7edd5d4ea5 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/PropertyDescriptor.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/PropertyDescriptor.java @@ -131,6 +131,10 @@ public class PropertyDescriptor extends VariableDescriptorImpl implements Callab this.setter = setter; } + public void setVisibility(@NotNull Visibility visibility) { + this.visibility = visibility; + } + @NotNull @Override public List getTypeParameters() { diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/Visibilities.java b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/Visibilities.java index 8651ec3b4f3..5fce7230afd 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/Visibilities.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/Visibilities.java @@ -32,6 +32,9 @@ public class Visibilities { public static final Visibility PRIVATE = new Visibility("private", false) { @Override protected boolean isVisible(@NotNull DeclarationDescriptorWithVisibility what, @NotNull DeclarationDescriptor from) { + if (what instanceof CallableMemberDescriptor && ((CallableMemberDescriptor)what).getKind() == CallableMemberDescriptor.Kind.FAKE_OVERRIDE) { + return false; + } DeclarationDescriptor parent = what; while (parent != null) { parent = parent.getContainingDeclaration(); @@ -93,7 +96,14 @@ public class Visibilities { public static final Visibility LOCAL = new Visibility("local", false) { @Override protected boolean isVisible(@NotNull DeclarationDescriptorWithVisibility what, @NotNull DeclarationDescriptor from) { - return true; + throw new IllegalStateException(); //This method shouldn't be invoked for LOCAL visibility + } + }; + + public static final Visibility INHERITED = new Visibility("inherited", false) { + @Override + protected boolean isVisible(@NotNull DeclarationDescriptorWithVisibility what, @NotNull DeclarationDescriptor from) { + throw new IllegalStateException("Visibility is unknown yet"); //This method shouldn't be invoked for INHERITED visibility } }; @@ -102,6 +112,9 @@ public class Visibilities { public static boolean isVisible(DeclarationDescriptorWithVisibility what, DeclarationDescriptor from) { DeclarationDescriptorWithVisibility parent = what; while (parent != null) { + if (parent.getVisibility() == LOCAL) { + return true; + } if (!parent.getVisibility().isVisible(parent, from)) { return false; } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/Errors.java b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/Errors.java index e6ba102a7eb..42028fc4d2c 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/Errors.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/Errors.java @@ -157,7 +157,10 @@ public interface Errors { DiagnosticFactory INITIALIZER_WITH_NO_ARGUMENTS = DiagnosticFactory.create(ERROR, "Constructor arguments required"); DiagnosticFactory MANY_CALLS_TO_THIS = DiagnosticFactory.create(ERROR, "Only one call to 'this(...)' is allowed"); DiagnosticFactory1 NOTHING_TO_OVERRIDE = DiagnosticFactory1.create(ERROR, "{0} overrides nothing", PositioningStrategies.positionModifier(JetTokens.OVERRIDE_KEYWORD), DescriptorRenderer.TEXT); - DiagnosticFactory3 VIRTUAL_MEMBER_HIDDEN = DiagnosticFactory3.create(ERROR, "''{0}'' hides ''{1}'' in class {2} and needs 'override' modifier", PositioningStrategies.POSITION_NAME_IDENTIFIER, DescriptorRenderer.TEXT, DescriptorRenderer.TEXT, DescriptorRenderer.TEXT); + DiagnosticFactory3 VIRTUAL_MEMBER_HIDDEN = + DiagnosticFactory3.create(ERROR, "''{0}'' hides ''{1}'' in class {2} and needs 'override' modifier", PositioningStrategies.POSITION_NAME_IDENTIFIER, DescriptorRenderer.TEXT, DescriptorRenderer.TEXT, DescriptorRenderer.TEXT); + DiagnosticFactory3 CANNOT_OVERRIDE_INVISIBLE_MEMBER = + DiagnosticFactory3.create(ERROR, "''{0}'' cannot has no access to ''{1}'' in class {2}, so it cannot override it", PositioningStrategies.positionModifier(JetTokens.OVERRIDE_KEYWORD), DescriptorRenderer.TEXT, DescriptorRenderer.TEXT, DescriptorRenderer.TEXT); DiagnosticFactory1 ENUM_ENTRY_SHOULD_BE_INITIALIZED = DiagnosticFactory1.create(ERROR, "Missing delegation specifier ''{0}''", PositioningStrategies.POSITION_NAME_IDENTIFIER, NAME); DiagnosticFactory1 ENUM_ENTRY_ILLEGAL_TYPE = DiagnosticFactory1.create(ERROR, "The type constructor of enum entry should be ''{0}''", NAME); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DeclarationResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DeclarationResolver.java index 96a8c8b0a6e..26ce64163e1 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DeclarationResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DeclarationResolver.java @@ -223,7 +223,7 @@ public class DeclarationResolver { parameter, trace ); classDescriptor.addPropertyDescriptor(propertyDescriptor); - context.getPrimaryConstructorParameterProperties().add(propertyDescriptor); + context.getPrimaryConstructorParameterProperties().put(parameter, propertyDescriptor); } } if (constructorDescriptor != null) { diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DescriptorResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DescriptorResolver.java index 50802066804..e40d2cdbcec 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DescriptorResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DescriptorResolver.java @@ -673,7 +673,8 @@ public class DescriptorResolver { @NotNull /*package*/ static Visibility resolveVisibilityFromModifiers(@Nullable JetModifierList modifierList) { - return resolveVisibilityFromModifiers(modifierList, Visibilities.INTERNAL); + Visibility defaultVisibility = modifierList != null && modifierList.hasModifier(JetTokens.OVERRIDE_KEYWORD) ? Visibilities.INHERITED : Visibilities.INTERNAL; + return resolveVisibilityFromModifiers(modifierList, defaultVisibility); } @NotNull diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/OverrideResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/OverrideResolver.java index 5cba0b13e25..e971843d3e1 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/OverrideResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/OverrideResolver.java @@ -16,14 +16,13 @@ package org.jetbrains.jet.lang.resolve; -import com.google.common.collect.Lists; -import com.google.common.collect.Multimap; -import com.google.common.collect.Sets; +import com.google.common.collect.*; import com.intellij.lang.ASTNode; import com.intellij.psi.PsiElement; import com.intellij.util.containers.LinkedMultiMap; import com.intellij.util.containers.MultiMap; import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.lang.descriptors.*; import org.jetbrains.jet.lang.diagnostics.Errors; import org.jetbrains.jet.lang.psi.*; @@ -67,15 +66,26 @@ public class OverrideResolver { public void process() { - generateOverrides(); - checkOverrides(); - checkVisibilityForOverriddenMembers(); + //all created fake descriptors are stored to resolve visibility on them later + Set fakeOverrides = Sets.newHashSet(); + generateOverrides(fakeOverrides); + + //functions and properties visibility can be inherited when overriding, so for overridden members + //it can be resolved only after overrides resolve is finished + resolveUnknownVisibilityForMembers(fakeOverrides); + + //invisible overridden descriptors are saved for proper error reporting + Multimap invisibleOverriddenDescriptors = LinkedHashMultimap.create(); + removeInvisibleOverriddenDescriptors(invisibleOverriddenDescriptors); + + checkVisibility(); + checkOverrides(invisibleOverriddenDescriptors); } /** - * Generate fake overrides and add overriden descriptors to existing descriptors. + * Generate fake overrides and add overridden descriptors to existing descriptors. */ - private void generateOverrides() { + private void generateOverrides(@NotNull Set fakeOverrides) { Set ourClasses = new HashSet(); ourClasses.addAll(context.getClasses().values()); ourClasses.addAll(context.getObjects().values()); @@ -83,11 +93,12 @@ public class OverrideResolver { Set processed = new HashSet(); for (MutableClassDescriptor clazz : ourClasses) { - generateOverridesInAClass(clazz, processed, ourClasses); + generateOverridesInAClass(clazz, processed, ourClasses, fakeOverrides); } } - private void generateOverridesInAClass(final MutableClassDescriptor classDescriptor, Set processed, Set ourClasses) { + private void generateOverridesInAClass(@NotNull final MutableClassDescriptor classDescriptor, @NotNull Set processed, + @NotNull Set ourClasses, @NotNull Set fakeOverrides) { if (!processed.add(classDescriptor)) { return; } @@ -100,7 +111,7 @@ public class OverrideResolver { for (JetType supertype : classDescriptor.getTypeConstructor().getSupertypes()) { ClassDescriptor superclass = (ClassDescriptor) supertype.getConstructor().getDeclarationDescriptor(); if (superclass instanceof MutableClassDescriptor) { - generateOverridesInAClass((MutableClassDescriptor) superclass, processed, ourClasses); + generateOverridesInAClass((MutableClassDescriptor) superclass, processed, ourClasses, fakeOverrides); } } @@ -115,7 +126,7 @@ public class OverrideResolver { functionNames.addAll(functionsFromCurrentByName.keySet()); for (String functionName : functionNames) { - generateOverridesInFunctionGroup(functionName, + generateOverridesInFunctionGroup(functionName, fakeOverrides, functionsFromSupertypesByName.get(functionName), functionsFromCurrentByName.get(functionName), classDescriptor, @@ -150,18 +161,15 @@ public class OverrideResolver { public static void generateOverridesInFunctionGroup( @NotNull String name, + @Nullable Set fakeOverrides, @NotNull Collection functionsFromSupertypes, @NotNull Collection functionsFromCurrent, @NotNull ClassDescriptor current, @NotNull DescriptorSink sink) { - List fakeOverrides = Lists.newArrayList(); + List fakeOverrideList = Lists.newArrayList(); for (CallableMemberDescriptor functionFromSupertype : functionsFromSupertypes) { - if (!Visibilities.isVisible(functionFromSupertype, current)) { - continue; - } - boolean overrides = false; for (CallableMemberDescriptor functionFromCurrent : functionsFromCurrent) { @@ -175,7 +183,7 @@ public class OverrideResolver { } } - for (CallableMemberDescriptor fakeOverride : fakeOverrides) { + for (CallableMemberDescriptor fakeOverride : fakeOverrideList) { if (OverridingUtil.isOverridableBy(functionFromSupertype, fakeOverride).getResult() == OverridingUtil.OverrideCompatibilityInfo.Result.OVERRIDABLE) { fakeOverride.addOverriddenDescriptor(functionFromSupertype); overrides = true; @@ -185,9 +193,10 @@ public class OverrideResolver { if (!overrides) { CallableMemberDescriptor fakeOverride = functionFromSupertype.copy(current, false, CallableMemberDescriptor.Kind.FAKE_OVERRIDE, false); fakeOverride.addOverriddenDescriptor(functionFromSupertype); - - fakeOverrides.add(fakeOverride); - + fakeOverrideList.add(fakeOverride); + if (fakeOverrides != null) { + fakeOverrides.add(fakeOverride); + } sink.addToScope(fakeOverride); } } @@ -222,21 +231,22 @@ public class OverrideResolver { return r; } - private void checkOverrides() { + private void checkOverrides(@NotNull Multimap invisibleOverriddenDescriptors) { for (Map.Entry entry : context.getClasses().entrySet()) { - checkOverridesInAClass(entry.getValue(), entry.getKey()); + checkOverridesInAClass(entry.getValue(), entry.getKey(), invisibleOverriddenDescriptors); } for (Map.Entry entry : context.getObjects().entrySet()) { - checkOverridesInAClass(entry.getValue(), entry.getKey()); + checkOverridesInAClass(entry.getValue(), entry.getKey(), invisibleOverriddenDescriptors); } } - protected void checkOverridesInAClass(MutableClassDescriptor classDescriptor, JetClassOrObject klass) { + protected void checkOverridesInAClass(@NotNull MutableClassDescriptor classDescriptor, @NotNull JetClassOrObject klass, + @NotNull Multimap invisibleOverriddenDescriptors) { if (topDownAnalysisParameters.isAnalyzingBootstrapLibrary()) return; // Check overrides for internal consistency for (CallableMemberDescriptor member : classDescriptor.getCallableMembers()) { - checkOverride(member); + checkOverrideForMember(member, invisibleOverriddenDescriptors); } // Check if everything that must be overridden, actually is @@ -271,34 +281,6 @@ public class OverrideResolver { trace.report(ABSTRACT_MEMBER_NOT_IMPLEMENTED.on(nameIdentifier, klass, memberDescriptor)); break; } - -// Set allOverriddenFunctions = Sets.newHashSet(); -// Collection allDescriptors = classDescriptor.getDefaultType().getMemberScope().getAllDescriptors(); -// for (DeclarationDescriptor descriptor : allDescriptors) { -// if (descriptor instanceof FunctionDescriptor) { -// FunctionDescriptor functionDescriptor = (FunctionDescriptor) descriptor; -// if (functionDescriptor.getModality() != Modality.ABSTRACT) { -// for (FunctionDescriptor overriddenDescriptor : functionDescriptor.getOverriddenDescriptors()) { -// allOverriddenFunctions.add(overriddenDescriptor.getOriginal()); -// } -// } -// } -// } -// boolean foundError = false; -// for (DeclarationDescriptor descriptor : allDescriptors) { -// if (descriptor instanceof FunctionDescriptor) { -// FunctionDescriptor functionDescriptor = (FunctionDescriptor) descriptor; -// if (functionDescriptor.getModality() == Modality.ABSTRACT && !allOverriddenFunctions.contains(functionDescriptor.getOriginal()) && !foundError && nameIdentifier != null) { -// DeclarationDescriptor declarationDescriptor = functionDescriptor.getContainingDeclaration(); -// if (declarationDescriptor != classDescriptor) { -//// trace.getErrorHandler().genericError(nameIdentifier.getNode(), "Class '" + klass.getName() + "' must be declared abstract or implement abstract method '" + -//// functionDescriptor.getName() + "' declared in " + declarationDescriptor.getName()); -// trace.report(ABSTRACT_MEMBER_NOT_IMPLEMENTED.on(nameIdentifier, klass, functionDescriptor)); -// foundError = true; -// } -// } -// } -// } } public static void collectMissingImplementations(MutableClassDescriptor classDescriptor, Set abstractNoImpl, Set manyImpl) { @@ -317,21 +299,21 @@ public class OverrideResolver { } } else { - Collection overridenDeclarations = OverridingUtil.getOverridenDeclarations(descriptor); - if (overridenDeclarations.size() == 0) { + Collection overriddenDeclarations = OverridingUtil.getOverridenDeclarations(descriptor); + if (overriddenDeclarations.size() == 0) { throw new IllegalStateException(); } - else if (overridenDeclarations.size() == 1) { - CallableMemberDescriptor single = overridenDeclarations.iterator().next(); + else if (overriddenDeclarations.size() == 1) { + CallableMemberDescriptor single = overriddenDeclarations.iterator().next(); if (single.getModality() == Modality.ABSTRACT) { abstractNoImpl.add(single); } } else { List nonAbstractManyImpl = Lists.newArrayList(); - for (CallableMemberDescriptor overriden : overridenDeclarations) { - if (overriden.getModality() != Modality.ABSTRACT) { - nonAbstractManyImpl.add(overriden); + for (CallableMemberDescriptor overridden : overriddenDeclarations) { + if (overridden.getModality() != Modality.ABSTRACT) { + nonAbstractManyImpl.add(overridden); } } if (nonAbstractManyImpl.size() > 1) { @@ -371,7 +353,8 @@ public class OverrideResolver { return factoredMembers; } - private void checkOverride(CallableMemberDescriptor declared) { + private void checkOverrideForMember(@NotNull CallableMemberDescriptor declared, + @NotNull Multimap invisibleOverriddenDescriptors) { JetNamedDeclaration member = (JetNamedDeclaration) BindingContextUtils.descriptorToDeclaration(trace.getBindingContext(), declared); if (member == null) { assert trace.get(DELEGATED, declared); @@ -410,7 +393,13 @@ public class OverrideResolver { } } if (hasOverrideModifier && declared.getOverriddenDescriptors().size() == 0) { - trace.report(NOTHING_TO_OVERRIDE.on(member, declared)); + if (!invisibleOverriddenDescriptors.get(declared).isEmpty()) { + CallableDescriptor descriptor = invisibleOverriddenDescriptors.values().iterator().next(); + trace.report(CANNOT_OVERRIDE_INVISIBLE_MEMBER.on(member, declared, descriptor, descriptor.getContainingDeclaration())); + } + else { + trace.report(NOTHING_TO_OVERRIDE.on(member, declared)); + } } PsiElement nameIdentifier = member.getNameIdentifier(); if (!hasOverrideModifier && declared.getOverriddenDescriptors().size() > 0 && nameIdentifier != null) { @@ -427,38 +416,102 @@ public class OverrideResolver { return false; } - private void checkVisibilityForOverriddenMembers() { - for (Map.Entry entry : context.getFunctions().entrySet()) { - JetNamedFunction function = entry.getKey(); - SimpleFunctionDescriptor functionDescriptor = entry.getValue(); - - checkVisibilityForMember(functionDescriptor.getVisibility(), function, functionDescriptor.getOverriddenDescriptors()); + private void resolveUnknownVisibilityForMembers(@NotNull Set fakeOverrides) { + for (CallableMemberDescriptor override : fakeOverrides) { + resolveUnknownVisibilityForMember(override); } - for (Map.Entry entry : context.getProperties().entrySet()) { - JetProperty property = entry.getKey(); - PropertyDescriptor propertyDescriptor = entry.getValue(); - - checkVisibilityForMember(propertyDescriptor.getVisibility(), property, propertyDescriptor.getOverriddenDescriptors()); + for (CallableMemberDescriptor memberDescriptor : context.getMembers().values()) { + resolveUnknownVisibilityForMember(memberDescriptor); } - for (PropertyDescriptor propertyDescriptor : context.getPrimaryConstructorParameterProperties()) { - PsiElement parameter = BindingContextUtils.descriptorToDeclaration(trace.getBindingContext(), propertyDescriptor); - if (parameter instanceof JetParameter) { - checkVisibilityForMember(propertyDescriptor.getVisibility(), (JetParameter)parameter, propertyDescriptor.getOverriddenDescriptors()); + for (PropertyDescriptor propertyDescriptor : context.getProperties().values()) { + for (PropertyAccessorDescriptor accessor : propertyDescriptor.getAccessors()) { + if (accessor != null && accessor.getVisibility() == Visibilities.INHERITED) { + accessor.setVisibility(propertyDescriptor.getVisibility()); + } } } } - private void checkVisibilityForMember(@NotNull Visibility visibility, - @NotNull JetModifierListOwner modifierListOwner, - @NotNull Collection descriptors) { + private void resolveUnknownVisibilityForMember(@NotNull CallableMemberDescriptor memberDescriptor) { + resolveUnknownVisibilityForOverriddenDescriptors(memberDescriptor.getOverriddenDescriptors()); + if (memberDescriptor.getVisibility() != Visibilities.INHERITED) { + return; + } + + Visibility visibility = findMaxVisibility(memberDescriptor.getOverriddenDescriptors()); + + if (memberDescriptor instanceof PropertyDescriptor) { + ((PropertyDescriptor)memberDescriptor).setVisibility(visibility); + } + else { + assert memberDescriptor instanceof FunctionDescriptorImpl; + ((FunctionDescriptorImpl)memberDescriptor).setVisibility(visibility); + } + } + + private void removeInvisibleOverriddenDescriptors(@NotNull Multimap invisibleOverriddenDescriptors) { + for (CallableMemberDescriptor memberDescriptor : context.getMembers().values()) { + Set overriddenDescriptors = memberDescriptor.getOverriddenDescriptors(); + for (Iterator iterator = overriddenDescriptors.iterator(); iterator.hasNext(); ) { + CallableDescriptor superDescriptor = iterator.next(); + if (!Visibilities.isVisible(superDescriptor, memberDescriptor)) { + invisibleOverriddenDescriptors.put(memberDescriptor, superDescriptor); + iterator.remove(); + } + } + } + } + + private void resolveUnknownVisibilityForOverriddenDescriptors(@NotNull Collection descriptors) { for (CallableMemberDescriptor descriptor : descriptors) { + if (descriptor.getVisibility() == Visibilities.INHERITED) { + resolveUnknownVisibilityForMember(descriptor); + } + } + } + + @NotNull + private Visibility findMaxVisibility(@NotNull Collection descriptors) { + if (descriptors.isEmpty()) { + return Visibilities.INTERNAL; + } + Visibility maxVisibility = null; + for (CallableMemberDescriptor descriptor : descriptors) { + Visibility visibility = descriptor.getVisibility(); + assert visibility != Visibilities.INHERITED; + if (maxVisibility == null) { + maxVisibility = visibility; + continue; + } + Integer compare = Visibilities.compare(visibility, maxVisibility); + if (compare == null) { + maxVisibility = Visibilities.PUBLIC; //todo error or warning when inference only from incomparable visibilities + continue; + } + if (compare > 0) { + maxVisibility = visibility; + } + } + assert maxVisibility != null; + return maxVisibility; + } + + private void checkVisibility() { + for (Map.Entry entry : context.getMembers().entrySet()) { + checkVisibilityForMember(entry.getKey(), entry.getValue()); + } + } + + private void checkVisibilityForMember(@NotNull JetDeclaration declaration, @NotNull CallableMemberDescriptor memberDescriptor) { + Visibility visibility = memberDescriptor.getVisibility(); + for (CallableMemberDescriptor descriptor : memberDescriptor.getOverriddenDescriptors()) { Integer compare = Visibilities.compare(visibility, descriptor.getVisibility()); if (compare == null) { - trace.report(CANNOT_CHANGE_ACCESS_PRIVILEGE.on(modifierListOwner, descriptor.getVisibility(), descriptor, descriptor.getContainingDeclaration())); + trace.report(CANNOT_CHANGE_ACCESS_PRIVILEGE.on(declaration, descriptor.getVisibility(), descriptor, descriptor.getContainingDeclaration())); return; } - if (compare < 0) { - trace.report(CANNOT_WEAKEN_ACCESS_PRIVILEGE.on(modifierListOwner, descriptor.getVisibility(), descriptor, descriptor.getContainingDeclaration())); + else if (compare < 0) { + trace.report(CANNOT_WEAKEN_ACCESS_PRIVILEGE.on(declaration, descriptor.getVisibility(), descriptor, descriptor.getContainingDeclaration())); return; } } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalysisContext.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalysisContext.java index ba63fb3ed5f..6f7c088fae8 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalysisContext.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalysisContext.java @@ -16,6 +16,7 @@ package org.jetbrains.jet.lang.resolve; +import com.google.common.collect.LinkedHashMultimap; import com.google.common.collect.Maps; import com.google.common.collect.Sets; import com.intellij.psi.PsiElement; @@ -46,7 +47,8 @@ public class TopDownAnalysisContext { private final Map functions = Maps.newLinkedHashMap(); private final Map constructors = Maps.newLinkedHashMap(); private final Map properties = Maps.newLinkedHashMap(); - private final Set primaryConstructorParameterProperties = Sets.newHashSet(); + private final Map primaryConstructorParameterProperties = Maps.newHashMap(); + private Map members = null; private StringBuilder debugOutput; @@ -114,7 +116,7 @@ public class TopDownAnalysisContext { return namespaceDescriptors; } - public Set getPrimaryConstructorParameterProperties() { + public Map getPrimaryConstructorParameterProperties() { return primaryConstructorParameterProperties; } @@ -134,4 +136,13 @@ public class TopDownAnalysisContext { return functions; } + public Map getMembers() { + if (members == null) { + members = Maps.newHashMap(); + members.putAll(functions); + members.putAll(properties); + members.putAll(primaryConstructorParameterProperties); + } + return members; + } } diff --git a/compiler/testData/diagnostics/tests/scopes/visibility_inherit_modifier.jet b/compiler/testData/diagnostics/tests/scopes/VisibilityInheritModifier.jet similarity index 78% rename from compiler/testData/diagnostics/tests/scopes/visibility_inherit_modifier.jet rename to compiler/testData/diagnostics/tests/scopes/VisibilityInheritModifier.jet index 345369ca996..db64398e7c0 100644 --- a/compiler/testData/diagnostics/tests/scopes/visibility_inherit_modifier.jet +++ b/compiler/testData/diagnostics/tests/scopes/VisibilityInheritModifier.jet @@ -18,7 +18,7 @@ open class D { } class E : D() { - internal override fun self() = this + internal override fun self() = this fun test() { val s : E = self() @@ -31,7 +31,11 @@ open class F { } class G : F() { - override fun protected_fun() {} + override fun protected_fun() {} +} + +fun test_fun_stays_protected(g: G) { + g.protected_fun() } //------------ @@ -57,11 +61,11 @@ trait T { } open class L : T { - override fun foo() {} + override fun foo() {} } class M : L() { - internal override fun foo() {} + internal override fun foo() {} } //--------------- trait R { diff --git a/compiler/testData/diagnostics/tests/scopes/kt151.jet b/compiler/testData/diagnostics/tests/scopes/kt151.jet new file mode 100644 index 00000000000..6387a2b3810 --- /dev/null +++ b/compiler/testData/diagnostics/tests/scopes/kt151.jet @@ -0,0 +1,40 @@ +//KT-151 Inherit visibility when overriding +package kt151 + +open class A { + protected open fun x() {} +} + +class B : A() { + override fun x() {} // No visibility modifier required +} + +fun test(b: B) { + b.x() +} + + +//more tests +open class C { + internal open fun foo() {} +} + +trait T { + protected fun foo() {} +} + +class D : C(), T { + protected override fun foo() {} +} + +class E : C(), T { + internal override fun foo() {} +} + +class F : C(), T { + private override fun foo() {} +} + +class G : C(), T { + override fun foo() {} +} \ No newline at end of file diff --git a/idea/testData/quickfix/modifiers/beforeVisibilityModifer2.kt b/idea/testData/quickfix/modifiers/beforeVisibilityModifer2.kt index ed204c0fa96..d88c204bde4 100644 --- a/idea/testData/quickfix/modifiers/beforeVisibilityModifer2.kt +++ b/idea/testData/quickfix/modifiers/beforeVisibilityModifer2.kt @@ -4,5 +4,5 @@ open class A { } class B : A() { - override fun run() {} + internal override fun run() {} } diff --git a/idea/testData/quickfix/modifiers/beforeVisibilityModiferParameter.kt b/idea/testData/quickfix/modifiers/beforeVisibilityModiferParameter.kt index d3c57fabf7f..cf8682a0135 100644 --- a/idea/testData/quickfix/modifiers/beforeVisibilityModiferParameter.kt +++ b/idea/testData/quickfix/modifiers/beforeVisibilityModiferParameter.kt @@ -4,6 +4,6 @@ trait ParseResult { public val value : T } -class Success(override val value : T) : ParseResult { +class Success(internal override val value : T) : ParseResult { public override val success : Boolean = true } \ No newline at end of file From d08bb4e6eca0a686c7311a65c05e75123613b07e Mon Sep 17 00:00:00 2001 From: Svetlana Isakova Date: Wed, 18 Apr 2012 19:02:09 +0400 Subject: [PATCH 04/10] test for KT-1805 Better diagnostic for access to private field of parent class #KT-1805 Fixed --- .../diagnostics/tests/scopes/kt1805.jet | 20 +++++++++++++++++++ .../basic/VisibilityInSubclassForce.kt | 5 +---- 2 files changed, 21 insertions(+), 4 deletions(-) create mode 100644 compiler/testData/diagnostics/tests/scopes/kt1805.jet diff --git a/compiler/testData/diagnostics/tests/scopes/kt1805.jet b/compiler/testData/diagnostics/tests/scopes/kt1805.jet new file mode 100644 index 00000000000..ae88a9f6f6f --- /dev/null +++ b/compiler/testData/diagnostics/tests/scopes/kt1805.jet @@ -0,0 +1,20 @@ +package kt1805 +//KT-1805 Better diagnostic for access to private field of parent class + +open class Some { + private val privateField = 12 +} + +class SomeSubclass : Some() { + fun test() { + this.privateField // 1. Unresolved reference + } +} + +fun test() { + val s2 = Some() + s2.privateField // 2. Can't access to 'privateField' in Some + + val s1 = SomeSubclass() + s1.privateField // 3. Unresolved reference +} \ No newline at end of file diff --git a/idea/testData/completion/basic/VisibilityInSubclassForce.kt b/idea/testData/completion/basic/VisibilityInSubclassForce.kt index a28241706be..66f468b854b 100644 --- a/idea/testData/completion/basic/VisibilityInSubclassForce.kt +++ b/idea/testData/completion/basic/VisibilityInSubclassForce.kt @@ -12,7 +12,4 @@ class SomeSubclass : Some() { } // TIME: 2 -// EXIST: testPublic, testProtected, testPackage - -// Should exist after KT-1805 Better diagnostic for access to private field of parent class -// ABSENT: testPrivate \ No newline at end of file +// EXIST: testPublic, testProtected, testPackage, testPrivate From 71102627c0a7979402852ec92dbcac3b00340b45 Mon Sep 17 00:00:00 2001 From: Svetlana Isakova Date: Wed, 18 Apr 2012 19:59:15 +0400 Subject: [PATCH 05/10] 'isClassObject' method moved from CodegenUtil to DescriptorUtils --- .../jetbrains/jet/codegen/ClosureAnnotator.java | 3 ++- .../org/jetbrains/jet/codegen/CodegenUtil.java | 15 --------------- .../jetbrains/jet/codegen/ExpressionCodegen.java | 5 +++-- .../org/jetbrains/jet/codegen/JetTypeMapper.java | 2 +- .../jetbrains/jet/codegen/PropertyCodegen.java | 3 ++- .../jet/lang/resolve/DescriptorUtils.java | 14 ++++++++++++++ 6 files changed, 22 insertions(+), 20 deletions(-) diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/ClosureAnnotator.java b/compiler/backend/src/org/jetbrains/jet/codegen/ClosureAnnotator.java index 91a827e4e66..d4d3242be61 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/ClosureAnnotator.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/ClosureAnnotator.java @@ -22,6 +22,7 @@ import org.jetbrains.jet.lang.descriptors.*; import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor; import org.jetbrains.jet.lang.psi.*; import org.jetbrains.jet.lang.resolve.BindingContext; +import org.jetbrains.jet.lang.resolve.DescriptorUtils; import org.jetbrains.jet.lang.resolve.FqName; import org.jetbrains.jet.lang.resolve.java.JvmAbi; import org.jetbrains.jet.lang.resolve.scopes.JetScope; @@ -118,7 +119,7 @@ public class ClosureAnnotator { } public boolean hasThis0(ClassDescriptor classDescriptor) { - if(CodegenUtil.isClassObject(classDescriptor)) + if(DescriptorUtils.isClassObject(classDescriptor)) return false; ClassDescriptor other = enclosing.get(classDescriptor); diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/CodegenUtil.java b/compiler/backend/src/org/jetbrains/jet/codegen/CodegenUtil.java index 38e20c4a7dd..5188c638b1f 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/CodegenUtil.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/CodegenUtil.java @@ -42,21 +42,6 @@ public class CodegenUtil { public static boolean isInterface(JetType type) { return isInterface(type.getConstructor().getDeclarationDescriptor()); } - - public static boolean isClassObject(DeclarationDescriptor descriptor) { - if(descriptor instanceof ClassDescriptor) { - ClassDescriptor classDescriptor = (ClassDescriptor) descriptor; - if(classDescriptor.getKind() == ClassKind.OBJECT) { - if(classDescriptor.getContainingDeclaration() instanceof ClassDescriptor) { - ClassDescriptor containingDeclaration = (ClassDescriptor) classDescriptor.getContainingDeclaration(); - if(classDescriptor.getDefaultType().equals(containingDeclaration.getClassObjectType())) { - return true; - } - } - } - } - return false; - } public static SimpleFunctionDescriptor createInvoke(FunctionDescriptor fd) { int arity = fd.getValueParameters().size(); diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java b/compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java index 96db28b8a60..7637d081dbf 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java @@ -1021,7 +1021,8 @@ public class ExpressionCodegen extends JetVisitor { final boolean directToField = expression.getReferencedNameElementType() == JetTokens.FIELD_IDENTIFIER && contextKind() != OwnerKind.TRAIT_IMPL ; JetExpression r = getReceiverForSelector(expression); final boolean isSuper = r instanceof JetSuperExpression; - if(propertyDescriptor.getVisibility() == Visibilities.PRIVATE && !CodegenUtil.isClassObject(propertyDescriptor.getContainingDeclaration())) { + if(propertyDescriptor.getVisibility() == Visibilities.PRIVATE && !DescriptorUtils + .isClassObject(propertyDescriptor.getContainingDeclaration())) { if(context.getClassOrNamespaceDescriptor() != propertyDescriptor.getContainingDeclaration()) { DeclarationDescriptor enclosed = propertyDescriptor.getContainingDeclaration(); if(enclosed != null && enclosed != context.getThisDescriptor()) { @@ -1374,7 +1375,7 @@ public class ExpressionCodegen extends JetVisitor { Type exprType = asmType(descriptor.getType()); ClassReceiver classReceiver = (ClassReceiver) descriptor; ClassDescriptor classReceiverDeclarationDescriptor = (ClassDescriptor) classReceiver.getDeclarationDescriptor(); - if(CodegenUtil.isClassObject(classReceiverDeclarationDescriptor)) { + if(DescriptorUtils.isClassObject(classReceiverDeclarationDescriptor)) { ClassDescriptor containingDeclaration = (ClassDescriptor) classReceiverDeclarationDescriptor.getContainingDeclaration(); Type classObjType = typeMapper.mapType(containingDeclaration.getDefaultType(), MapTypeMode.IMPL); v.getstatic(classObjType.getInternalName(), "$classobj", exprType.getDescriptor()); diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/JetTypeMapper.java b/compiler/backend/src/org/jetbrains/jet/codegen/JetTypeMapper.java index 907c5341d3b..3508bb9eb03 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/JetTypeMapper.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/JetTypeMapper.java @@ -835,7 +835,7 @@ public class JetTypeMapper { return ACC_PROTECTED; } else if (p.getVisibility() == Visibilities.PRIVATE) { - if(CodegenUtil.isClassObject(declaration)) { + if(DescriptorUtils.isClassObject(declaration)) { return defaultFlags; } return ACC_PRIVATE; diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/PropertyCodegen.java b/compiler/backend/src/org/jetbrains/jet/codegen/PropertyCodegen.java index 1e2bcb8886f..f8070e10c35 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/PropertyCodegen.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/PropertyCodegen.java @@ -25,6 +25,7 @@ import org.jetbrains.jet.lang.descriptors.*; import org.jetbrains.jet.lang.psi.*; import org.jetbrains.jet.lang.resolve.BindingContext; import org.jetbrains.jet.lang.resolve.BindingContextUtils; +import org.jetbrains.jet.lang.resolve.DescriptorUtils; import org.jetbrains.jet.lang.resolve.constants.CompileTimeConstant; import org.jetbrains.jet.lang.resolve.java.JvmAbi; import org.jetbrains.jet.lang.resolve.java.JvmStdlibNames; @@ -121,7 +122,7 @@ public class PropertyCodegen { } private static boolean isExternallyAccessible(PropertyDescriptor p) { - return p.getVisibility() != Visibilities.PRIVATE || CodegenUtil.isClassObject(p.getContainingDeclaration()); + return p.getVisibility() != Visibilities.PRIVATE || DescriptorUtils.isClassObject(p.getContainingDeclaration()); } private void generateSetter(JetProperty p, PropertyDescriptor propertyDescriptor) { diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DescriptorUtils.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DescriptorUtils.java index 8827c70dd77..5ce30d66e3f 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DescriptorUtils.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DescriptorUtils.java @@ -314,4 +314,18 @@ public class DescriptorUtils { return namespaceDescriptor.getContainingDeclaration() instanceof ModuleDescriptor; } + public static boolean isClassObject(@NotNull DeclarationDescriptor descriptor) { + if(descriptor instanceof ClassDescriptor) { + ClassDescriptor classDescriptor = (ClassDescriptor) descriptor; + if(classDescriptor.getKind() == ClassKind.OBJECT) { + if(classDescriptor.getContainingDeclaration() instanceof ClassDescriptor) { + ClassDescriptor containingDeclaration = (ClassDescriptor) classDescriptor.getContainingDeclaration(); + if(classDescriptor.getDefaultType().equals(containingDeclaration.getClassObjectType())) { + return true; + } + } + } + } + return false; + } } From 08e18e5d9c49806d6030e6741ca0c2bdebef4e1c Mon Sep 17 00:00:00 2001 From: Svetlana Isakova Date: Wed, 18 Apr 2012 19:59:34 +0400 Subject: [PATCH 06/10] KT-1806 accessing private member in object class/anonymous object is not highlighted as error #KT-1806 fixed --- .../jet/lang/descriptors/Visibilities.java | 4 ++-- .../diagnostics/tests/scopes/kt1806.jet | 22 +++++++++++++++++++ 2 files changed, 24 insertions(+), 2 deletions(-) create mode 100644 compiler/testData/diagnostics/tests/scopes/kt1806.jet diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/Visibilities.java b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/Visibilities.java index 5fce7230afd..10df49710e6 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/Visibilities.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/Visibilities.java @@ -38,8 +38,8 @@ public class Visibilities { DeclarationDescriptor parent = what; while (parent != null) { parent = parent.getContainingDeclaration(); - if ((parent instanceof ClassDescriptor && ((ClassDescriptor)parent).getKind() != ClassKind.OBJECT) || - parent instanceof NamespaceDescriptor) { + if ((parent instanceof ClassDescriptor && !DescriptorUtils.isClassObject(parent)) || + parent instanceof NamespaceDescriptor) { break; } } diff --git a/compiler/testData/diagnostics/tests/scopes/kt1806.jet b/compiler/testData/diagnostics/tests/scopes/kt1806.jet new file mode 100644 index 00000000000..674d89f069d --- /dev/null +++ b/compiler/testData/diagnostics/tests/scopes/kt1806.jet @@ -0,0 +1,22 @@ +//KT-1806 accessing private member in object class/anonymous object is not highlighted as error +package kt1806 + +object MyObject { + private var message: String = "'Static'" + +} + +fun test1() { + + doSmth(MyObject.message) +} + +val MyObject1 = object { + private var message: String = "'Static'" +} + +fun test2() { + doSmth(MyObject1.message) +} + +fun doSmth(s: String) = s \ No newline at end of file From 1fa469861158c777d7650ff1d75cafc22ed221b2 Mon Sep 17 00:00:00 2001 From: Svetlana Isakova Date: Wed, 18 Apr 2012 20:42:55 +0400 Subject: [PATCH 07/10] KT-1778 Automatically cast error #KT-1778 fixed --- .../jet/lang/types/expressions/DataFlowUtils.java | 4 ++-- .../tests/nullabilityAndAutoCasts/kt1778.jet | 11 +++++++++++ 2 files changed, 13 insertions(+), 2 deletions(-) create mode 100644 compiler/testData/diagnostics/tests/nullabilityAndAutoCasts/kt1778.jet diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/DataFlowUtils.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/DataFlowUtils.java index 1697a8dcced..d2f9a040861 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/DataFlowUtils.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/DataFlowUtils.java @@ -48,7 +48,7 @@ public class DataFlowUtils { @NotNull public static DataFlowInfo extractDataFlowInfoFromCondition(@Nullable JetExpression condition, final boolean conditionValue, @Nullable final WritableScope scopeToExtend, final ExpressionTypingContext context) { if (condition == null) return context.dataFlowInfo; - final Ref result = new Ref(context.dataFlowInfo); + final Ref result = new Ref(null); condition.accept(new JetVisitorVoid() { @Override public void visitIsExpression(JetIsExpression expression) { @@ -148,7 +148,7 @@ public class DataFlowUtils { if (result.get() == null) { return context.dataFlowInfo; } - return result.get(); + return context.dataFlowInfo.and(result.get()); } @Nullable diff --git a/compiler/testData/diagnostics/tests/nullabilityAndAutoCasts/kt1778.jet b/compiler/testData/diagnostics/tests/nullabilityAndAutoCasts/kt1778.jet new file mode 100644 index 00000000000..b4c46e0b96e --- /dev/null +++ b/compiler/testData/diagnostics/tests/nullabilityAndAutoCasts/kt1778.jet @@ -0,0 +1,11 @@ +//KT-1778 Automatically cast error +package kt1778 + +fun main(args : Array) { + val x = args[0]: Any + if(x is 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 + } +} \ No newline at end of file From ae4b391c8eee932dcd143a896575370974d7b11c Mon Sep 17 00:00:00 2001 From: Svetlana Isakova Date: Wed, 18 Apr 2012 22:03:55 +0400 Subject: [PATCH 08/10] KT-1820 Write test for ASSIGN_OPERATOR_AMBIGUITY #KT-1820 fixed --- .../AssignOperatorAmbiguity.jet | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) create mode 100644 compiler/testData/diagnostics/tests/operatorsOverloading/AssignOperatorAmbiguity.jet diff --git a/compiler/testData/diagnostics/tests/operatorsOverloading/AssignOperatorAmbiguity.jet b/compiler/testData/diagnostics/tests/operatorsOverloading/AssignOperatorAmbiguity.jet new file mode 100644 index 00000000000..e08c71ea005 --- /dev/null +++ b/compiler/testData/diagnostics/tests/operatorsOverloading/AssignOperatorAmbiguity.jet @@ -0,0 +1,17 @@ +//KT-1820 Write test for ASSIGN_OPERATOR_AMBIGUITY +package kt1820 + +class MyInt(val i: Int) { + fun plus(m: MyInt) : MyInt = MyInt(m.i + i) +} + +fun Any.plusAssign(a: Any) {} + +fun test(m: MyInt) { + m += m + + var i = 1 + i += 34 +} + + From 5c32f5f0e78596fc25815a692a592c3a4c379a47 Mon Sep 17 00:00:00 2001 From: Svetlana Isakova Date: Wed, 18 Apr 2012 22:04:28 +0400 Subject: [PATCH 09/10] KT-1821 Write test for ITERATOR_AMBIGUITY diagnostic #KT-1821 fixed --- .../IteratorAmbiguity.jet | 27 +++++++++++++++++++ 1 file changed, 27 insertions(+) create mode 100644 compiler/testData/diagnostics/tests/operatorsOverloading/IteratorAmbiguity.jet diff --git a/compiler/testData/diagnostics/tests/operatorsOverloading/IteratorAmbiguity.jet b/compiler/testData/diagnostics/tests/operatorsOverloading/IteratorAmbiguity.jet new file mode 100644 index 00000000000..b9d90ddbb5f --- /dev/null +++ b/compiler/testData/diagnostics/tests/operatorsOverloading/IteratorAmbiguity.jet @@ -0,0 +1,27 @@ +//KT-1821 Write test for ITERATOR_AMBIGUITY diagnostic + +trait MyCollectionInterface { +} + +trait MyAnotherCollectionInterface { +} + +class MyCollection : MyCollectionInterface, MyAnotherCollectionInterface { +} + +fun MyCollectionInterface.iterator() = MyIterator() + +fun MyAnotherCollectionInterface.iterator() = MyIterator() + +class MyIterator { + fun next() : MyElement = MyElement() + fun hasNext() = true +} + +class MyElement + +fun test1(collection: MyCollection) { + collection.iterator() + for (val element in collection) { + } +} \ No newline at end of file From 77dad4fbfb848f887aec674a4fb49d939e0e6c9c Mon Sep 17 00:00:00 2001 From: Svetlana Isakova Date: Wed, 18 Apr 2012 22:04:55 +0400 Subject: [PATCH 10/10] incomplete code from EA --- .../jetbrains/jet/lang/resolve/calls/CallResolver.java | 4 +++- .../tests/incompleteCode/plusOnTheRight.jet | 10 ++++++++++ 2 files changed, 13 insertions(+), 1 deletion(-) create mode 100644 compiler/testData/diagnostics/tests/incompleteCode/plusOnTheRight.jet diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallResolver.java index bb344def4ee..5b62fdadd2a 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallResolver.java @@ -495,7 +495,9 @@ public class CallResolver { // and throw the results away // We'll type check the arguments later, with the inferred types expected TemporaryBindingTrace traceForUnknown = TemporaryBindingTrace.create(context.trace); - JetType type = expressionTypingServices.getType(context.scope, valueArgument.getArgumentExpression(), substituteDontCare.substitute(valueParameterDescriptor.getType(), Variance.INVARIANT), traceForUnknown); + JetExpression argumentExpression = valueArgument.getArgumentExpression(); + JetType type = argumentExpression != null ? expressionTypingServices.getType(context.scope, argumentExpression, + substituteDontCare.substitute(valueParameterDescriptor.getType(), Variance.INVARIANT), traceForUnknown) : null; if (type != null && !ErrorUtils.isErrorType(type)) { constraintSystem.addSubtypingConstraint(VALUE_ARGUMENT.assertSubtyping(type, effectiveExpectedType)); } diff --git a/compiler/testData/diagnostics/tests/incompleteCode/plusOnTheRight.jet b/compiler/testData/diagnostics/tests/incompleteCode/plusOnTheRight.jet new file mode 100644 index 00000000000..ed135a6aa94 --- /dev/null +++ b/compiler/testData/diagnostics/tests/incompleteCode/plusOnTheRight.jet @@ -0,0 +1,10 @@ +//EA-35646 +package a + +class MyClass1 { + public fun plus() {} +} + +fun main(arg: MyClass1) { + arg+ +}