From 46737dfb11b628bd045c850169156b65a398469b Mon Sep 17 00:00:00 2001 From: Andrey Breslav Date: Mon, 23 Jul 2012 16:41:23 +0400 Subject: [PATCH] Don't create constructors for traits --- .../jet/lang/resolve/BodyResolver.java | 1 + .../jet/lang/resolve/DeclarationResolver.java | 5 +- .../diagnostics/tests/TraitSupertypeList.kt | 2 +- .../diagnostics/SupertypeListChecks.txt | 50 +++++++++++++++++++ .../diagnostics/TraitSupertypeList.txt | 15 ++++++ .../controlFlowAnalysis/kt1185enums.txt | 46 +++++++++++++++++ 6 files changed, 116 insertions(+), 3 deletions(-) create mode 100644 compiler/testData/lazyResolve/diagnostics/SupertypeListChecks.txt create mode 100644 compiler/testData/lazyResolve/diagnostics/TraitSupertypeList.txt create mode 100644 compiler/testData/lazyResolve/diagnostics/controlFlowAnalysis/kt1185enums.txt diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BodyResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BodyResolver.java index 2a0ce001266..284c976b5a0 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BodyResolver.java +++ b/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 results = callResolver.resolveFunctionCall( 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 c3fdd406f96..1a805f5e54d 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DeclarationResolver.java +++ b/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); + } } } diff --git a/compiler/testData/diagnostics/tests/TraitSupertypeList.kt b/compiler/testData/diagnostics/tests/TraitSupertypeList.kt index 60c9ca79205..d9dba99bdeb 100644 --- a/compiler/testData/diagnostics/tests/TraitSupertypeList.kt +++ b/compiler/testData/diagnostics/tests/TraitSupertypeList.kt @@ -6,5 +6,5 @@ trait Foo() : bar() trait Foo2 : bar, Foo { } -open class Foo1() : bar(), bar, Foo, Foo() {} +open class Foo1() : bar(), bar, Foo, Foo() {} open class Foo12 : bar(), bar {} \ No newline at end of file diff --git a/compiler/testData/lazyResolve/diagnostics/SupertypeListChecks.txt b/compiler/testData/lazyResolve/diagnostics/SupertypeListChecks.txt new file mode 100644 index 00000000000..0f5ef169cd4 --- /dev/null +++ b/compiler/testData/lazyResolve/diagnostics/SupertypeListChecks.txt @@ -0,0 +1,50 @@ +namespace + +internal final class C1 : jet.Any { + public final /*constructor*/ fun (): C1 +} +internal open class C2 : jet.Any { + public final /*constructor*/ fun (): C2 +} +internal open class C3 : jet.Any { + public final /*constructor*/ fun (): C3 +} +internal final class CTest1 : OC1 { + public final /*constructor*/ fun (): CTest1 +} +internal final class CTest2 : C2 { + public final /*constructor*/ fun (): CTest2 +} +internal final class CTest3 : C2, C3 { + public final /*constructor*/ fun (): CTest3 +} +internal final class CTest4 : T1 { + public final /*constructor*/ fun (): CTest4 +} +internal final class CTest5 : T1, T1 { + public final /*constructor*/ fun (): CTest5 +} +internal final class CTest6 : C1 { + public final /*constructor*/ fun (): CTest6 +} +internal open class OC1 : jet.Any { + public final /*constructor*/ fun (): OC1 +} +internal abstract trait T1 : jet.Any { +} +internal abstract trait T2 : 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 { +} diff --git a/compiler/testData/lazyResolve/diagnostics/TraitSupertypeList.txt b/compiler/testData/lazyResolve/diagnostics/TraitSupertypeList.txt new file mode 100644 index 00000000000..3eefaa8cae9 --- /dev/null +++ b/compiler/testData/lazyResolve/diagnostics/TraitSupertypeList.txt @@ -0,0 +1,15 @@ +namespace + +internal abstract trait Foo : bar, bar, bar { +} +internal open class Foo1 : bar, bar, Foo, Foo { + public final /*constructor*/ fun (): Foo1 +} +internal open class Foo12 : bar, bar { + public final /*constructor*/ fun (): Foo12 +} +internal abstract trait Foo2 : bar, Foo { +} +internal open class bar : jet.Any { + public final /*constructor*/ fun (): bar +} diff --git a/compiler/testData/lazyResolve/diagnostics/controlFlowAnalysis/kt1185enums.txt b/compiler/testData/lazyResolve/diagnostics/controlFlowAnalysis/kt1185enums.txt new file mode 100644 index 00000000000..2557adb922f --- /dev/null +++ b/compiler/testData/lazyResolve/diagnostics/controlFlowAnalysis/kt1185enums.txt @@ -0,0 +1,46 @@ +namespace + +// +namespace kt1185 + +internal final enum class kt1185.Color : jet.Any { + public final /*constructor*/ fun (/*0*/ rgb: jet.Int): kt1185.Color + internal final val rgb: jet.Int + internal final class object kt1185.Color. { + internal final /*constructor*/ fun (): kt1185.Color. + internal final val BLUE: kt1185.Color..BLUE + internal final val GREEN: kt1185.Color..GREEN + internal final val RED: kt1185.Color..RED + } +} +internal final enum class kt1185.Direction : jet.Any { + public final /*constructor*/ fun (): kt1185.Direction + internal final class object kt1185.Direction. { + internal final /*constructor*/ fun (): kt1185.Direction. + internal final val EAST: kt1185.Direction..EAST + internal final val NORTH: kt1185.Direction..NORTH + internal final val SOUTH: kt1185.Direction..SOUTH + internal final val WEST: kt1185.Direction..WEST + } +} +internal final enum class kt1185.MyEnum : kt1185.SomeEnum { + public final /*constructor*/ fun (): kt1185.MyEnum + internal final class object kt1185.MyEnum. { + internal final /*constructor*/ fun (): kt1185.MyEnum. + internal final val A: kt1185.MyEnum..A + internal final val B: kt1185.MyEnum..B + } +} +internal open enum class kt1185.SomeEnum : jet.Any { + public final /*constructor*/ fun (): kt1185.SomeEnum + internal final class object kt1185.SomeEnum. { + internal final /*constructor*/ fun (): kt1185.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 +//