Test data for newly passing tests

compiler/testData/lazyResolve/diagnostics/ClassObjectVisibility.txt

@@ -0,0 +1,22 @@
+namespace <root>
+
+// <namespace name="foo">
+namespace foo
+
+internal final class foo.A : jet.Any {
+    public final /*constructor*/ fun <init>(): foo.A
+    public final class object foo.A.<no name provided> : jet.Any {
+        internal final /*constructor*/ fun <init>(): foo.A.<no name provided>
+        internal final val d: jet.Int
+        private final val f: foo.A.<no name provided>.f
+    }
+}
+internal final class foo.CCC : jet.Any {
+    public final /*constructor*/ fun <init>(): foo.CCC
+    private final class object foo.CCC.<no name provided> : jet.Any {
+        internal final /*constructor*/ fun <init>(): foo.CCC.<no name provided>
+        internal final val classObjectVar: jet.Int
+    }
+}
+internal final fun test(): jet.Tuple0
+// </namespace name="foo">

compiler/testData/lazyResolve/diagnostics/overload/ConflictingOverloadsIdenticalFunsTPInClass.txt

@@ -0,0 +1,7 @@
+namespace <root>
+
+internal final class Aaa : jet.Any {
+    public final /*constructor*/ fun <init>(): Aaa
+    internal final fun f(): jet.Int
+    internal final fun </*0*/ P : jet.Any?>f(): jet.Int
+}

compiler/testData/lazyResolve/diagnostics/override/DelegationFun.txt

@@ -0,0 +1,13 @@
+namespace <root>
+
+// <namespace name="delegation">
+namespace delegation
+
+internal abstract trait delegation.Aaa : jet.Any {
+    internal abstract fun foo(): jet.Tuple0
+}
+internal final class delegation.Bbb : delegation.Aaa {
+    public final /*constructor*/ fun <init>(/*0*/ aaa: delegation.Aaa): delegation.Bbb
+    internal open override /*1*/ fun foo(): jet.Tuple0
+}
+// </namespace name="delegation">

compiler/testData/lazyResolve/diagnostics/override/DelegationVal.txt

@@ -0,0 +1,13 @@
+namespace <root>
+
+// <namespace name="delegation">
+namespace delegation
+
+internal abstract trait delegation.Aaa : jet.Any {
+    internal abstract val i: jet.Int
+}
+internal final class delegation.Bbb : delegation.Aaa {
+    public final /*constructor*/ fun <init>(/*0*/ aaa: delegation.Aaa): delegation.Bbb
+    internal open override /*1*/ val i: jet.Int
+}
+// </namespace name="delegation">

compiler/testData/lazyResolve/diagnostics/override/DelegationVar.txt

@@ -0,0 +1,13 @@
+namespace <root>
+
+// <namespace name="delegation">
+namespace delegation
+
+internal abstract trait delegation.Aaa : jet.Any {
+    internal abstract var i: jet.Int
+}
+internal final class delegation.Bbb : delegation.Aaa {
+    public final /*constructor*/ fun <init>(/*0*/ aaa: delegation.Aaa): delegation.Bbb
+    internal open override /*1*/ var i: jet.Int
+}
+// </namespace name="delegation">

compiler/testData/lazyResolve/diagnostics/regressions/kt575.txt

@@ -0,0 +1,18 @@
+namespace <root>
+
+// <namespace name="kt575">
+namespace kt575
+
+internal final class kt575.Creature : jet.Any {
+    public final /*constructor*/ fun <init>(): kt575.Creature
+    internal final val A: kt575.Creature.A
+    internal final class kt575.Creature.C : jet.Any {
+        public final /*constructor*/ fun <init>(): kt575.Creature.C
+        internal final var ccc: jet.Int
+    }
+    internal final class object kt575.Creature.<no name provided> : jet.Any {
+        internal final /*constructor*/ fun <init>(): kt575.Creature.<no name provided>
+        internal final var numCreated: jet.Int private set
+    }
+}
+// </namespace name="kt575">

compiler/testData/lazyResolve/diagnostics/scopes/Imports.txt

