Secondary constructors resolve

compiler/frontend/src/org/jetbrains/kotlin/psi/JetClass.java

@@ -237,4 +237,18 @@ public class JetClass extends JetTypeParameterListOwnerStub<KotlinClassStub> imp
         }
         return body.getAllDefaultObjects();
     }
+
+    public boolean hasPrimaryConstructor() {
+        return hasExplicitPrimaryConstructor() || !hasSecondaryConstructors();
+    }
+
+    private boolean hasSecondaryConstructors() {
+        return !getSecondaryConstructors().isEmpty();
+    }
+
+    @NotNull
+    public List<JetSecondaryConstructor> getSecondaryConstructors() {
+        JetClassBody body = getBody();
+        return body != null ? body.getSecondaryConstructors() : Collections.<JetSecondaryConstructor>emptyList();
+    }
 }

compiler/frontend/src/org/jetbrains/kotlin/psi/JetClassBody.java

@@ -61,6 +61,11 @@ public class JetClassBody extends JetElementImplStub<KotlinPlaceHolderStub<JetCl
         return findChildrenByType(JetNodeTypes.ANONYMOUS_INITIALIZER);
     }
 
+    @NotNull
+    /* package-protected */ List<JetSecondaryConstructor> getSecondaryConstructors() {
+        return getStubOrPsiChildrenAsList(JetStubElementTypes.SECONDARY_CONSTRUCTOR);
+    }
+
     @NotNull
     public List<JetProperty> getProperties() {
         return getStubOrPsiChildrenAsList(JetStubElementTypes.PROPERTY);

compiler/frontend/src/org/jetbrains/kotlin/resolve/DescriptorResolver.java

@@ -1256,7 +1256,7 @@ public class DescriptorResolver {
             @NotNull JetClass classElement,
             BindingTrace trace
     ) {
-        if (classDescriptor.getKind() == ClassKind.ENUM_ENTRY) return null;
+        if (classDescriptor.getKind() == ClassKind.ENUM_ENTRY || !classElement.hasPrimaryConstructor()) return null;
         return createConstructorDescriptor(
                 scope,
                 classDescriptor,
@@ -1266,6 +1266,25 @@ public class DescriptorResolver {
                 classDescriptor.getTypeConstructor().getParameters(), classElement.getPrimaryConstructorParameters(), trace);
     }
 
+    @NotNull
+    public ConstructorDescriptorImpl resolveSecondaryConstructorDescriptor(
+            @NotNull JetScope scope,
+            @NotNull ClassDescriptor classDescriptor,
+            @NotNull JetSecondaryConstructor constructor,
+            @NotNull BindingTrace trace
+    ) {
+        return createConstructorDescriptor(
+                scope,
+                classDescriptor,
+                false,
+                constructor.getModifierList(),
+                constructor,
+                classDescriptor.getTypeConstructor().getParameters(),
+                constructor.getValueParameters(),
+                trace
+        );
+    }
+
     @NotNull
     public PropertyDescriptor resolvePrimaryConstructorParameterToAProperty(
             @NotNull ClassDescriptor classDescriptor,

compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyClassMemberScope.kt

@@ -262,9 +262,13 @@ public open class LazyClassMemberScope(
 
     override fun getPackage(name: Name): PackageViewDescriptor? = null
 
-    public fun getConstructors(): Set<ConstructorDescriptor> {
-        val constructor = getPrimaryConstructor()
-        return if (constructor != null) setOf(constructor) else setOf()
+    private val secondaryConstructors: NotNullLazyValue<Collection<ConstructorDescriptor>>
+            = c.storageManager.createLazyValue { resolveSecondaryConstructors() }
+
+    public fun getConstructors(): Collection<ConstructorDescriptor> {
+        val result = secondaryConstructors()
+        val primaryConstructor = getPrimaryConstructor()
+        return if (primaryConstructor == null) result else result + primaryConstructor
     }
 
     public fun getPrimaryConstructor(): ConstructorDescriptor? = primaryConstructor()
@@ -278,7 +282,7 @@ public open class LazyClassMemberScope(
                 classOrObject as JetClass
                 val constructor = c.descriptorResolver.resolvePrimaryConstructorDescriptor(
                         thisDescriptor.getScopeForClassHeaderResolution(), thisDescriptor, classOrObject, trace)
-                assert(constructor != null) { "No constructor created for $thisDescriptor" }
+                constructor ?: return null
                 setDeferredReturnType(constructor)
                 return constructor
             }
@@ -291,6 +295,20 @@ public open class LazyClassMemberScope(
         return null
     }
 
+    private fun resolveSecondaryConstructors(): Collection<ConstructorDescriptor> {
+        val classOrObject = declarationProvider.getOwnerInfo().getCorrespondingClassOrObject()
+        if (classOrObject !is JetClass) return emptyList()
+        if (thisDescriptor.getKind().isSingleton()) return emptyList()
+
+        return classOrObject.getSecondaryConstructors().map { constructor ->
+            val descriptor = c.descriptorResolver.resolveSecondaryConstructorDescriptor(
+                    thisDescriptor.getScopeForSecondaryConstructorHeaderResolution(), thisDescriptor, constructor, trace
+            )
+            setDeferredReturnType(descriptor)
+            descriptor
+        }
+    }
+
     protected fun setDeferredReturnType(descriptor: ConstructorDescriptorImpl) {
         descriptor.setReturnType(DeferredType.create(c.storageManager, trace, { thisDescriptor.getDefaultType() }))
     }

compiler/testData/diagnostics/tests/secondaryConstructors/constructorCallType.kt

@@ -0,0 +1,26 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+class A(x: Int) {
+    constructor(x: Double) {}
+    constructor(x: String) {}
+}
+val x1: A = A(1)
+val x2: A = A(1.0)
+val x3: A = A("abc")
+
+class B<R> {
+    constructor(x: String) {}
+    constructor(x: R) {}
+}
+
+val y1: B<Int> = B(1)
+val y2: B<Int> = B("")
+val y3: B<Int> = B<Int>(1)
+val y4: B<Int> = B<Int>("")
+
+val y5: B<String> = <!NONE_APPLICABLE!>B<!><String>(1)
+val y6: B<String> = <!OVERLOAD_RESOLUTION_AMBIGUITY!>B<!><String>("") // TODO: doesn't work here but ok on y8
+val y7: B<String> = <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>B<!>(1)
+val y8: B<String> = B("")
+
+val y9 = B(1)
+val y10 = <!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>B<!>("")

compiler/testData/diagnostics/tests/secondaryConstructors/constructorCallType.txt

@@ -0,0 +1,32 @@
+package
+
+internal val x1: A
+internal val x2: A
+internal val x3: A
+internal val y1: B<kotlin.Int>
+internal val y10: [ERROR : Type for B("")]
+internal val y2: B<kotlin.Int>
+internal val y3: B<kotlin.Int>
+internal val y4: B<kotlin.Int>
+internal val y5: B<kotlin.String>
+internal val y6: B<kotlin.String>
+internal val y7: B<kotlin.String>
+internal val y8: B<kotlin.String>
+internal val y9: B<kotlin.Int>
+
+internal final class A {
+    public constructor A(/*0*/ x: kotlin.Double)
+    public constructor A(/*0*/ x: kotlin.Int)
+    public constructor A(/*0*/ x: kotlin.String)
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+internal final class B</*0*/ R> {
+    public constructor B</*0*/ R>(/*0*/ x: R)
+    public constructor B</*0*/ R>(/*0*/ x: kotlin.String)
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}

compiler/testData/diagnostics/tests/secondaryConstructors/noPrimaryConstructor.kt

@@ -0,0 +1,8 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+class A {
+    constructor(x: Int) {
+
+    }
+}
+
+val x = A(<!NO_VALUE_FOR_PARAMETER!>)<!>

compiler/testData/diagnostics/tests/secondaryConstructors/noPrimaryConstructor.txt

@@ -0,0 +1,10 @@
+package
+
+internal val x: A
+
+internal final class A {
+    public constructor A(/*0*/ x: kotlin.Int)
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}

compiler/testData/resolvedCalls/secondaryConstructors/classWithGenerics.kt

@@ -0,0 +1,5 @@
+class A<T> {
+    constructor(x: T) {}
+}
+
+val y = <caret>A(1)

compiler/testData/resolvedCalls/secondaryConstructors/classWithGenerics.txt

@@ -0,0 +1,19 @@
+class A<T> {
+    constructor(x: T) {}
+}
+
+val y = <caret>A(1)
+
+
+Resolved call:
+
+Candidate descriptor: constructor A<T>(x: T) defined in A
+Resulting descriptor: constructor A<T>(x: Int) defined in A
+
+Explicit receiver kind = NO_EXPLICIT_RECEIVER
+Dispatch receiver = NO_RECEIVER
+Extension receiver = NO_RECEIVER
+
+Value arguments mapping:
+
+SUCCESS  x : Int = 1

compiler/testData/resolvedCalls/secondaryConstructors/classWithGenerics2.kt

@@ -0,0 +1,5 @@
+class A<T, R> {
+    constructor(x: T) {}
+}
+
+val y = <caret>A<Int, String>(1)

compiler/testData/resolvedCalls/secondaryConstructors/classWithGenerics2.txt

@@ -0,0 +1,19 @@
+class A<T, R> {
+    constructor(x: T) {}
+}
+
+val y = <caret>A<Int, String>(1)
+
+
+Resolved call:
+
+Candidate descriptor: constructor A<T, R>(x: T) defined in A
+Resulting descriptor: constructor A<T, R>(x: Int) defined in A
+
+Explicit receiver kind = NO_EXPLICIT_RECEIVER
+Dispatch receiver = NO_RECEIVER
+Extension receiver = NO_RECEIVER
+
+Value arguments mapping:
+
+SUCCESS  x : Int = 1

compiler/testData/resolvedCalls/secondaryConstructors/classWithGenerics3.kt

@@ -0,0 +1,6 @@
+class B<R> {
+    constructor(x: String) {}
+    constructor(x: R) {}
+}
+
+val y8: B<String> = <caret>B("")

compiler/testData/resolvedCalls/secondaryConstructors/classWithGenerics3.txt

@@ -0,0 +1,20 @@
+class B<R> {
+    constructor(x: String) {}
+    constructor(x: R) {}
+}
+
+val y8: B<String> = <caret>B("")
+
+
+Resolved call:
+
+Candidate descriptor: constructor B<R>(x: String) defined in B
+Resulting descriptor: constructor B<R>(x: String) defined in B
+
+Explicit receiver kind = NO_EXPLICIT_RECEIVER
+Dispatch receiver = NO_RECEIVER
+Extension receiver = NO_RECEIVER
+
+Value arguments mapping:
+
+SUCCESS  x : String = ""

compiler/testData/resolvedCalls/secondaryConstructors/explicitPrimaryArgs.kt

@@ -0,0 +1,10 @@
+class A(x: Double) {
+    constructor(x: Int) {
+
+    }
+    constructor(x: String) {
+
+    }
+}
+
+<caret>A(1.0)

compiler/testData/resolvedCalls/secondaryConstructors/explicitPrimaryArgs.txt

@@ -0,0 +1,23 @@
+class A(x: Double) {
+    constructor(x: Int) {
+
+    }
+    constructor(x: String) {
+
+    }
+}
+
+<caret>A(1.0)
+
+
+Resolved call:
+
+Resulting descriptor: constructor A(x: Double) defined in A
+
+Explicit receiver kind = NO_EXPLICIT_RECEIVER
+Dispatch receiver = NO_RECEIVER
+Extension receiver = NO_RECEIVER
+
+Value arguments mapping:
+
+SUCCESS  x : Double = 1.0

compiler/testData/resolvedCalls/secondaryConstructors/explicitPrimaryCallSecondary.kt

@@ -0,0 +1,10 @@
+class A(x: Double) {
+    constructor(x: Int) {
+
+    }
+    constructor(x: String) {
+
+    }
+}
+
+<caret>A("abc")

compiler/testData/resolvedCalls/secondaryConstructors/explicitPrimaryCallSecondary.txt

@@ -0,0 +1,23 @@
+class A(x: Double) {
+    constructor(x: Int) {
+
+    }
+    constructor(x: String) {
+
+    }
+}
+
+<caret>A("abc")
+
+
+Resolved call:
+
+Resulting descriptor: constructor A(x: String) defined in A
+
+Explicit receiver kind = NO_EXPLICIT_RECEIVER
+Dispatch receiver = NO_RECEIVER
+Extension receiver = NO_RECEIVER
+
+Value arguments mapping:
+
+SUCCESS  x : String = "abc"

compiler/testData/resolvedCalls/secondaryConstructors/explicitPrimaryNoArgs.kt

@@ -0,0 +1,10 @@
+class A() {
+    constructor(x: Int) {
+
+    }
+    constructor(x: String) {
+
+    }
+}
+
+<caret>A()

compiler/testData/resolvedCalls/secondaryConstructors/explicitPrimaryNoArgs.txt

@@ -0,0 +1,19 @@
+class A() {
+    constructor(x: Int) {
+
+    }
+    constructor(x: String) {
+
+    }
+}
+
+<caret>A()
+
+
+Resolved call:
+
+Resulting descriptor: constructor A() defined in A
+
+Explicit receiver kind = NO_EXPLICIT_RECEIVER
+Dispatch receiver = NO_RECEIVER
+Extension receiver = NO_RECEIVER

compiler/testData/resolvedCalls/secondaryConstructors/implicitPrimary.kt

@@ -0,0 +1,3 @@
+class A
+
+<caret>A()

compiler/testData/resolvedCalls/secondaryConstructors/implicitPrimary.txt

@@ -0,0 +1,12 @@
+class A
+
+<caret>A()
+
+
+Resolved call:
+
+Resulting descriptor: constructor A() defined in A
+
+Explicit receiver kind = NO_EXPLICIT_RECEIVER
+Dispatch receiver = NO_RECEIVER
+Extension receiver = NO_RECEIVER

compiler/testData/resolvedCalls/secondaryConstructors/overload1.kt

@@ -0,0 +1,10 @@
+class A {
+    constructor(x: Int) {
+
+    }
+    constructor(x: String) {
+
+    }
+}
+
+<caret>A("abc")

compiler/testData/resolvedCalls/secondaryConstructors/overload1.txt

@@ -0,0 +1,23 @@
+class A {
+    constructor(x: Int) {
+
+    }
+    constructor(x: String) {
+
+    }
+}
+
+<caret>A("abc")
+
+
+Resolved call:
+
+Resulting descriptor: constructor A(x: String) defined in A
+
+Explicit receiver kind = NO_EXPLICIT_RECEIVER
+Dispatch receiver = NO_RECEIVER
+Extension receiver = NO_RECEIVER
+
+Value arguments mapping:
+
+SUCCESS  x : String = "abc"

compiler/testData/resolvedCalls/secondaryConstructors/overload2.kt

@@ -0,0 +1,10 @@
+class A {
+    constructor(x: Int) {
+
+    }
+    constructor(x: String) {
+
+    }
+}
+
+<caret>A(1)

compiler/testData/resolvedCalls/secondaryConstructors/overload2.txt

@@ -0,0 +1,23 @@
+class A {
+    constructor(x: Int) {
+
+    }
+    constructor(x: String) {
+
+    }
+}
+
+<caret>A(1)
+
+
+Resolved call:
+
+Resulting descriptor: constructor A(x: Int) defined in A
+
+Explicit receiver kind = NO_EXPLICIT_RECEIVER
+Dispatch receiver = NO_RECEIVER
+Extension receiver = NO_RECEIVER
+
+Value arguments mapping:
+
+SUCCESS  x : Int = 1

compiler/testData/resolvedCalls/secondaryConstructors/overload3.kt

@@ -0,0 +1,10 @@
+class A {
+    constructor(x: Int) {
+
+    }
+    constructor(x: Int, y: String) {
+
+    }
+}
+
+<caret>A(1, "abc")

compiler/testData/resolvedCalls/secondaryConstructors/overload3.txt

@@ -0,0 +1,24 @@
+class A {
+    constructor(x: Int) {
+
+    }
+    constructor(x: Int, y: String) {
+
+    }
+}
+
+<caret>A(1, "abc")
+
+
+Resolved call:
+
+Resulting descriptor: constructor A(x: Int, y: String) defined in A
+
+Explicit receiver kind = NO_EXPLICIT_RECEIVER
+Dispatch receiver = NO_RECEIVER
+Extension receiver = NO_RECEIVER
+
+Value arguments mapping:
+
+SUCCESS  x : Int = 1
+SUCCESS  y : String = "abc"

compiler/testData/resolvedCalls/secondaryConstructors/overloadDefault.kt

@@ -0,0 +1,10 @@
+class A {
+    constructor(x: Int) {
+
+    }
+    constructor(x: Double, y: String = "abc") {
+
+    }
+}
+
+<caret>A(1.0)

compiler/testData/resolvedCalls/secondaryConstructors/overloadDefault.txt

@@ -0,0 +1,23 @@
+class A {
+    constructor(x: Int) {
+
+    }
+    constructor(x: Double, y: String = "abc") {
+
+    }
+}
+
+<caret>A(1.0)
+
+
+Resolved call:
+
+Resulting descriptor: constructor A(x: Double, y: String = ...) defined in A
+
+Explicit receiver kind = NO_EXPLICIT_RECEIVER
+Dispatch receiver = NO_RECEIVER
+Extension receiver = NO_RECEIVER
+
+Value arguments mapping:
+
+SUCCESS  x : Double = 1.0

compiler/testData/resolvedCalls/secondaryConstructors/overloadNamed.kt

@@ -0,0 +1,10 @@
+class A {
+    constructor(x: Int) {
+
+    }
+    constructor(x: Double, y: String = "abc") {
+
+    }
+}
+
+<caret>A(x=1.0)

compiler/testData/resolvedCalls/secondaryConstructors/overloadNamed.txt

@@ -0,0 +1,23 @@
+class A {
+    constructor(x: Int) {
+
+    }
+    constructor(x: Double, y: String = "abc") {
+
+    }
+}
+
+<caret>A(x=1.0)
+
+
+Resolved call:
+
+Resulting descriptor: constructor A(x: Double, y: String = ...) defined in A
+
+Explicit receiver kind = NO_EXPLICIT_RECEIVER
+Dispatch receiver = NO_RECEIVER
+Extension receiver = NO_RECEIVER
+
+Value arguments mapping:
+
+SUCCESS  x : Double = 1.0

compiler/testData/resolvedCalls/secondaryConstructors/simple.kt

@@ -0,0 +1,7 @@
+class A {
+    constructor(x: Int) {
+
+    }
+}
+
+<caret>A(1)

compiler/testData/resolvedCalls/secondaryConstructors/simple.txt

@@ -0,0 +1,20 @@
+class A {
+    constructor(x: Int) {
+
+    }
+}
+
+<caret>A(1)
+
+
+Resolved call:
+
+Resulting descriptor: constructor A(x: Int) defined in A
+
+Explicit receiver kind = NO_EXPLICIT_RECEIVER
+Dispatch receiver = NO_RECEIVER
+Extension receiver = NO_RECEIVER
+
+Value arguments mapping:
+
+SUCCESS  x : Int = 1

compiler/testData/resolvedCalls/secondaryConstructors/varargs.kt

@@ -0,0 +1,5 @@
+class A {
+    constructor(vararg x: Int) {}
+}
+
+val y = <caret>A(0, *intArray(1, 2, 3), 4))

compiler/testData/resolvedCalls/secondaryConstructors/varargs.txt

@@ -0,0 +1,20 @@
+class A {
+    constructor(vararg x: Int) {}
+}
+
+val y = <caret>A(0, *intArray(1, 2, 3), 4))
+
+
+Resolved call:
+
+Resulting descriptor: constructor A(vararg x: Int) defined in A
+
+Explicit receiver kind = NO_EXPLICIT_RECEIVER
+Dispatch receiver = NO_RECEIVER
+Extension receiver = NO_RECEIVER
+
+Value arguments mapping:
+
+SUCCESS  x : IntArray = 0
+SUCCESS  x : IntArray = intArray(1, 2, 3)
+SUCCESS  x : IntArray = 4

compiler/tests/org/jetbrains/kotlin/checkers/JetDiagnosticsTestGenerated.java

@@ -86,6 +86,7 @@ public class JetDiagnosticsTestGenerated extends AbstractJetDiagnosticsTest {
             Tests.Regressions.class,
             Tests.Resolve.class,
             Tests.Scopes.class,
+            Tests.SecondaryConstructors.class,
             Tests.SenselessComparison.class,
             Tests.Shadowing.class,
             Tests.SmartCasts.class,
@@ -10388,6 +10389,27 @@ public class JetDiagnosticsTestGenerated extends AbstractJetDiagnosticsTest {
             }
         }
 
+        @TestMetadata("compiler/testData/diagnostics/tests/secondaryConstructors")
+        @TestDataPath("$PROJECT_ROOT")
+        @RunWith(JUnit3RunnerWithInners.class)
+        public static class SecondaryConstructors extends AbstractJetDiagnosticsTest {
+            public void testAllFilesPresentInSecondaryConstructors() throws Exception {
+                JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/secondaryConstructors"), Pattern.compile("^(.+)\\.kt$"), true);
+            }
+
+            @TestMetadata("constructorCallType.kt")
+            public void testConstructorCallType() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/secondaryConstructors/constructorCallType.kt");
+                doTest(fileName);
+            }
+
+            @TestMetadata("noPrimaryConstructor.kt")
+            public void testNoPrimaryConstructor() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/secondaryConstructors/noPrimaryConstructor.kt");
+                doTest(fileName);
+            }
+        }
+
         @TestMetadata("compiler/testData/diagnostics/tests/senselessComparison")
         @TestDataPath("$PROJECT_ROOT")
         @RunWith(JUnit3RunnerWithInners.class)

compiler/tests/org/jetbrains/kotlin/resolve/calls/ResolvedCallsTestGenerated.java

@@ -39,6 +39,7 @@ import java.util.regex.Pattern;
         ResolvedCallsTestGenerated.ObjectsAndClassObjects.class,
         ResolvedCallsTestGenerated.RealExamples.class,
         ResolvedCallsTestGenerated.Resolve.class,
+        ResolvedCallsTestGenerated.SecondaryConstructors.class,
         ResolvedCallsTestGenerated.ThisOrSuper.class,
 })
 @RunWith(JUnit3RunnerWithInners.class)
