Don't create constructors for traits

compiler/frontend/src/org/jetbrains/jet/lang/resolve/BodyResolver.java

@@ -202,6 +202,7 @@ public class BodyResolver {
                 if (typeReference == null) return;
                 if (descriptor.getUnsubstitutedPrimaryConstructor() == null) {
                     assert descriptor.getKind() == ClassKind.TRAIT;
+                    recordSupertype(typeReference, trace.getBindingContext().get(BindingContext.TYPE, typeReference));
                     return;
                 }
                 OverloadResolutionResults<FunctionDescriptor> results = callResolver.resolveFunctionCall(

compiler/frontend/src/org/jetbrains/jet/lang/resolve/DeclarationResolver.java

@@ -221,7 +221,6 @@ public class DeclarationResolver {
             if (primaryConstructorParameterList != null) {
                 trace.report(CONSTRUCTOR_IN_TRAIT.on(primaryConstructorParameterList));
             }
-            if (!klass.hasPrimaryConstructor()) return;
         }
 
         // TODO : not all the parameters are real properties
@@ -244,7 +243,9 @@ public class DeclarationResolver {
                     context.getPrimaryConstructorParameterProperties().put(parameter, propertyDescriptor);
                 }
             }
-            classDescriptor.setPrimaryConstructor(constructorDescriptor, trace);
+            if (classDescriptor.getKind() != ClassKind.TRAIT) {
+                classDescriptor.setPrimaryConstructor(constructorDescriptor, trace);
+            }
         }
     }
 

compiler/testData/diagnostics/tests/TraitSupertypeList.kt

@@ -6,5 +6,5 @@ trait Foo<!CONSTRUCTOR_IN_TRAIT!>()<!> : bar<!SUPERTYPE_INITIALIZED_IN_TRAIT!>()
 trait Foo2 : bar, Foo {
 }
 
-open class Foo1() : bar(), <!SUPERTYPE_NOT_INITIALIZED_DEFAULT, MANY_CLASSES_IN_SUPERTYPE_LIST, SUPERTYPE_APPEARS_TWICE!>bar<!>, Foo, <!SUPERTYPE_APPEARS_TWICE!>Foo<!><!CONSTRUCTOR_IN_TRAIT!>()<!> {}
+open class Foo1() : bar(), <!SUPERTYPE_NOT_INITIALIZED_DEFAULT, MANY_CLASSES_IN_SUPERTYPE_LIST, SUPERTYPE_APPEARS_TWICE!>bar<!>, Foo, <!SUPERTYPE_APPEARS_TWICE!>Foo<!><!NO_CONSTRUCTOR!>()<!> {}
 open class Foo12 : bar(), <!SUPERTYPE_NOT_INITIALIZED_DEFAULT, MANY_CLASSES_IN_SUPERTYPE_LIST, SUPERTYPE_APPEARS_TWICE!>bar<!> {}

compiler/testData/lazyResolve/diagnostics/SupertypeListChecks.txt

@@ -0,0 +1,50 @@
+namespace <root>
+
+internal final class C1 : jet.Any {
+    public final /*constructor*/ fun <init>(): C1
+}
+internal open class C2 : jet.Any {
+    public final /*constructor*/ fun <init>(): C2
+}
+internal open class C3 : jet.Any {
+    public final /*constructor*/ fun <init>(): C3
+}
+internal final class CTest1 : OC1 {
+    public final /*constructor*/ fun <init>(): CTest1
+}
+internal final class CTest2 : C2 {
+    public final /*constructor*/ fun <init>(): CTest2
+}
+internal final class CTest3 : C2, C3 {
+    public final /*constructor*/ fun <init>(): CTest3
+}
+internal final class CTest4 : T1 {
+    public final /*constructor*/ fun <init>(): CTest4
+}
+internal final class CTest5 : T1, T1 {
+    public final /*constructor*/ fun <init>(): CTest5
+}
+internal final class CTest6 : C1 {
+    public final /*constructor*/ fun <init>(): CTest6
+}
+internal open class OC1 : jet.Any {
+    public final /*constructor*/ fun <init>(): OC1
+}
+internal abstract trait T1 : jet.Any {
+}
+internal abstract trait T2</*0*/ T : jet.Any?> : jet.Any {
+}
+internal abstract trait Test : jet.Any {
+}
+internal abstract trait Test1 : C2 {
+}
+internal abstract trait Test2 : C2 {
+}
+internal abstract trait Test3 : C2, C3 {
+}
+internal abstract trait Test4 : T1 {
+}
+internal abstract trait Test5 : T1, T1 {
+}
+internal abstract trait Test6 : C1 {
+}