@@ -0,0 +1,65 @@
+namespace <root>
+
+// <namespace name="a">
+namespace a
+
+internal final fun test(/*0*/ arg: b.B): jet.Tuple0
+// </namespace name="a">
+// <namespace name="b">
+namespace b
+
+internal final class b.B : jet.Any {
+    public final /*constructor*/ fun <init>(): b.B
+}
+internal final class b.C : jet.Any {
+    public final /*constructor*/ fun <init>(): b.C
+    internal final class object b.C.<no name provided> : jet.Any {
+        internal final /*constructor*/ fun <init>(): b.C.<no name provided>
+        internal final fun bar(): jet.Tuple0
+        internal final val cValue: jet.Int
+    }
+}
+internal final class b.D : jet.Any {
+    public final /*constructor*/ fun <init>(): b.D
+    internal final val dValue: jet.String
+    internal final fun fff(/*0*/ s: jet.String): jet.String
+}
+internal final class b.E : jet.Any {
+    public final /*constructor*/ fun <init>(): b.E
+    internal final class object b.E.<no name provided> : jet.Any {
+        internal final /*constructor*/ fun <init>(): b.E.<no name provided>
+        internal final val f: b.F
+    }
+}
+internal final class b.F : jet.Any {
+    public final /*constructor*/ fun <init>(): b.F
+    internal final fun f(): jet.Tuple0
+}
+internal final val constant: b.D
+internal final val value: jet.Int
+internal final fun bar(): jet.Tuple0
+internal final fun b.B.ext(): jet.Tuple0
+internal final fun foo(/*0*/ i: jet.Int): jet.Int
+// </namespace name="b">
+// <namespace name="c">
+namespace c
+
+internal final val C: c.C
+internal final fun foo(): jet.Tuple0
+// </namespace name="c">
+// <namespace name="d">
+namespace d
+
+internal final class d.A : jet.Any {
+    public final /*constructor*/ fun <init>(): d.A
+    internal final class object d.A.<no name provided> : jet.Any {
+        internal final /*constructor*/ fun <init>(): d.A.<no name provided>
+        internal final val C: d.A.<no name provided>.C
+        internal open class d.A.<no name provided>.B : jet.Any {
+            public final /*constructor*/ fun <init>(): d.A.<no name provided>.B
+        }
+    }
+}
+internal final val b: d.A.<no name provided>.B
+internal final val c: d.A.<no name provided>.B
+// </namespace name="d">

compiler/testData/lazyResolve/diagnostics/scopes/kt900.txt

@@ -0,0 +1,42 @@
+namespace <root>
+
+// <namespace name="a">
+namespace a
+
+internal final class a.A : jet.Any {
+    public final /*constructor*/ fun <init>(): a.A
+    internal final class object a.A.<no name provided> : jet.Any {
+        internal final /*constructor*/ fun <init>(): a.A.<no name provided>
+        internal final val P: a.A.<no name provided>.P
+        internal final class a.A.<no name provided>.B : jet.Any {
+            public final /*constructor*/ fun <init>(): a.A.<no name provided>.B
+            internal final class object a.A.<no name provided>.B.<no name provided> : jet.Any {
+                internal final /*constructor*/ fun <init>(): a.A.<no name provided>.B.<no name provided>
+                internal final fun foo(): jet.Tuple0
+            }
+        }
+    }
+}
+internal final val N: a.N
+internal final fun foo(): jet.Tuple0
+// </namespace name="a">
+// <namespace name="b">
+namespace b
+
+internal final class b.A : jet.Any {
+    public final /*constructor*/ fun <init>(): b.A
+    internal final class object b.A.<no name provided> : jet.Any {
+        internal final /*constructor*/ fun <init>(): b.A.<no name provided>
+        internal final val P: b.A.<no name provided>.P
+        internal final class b.A.<no name provided>.B : jet.Any {
+            public final /*constructor*/ fun <init>(): b.A.<no name provided>.B
+            internal final class object b.A.<no name provided>.B.<no name provided> : jet.Any {
+                internal final /*constructor*/ fun <init>(): b.A.<no name provided>.B.<no name provided>
+                internal final fun foo(): jet.Tuple0
+            }
+        }
+    }
+}
+internal final val N: b.N
+internal final fun foo(): jet.Tuple0
+// </namespace name="b">