@@ -529,6 +530,99 @@ public class ResolvedCallsTestGenerated extends AbstractResolvedCallsTest {
         }
     }
 
+    @TestMetadata("compiler/testData/resolvedCalls/secondaryConstructors")
+    @TestDataPath("$PROJECT_ROOT")
+    @RunWith(JUnit3RunnerWithInners.class)
+    public static class SecondaryConstructors extends AbstractResolvedCallsTest {
+        public void testAllFilesPresentInSecondaryConstructors() throws Exception {
+            JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/resolvedCalls/secondaryConstructors"), Pattern.compile("^(.+)\\.kt$"), true);
+        }
+
+        @TestMetadata("classWithGenerics.kt")
+        public void testClassWithGenerics() throws Exception {
+            String fileName = JetTestUtils.navigationMetadata("compiler/testData/resolvedCalls/secondaryConstructors/classWithGenerics.kt");
+            doTest(fileName);
+        }
+
+        @TestMetadata("classWithGenerics2.kt")
+        public void testClassWithGenerics2() throws Exception {
+            String fileName = JetTestUtils.navigationMetadata("compiler/testData/resolvedCalls/secondaryConstructors/classWithGenerics2.kt");
+            doTest(fileName);
+        }
+
+        @TestMetadata("classWithGenerics3.kt")
+        public void testClassWithGenerics3() throws Exception {
+            String fileName = JetTestUtils.navigationMetadata("compiler/testData/resolvedCalls/secondaryConstructors/classWithGenerics3.kt");
+            doTest(fileName);
+        }
+
+        @TestMetadata("explicitPrimaryArgs.kt")
+        public void testExplicitPrimaryArgs() throws Exception {
+            String fileName = JetTestUtils.navigationMetadata("compiler/testData/resolvedCalls/secondaryConstructors/explicitPrimaryArgs.kt");
+            doTest(fileName);
+        }
+
+        @TestMetadata("explicitPrimaryCallSecondary.kt")
+        public void testExplicitPrimaryCallSecondary() throws Exception {
+            String fileName = JetTestUtils.navigationMetadata("compiler/testData/resolvedCalls/secondaryConstructors/explicitPrimaryCallSecondary.kt");
+            doTest(fileName);
+        }
+
+        @TestMetadata("explicitPrimaryNoArgs.kt")
+        public void testExplicitPrimaryNoArgs() throws Exception {
+            String fileName = JetTestUtils.navigationMetadata("compiler/testData/resolvedCalls/secondaryConstructors/explicitPrimaryNoArgs.kt");
+            doTest(fileName);
+        }
+
+        @TestMetadata("implicitPrimary.kt")
+        public void testImplicitPrimary() throws Exception {
+            String fileName = JetTestUtils.navigationMetadata("compiler/testData/resolvedCalls/secondaryConstructors/implicitPrimary.kt");
+            doTest(fileName);
+        }
+
+        @TestMetadata("overload1.kt")
+        public void testOverload1() throws Exception {
+            String fileName = JetTestUtils.navigationMetadata("compiler/testData/resolvedCalls/secondaryConstructors/overload1.kt");
+            doTest(fileName);
+        }
+
+        @TestMetadata("overload2.kt")
+        public void testOverload2() throws Exception {
+            String fileName = JetTestUtils.navigationMetadata("compiler/testData/resolvedCalls/secondaryConstructors/overload2.kt");
+            doTest(fileName);
+        }
+
+        @TestMetadata("overload3.kt")
+        public void testOverload3() throws Exception {
+            String fileName = JetTestUtils.navigationMetadata("compiler/testData/resolvedCalls/secondaryConstructors/overload3.kt");
+            doTest(fileName);
+        }
+
+        @TestMetadata("overloadDefault.kt")
+        public void testOverloadDefault() throws Exception {
+            String fileName = JetTestUtils.navigationMetadata("compiler/testData/resolvedCalls/secondaryConstructors/overloadDefault.kt");
+            doTest(fileName);
+        }
+
+        @TestMetadata("overloadNamed.kt")
+        public void testOverloadNamed() throws Exception {
+            String fileName = JetTestUtils.navigationMetadata("compiler/testData/resolvedCalls/secondaryConstructors/overloadNamed.kt");
+            doTest(fileName);
+        }
+
+        @TestMetadata("simple.kt")
+        public void testSimple() throws Exception {
+            String fileName = JetTestUtils.navigationMetadata("compiler/testData/resolvedCalls/secondaryConstructors/simple.kt");
+            doTest(fileName);
+        }
+
+        @TestMetadata("varargs.kt")
+        public void testVarargs() throws Exception {
+            String fileName = JetTestUtils.navigationMetadata("compiler/testData/resolvedCalls/secondaryConstructors/varargs.kt");
+            doTest(fileName);
+        }
+    }
+
     @TestMetadata("compiler/testData/resolvedCalls/thisOrSuper")
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)