[FIR-TEST] Add new testdata generated after changes in previous commit

2019-12-11 16:16:22 +03:00
parent e9c02a1cca
commit 2536fa0cd5
4578 changed files with 104067 additions and 1 deletions
@@ -0,0 +1,17 @@
+// FILE: a.kt
+package a
+
+class X
+
+// FILE: b.kt
+package b
+
+class X
+
+// FILE: c.kt
+package c
+
+import a.*
+import b.*
+
+class Y : X
@@ -0,0 +1,17 @@
+// FILE: a.kt
+package a
+
+open class X
+
+// FILE: b.kt
+package b
+
+class X
+
+// FILE: c.kt
+package c
+
+import a.X
+import b.*
+
+class Y : X()
@@ -0,0 +1,19 @@
+// FILE: a.kt
+package a
+
+fun X(p: Int) {}
+
+// FILE: b.kt
+package b
+
+fun X(): Int = 1
+
+// FILE: c.kt
+package c
+
+import b.*
+import a.X
+
+fun foo() {
+    val v: Int = X()
+}
@@ -0,0 +1,19 @@
+// FILE: a.kt
+package a
+
+var X: Int = 1
+
+// FILE: b.kt
+package b
+
+var X: String = ""
+
+// FILE: c.kt
+package c
+
+import a.X
+import b.*
+
+fun foo() {
+    X = 1
+}
@@ -0,0 +1,73 @@
+// FILE: j/JavaPublic.java
+package j;
+
+public class JavaPublic {
+    public static void javaM() {}
+    public static int javaP = 4;
+    static int javaPackageLocal = 5;
+}
+
+// FILE: j/JavaPackageLocal.java
+package j;
+
+class JavaPackageLocal {
+    static void javaMPackage() {}
+    static int javaPPackage = 4;
+}
+
+// FILE: j/JavaProtected.java
+package j;
+
+public class JavaProtected {
+    protected static void javaMProtected() {}
+    protected static int javaPProtected = 4;
+}
+
+// FILE: j/JavaPrivate.java
+package j;
+
+public class JavaPrivate {
+    private static void javaMPrivate() {}
+    private static int javaPPrivate = 4;
+}
+
+
+// FILE: k1.kt
+package k
+
+import j.JavaPublic
+import j.JavaPublic.javaM
+import j.JavaPublic.javaP
+import j.JavaPublic.javaPackageLocal
+
+import j.JavaPackageLocal
+import j.JavaPackageLocal.javaMPackage
+import j.JavaPackageLocal.javaPPackage
+
+import j.JavaProtected
+import j.JavaProtected.javaMProtected
+import j.JavaProtected.javaPProtected
+
+import j.JavaPrivate
+import j.JavaPrivate.javaMPrivate
+import j.JavaPrivate.javaPPrivate
+
+// FILE: k2.kt
+package j
+
+import j.JavaPublic
+import j.JavaPublic.javaM
+import j.JavaPublic.javaP
+import j.JavaPublic.javaPackageLocal
+
+import j.JavaPackageLocal
+import j.JavaPackageLocal.javaMPackage
+import j.JavaPackageLocal.javaPPackage
+
+import j.JavaProtected
+import j.JavaProtected.javaMProtected
+import j.JavaProtected.javaPProtected
+
+import j.JavaPrivate
+import j.JavaPrivate.javaMPrivate
+import j.JavaPrivate.javaPPrivate
@@ -0,0 +1,62 @@
+// FILE: j/JavaPackageLocal.java
+package j;
+
+public class JavaPackageLocal {
+    static void javaMPackage() {}
+    static int javaPPackage = 4;
+}
+
+// FILE: j/JavaProtected.java
+package j;
+
+public class JavaProtected {
+    protected static void javaMProtectedStatic() {}
+    protected static int javaPProtectedStatic = 4;
+    protected final int javaPProtectedPackage = 4;
+}
+
+// FILE: k.kt
+package k
+
+import j.JavaProtected
+import j.JavaPackageLocal
+
+class A {
+    val p1 = JavaPackageLocal.<!INAPPLICABLE_CANDIDATE!>javaPPackage<!>
+    val p2 = JavaProtected.<!INAPPLICABLE_CANDIDATE!>javaPProtectedStatic<!>
+    val p3 = JavaProtected().<!INAPPLICABLE_CANDIDATE!>javaPProtectedPackage<!>
+
+    fun test() {
+        JavaProtected.<!INAPPLICABLE_CANDIDATE!>javaMProtectedStatic<!>()
+        JavaPackageLocal.<!INAPPLICABLE_CANDIDATE!>javaMPackage<!>()
+    }
+}
+
+class B : JavaProtected() {
+    val p1 = JavaPackageLocal.<!INAPPLICABLE_CANDIDATE!>javaPPackage<!>
+    val p2 = JavaProtected.javaPProtectedStatic
+    val p3 = javaPProtectedPackage
+
+    fun test() {
+        JavaProtected.javaMProtectedStatic()
+        JavaPackageLocal.<!INAPPLICABLE_CANDIDATE!>javaMPackage<!>()
+    }
+}
+
+// FILE: j.kt
+package j
+
+import j.JavaProtected
+import j.JavaPackageLocal
+
+class C {
+    val p1 = JavaPackageLocal.javaPPackage
+    val p2 = JavaProtected.javaPProtectedStatic
+    val p3 = JavaProtected().javaPProtectedPackage
+
+    fun test() {
+        JavaProtected.javaMProtectedStatic()
+        JavaProtected.javaMProtectedStatic()
+        JavaPackageLocal.javaMPackage()
+    }
+}
@@ -0,0 +1,28 @@
+// MODULE: m1
+// FILE: k1.kt
+package k
+
+private class KPrivate
+internal class KInternal
+public class KPublic
+
+class A {
+    protected class KProtected
+}
+
+// FILE: k2.kt
+package k2
+
+import k.KPrivate
+import k.KInternal
+import k.KPublic
+import k.A.KProtected
+
+// MODULE: m2(m1)
+// FILE: k3.kt
+package k3
+
+import k.KPrivate
+import k.KInternal
+import k.KPublic
+import k.A.KProtected
@@ -0,0 +1,81 @@
+// MODULE: m1
+// FILE: a.kt
+package a
+
+class B {
+    fun m1() {}
+}
+
+// MODULE: m2
+// FILE: b.kt
+package a
+
+class B {
+    fun m2() {}
+}
+
+// MODULE: m3(m1, m2)
+// FILE: c.kt
+import a.B
+
+fun test(b: B) {
+    b.m1()
+    b.<!UNRESOLVED_REFERENCE!>m2<!>()
+
+    val b_: B = B()
+    b_.m1()
+
+    val b_1: a.B = B()
+    b_1.m1()
+
+    val b_2: B = a.B()
+    b_2.m1()
+
+    val b_3: B = B()
+    b_3.m1()
+
+    val b_4: B = a.B()
+    b_4.m1()
+}
+
+
+//----------------------------TOP LEVEL---------------------
+// MODULE: top_m1
+// FILE: top_a.kt
+class B {
+    fun m1() {}
+}
+
+// MODULE: top_m2
+// FILE: top_b.kt
+class B {
+    fun m2() {}
+}
+
+// MODULE: top_m3(top_m1, top_m2)
+// FILE: top_c.kt
+import B
+
+fun test(b: B) {
+    b.m1()
+    b.<!UNRESOLVED_REFERENCE!>m2<!>()
+
+    val b_: B = B()
+    b_.m1()
+
+    val b_2 = B()
+    b_2.m1()
+}
+
+// FILE: top_d.kt
+
+fun test2(b: B) {
+    b.m1()
+    b.<!UNRESOLVED_REFERENCE!>m2<!>()
+
+    val b_: B = B()
+    b_.m1()
+
+    val b_2 = B()
+    b_2.m1()
+}
@@ -0,0 +1,76 @@
+// !WITH_NEW_INFERENCE
+// MODULE: m1
+// FILE: a.kt
+package a
+
+class B {
+    fun m1() {}
+}
+
+// MODULE: m2
+// FILE: b.kt
+package a
+
+class B {
+    fun m2() {}
+}
+
+// MODULE: m3(m2, m1)
+// FILE: b.kt
+import a.*
+
+
+fun test(b: B) {
+    b.m2()
+    b.<!UNRESOLVED_REFERENCE!>m1<!>()
+
+    val b_: B = B()
+    b_.m2()
+
+    val b_1: a.B = B()
+    b_1.m2()
+
+    val b_2: B = a.B()
+    b_2.m2()
+
+    val b_3 = B()
+    b_3.m2()
+
+    val b_4 = a.B()
+    b_4.m2()
+}
+
+
+//----------------------------TOP LEVEL---------------------
+
+// MODULE: top_m1
+// FILE: top_a.kt
+class B {
+    fun m1() {}
+}
+
+// MODULE: top_m2
+// FILE: top_b.kt
+class B {
+    fun m2() {}
+}
+
+// MODULE: top_m3(top_m2, top_m1)
+// FILE: top_c.kt
+
+fun test(b: B) {
+    b.m2()
+    b.<!UNRESOLVED_REFERENCE!>m1<!>()
+
+    val b_: B = B()
+    b_.m2()
+
+    val b_2 = B()
+    b_2.m2()
+
+    val b_3 = B()
+    b_3.m2()
+
+    val b_4 = <!UNRESOLVED_REFERENCE!>a<!>.<!UNRESOLVED_REFERENCE!>B<!>()
+    b_4.<!UNRESOLVED_REFERENCE!>m2<!>()
+}
@@ -0,0 +1,15 @@
+//FILE:a.kt
+package a
+
+import b.O
+import c.O
+
+//FILE:b.kt
+package b
+
+object O {}
+
+//FILE:c.kt
+package c
+
+object O {}
@@ -0,0 +1,16 @@
+// FILE: a.kt
+package a
+
+class X
+
+// FILE: b.kt
+package b
+
+open class X
+
+// FILE: b1.kt
+package b
+
+import a.*
+
+class Y : X() // class from the current package should take priority
@@ -0,0 +1,16 @@
+// FILE: a.kt
+package a
+
+open class Y
+
+// FILE: b.kt
+package b
+
+class X
+
+// FILE: b1.kt
+package b
+
+import a.Y as X
+
+class Y : X() // class from explicit import should take priority
@@ -0,0 +1,6 @@
+import java.lang.reflect.*
+import java.util.List
+
+fun foo(
+        p1: Array<String> /* should be resolved to kotlin.Array */,
+        p2: List<String> /* should be resolved to java.util.List */) { }
@@ -0,0 +1,17 @@
+// FILE: a.kt
+package a
+
+class X
+
+// FILE: b.kt
+package b
+
+class X
+
+// FILE: c.kt
+package c
+
+import a.X
+import b.X
+
+class Y : X
@@ -0,0 +1,19 @@
+// FILE: a.kt
+package a
+
+fun X(p: Int) {}
+
+// FILE: b.kt
+package b
+
+fun X(): Int = 1
+
+// FILE: c.kt
+package c
+
+import b.X
+import a.X
+
+fun foo() {
+    val v: Int = X()
+}
@@ -0,0 +1,17 @@
+// FILE: a.kt
+package a.x
+
+class X
+
+// FILE: b.kt
+package b.x
+
+class X
+
+// FILE: c.kt
+package c
+
+import a.x
+import b.x
+
+class Y : x.X
@@ -0,0 +1,48 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+// FILE: 1.kt
+package a
+
+class someFun() {}
+fun someFun(i: Int) {}
+
+class someVal() {}
+val Int.someVal: Int get() = 3
+
+class A
+
+class B
+
+// FILE: 2.kt
+package b
+
+class someFun
+class someVal
+class someAll
+
+fun A() {}
+
+class B
+
+
+// FILE: 3.kt
+import a.someFun
+import b.someFun
+
+import a.someVal
+import b.someVal
+
+import a.A
+import b.A
+
+// FILE: 4.kt
+import b.*
+import a.B
+
+// FILE: 5.kt
+package b
+
+import a.B
+
+// FILE: 6.kt
+import a.B
+import b.B
@@ -0,0 +1,138 @@
+// FILE: a.kt
+package a
+
+class C1 {
+    companion object O {
+        class A
+        object B
+
+        fun bar() {}
+    }
+}
+
+
+class C2 {
+    companion object S {
+
+        val prop: String = ""
+
+        fun o(s: String) = Unit
+        fun o(i: Int) = Unit
+
+        fun Int.ext() = Unit
+        var String.ext: Int
+            get() = 3
+            set(i) {
+            }
+
+        fun A(c: Int) = A()
+
+        class A()
+
+        fun <T> genericFun(t: T, t2: T): T = t
+    }
+}
+
+open class Base {
+    fun f() {
+    }
+
+    fun <T> g(t: T) {
+    }
+
+    val p = 1
+    val Int.ext: Int
+        get() = 4
+}
+
+interface BaseI<T> {
+    fun fromI(): Int = 3
+
+    fun genericFromI(t: T) = t
+}
+
+class C3 {
+    companion object K: Base(), BaseI<Int> {
+        val own: String = ""
+    }
+}
+
+// FILE: b.kt
+package b
+
+import a.C1.O.*
+
+fun testErroneusAllUnderImportFromObject() {
+    A()
+    B
+    bar()
+}
+
+// FILE: c.kt
+package c
+
+import a.C2.S.prop
+import a.C2.S.o
+import a.C2.S.ext
+import a.C2.S.A
+import a.C2.S.genericFun
+import a.C2.S.ext as extRenamed
+
+fun testImportFromObjectByName() {
+    prop
+    o("a")
+    o(3)
+    3.ext()
+    "".ext = 3
+    val c: Int = "".ext
+
+    3.extRenamed()
+    "".extRenamed = 3
+    val c2: Int = "".extRenamed
+
+    A()
+    A(3)
+
+    val a: Int = genericFun(3, 3)
+    val s: String = genericFun("A", "b")
+    val b: Boolean = genericFun(true, false)
+}
+
+fun <T> t(t: T): T {
+    return genericFun(t, t)
+}
+
+// FILE: d.kt
+package d
+
+import a.C2.S.prop as renamed
+
+fun testFunImportedFromObjectHasNoDispatchReceiver(l: a.C2.S) {
+    l.<!UNRESOLVED_REFERENCE!>renamed<!>
+    l.prop
+    renamed
+}
+
+// FILE: e.kt
+
+package e
+
+import a.C3.K.f
+import a.C3.K.g
+import a.C3.K.p
+import a.C3.K.own
+import a.C3.K.fromI
+import a.C3.K.genericFromI
+import a.C3.K.ext
+
+fun testMembersFromSupertypes() {
+    f()
+    g("")
+    p
+    fromI()
+
+    genericFromI(3)
+    <!INAPPLICABLE_CANDIDATE!>genericFromI<!>("a")
+
+    own
+}
@@ -0,0 +1,8 @@
+package a
+
+import a.A as ER
+
+interface A {
+    val a: A
+    val b: ER
+}
@@ -0,0 +1,132 @@
+// FILE: a.kt
+package a
+
+object O {
+    class A
+    object B
+
+    fun bar() {}
+}
+
+
+object S {
+
+    val prop: String = ""
+
+    fun o(s: String) = Unit
+    fun o(i: Int) = Unit
+
+    fun Int.ext() = Unit
+    var String.ext: Int
+        get() = 3
+        set(i) {
+        }
+
+    fun A(c: Int) = A()
+
+    class A()
+
+    fun <T> genericFun(t: T, t2: T): T = t
+}
+
+open class Base {
+    fun f() {
+    }
+
+    fun <T> g(t: T) {
+    }
+
+    val p = 1
+    val Int.ext: Int
+        get() = 4
+}
+
+interface BaseI<T> {
+    fun fromI(): Int = 3
+
+    fun genericFromI(t: T) = t
+}
+
+object K: Base(), BaseI<Int> {
+    val own: String = ""
+}
+
+// FILE: b.kt
+package b
+
+import a.O.*
+
+fun testErroneusAllUnderImportFromObject() {
+    A()
+    B
+    bar()
+}
+
+// FILE: c.kt
+package c
+
+import a.S.prop
+import a.S.o
+import a.S.ext
+import a.S.A
+import a.S.genericFun
+import a.S.ext as extRenamed
+
+fun testImportFromObjectByName() {
+    prop
+    o("a")
+    o(3)
+    3.ext()
+    "".ext = 3
+    val c: Int = "".ext
+
+    3.extRenamed()
+    "".extRenamed = 3
+    val c2: Int = "".extRenamed
+
+    A()
+    A(3)
+
+    val a: Int = genericFun(3, 3)
+    val s: String = genericFun("A", "b")
+    val b: Boolean = genericFun(true, false)
+}
+
+fun <T> t(t: T): T {
+    return genericFun(t, t)
+}
+
+// FILE: d.kt
+package d
+
+import a.S.prop as renamed
+
+fun testFunImportedFromObjectHasNoDispatchReceiver(l: a.S) {
+    l.<!UNRESOLVED_REFERENCE!>renamed<!>
+    l.prop
+    renamed
+}
+
+// FILE: e.kt
+
+package e
+
+import a.K.f
+import a.K.g
+import a.K.p
+import a.K.own
+import a.K.fromI
+import a.K.genericFromI
+import a.K.ext
+
+fun testMembersFromSupertypes() {
+    f()
+    g("")
+    p
+    fromI()
+
+    genericFromI(3)
+    <!INAPPLICABLE_CANDIDATE!>genericFromI<!>("a")
+
+    own
+}
@@ -0,0 +1,32 @@
+// FILE: rootPackage.kt
+class Klass {
+    class Nested
+}
+
+class NotImported
+
+fun function() = ""
+
+val property = ""
+
+// FILE: anotherFromRootPackage.kt
+fun foo(): Klass {
+    function() + property
+    return Klass()
+}
+
+// FILE: anotherFromRootPackage.kt
+package pkg
+
+import Klass
+import Klass.Nested
+import function
+import property
+
+fun foo(): Klass {
+    function() + property
+    return Klass()
+}
+
+val v: Nested = Nested()
+val x: NotImported = <!UNRESOLVED_REFERENCE!>NotImported<!>()
@@ -0,0 +1,9 @@
+// ResolveSession.resolveToDescriptor used to crash on such code, so we just check that it's ok now
+import kotlin.Double
+import kotlin.collections.List
+import kotlin.arrayOfNulls
+
+class List {}
+
+fun arrayOfNulls(){}
+val arrayOfNulls: Int = 0
@@ -0,0 +1,10 @@
+package a
+
+import a.A.Nested as X
+
+interface A {
+    class Nested
+
+    val a: Nested
+    val b: X
+}
@@ -0,0 +1,19 @@
+// FILE: a.kt
+
+package foo
+
+object Bar {
+    fun bar() {}
+}
+
+// FILE: b.kt
+
+package baz
+
+import foo.Bar
+
+class C: Bar
+
+fun test() {
+    Bar.bar()
+}
@@ -0,0 +1,12 @@
+//FILE:a.kt
+package a
+
+// no error is reported
+import b.a
+
+fun foo() = a
+
+//FILE:b.kt
+package b
+
+object a {}
@@ -0,0 +1,45 @@
+// !DIAGNOSTICS: -UNUSED_EXPRESSION -UNUSED_PARAMETER -UNUSED_VARIABLE
+// !WITH_NEW_INFERENCE
+// FILE: 1.kt
+package k
+
+private fun zero() {}
+private fun zero(a: Int) {}
+private fun zero(a: String) {}
+
+fun one() {}
+private fun one(a: Int) {}
+private fun one(a: String) {}
+
+fun two() {}
+fun two(a: Int) {}
+private fun two(a: String) {}
+
+fun all() {}
+fun all(a: Int) {}
+fun all(a: String) {}
+
+// FILE: 2.kt
+
+import k.zero
+import k.one
+import k.two
+import k.all
+
+fun test() {
+    <!INAPPLICABLE_CANDIDATE!>zero<!>()
+    <!INAPPLICABLE_CANDIDATE!>zero<!>(1)
+    <!INAPPLICABLE_CANDIDATE!>zero<!>("")
+
+    one()
+    <!INAPPLICABLE_CANDIDATE!>one<!>(1)
+    <!INAPPLICABLE_CANDIDATE!>one<!>("")
+
+    two()
+    two(1)
+    <!INAPPLICABLE_CANDIDATE!>two<!>("")
+
+    all()
+    all(1)
+    all("")
+}
@@ -0,0 +1,37 @@
+package test
+
+import test.TopLevelClass.NestedClass
+import test.TopLevelClass.NestedClass.InNested
+import test.TopLevelEnum.NestedEnum.NestedEntry
+import test.TopLevelObject.inObject
+import test.TopLevelEnum.E1
+
+private class TopLevelClass {
+    private class NestedClass {
+        class InNested
+    }
+
+    fun test() {
+        InNested()
+    }
+}
+
+private enum class TopLevelEnum(private val e: NestedEnum) {
+    E1(NestedEntry);
+
+    private enum class NestedEnum {
+        NestedEntry;
+    }
+}
+
+private object TopLevelObject {
+    fun inObject() {}
+}
+
+fun testAccess() {
+    <!INAPPLICABLE_CANDIDATE!>NestedClass<!>()
+    E1
+    InNested()
+    NestedEntry
+    inObject()
+}
@@ -0,0 +1,26 @@
+// FILE: A.kt
+
+class A {
+    private class Nested {
+        object O1
+    }
+}
+
+// FILE: B.java
+
+public class B {
+    private static class JC {
+        public static class JC1 {
+        }
+    }
+}
+
+// FILE: C.kt
+
+import A.Nested.*
+import B.JC.JC1
+
+fun test() {
+    O1
+    JC1()
+}
@@ -0,0 +1,32 @@
+package test
+
+import test.TopLevelClass.NestedClass.*
+import test.TopLevelEnum.NestedEnum.*
+import test.TopLevelEnum.*
+
+private class TopLevelClass {
+    private class NestedClass {
+        class A1
+        object A2
+    }
+
+    fun test() {
+        A1()
+        A2
+    }
+}
+
+private enum class TopLevelEnum(private val e: NestedEnum) {
+    E1(NestedEntry);
+
+    private enum class NestedEnum {
+        NestedEntry;
+    }
+}
+
+fun testAccess() {
+    E1
+    NestedEntry
+    A1()
+    A2
+}
@@ -0,0 +1,14 @@
+package p
+
+import p.Foo.Nested
+
+open class Foo {
+    protected class Nested
+}
+
+class Bar: Foo() {
+    protected fun foo(): Nested? = null
+}
+
+private fun foo(): Nested? = null
+private fun bar(): p.Foo.Nested? = null
@@ -0,0 +1,23 @@
+// FILE: b.kt
+// KT-355 Resolve imports after all symbols are built
+
+package a
+  import b.*
+  val x : X = X()
+
+// FILE: b.kt
+package b
+  class X() {
+
+  }
+
+// FILE: b.kt
+package c
+  import d.X
+  val x : X = X()
+
+// FILE: b.kt
+package d
+  class X() {
+
+  }
@@ -0,0 +1,14 @@
+// FILE: a.kt
+
+package weatherForecast
+
+fun weatherToday() = "snow"
+
+// FILE: b.kt
+
+package myApp
+
+import weatherForecast.weatherToday
+import weatherForecast.weatherToday
+
+fun needUmbrella() = weatherToday() == "rain"
@@ -0,0 +1,14 @@
+// FILE: a.kt
+
+package weatherForecast
+
+fun weatherToday() = "snow"
+
+// FILE: b.kt
+
+package myApp
+
+import weatherForecast.*
+import weatherForecast.*
+
+fun needUmbrella() = weatherToday() == "rain"
@@ -0,0 +1,102 @@
+// !WITH_NEW_INFERENCE
+// FILE:a.kt
+package a
+
+import b.B        //class
+import b.foo      //function
+import b.ext      //extension function
+import b.value    //property
+import b.C.Companion.bar    //function from companion object
+import b.C.Companion.cValue //property from companion object
+import b.constant.fff     //function from val
+import b.constant.dValue  //property from val
+import b.constant
+import b.E.Companion.f      //val from companion object
+import smth.illegal
+import b.C.smth.illegal
+import b.bar.smth
+import b.bar.*
+import b.unr.unr.unr
+import unr.unr.unr
+
+fun test(arg: B) {
+    foo(value)
+    arg.ext()
+
+    bar()
+    foo(cValue)
+
+    <!UNRESOLVED_REFERENCE!>fff<!>(<!UNRESOLVED_REFERENCE!>dValue<!>)
+
+    constant.fff(constant.dValue)
+
+    f.f()
+}
+
+// FILE:b.kt
+package b
+
+class B() {}
+
+fun foo(i: Int) = i
+
+fun B.ext() {}
+
+val value = 0
+
+class C() {
+    companion object {
+        fun bar() {}
+        val cValue = 1
+    }
+}
+
+class D() {
+    fun fff(s: String) = s
+    val dValue = "w"
+}
+
+val constant = D()
+
+class E() {
+    companion object {
+        val f = F()
+    }
+}
+
+class F() {
+    fun f() {}
+}
+
+fun bar() {}
+
+//FILE:c.kt
+package c
+
+import c.C.*
+
+object C {
+    fun f() {
+    }
+    val i = 348
+}
+
+fun foo() {
+    if (i == 3) f()
+}
+
+//FILE:d.kt
+package d
+
+import d.A.Companion.B
+import d.A.Companion.C
+
+val b : B = B()
+val c : B = C
+
+class A() {
+    companion object {
+        open class B() {}
+        object C : B() {}
+    }
+}
@@ -0,0 +1,15 @@
+//FILE:a.kt
+package a
+
+import b.foo
+import c.foo // TODO: need warning here
+
+//FILE:b.kt
+package b
+
+fun foo() = 2
+
+//FILE:c.kt
+package c
+
+fun foo() = 1
@@ -0,0 +1,18 @@
+// FILE: a.kt
+package p1
+
+private class X
+private class Y
+
+// FILE: b.kt
+package p2
+
+class X
+
+// FILE: c.kt
+package p1
+
+import p2.*
+
+val x: X = X()
+val y: Y = <!INAPPLICABLE_CANDIDATE!>Y<!>()
@@ -0,0 +1,12 @@
+// FILE: File.kt
+package pack
+
+public open class InetAddressImpl
+
+// FILE: Main.kt
+package a
+
+import java.net.* // should not import java.net.InetAddressImpl because it's package local
+import pack.*
+
+class X : <!UNRESOLVED_REFERENCE!>InetAddressImpl<!>() // should resolve to our pack.InetAddressImpl
@@ -0,0 +1,9 @@
+package test
+
+import some.<!SYNTAX!><!>
+import <!SYNTAX!>.some<!>
+import <!SYNTAX!>.kotlin<!>
+import kotlin.<!SYNTAX!><!>
+import<!SYNTAX!><!>
+import <!SYNTAX!>.<!>
+import <!SYNTAX!>*<!>
@@ -0,0 +1,31 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+// FILE: a.kt
+package a
+
+class A {
+    class B
+}
+
+// FILE: b.kt
+package a
+
+class D {
+    class B
+}
+
+// FILE: c.kt
+import a.A.B
+import a.D.B
+
+fun test(b: B) {
+    B()
+}
+
+// FILE: d.kt
+import a.A.*
+import a.D.*
+
+// todo ambiguvity here
+fun test2(b: B) {
+    B()
+}
@@ -0,0 +1,16 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+// FILE: a.kt
+package a
+
+interface A
+
+operator fun A.plus(other: A): A = this
+
+// FILE: b.kt
+package b
+
+import a.A
+import a.plus as minus
+
+fun test(a1: A, a2: A) =
+        a1 - a2
@@ -0,0 +1,17 @@
+// FILE: File1.kt
+package pack1
+
+private class SomeClass
+
+// FILE: File2.kt
+package pack2
+
+public open class SomeClass
+
+// FILE: Main.kt
+package a
+
+import pack1.*
+import pack2.*
+
+class X : <!INAPPLICABLE_CANDIDATE!>SomeClass<!>()
@@ -0,0 +1,11 @@
+// FILE: File1.kt
+package pack1
+
+private open class SomeClass
+
+// FILE: Main.kt
+package a
+
+import pack1.*
+
+private class X : <!INAPPLICABLE_CANDIDATE!>SomeClass<!>()
@@ -0,0 +1,152 @@
+// MODULE: m1
+// FILE: a.kt
+package a.b
+
+fun ab_fun() {}
+
+class c {
+    fun ab_c() {}
+
+    class d {
+        fun ab_cd() {}
+    }
+}
+
+// MODULE: m2
+// FILE: b.kt
+package a
+
+fun a_fun() {}
+
+class b {
+    fun a_b() {}
+
+    class c {
+        fun a_bc() {}
+    }
+}
+
+// MODULE: m3(m1, m2)
+// FILE: c.kt
+import a.a_fun
+import a.b
+
+import a.b.ab_fun
+import a.b.c
+
+fun test(a_b: b) {
+    a_b.a_b()
+
+    val a_bc: b.c = b.c()
+    a_bc.a_bc()
+
+    val a_bc2 = b.c()
+    a_bc2.a_bc()
+
+    a_fun()
+}
+
+fun test2(ab_c: c) {
+    ab_c.ab_c()
+
+    val ab_cd: c.d = c.d()
+    ab_cd.ab_cd()
+
+    val ab_cd2 = c.d()
+    ab_cd2.ab_cd()
+
+    ab_fun()
+}
+
+// FILE: d.kt
+package a
+
+import a.b.ab_fun
+import a.b.c
+
+fun test(a_b: b) {
+    a_b.a_b()
+
+    val a_bc: b.c = b.c()
+    a_bc.a_bc()
+
+    val a_bc2 = b.c()
+    a_bc2.a_bc()
+
+    a_fun()
+}
+
+fun test2(ab_c: c) {
+    ab_c.ab_c()
+
+    val ab_cd: c.d = c.d()
+    ab_cd.ab_cd()
+
+    val ab_cd2 = c.d()
+    ab_cd2.ab_cd()
+
+    ab_fun()
+}
+
+//---- Changed dependence order
+// MODULE: m4(m2, m1)
+// FILE: c.kt
+import a.a_fun
+import a.b
+
+import a.b.ab_fun
+import a.b.c
+
+fun test(a_b: b) {
+    a_b.a_b()
+
+    val a_bc: b.c = b.c()
+    a_bc.a_bc()
+
+    val a_bc2 = b.c()
+    a_bc2.a_bc()
+
+    a_fun()
+}
+
+fun test2(ab_c: c) {
+    ab_c.ab_c()
+
+    val ab_cd: c.d = c.d()
+    ab_cd.ab_cd()
+
+    val ab_cd2 = c.d()
+    ab_cd2.ab_cd()
+
+    ab_fun()
+}
+
+// FILE: d.kt
+package a
+
+import a.b.ab_fun
+import a.b.c
+
+fun test(a_b: b) {
+    a_b.a_b()
+
+    val a_bc: b.c = b.c()
+    a_bc.a_bc()
+
+    val a_bc2 = b.c()
+    a_bc2.a_bc()
+
+    a_fun()
+}
+
+fun test2(ab_c: c) {
+    ab_c.ab_c()
+
+    val ab_cd: c.d = c.d()
+    ab_cd.ab_cd()
+
+    val ab_cd2 = c.d()
+    ab_cd2.ab_cd()
+
+    ab_fun()
+}
@@ -0,0 +1,21 @@
+// FILE: File1.kt
+package pack1
+
+public class SomeClass {
+    private class N
+    public open class PublicNested
+}
+
+// FILE: File2.kt
+package pack2
+
+public open class N
+
+// FILE: Main.kt
+package a
+
+import pack1.SomeClass.*
+import pack2.*
+
+class X : <!INAPPLICABLE_CANDIDATE!>N<!>()
+class Y : PublicNested()
@@ -0,0 +1,14 @@
+// FILE: File1.kt
+package pack1
+
+public class SomeClass {
+    private class N
+    public open class PublicNested
+}
+
+// FILE: Main.kt
+package a
+
+import pack1.SomeClass.*
+
+private class X : <!INAPPLICABLE_CANDIDATE!>N<!>()
@@ -0,0 +1,22 @@
+// FILE: a.kt
+package a
+
+val x = 1
+val y = 1
+
+// FILE: b.kt
+package b
+
+val x = ""
+
+// FILE: c.kt
+package c
+
+import a.x as AX
+import a.*
+import b.*
+import a.y as AY
+
+val v1: Int = AX
+val v2: String = <!AMBIGUITY!>x<!>
+val v3 = y
@@ -0,0 +1,47 @@
+package a
+
+import a.A.*
+import a.A.C
+import a.A.C.*
+import a.A.D.*
+import a.A.C.*
+import a.A.C.G
+import a.A.E.J.*
+import a.A.CO.*
+import a.A.CO
+
+import a.B.C.*
+import a.B.C.A.*
+import a.B.C.D.*
+
+import a.E.*
+import a.E.E1
+import a.E.E2.*
+
+class A {
+    object C {
+        object G
+    }
+    object D {
+
+    }
+
+    class E {
+        object J
+    }
+
+    companion object CO {
+        object H
+    }
+}
+
+enum class E {
+    E1, E2
+}
+
+object B {
+    class C {
+        object A
+        object D
+    }
+}
@@ -0,0 +1,60 @@
+// FILE:a.kt
+package a
+
+val foo = 2
+fun bar() {}
+
+class B {
+    val foo = 2
+    fun bar() {}
+
+    class C
+}
+
+// FILE:b.kt
+package a.b.c
+
+class D {
+    class E {
+
+    }
+}
+
+
+// FILE:c.kt
+import<!SYNTAX!><!> ;
+import <!SYNTAX!>.<!>
+import a.<!SYNTAX!><!> ;
+import <!SYNTAX!>.a.<!> ;
+import <!SYNTAX!>.a.b<!> ;
+import <!SYNTAX!>.a.B<!> ;
+import a.B.<!SYNTAX!><!> ;
+import a.B.C.<!SYNTAX!><!> ;
+import a.B.foo.<!SYNTAX!><!> ;
+import a.B.bar.<!SYNTAX!><!> ;
+import a.b.<!SYNTAX!><!> ;
+import a.b.c.<!SYNTAX!><!> ;
+import a.<!SYNTAX!>%<!>.b.c.<!SYNTAX!><!> ;
+import a.b.c.D.<!SYNTAX!><!> ;
+import a.b.c.D.E.<!SYNTAX!><!> ;
+
+// FILE:d.kt
+import<!SYNTAX!><!>
+import <!SYNTAX!>.<!>
+import a.<!SYNTAX!><!>
+import <!SYNTAX!>.a.<!>
+import <!SYNTAX!>.a.b<!>
+import <!SYNTAX!>.a.B<!>
+import a.B.<!SYNTAX!><!> as<!SYNTAX!><!>
+import a.B.<!SYNTAX!><!> as A
+import a.B.<!SYNTAX!><!>
+import a.B.C.<!SYNTAX!><!>
+import a.B.foo.<!SYNTAX!><!>
+import a.B.bar.<!SYNTAX!><!>
+import a.b.<!SYNTAX!><!>
+import a.b.c.<!SYNTAX!><!>
+import a.<!SYNTAX!>%<!>.b.c.<!SYNTAX!><!>
+import a.b.c.D.<!SYNTAX!><!>
+import a.b.c.D.E.<!SYNTAX!><!>
+
+import a<!SYNTAX!>?.<!><!SYNTAX!>b<!>
@@ -0,0 +1,68 @@
+// MODULE: m1
+// FILE: a.kt
+package a
+
+fun a_fun() {}
+
+class b {
+    fun a_b() {}
+
+    class c {
+        fun a_bc() {}
+    }
+}
+
+// MODULE: m2
+// FILE: b.kt
+fun _fun() {}
+
+class a {
+    fun _a() {}
+
+    class b {
+        fun _ab() {}
+    }
+}
+
+// MODULE: m3(m1, m2)
+// FILE: c.kt
+import a.a_fun
+import a.b
+
+fun test(a_b: b) {
+    a_b.a_b()
+
+    val a_bc: b.c = b.c()
+    a_bc.a_bc()
+
+    a_fun()
+}
+
+// FILE: d.kt
+fun test2(_a: a) {
+    _a._a()
+
+    val _ab: a.b = a.b()
+    _ab._ab()
+
+    val _ab2 = a.b()
+    _ab2._ab()
+
+    _fun()
+}
+
+// FILE: e.kt
+import a
+import _fun
+
+fun test3(_a: a) {
+    _a._a()
+
+    val _ab: a.b = a.b()
+    _ab._ab()
+
+    val _ab2 = a.b()
+    _ab2._ab()
+
+    _fun()
+}
@@ -0,0 +1,78 @@
+// FILE:a.kt
+package a.b
+
+// FILE:a.kt
+package a
+
+val foo = object {
+    fun bar() {}
+}
+
+fun bar() = object {
+    val foo = 239
+}
+
+class B {
+    val foo = object {
+        fun bar() {}
+    }
+
+    fun bar() = object {
+        val foo = 239
+    }
+}
+
+object C {
+    val foo = object {
+        fun bar() {}
+    }
+
+    fun bar() = object {
+        val foo = 239
+    }
+
+    class Nested
+}
+
+class D {
+    companion object {
+        val foo = object {
+            fun bar() {}
+        }
+
+        fun bar() = object {
+            val foo = 239
+        }
+    }
+}
+
+
+// FILE:b.kt
+import a
+import a.b
+
+import a.foo
+import a.foo.bar
+import a.bar
+import a.bar.foo
+
+import a.B.foo
+import a.B.foo.bar
+import a.B.bar
+import a.B.bar.foo
+
+import a.C.foo
+import a.C.foo.bar
+import a.C.bar
+import a.C.bar.foo
+import a.C.Nested
+
+import a.D.foo
+import a.D.foo.bar
+import a.D.bar
+import a.D.bar.foo
+
+import a.D.Companion.foo
+import a.D.Companion.foo.bar
+import a.D.Companion.bar
+import a.D.Companion.bar.foo
@@ -0,0 +1,13 @@
+// FILE: importFunctionWithAllUnderImport.kt
+package test
+
+import testOther.*
+
+class B: A()
+val inferTypeFromImportedFun = testFun()
+
+// FILE: importFunctionWithAllUnderImportOther.kt
+package testOther
+
+open class A
+fun testFun() = 1
@@ -0,0 +1,22 @@
+//FILE:mainFile.kt
+//----------------------------------------------------------------------------------
+package test
+
+import testing.other.*
+import testing.TestFun
+
+// Resolve shouldn't be ambiguous
+val a = TestFun()
+
+
+//FILE:testing.kt
+//----------------------------------------------------------------------------------
+package testing
+
+class TestFun
+
+//FILE:testingOther.kt
+//----------------------------------------------------------------------------------
+package testing.other
+
+fun TestFun() = 12
@@ -0,0 +1,16 @@
+// FILE: A.kt
+
+import B.foo
+
+fun test() {
+    <!INAPPLICABLE_CANDIDATE!>foo<!>
+}
+
+// FILE: B.kt
+object B : C<String>()
+
+// FILE: C.kt
+
+open class C<T> {
+    private var foo: String = "abc"
+}
@@ -0,0 +1,46 @@
+// FILE: 1.kt
+
+package anotherpackage
+
+interface IInterfaceInput<in T> {
+    fun doSomething(input: T)
+}
+
+// FILE: 2.kt
+
+package anotherpackage
+
+interface IInterfaceOutput<out T> {
+    fun doSomething(): T?
+}
+
+// FILE: 3.kt
+
+package mypackage.nestedpackage
+
+import mypackage.nestedpackage.Bar.Baz
+import anotherpackage.IInterfaceInput
+import anotherpackage.IInterfaceOutput
+
+class Foo() {
+    class FooNest {
+        val bar = Bar()
+
+        fun myFun(): List<Baz> {
+            return <!UNRESOLVED_REFERENCE!>listOf<!>(bar.doSomething())
+        }
+    }
+}
+
+class Bar() : IInterfaceInput<Baz>, IInterfaceOutput<Baz> {
+    override fun doSomething(input: Baz) {
+        throw UnsupportedOperationException("not implemented")
+    }
+
+    override fun doSomething(): Baz {
+        throw UnsupportedOperationException("not implemented")
+    }
+
+}
+
+data class Baz(val myField: Int)
@@ -0,0 +1,17 @@
+// FILE: propertyClassFileDependencyRecursion.kt
+package test
+
+import other.prop
+
+// Note: "prop" is expected to be unresolved and replaced to Any
+class PropType: prop
+
+// Note: this time "prop" should be resolved and type should be inferred for "checkTypeProp"
+val checkTypeProp = prop
+
+// FILE: propertyClassFileDependencyRecursionOther.kt
+package other
+
+import test.PropType
+
+val prop: PropType? = null
@@ -0,0 +1,105 @@
+// !WITH_NEW_INFERENCE
+// FILE:a.kt
+package a
+
+<!SYNTAX!><<!><!SYNTAX!><<!><!SYNTAX!><<!> <!SYNTAX!>FOOO<!><!SYNTAX!><!>
+import b.B        //class
+import b.foo      //function
+import b.ext      //extension function
+import b.value    //property
+import b.C.Companion.bar    //function from companion object
+import b.C.Companion.cValue //property from companion object
+import b.constant.fff     //function from val
+import b.constant.dValue  //property from val
+import smth.illegal
+import b.C.smth.illegal
+
+<!SYNTAX!><<!><!SYNTAX!><<!><!SYNTAX!><<!><!SYNTAX!>HEAD<!><!SYNTAX!><!>
+import b.bar.smth
+import b.bar.*
+import b.unr.unr.unr
+import unr.unr.unr
+import b.constant
+import b.E.Companion.f      //val from companion object
+
+fun test(arg: B) {
+    foo(value)
+    arg.ext()
+
+    bar()
+    foo(cValue)
+
+    <!UNRESOLVED_REFERENCE!>fff<!>(<!UNRESOLVED_REFERENCE!>dValue<!>)
+
+    constant.fff(constant.dValue)
+
+    f.f()
+}
+
+// FILE:b.kt
+package b
+
+class B() {}
+
+fun foo(i: Int) = i
+
+fun B.ext() {}
+
+val value = 0
+
+class C() {
+    companion object {
+        fun bar() {}
+        val cValue = 1
+    }
+}
+
+class D() {
+    fun fff(s: String) = s
+    val dValue = "w"
+}
+
+val constant = D()
+
+class E() {
+    companion object {
+        val f = F()
+    }
+}
+
+class F() {
+    fun f() {}
+}
+
+fun bar() {}
+
+//FILE:c.kt
+package c
+
+import c.C.*
+
+object C {
+    fun f() {
+    }
+    val i = 348
+}
+
+fun foo() {
+    if (i == 3) f()
+}
+
+//FILE:d.kt
+package d
+
+import d.A.Companion.B
+import d.A.Companion.C
+
+val b : B = B()
+val c : B = C
+
+class A() {
+    companion object {
+        open class B() {}
+        object C : B() {}
+    }
+}