compiler/testData/lazyResolve/diagnostics/TraitSupertypeList.txt

@@ -0,0 +1,15 @@
+namespace <root>
+
+internal abstract trait Foo : bar, bar, bar {
+}
+internal open class Foo1 : bar, bar, Foo, Foo {
+    public final /*constructor*/ fun <init>(): Foo1
+}
+internal open class Foo12 : bar, bar {
+    public final /*constructor*/ fun <init>(): Foo12
+}
+internal abstract trait Foo2 : bar, Foo {
+}
+internal open class bar : jet.Any {
+    public final /*constructor*/ fun <init>(): bar
+}

compiler/testData/lazyResolve/diagnostics/controlFlowAnalysis/kt1185enums.txt

@@ -0,0 +1,46 @@
+namespace <root>
+
+// <namespace name="kt1185">
+namespace kt1185
+
+internal final enum class kt1185.Color : jet.Any {
+    public final /*constructor*/ fun <init>(/*0*/ rgb: jet.Int): kt1185.Color
+    internal final val rgb: jet.Int
+    internal final class object kt1185.Color.<class-object-for-Color> {
+        internal final /*constructor*/ fun <init>(): kt1185.Color.<class-object-for-Color>
+        internal final val BLUE: kt1185.Color.<class-object-for-Color>.BLUE
+        internal final val GREEN: kt1185.Color.<class-object-for-Color>.GREEN
+        internal final val RED: kt1185.Color.<class-object-for-Color>.RED
+    }
+}
+internal final enum class kt1185.Direction : jet.Any {
+    public final /*constructor*/ fun <init>(): kt1185.Direction
+    internal final class object kt1185.Direction.<class-object-for-Direction> {
+        internal final /*constructor*/ fun <init>(): kt1185.Direction.<class-object-for-Direction>
+        internal final val EAST: kt1185.Direction.<class-object-for-Direction>.EAST
+        internal final val NORTH: kt1185.Direction.<class-object-for-Direction>.NORTH
+        internal final val SOUTH: kt1185.Direction.<class-object-for-Direction>.SOUTH
+        internal final val WEST: kt1185.Direction.<class-object-for-Direction>.WEST
+    }
+}
+internal final enum class kt1185.MyEnum : kt1185.SomeEnum {
+    public final /*constructor*/ fun <init>(): kt1185.MyEnum
+    internal final class object kt1185.MyEnum.<class-object-for-MyEnum> {
+        internal final /*constructor*/ fun <init>(): kt1185.MyEnum.<class-object-for-MyEnum>
+        internal final val A: kt1185.MyEnum.<class-object-for-MyEnum>.A
+        internal final val B: kt1185.MyEnum.<class-object-for-MyEnum>.B
+    }
+}
+internal open enum class kt1185.SomeEnum : jet.Any {
+    public final /*constructor*/ fun <init>(): kt1185.SomeEnum
+    internal final class object kt1185.SomeEnum.<class-object-for-SomeEnum> {
+        internal final /*constructor*/ fun <init>(): kt1185.SomeEnum.<class-object-for-SomeEnum>
+    }
+}
+internal final fun bar(/*0*/ c: kt1185.Color): jet.Int
+internal final fun bar1(/*0*/ c: kt1185.Color): jet.Int
+internal final fun foo(/*0*/ d: kt1185.Direction): jet.Int
+internal final fun foo1(/*0*/ d: kt1185.Direction): jet.Int
+internal final fun g(/*0*/ me: kt1185.SomeEnum): jet.Int
+internal final fun t2(/*0*/ me: kt1185.MyEnum): jet.Int
+// </namespace name="kt1185">