Cast findViewById() result to Views safely

(cherry picked from commit 311b3cc)

.idea/ant.xml

@@ -13,5 +13,6 @@
     </buildFile>
     <buildFile url="file://$PROJECT_DIR$/pluginPublisher/TeamCityPluginPublisher.xml" />
     <buildFile url="file://$PROJECT_DIR$/idea-runner/runner.xml" />
+    <buildFile url="file://$PROJECT_DIR$/replicate_versions.xml" />
   </component>
 </project>

.idea/artifacts/KotlinPlugin.xml

@@ -26,7 +26,6 @@
           <element id="module-output" name="idea-jps-common" />
           <element id="module-output" name="preloader" />
           <element id="module-output" name="serialization" />
-          <element id="module-output" name="serialization.js" />
           <element id="module-output" name="serialization.jvm" />
           <element id="module-output" name="backend-common" />
           <element id="library" level="project" name="builtins" />
@@ -40,6 +39,7 @@
           <element id="module-output" name="ide-common" />
           <element id="file-copy" path="$PROJECT_DIR$/resources/kotlinManifest.properties" />
           <element id="module-output" name="kotlin-android-plugin" />
+          <element id="module-output" name="js.serializer" />
         </element>
         <element id="library" level="project" name="javax.inject" />
         <element id="directory" name="jps">

.idea/modules.xml

@@ -49,7 +49,6 @@
       <module fileurl="file://$PROJECT_DIR$/core/reflection.jvm/reflection.jvm.iml" filepath="$PROJECT_DIR$/core/reflection.jvm/reflection.jvm.iml" group="core" />
       <module fileurl="file://$PROJECT_DIR$/core/runtime.jvm/runtime.jvm.iml" filepath="$PROJECT_DIR$/core/runtime.jvm/runtime.jvm.iml" group="core" />
       <module fileurl="file://$PROJECT_DIR$/core/serialization/serialization.iml" filepath="$PROJECT_DIR$/core/serialization/serialization.iml" group="core" />
-      <module fileurl="file://$PROJECT_DIR$/core/serialization.js/serialization.js.iml" filepath="$PROJECT_DIR$/core/serialization.js/serialization.js.iml" group="core" />
       <module fileurl="file://$PROJECT_DIR$/core/serialization.jvm/serialization.jvm.iml" filepath="$PROJECT_DIR$/core/serialization.jvm/serialization.jvm.iml" group="core" />
       <module fileurl="file://$PROJECT_DIR$/compiler/util/util.iml" filepath="$PROJECT_DIR$/compiler/util/util.iml" />
       <module fileurl="file://$PROJECT_DIR$/core/util.runtime/util.runtime.iml" filepath="$PROJECT_DIR$/core/util.runtime/util.runtime.iml" group="core" />

TeamCityBuild.xml

@@ -1,5 +1,6 @@
 <project name="Jet CI Steps" default="none">
     <import file="build.xml" optional="false"/>
+    <import file="replicate_versions.xml" optional="false"/>
 
     <property name="build.number" value="snapshot"/>
     <property name="jdk16.home" value="${java.home}"/>
@@ -12,6 +13,10 @@
     <property name="plugin.xml.bk" value="${version_substitute_dir}/plugin.xml.bk"/>
     <property name="plugin.xml.versioned" value="${plugin.xml}.versioned" />
 
+    <property name="android-extensions.plugin.xml" value="plugins/android-idea-plugin/src/META-INF/plugin.xml"/>
+    <property name="android-extensions.plugin.xml.bk" value="${version_substitute_dir}/kotlin-android-extensions.plugin.xml.bk"/>
+    <property name="android-extensions.plugin.xml.versioned" value="${android-extensions.plugin.xml}.versioned" />
+
     <property name="compiler.version.java" value="compiler/cli/cli-common/src/org/jetbrains/kotlin/cli/common/KotlinVersion.java"/>
     <property name="compiler.version.java.bk" value="${version_substitute_dir}/KotlinVersion.java.bk"/>
     <property name="compiler.version.java.versioned" value="${compiler.version.java}.versioned" />
@@ -82,15 +87,24 @@
           target.file.versioned="${plugin.xml.versioned}"
           test.string="&lt;version&gt;@snapshot@&lt;/version&gt;"/>
 
+      <substituteVersionInFile
+          target.file="${android-extensions.plugin.xml}"
+          target.file.bk="${android-extensions.plugin.xml.bk}"
+          target.file.versioned="${android-extensions.plugin.xml.versioned}"
+          test.string="&lt;version&gt;@snapshot@&lt;/version&gt;"/>
+
       <substituteVersionInFile
           target.file="${compiler.version.java}"
           target.file.bk="${compiler.version.java.bk}"
           target.file.versioned="${compiler.version.java.versioned}"
           test.string="public static final String VERSION = &quot;@snapshot@&quot;;"/>
+
+      <replicateIdeaVersion target.file="${android-extensions.plugin.xml}" />
     </target>
 
   <target name="revertTemplateFiles">
       <copy file="${plugin.xml.bk}" tofile="${plugin.xml}" overwrite="true"/>
+      <copy file="${android-extensions.plugin.xml.bk}" tofile="${android-extensions.plugin.xml}" overwrite="true"/>
       <copy file="${compiler.version.java.bk}" tofile="${compiler.version.java}" overwrite="true"/>
 
       <delete dir="${version_substitute_dir}" quiet="true"/>

build.xml

@@ -99,7 +99,6 @@
         <include name="core/descriptors/src"/>
         <include name="core/serialization/src"/>
         <include name="core/descriptor.loader.java/src"/>
-        <include name="core/serialization.js/src"/>
         <include name="core/serialization.jvm/src"/>
         <include name="core/util.runtime/src"/>
         <include name="compiler/frontend/src"/>
@@ -127,7 +126,6 @@
         <include name="serialization/**"/>
         <include name="descriptor.loader.java/**"/>
         <include name="frontend.java/**"/>
-        <include name="serialization.js/**"/>
         <include name="serialization.jvm/**"/>
         <include name="backend/**"/>
         <include name="backend-common/**"/>
@@ -194,7 +192,6 @@
             <fileset dir="core/descriptors/src"/>
             <fileset dir="core/descriptor.loader.java/src"/>
             <fileset dir="core/serialization/src"/>
-            <fileset dir="core/serialization.js/src"/>
             <fileset dir="core/serialization.jvm/src"/>
             <fileset dir="core/util.runtime/src"/>
             <fileset dir="compiler/frontend/src"/>

compiler/backend/src/org/jetbrains/kotlin/codegen/ExpressionCodegen.java

@@ -1913,8 +1913,9 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
                 ExpressionCodegenExtension.Context context = new ExpressionCodegenExtension.Context(typeMapper, v);
                 JetType returnType = propertyDescriptor.getReturnType();
                 for (ExpressionCodegenExtension extension : codegenExtensions) {
-                    if (returnType != null && extension.apply(receiver, resolvedCall, context)) {
-                        return StackValue.onStack(typeMapper.mapType(returnType));
+                    if (returnType != null) {
+                        StackValue value = extension.applyProperty(receiver, resolvedCall, context);
+                        if (value != null) return value;
                     }
                 }
             }
@@ -2352,7 +2353,7 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
             if (!codegenExtensions.isEmpty()) {
                 ExpressionCodegenExtension.Context context = new ExpressionCodegenExtension.Context(typeMapper, v);
                 for (ExpressionCodegenExtension extension : codegenExtensions) {
-                    if (extension.apply(receiver, resolvedCall, context)) return;
+                    if (extension.applyFunction(receiver, resolvedCall, context)) return;
                 }
             }
 

compiler/backend/src/org/jetbrains/kotlin/codegen/ImplementationBodyCodegen.java

@@ -1176,7 +1176,9 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
         JetSecondaryConstructor constructor =
                 (JetSecondaryConstructor) DescriptorToSourceUtils.descriptorToDeclaration(constructorDescriptor);
         assert constructor != null;
-        codegen.gen(constructor.getBodyExpression(), Type.VOID_TYPE);
+        if (constructor.hasBody()) {
+            codegen.gen(constructor.getBodyExpression(), Type.VOID_TYPE);
+        }
 
         iv.visitInsn(RETURN);
     }

compiler/backend/src/org/jetbrains/kotlin/codegen/extensions/ExpressionCodegenExtension.kt

@@ -35,9 +35,17 @@ public trait ExpressionCodegenExtension {
             public val v: InstructionAdapter
     )
 
-    // Function is responsible to put the value on stack by itself.
-    // Returns false if not applicable, and if stack was not modified.
-    public fun apply(receiver: StackValue, resolvedCall: ResolvedCall<*>, c: Context): Boolean
+    /**
+     *  Used for generating custom byte code for the property value obtain. This function has lazy semantics.
+     *  Returns new stack value.
+     */
+    public fun applyProperty(receiver: StackValue, resolvedCall: ResolvedCall<*>, c: Context): StackValue? = null
+
+    /**
+     *  Used for generating custom byte code for the function call. This function has non-lazy semantics.
+     *  Returns true if the stack was modified.
+     */
+    public fun applyFunction(receiver: StackValue, resolvedCall: ResolvedCall<*>, c: Context): Boolean = false
 
     public fun generateClassSyntheticParts(
             classBuilder: ClassBuilder,

compiler/frontend.java/src/org/jetbrains/kotlin/load/kotlin/KotlinJvmCheckerProvider.kt

@@ -17,7 +17,7 @@
 package org.jetbrains.kotlin.load.kotlin
 
 import org.jetbrains.kotlin.resolve.AdditionalCheckerProvider
-import org.jetbrains.kotlin.resolve.AnnotationChecker
+import org.jetbrains.kotlin.resolve.DeclarationChecker
 import org.jetbrains.kotlin.resolve.annotations.hasPlatformStaticAnnotation
 import org.jetbrains.kotlin.resolve.DescriptorUtils
 import org.jetbrains.kotlin.descriptors.ClassKind
@@ -59,12 +59,12 @@ import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.types.expressions.SenselessComparisonChecker
 
 public object KotlinJvmCheckerProvider : AdditionalCheckerProvider(
-        additionalAnnotationCheckers = listOf(PlatformStaticAnnotationChecker(), LocalFunInlineChecker(), ReifiedTypeParameterAnnotationChecker(), NativeFunChecker()),
+        additionalDeclarationCheckers = listOf(PlatformStaticAnnotationChecker(), LocalFunInlineChecker(), ReifiedTypeParameterAnnotationChecker(), NativeFunChecker()),
         additionalCallCheckers = listOf(NeedSyntheticChecker()),
         additionalTypeCheckers = listOf(JavaNullabilityWarningsChecker())
 )
 
-public class LocalFunInlineChecker : AnnotationChecker {
+public class LocalFunInlineChecker : DeclarationChecker {
 
     override fun check(declaration: JetDeclaration, descriptor: DeclarationDescriptor, diagnosticHolder: DiagnosticSink) {
         if (descriptor.hasInlineAnnotation() &&
@@ -76,7 +76,7 @@ public class LocalFunInlineChecker : AnnotationChecker {
     }
 }
 
-public class PlatformStaticAnnotationChecker : AnnotationChecker {
+public class PlatformStaticAnnotationChecker : DeclarationChecker {
 
     override fun check(declaration: JetDeclaration, descriptor: DeclarationDescriptor, diagnosticHolder: DiagnosticSink) {
         if (descriptor.hasPlatformStaticAnnotation()) {
@@ -116,7 +116,7 @@ public class PlatformStaticAnnotationChecker : AnnotationChecker {
     }
 }
 
-public class ReifiedTypeParameterAnnotationChecker : AnnotationChecker {
+public class ReifiedTypeParameterAnnotationChecker : DeclarationChecker {
 
     override fun check(declaration: JetDeclaration, descriptor: DeclarationDescriptor, diagnosticHolder: DiagnosticSink) {
         if (descriptor.hasIntrinsicAnnotation()) return

compiler/frontend.java/src/org/jetbrains/kotlin/load/kotlin/native.kt

@@ -17,13 +17,15 @@
 package org.jetbrains.kotlin.load.kotlin.nativeDeclarations
 
 import org.jetbrains.kotlin.resolve.DescriptorUtils
-import org.jetbrains.kotlin.resolve.AnnotationChecker
+import org.jetbrains.kotlin.resolve.DeclarationChecker
 import org.jetbrains.kotlin.psi.JetDeclaration
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 import org.jetbrains.kotlin.diagnostics.DiagnosticSink
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor
+import org.jetbrains.kotlin.descriptors.ConstructorDescriptor
 import org.jetbrains.kotlin.descriptors.Modality
+import org.jetbrains.kotlin.diagnostics.Errors
 import org.jetbrains.kotlin.resolve.jvm.diagnostics.ErrorsJvm
 import org.jetbrains.kotlin.psi.JetDeclarationWithBody
 import org.jetbrains.kotlin.resolve.annotations.hasInlineAnnotation
@@ -38,7 +40,7 @@ public fun DeclarationDescriptor.hasNativeAnnotation(): Boolean {
 
 public class SuppressNoBodyErrorsForNativeDeclarations : SuppressDiagnosticsByAnnotations(FUNCTION_NO_BODY_ERRORS, NATIVE_ANNOTATION_CLASS_NAME)
 
-public class NativeFunChecker : AnnotationChecker {
+public class NativeFunChecker : DeclarationChecker {
     override fun check(declaration: JetDeclaration, descriptor: DeclarationDescriptor, diagnosticHolder: DiagnosticSink) {
         if (!descriptor.hasNativeAnnotation()) return
 
@@ -50,7 +52,10 @@ public class NativeFunChecker : AnnotationChecker {
             diagnosticHolder.report(ErrorsJvm.NATIVE_DECLARATION_CANNOT_BE_ABSTRACT.on(declaration))
         }
 
-        if (declaration is JetDeclarationWithBody && declaration.hasBody()) {
+        if (descriptor is ConstructorDescriptor) {
+            diagnosticHolder.report(Errors.INAPPLICABLE_ANNOTATION.on(declaration));
+        }
+        else if (declaration is JetDeclarationWithBody && declaration.hasBody()) {
             diagnosticHolder.report(ErrorsJvm.NATIVE_DECLARATION_CANNOT_HAVE_BODY.on(declaration))
         }
 

compiler/frontend/src/org/jetbrains/kotlin/cfg/JetControlFlowProcessor.java

@@ -1441,10 +1441,7 @@ public class JetControlFlowProcessor {
             processParameters(constructor.getValueParameters());
             generateCallOrMarkUnresolved(constructor.getDelegationCall());
 
-            if (constructor.getDelegationCall() != null &&
-                constructor.getDelegationCall().getCalleeExpression() != null &&
-                !constructor.getDelegationCall().getCalleeExpression().isThis()
-            ) {
+            if (!constructor.getDelegationCall().isCallToThis()) {
                 generateClassOrObjectInitializers(classOrObject);
             }
 

compiler/frontend/src/org/jetbrains/kotlin/diagnostics/Errors.java

@@ -155,8 +155,7 @@ public interface Errors {
 
     // Secondary constructors
 
-    DiagnosticFactory0<JetConstructorDelegationCall> CYCLIC_CONSTRUCTOR_DELEGATION_CALL =
-            DiagnosticFactory0.create(ERROR, PositioningStrategies.SECONDARY_CONSTRUCTOR_DELEGATION_CALL);
+    DiagnosticFactory0<JetConstructorDelegationReferenceExpression> CYCLIC_CONSTRUCTOR_DELEGATION_CALL = DiagnosticFactory0.create(ERROR);
 
     DiagnosticFactory0<JetSecondaryConstructor> SECONDARY_CONSTRUCTOR_IN_OBJECT = DiagnosticFactory0.create(ERROR);
     DiagnosticFactory0<JetDelegatorToSuperCall> SUPERTYPE_INITIALIZED_WITHOUT_PRIMARY_CONSTRUCTOR = DiagnosticFactory0.create(ERROR);
@@ -165,10 +164,12 @@ public interface Errors {
     DiagnosticFactory0<JetConstructorDelegationCall> PRIMARY_CONSTRUCTOR_DELEGATION_CALL_EXPECTED =
             DiagnosticFactory0.create(ERROR, PositioningStrategies.SECONDARY_CONSTRUCTOR_DELEGATION_CALL);
 
-    DiagnosticFactory0<JetConstructorDelegationCall> DELEGATION_SUPER_CALL_IN_ENUM_CONSTRUCTOR =
-            DiagnosticFactory0.create(ERROR, PositioningStrategies.SECONDARY_CONSTRUCTOR_DELEGATION_CALL);
+    DiagnosticFactory0<JetConstructorDelegationReferenceExpression> DELEGATION_SUPER_CALL_IN_ENUM_CONSTRUCTOR =
+            DiagnosticFactory0.create(ERROR);
 
     DiagnosticFactory0<PsiElement> PRIMARY_CONSTRUCTOR_REQUIRED_FOR_DATA_CLASS = DiagnosticFactory0.create(ERROR);
+    DiagnosticFactory0<JetConstructorDelegationCall> EXPLICIT_DELEGATION_CALL_REQUIRED =
+            DiagnosticFactory0.create(ERROR, PositioningStrategies.SECONDARY_CONSTRUCTOR_DELEGATION_CALL);
 
     // Trait-specific
 
@@ -411,8 +412,7 @@ public interface Errors {
     DiagnosticFactory0<JetExpression> NOT_A_CLASS = DiagnosticFactory0.create(ERROR);
 
     DiagnosticFactory1<PsiElement, Collection<? extends ResolvedCall<?>>> OVERLOAD_RESOLUTION_AMBIGUITY = DiagnosticFactory1.create(ERROR);
-    DiagnosticFactory1<PsiElement, Collection<? extends ResolvedCall<?>>> NONE_APPLICABLE =
-            DiagnosticFactory1.create(ERROR, PositioningStrategies.SECONDARY_CONSTRUCTOR_DELEGATION_CALL_OR_DEFAULT);
+    DiagnosticFactory1<PsiElement, Collection<? extends ResolvedCall<?>>> NONE_APPLICABLE = DiagnosticFactory1.create(ERROR);
     DiagnosticFactory1<PsiElement, Collection<? extends ResolvedCall<?>>> CANNOT_COMPLETE_RESOLVE = DiagnosticFactory1.create(ERROR);
     DiagnosticFactory1<PsiElement, Collection<? extends ResolvedCall<?>>> UNRESOLVED_REFERENCE_WRONG_RECEIVER = DiagnosticFactory1.create(ERROR);
 

compiler/frontend/src/org/jetbrains/kotlin/diagnostics/PositioningStrategies.kt

@@ -62,6 +62,9 @@ public object PositioningStrategies {
                             element.getNameIdentifier() ?: element.getObjectKeyword()
                     )
                 }
+                is JetConstructorDelegationCall -> {
+                    return SECONDARY_CONSTRUCTOR_DELEGATION_CALL.mark(element)
+                }
                 else -> {
                     return super.mark(element)
                 }
@@ -415,24 +418,12 @@ public object PositioningStrategies {
     public val SECONDARY_CONSTRUCTOR_DELEGATION_CALL: PositioningStrategy<JetConstructorDelegationCall> =
             object : PositioningStrategy<JetConstructorDelegationCall>() {
                 override fun mark(element: JetConstructorDelegationCall): List<TextRange> {
-                    if (element.getCalleeExpression()?.isEmpty() ?: false) {
+                    if (element.isImplicit()) {
                         val constructor = element.getStrictParentOfType<JetSecondaryConstructor>()!!
-                        return markElement(constructor.getConstructorKeyword())
+                        val valueParameterList = constructor.getValueParameterList() ?: return markElement(constructor)
+                        return markRange(constructor.getConstructorKeyword(), valueParameterList.getLastChild())
                     }
                     return markElement(element.getCalleeExpression() ?: element)
                 }
             }
-
-    public val SECONDARY_CONSTRUCTOR_DELEGATION_CALL_OR_DEFAULT: PositioningStrategy<PsiElement> =
-            object : PositioningStrategy<PsiElement>() {
-                override fun mark(element: PsiElement): List<TextRange> {
-                    val parent = element.getParent()
-                    if (parent is JetConstructorDelegationCall) {
-                        return SECONDARY_CONSTRUCTOR_DELEGATION_CALL.mark(parent)
-                    }
-                    else {
-                        return DEFAULT.mark(element)
-                    }
-                }
-            }
 }

compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DefaultErrorMessages.java

@@ -425,6 +425,8 @@ public class DefaultErrorMessages {
         MAP.put(PRIMARY_CONSTRUCTOR_DELEGATION_CALL_EXPECTED, "Primary constructor call expected");
         MAP.put(DELEGATION_SUPER_CALL_IN_ENUM_CONSTRUCTOR, "Call to super is not allowed in enum constructor");
         MAP.put(PRIMARY_CONSTRUCTOR_REQUIRED_FOR_DATA_CLASS, "Primary constructor required for data class");
+        MAP.put(EXPLICIT_DELEGATION_CALL_REQUIRED,
+                "Explicit 'this' or 'super' call is required. There is no constructor in superclass that can be called without arguments");
 
         MAP.put(INIT_KEYWORD_BEFORE_CLASS_INITIALIZER_EXPECTED, "Expecting 'init' keyword before class initializer");
 

compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DiagnosticRendererUtil.kt

@@ -23,3 +23,5 @@ import org.jetbrains.kotlin.renderer.DescriptorRendererImpl
 public fun <P> renderParameter(parameter: P, renderer: Renderer<P>?): Any = renderer?.render(parameter) ?: parameter
 
 public fun ClassDescriptor.renderKindWithName(): String = "${DescriptorRendererImpl.getClassKindPrefix(this)} '${getName()}'"
+
+public fun ClassDescriptor.renderKind(): String = DescriptorRendererImpl.getClassKindPrefix(this)

compiler/frontend/src/org/jetbrains/kotlin/parsing/JetExpressionParsing.java

@@ -423,9 +423,13 @@ public class JetExpressionParsing extends AbstractJetParsing {
     private void parsePostfixExpression() {
         PsiBuilder.Marker expression = mark();
 
+        boolean firstExpressionParsed;
         boolean doubleColonExpression = parseDoubleColonExpression();
         if (!doubleColonExpression) {
-            parseAtomicExpression();
+            firstExpressionParsed = parseAtomicExpression();
+        }
+        else {
+            firstExpressionParsed = true;
         }
 
         while (true) {
@@ -439,19 +443,24 @@ public class JetExpressionParsing extends AbstractJetParsing {
             else if (!doubleColonExpression && parseCallSuffix()) {
                 expression.done(CALL_EXPRESSION);
             }
-            else if (at(DOT)) {
-                advance(); // DOT
+            else if (at(DOT) || at(SAFE_ACCESS)) {
+                IElementType expressionType = at(DOT) ? DOT_QUALIFIED_EXPRESSION : SAFE_ACCESS_EXPRESSION;
+                advance(); // DOT or SAFE_ACCESS
+
+                if (!firstExpressionParsed) {
+                    expression.drop();
+                    expression = mark();
+                }
 
                 parseCallExpression();
 
-                expression.done(DOT_QUALIFIED_EXPRESSION);
-            }
-            else if (at(SAFE_ACCESS)) {
-                advance(); // SAFE_ACCESS
-
-                parseCallExpression();
-
-                expression.done(SAFE_ACCESS_EXPRESSION);
+                if (firstExpressionParsed) {
+                    expression.done(expressionType);
+                }
+                else {
+                    firstExpressionParsed = true;
+                    continue;
+                }
             }
             else if (atSet(Precedence.POSTFIX.getOperations())) {
                 parseOperationReference();
@@ -557,9 +566,11 @@ public class JetExpressionParsing extends AbstractJetParsing {
      *   : "package" // for the root package
      *   ;
      */
-    private void parseAtomicExpression() {
+    private boolean parseAtomicExpression() {
         //        System.out.println("atom at "  + myBuilder.getTokenText());
 
+        boolean ok = true;
+
         if (at(LPAR)) {
             parseParenthesizedExpression();
         }
@@ -625,9 +636,12 @@ public class JetExpressionParsing extends AbstractJetParsing {
             parseStringTemplate();
         }
         else if (!parseLiteralConstant()) {
+            ok = false;
             // TODO: better recovery if FIRST(element) did not match
             errorWithRecovery("Expecting an element", EXPRESSION_FOLLOW);
         }
+
+        return ok;
     }
 
     /*

compiler/frontend/src/org/jetbrains/kotlin/parsing/JetParsing.java

@@ -873,7 +873,7 @@ public class JetParsing extends AbstractJetParsing {
 
         advance(); // CONSTRUCTOR_KEYWORD
 
-        TokenSet valueArgsRecoverySet = TokenSet.create(COLON, LBRACE, SEMICOLON, RPAR);
+        TokenSet valueArgsRecoverySet = TokenSet.create(COLON, LBRACE, SEMICOLON, RPAR, EOL_OR_SEMICOLON, RBRACE);
         if (at(LPAR)) {
             parseValueParameterList(false, /*typeRequired = */ true, valueArgsRecoverySet);
         }
@@ -888,16 +888,26 @@ public class JetParsing extends AbstractJetParsing {
 
             if (at(THIS_KEYWORD) || at(SUPER_KEYWORD)) {
                 parseThisOrSuper();
+                myExpressionParsing.parseValueArgumentList();
             }
             else {
-                // if we're on LPAR it's probably start of value arguments list
-                if (!at(LPAR)) {
-                    advance(); // wrong delegation call keyword?
-                }
                 error("Expecting a 'this' or 'super' constructor call");
-            }
+                PsiBuilder.Marker beforeWrongDelegationCallee = null;
+                if (!at(LPAR)) {
+                    beforeWrongDelegationCallee = mark();
+                    advance(); // wrong delegation callee
+                }
+                myExpressionParsing.parseValueArgumentList();
 
-            myExpressionParsing.parseValueArgumentList();
+                if (beforeWrongDelegationCallee != null) {
+                    if (at(LBRACE)) {
+                        beforeWrongDelegationCallee.drop();
+                    }
+                    else {
+                        beforeWrongDelegationCallee.rollbackTo();
+                    }
+                }
+            }
 
             delegationCall.done(CONSTRUCTOR_DELEGATION_CALL);
         }
@@ -908,7 +918,9 @@ public class JetParsing extends AbstractJetParsing {
             emptyDelegationCall.done(CONSTRUCTOR_DELEGATION_CALL);
         }
 
-        parseBlock();
+        if (at(LBRACE)) {
+            parseBlock();
+        }
     }
 
     private void parseThisOrSuper() {

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

@@ -64,4 +64,14 @@ public class JetConstructorDelegationCall extends JetElementImpl implements JetC
     public JetConstructorDelegationReferenceExpression getCalleeExpression() {
         return findChildByClass(JetConstructorDelegationReferenceExpression.class);
     }
+
+    public boolean isImplicit() {
+        JetConstructorDelegationReferenceExpression callee = getCalleeExpression();
+        return callee != null && callee.getFirstChild() == null;
+    }
+
+    public boolean isCallToThis() {
+        JetConstructorDelegationReferenceExpression callee = getCalleeExpression();
+        return callee != null && callee.isThis();
+    }
 }

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

@@ -28,8 +28,4 @@ public class JetConstructorDelegationReferenceExpression extends JetExpressionIm
     public boolean isThis() {
         return findChildByType(JetTokens.THIS_KEYWORD) != null;
     }
-
-    public boolean isEmpty() {
-        return getFirstChild() == null;
-    }
 }

compiler/frontend/src/org/jetbrains/kotlin/psi/JetPsiFactory.kt

@@ -363,7 +363,7 @@ public class JetPsiFactory(private val project: Project) {
 
     public fun createConstructorDelegationCall(text: String): JetConstructorDelegationCall {
         val colonOrEmpty = if (text.isEmpty()) "" else ": "
-        return createClass("class A { constructor()$colonOrEmpty$text {}").getSecondaryConstructors().first().getDelegationCall()!!
+        return createClass("class A { constructor()$colonOrEmpty$text {}").getSecondaryConstructors().first().getDelegationCall()
     }
 
     public inner class IfChainBuilder() {

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

@@ -88,7 +88,7 @@ public class JetSecondaryConstructor extends JetDeclarationStub<KotlinPlaceHolde
 
     @Nullable
     @Override
-    public JetExpression getBodyExpression() {
+    public JetBlockExpression getBodyExpression() {
         return findChildByClass(JetBlockExpression.class);
     }
 
@@ -105,7 +105,7 @@ public class JetSecondaryConstructor extends JetDeclarationStub<KotlinPlaceHolde
 
     @Override
     public boolean hasBody() {
-        return true;
+        return getBodyExpression() != null;
     }
 
     @Override
@@ -172,16 +172,36 @@ public class JetSecondaryConstructor extends JetDeclarationStub<KotlinPlaceHolde
         throw new IncorrectOperationException("setName to constructor");
     }
 
-    @Nullable
+    @NotNull
     public JetConstructorDelegationCall getDelegationCall() {
         return findChildByClass(JetConstructorDelegationCall.class);
     }
 
+    public boolean hasImplicitDelegationCall() {
+        return getDelegationCall().isImplicit();
+    }
+
     @NotNull
     public JetClassOrObject getClassOrObject() {
         return (JetClassOrObject) getParent().getParent();
     }
 
+    @NotNull
+    public JetConstructorDelegationCall replaceImplicitDelegationCallWithExplicit(boolean isThis) {
+        JetPsiFactory psiFactory = new JetPsiFactory(getProject());
+        JetConstructorDelegationCall current = getDelegationCall();
+
+        assert current.isImplicit()
+                : "Method should not be called with explicit delegation call: " + getText();
+        current.delete();
+
+        PsiElement colon = addAfter(psiFactory.createColon(), getValueParameterList());
+
+        String delegationName = isThis ? "this" : "super";
+
+        return (JetConstructorDelegationCall) addAfter(psiFactory.createConstructorDelegationCall(delegationName + "()"), colon);
+    }
+
     @NotNull
     public PsiElement getConstructorKeyword() {
         return findNotNullChildByType(JetTokens.CONSTRUCTOR_KEYWORD);

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

@@ -24,4 +24,11 @@ public class JetTreeVisitor<D> extends JetVisitor<Void, D> {
         element.acceptChildren(this, data);
         return null;
     }
+
+    @Override
+    public Void visitJetFile(@NotNull JetFile file, D data) {
+        super.visitJetFile(file, data);
+        file.acceptChildren(this, data);
+        return null;
+    }
 }

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

@@ -45,4 +45,8 @@ public class JetValueArgumentList extends JetElementImpl {
         return findChildByType(JetTokens.RPAR);
     }
 
+    @Nullable
+    public PsiElement getLeftParenthesis() {
+        return findChildByType(JetTokens.LPAR);
+    }
 }

compiler/frontend/src/org/jetbrains/kotlin/resolve/AdditionalCheckerProvider.kt

@@ -18,17 +18,17 @@ package org.jetbrains.kotlin.resolve
 
 import org.jetbrains.kotlin.resolve.calls.checkers.*
 
-private val DEFAULT_ANNOTATION_CHECKERS = listOf(DataClassAnnotationChecker())
+private val DEFAULT_DECLARATION_CHECKERS = listOf(DataClassAnnotationChecker())
 private val DEFAULT_CALL_CHECKERS = listOf(CapturingInClosureChecker(), InlineCheckerWrapper(), ReifiedTypeParameterSubstitutionChecker())
 private val DEFAULT_TYPE_CHECKERS = listOf(TypeApproximator())
 
 public abstract class AdditionalCheckerProvider(
-        additionalAnnotationCheckers: List<AnnotationChecker>,
+        additionalDeclarationCheckers: List<DeclarationChecker>,
         additionalCallCheckers: List<CallChecker>,
         additionalTypeCheckers: List<AdditionalTypeChecker>
 ) {
 
-    public val annotationCheckers: List<AnnotationChecker> = DEFAULT_ANNOTATION_CHECKERS + additionalAnnotationCheckers
+    public val declarationCheckers: List<DeclarationChecker> = DEFAULT_DECLARATION_CHECKERS + additionalDeclarationCheckers
     public val callCheckers: List<CallChecker> = DEFAULT_CALL_CHECKERS + additionalCallCheckers
     public val additionalTypeCheckers: List<AdditionalTypeChecker> = DEFAULT_TYPE_CHECKERS + additionalTypeCheckers
 

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

@@ -217,8 +217,9 @@ public class BodyResolver {
             PsiElement constructorToReport = DescriptorToSourceUtils.descriptorToDeclaration(currentConstructor);
             if (constructorToReport != null) {
                 JetConstructorDelegationCall call = ((JetSecondaryConstructor) constructorToReport).getDelegationCall();
-                assert call != null : "resolved call can't be null";
-                trace.report(CYCLIC_CONSTRUCTOR_DELEGATION_CALL.on(call));
+                assert call.getCalleeExpression() != null
+                        : "Callee expression of delegation call should not be null on cycle as there should be explicit 'this' calls";
+                trace.report(CYCLIC_CONSTRUCTOR_DELEGATION_CALL.on(call.getCalleeExpression()));
             }
 
             currentConstructor = getDelegatedConstructor(currentConstructor);
@@ -229,7 +230,7 @@ public class BodyResolver {
     @Nullable
     private ConstructorDescriptor getDelegatedConstructor(@NotNull ConstructorDescriptor constructor) {
         ResolvedCall<ConstructorDescriptor> call = trace.get(CONSTRUCTOR_RESOLVED_DELEGATION_CALL, constructor);
-        return call == null ? null : call.getResultingDescriptor().getOriginal();
+        return call == null || !call.getStatus().isSuccess() ? null : call.getResultingDescriptor().getOriginal();
     }
 
     public void resolveBodies(@NotNull BodiesResolveContext c) {

compiler/frontend/src/org/jetbrains/kotlin/resolve/DataClassAnnotationChecker.kt

@@ -22,7 +22,7 @@ import org.jetbrains.kotlin.diagnostics.*
 import org.jetbrains.kotlin.builtins.*
 
 
-public class DataClassAnnotationChecker : AnnotationChecker {
+public class DataClassAnnotationChecker : DeclarationChecker {
     override fun check(declaration: JetDeclaration, descriptor: DeclarationDescriptor, diagnosticHolder: DiagnosticSink) {
         if (descriptor !is ClassDescriptor) return
         if (declaration !is JetClassOrObject) return

compiler/frontend/src/org/jetbrains/kotlin/resolve/DeclarationChecker.kt

@@ -20,7 +20,7 @@ import org.jetbrains.kotlin.psi.JetDeclaration
 import org.jetbrains.kotlin.diagnostics.DiagnosticSink
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 
-public trait AnnotationChecker {
+public trait DeclarationChecker {
 
     public fun check(declaration: JetDeclaration, descriptor: DeclarationDescriptor, diagnosticHolder: DiagnosticSink);
 

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

@@ -105,6 +105,14 @@ public class DeclarationsChecker {
             modifiersChecker.checkModifiersForDeclaration(property, propertyDescriptor);
         }
 
+        for (Map.Entry<JetSecondaryConstructor, ConstructorDescriptor> entry : bodiesResolveContext.getSecondaryConstructors().entrySet()) {
+            ConstructorDescriptor constructorDescriptor = entry.getValue();
+            JetSecondaryConstructor declaration = entry.getKey();
+            modifiersChecker.reportIllegalModalityModifiers(declaration);
+            reportErrorIfHasIllegalModifier(declaration);
+            modifiersChecker.checkModifiersForDeclaration(declaration, constructorDescriptor);
+        }
+
     }
 
     private void reportErrorIfHasIllegalModifier(JetModifierListOwner declaration) {

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

@@ -145,17 +145,24 @@ public class ModifiersChecker {
             checkDefaultModifier(modifierListOwner);
             checkModalityModifiers(modifierListOwner);
             checkVisibilityModifiers(modifierListOwner, descriptor);
-            checkVarianceModifiersOfTypeParameters(modifierListOwner);
+            checkVarianceModifiers(modifierListOwner);
+            checkVarargsModifiers(modifierListOwner, descriptor);
         }
         checkPlatformNameApplicability(descriptor);
-        runAnnotationCheckers(modifierListOwner, descriptor);
+        runDeclarationCheckers(modifierListOwner, descriptor);
+    }
+
+    private void checkVarargsModifiers(@NotNull JetDeclaration owner, @NotNull MemberDescriptor descriptor) {
+        if (!(owner instanceof JetParameter)) {
+            reportIllegalModifiers(owner, Collections.singleton(VARARG_KEYWORD));
+        }
     }
 
     public void checkModifiersForLocalDeclaration(@NotNull JetDeclaration modifierListOwner, @NotNull DeclarationDescriptor descriptor) {
         reportIllegalModalityModifiers(modifierListOwner);
         reportIllegalVisibilityModifiers(modifierListOwner);
         checkPlatformNameApplicability(descriptor);
-        runAnnotationCheckers(modifierListOwner, descriptor);
+        runDeclarationCheckers(modifierListOwner, descriptor);
     }
 
     public void reportIllegalModalityModifiers(@NotNull JetModifierListOwner modifierListOwner) {
@@ -288,7 +295,8 @@ public class ModifiersChecker {
         JetAnnotationEntry annotationEntry = trace.get(BindingContext.ANNOTATION_DESCRIPTOR_TO_PSI_ELEMENT, annotation);
         if (annotationEntry == null) return;
 
-        if (!DescriptorUtils.isTopLevelDeclaration(descriptor) || !(descriptor instanceof FunctionDescriptor)) {
+        if (!DescriptorUtils.isTopLevelDeclaration(descriptor) || !(descriptor instanceof FunctionDescriptor) ||
+            descriptor instanceof ConstructorDescriptor) {
             trace.report(INAPPLICABLE_ANNOTATION.on(annotationEntry));
         }
 
@@ -394,13 +402,14 @@ public class ModifiersChecker {
         return Visibilities.INTERNAL;
     }
 
-    private void runAnnotationCheckers(@NotNull JetDeclaration declaration, @NotNull DeclarationDescriptor descriptor) {
-        for (AnnotationChecker checker : additionalCheckerProvider.getAnnotationCheckers()) {
+    private void runDeclarationCheckers(@NotNull JetDeclaration declaration, @NotNull DeclarationDescriptor descriptor) {
+        for (DeclarationChecker checker : additionalCheckerProvider.getDeclarationCheckers()) {
             checker.check(declaration, descriptor, trace);
         }
     }
 
-    public void checkVarianceModifiersOfTypeParameters(@NotNull JetModifierListOwner modifierListOwner) {
+    public void checkVarianceModifiers(@NotNull JetModifierListOwner modifierListOwner) {
+        reportIllegalModifiers(modifierListOwner, Arrays.asList(IN_KEYWORD, OUT_KEYWORD, REIFIED_KEYWORD));
         if (!(modifierListOwner instanceof JetTypeParameterListOwner)) return;
         List<JetTypeParameter> typeParameters = ((JetTypeParameterListOwner) modifierListOwner).getTypeParameters();
         for (JetTypeParameter typeParameter : typeParameters) {

compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallResolver.java

@@ -188,7 +188,17 @@ public class CallResolver {
             @NotNull Collection<ResolutionCandidate<D>> candidates,
             @NotNull CallTransformer<D, F> callTransformer
     ) {
-        TracingStrategy tracing = TracingStrategyImpl.create(referenceExpression, context.call);
+        return computeTasksFromCandidatesAndResolvedCall(context, candidates, callTransformer,
+                                                         TracingStrategyImpl.create(referenceExpression, context.call));
+    }
+
+    @NotNull
+    private <D extends CallableDescriptor, F extends D> OverloadResolutionResults<F> computeTasksFromCandidatesAndResolvedCall(
+            @NotNull BasicCallResolutionContext context,
+            @NotNull Collection<ResolutionCandidate<D>> candidates,
+            @NotNull CallTransformer<D, F> callTransformer,
+            @NotNull TracingStrategy tracing
+    ) {
         List<ResolutionTask<D, F>> prioritizedTasks =
                 taskPrioritizer.<D, F>computePrioritizedTasksFromCandidates(context, candidates, tracing);
         return doResolveCallOrGetCachedResults(context, prioritizedTasks, callTransformer, tracing);
@@ -291,11 +301,10 @@ public class CallResolver {
     public OverloadResolutionResults<FunctionDescriptor> resolveConstructorDelegationCall(
             @NotNull BindingTrace trace, @NotNull JetScope scope, @NotNull DataFlowInfo dataFlowInfo,
             @NotNull ConstructorDescriptor constructorDescriptor,
-            @Nullable JetConstructorDelegationCall call
+            @NotNull JetConstructorDelegationCall call
     ) {
-        // Returns `null` when there is nothing to resolve in trivial cases like `null` call expression or
+        // Method returns `null` when there is nothing to resolve in trivial cases like `null` call expression or
         // when super call should be conventional enum constructor and super call should be empty
-        if (call == null) return null;
 
         BasicCallResolutionContext context = BasicCallResolutionContext.create(
                 trace, scope,
@@ -306,13 +315,13 @@ public class CallResolver {
 
         if (call.getCalleeExpression() == null) return checkArgumentTypesAndFail(context);
 
-        if (constructorDescriptor.getContainingDeclaration().getKind() == ClassKind.ENUM_CLASS &&
-            call.getCalleeExpression().isEmpty()) {
+        if (constructorDescriptor.getContainingDeclaration().getKind() == ClassKind.ENUM_CLASS && call.isImplicit()) {
             return null;
         }
 
         return resolveConstructorDelegationCall(
                 context,
+                call,
                 call.getCalleeExpression(),
                 constructorDescriptor
         );
@@ -321,6 +330,7 @@ public class CallResolver {
     @NotNull
     private OverloadResolutionResults<FunctionDescriptor> resolveConstructorDelegationCall(
             @NotNull BasicCallResolutionContext context,
+            @NotNull JetConstructorDelegationCall call,
             @NotNull JetConstructorDelegationReferenceExpression calleeExpression,
             @NotNull ConstructorDescriptor calleeConstructor
     ) {
@@ -328,7 +338,7 @@ public class CallResolver {
 
         boolean isThisCall = calleeExpression.isThis();
         if (currentClassDescriptor.getKind() == ClassKind.ENUM_CLASS && !isThisCall) {
-            context.trace.report(DELEGATION_SUPER_CALL_IN_ENUM_CONSTRUCTOR.on((JetConstructorDelegationCall) calleeExpression.getParent()));
+            context.trace.report(DELEGATION_SUPER_CALL_IN_ENUM_CONSTRUCTOR.on(calleeExpression));
             return checkArgumentTypesAndFail(context);
         }
 
@@ -364,7 +374,11 @@ public class CallResolver {
                     knownTypeParametersSubstitutor));
         }
 
-        return computeTasksFromCandidatesAndResolvedCall(context, calleeExpression, candidates, CallTransformer.FUNCTION_CALL_TRANSFORMER);
+        TracingStrategy tracing = call.isImplicit() ?
+                                  new TracingStrategyForImplicitConstructorDelegationCall(call, context.call) :
+                                  TracingStrategyImpl.create(calleeExpression, context.call);
+
+        return computeTasksFromCandidatesAndResolvedCall(context, candidates, CallTransformer.FUNCTION_CALL_TRANSFORMER, tracing);
     }
 
     public OverloadResolutionResults<FunctionDescriptor> resolveCallWithKnownCandidate(

compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/TracingStrategyForImplicitConstructorDelegationCall.kt

@@ -0,0 +1,145 @@
+/*
+ * Copyright 2010-2015 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jetbrains.kotlin.resolve.calls.tasks
+
+import org.jetbrains.kotlin.descriptors.*
+import org.jetbrains.kotlin.diagnostics.Errors
+import org.jetbrains.kotlin.diagnostics.Errors.UNRESOLVED_REFERENCE
+import org.jetbrains.kotlin.diagnostics.Errors.UNRESOLVED_REFERENCE_WRONG_RECEIVER
+import org.jetbrains.kotlin.psi.Call
+import org.jetbrains.kotlin.psi.JetConstructorDelegationCall
+import org.jetbrains.kotlin.psi.JetFunctionLiteralArgument
+import org.jetbrains.kotlin.psi.JetSecondaryConstructor
+import org.jetbrains.kotlin.resolve.BindingContext.CALL
+import org.jetbrains.kotlin.resolve.BindingContext.REFERENCE_TARGET
+import org.jetbrains.kotlin.resolve.BindingContext.RESOLVED_CALL
+import org.jetbrains.kotlin.resolve.BindingTrace
+import org.jetbrains.kotlin.resolve.calls.inference.InferenceErrorData
+import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall
+import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue
+import org.jetbrains.kotlin.types.ErrorUtils
+import org.jetbrains.kotlin.types.JetType
+
+
+public class TracingStrategyForImplicitConstructorDelegationCall(
+        val delegationCall: JetConstructorDelegationCall, call: Call
+) : AbstractTracingStrategy(delegationCall.getCalleeExpression()!!, call) {
+
+    val calleeExpression = delegationCall.getCalleeExpression()
+
+    override fun bindCall(trace: BindingTrace, call: Call) {
+        trace.record(CALL, call.getCalleeExpression(), call)
+    }
+
+    override fun <D : CallableDescriptor> bindReference(trace: BindingTrace, resolvedCall: ResolvedCall<D>) {
+        val descriptor = resolvedCall.getCandidateDescriptor()
+        val storedReference = trace.get(REFERENCE_TARGET, calleeExpression)
+        if (storedReference == null || !ErrorUtils.isError(descriptor)) {
+            trace.record(REFERENCE_TARGET, calleeExpression, descriptor)
+        }
+    }
+
+    override fun <D : CallableDescriptor> bindResolvedCall(trace: BindingTrace, resolvedCall: ResolvedCall<D>) {
+        trace.record(RESOLVED_CALL, call, resolvedCall)
+    }
+
+    override fun unresolvedReference(trace: BindingTrace) {
+        trace.report(UNRESOLVED_REFERENCE.on(calleeExpression, calleeExpression))
+    }
+
+    override fun <D : CallableDescriptor> unresolvedReferenceWrongReceiver(trace: BindingTrace, candidates: Collection<ResolvedCall<D>>) {
+        trace.report(UNRESOLVED_REFERENCE_WRONG_RECEIVER.on(reference, candidates))
+    }
+
+    override fun noValueForParameter(trace: BindingTrace, valueParameter: ValueParameterDescriptor) {
+        reportError(trace)
+    }
+
+    override fun <D : CallableDescriptor?> ambiguity(trace: BindingTrace, descriptors: MutableCollection<out ResolvedCall<D>>) {
+        reportError(trace)
+    }
+
+    override fun <D : CallableDescriptor?> noneApplicable(trace: BindingTrace, descriptors: MutableCollection<out ResolvedCall<D>>) {
+        reportError(trace)
+    }
+
+    override fun invisibleMember(trace: BindingTrace, descriptor: DeclarationDescriptorWithVisibility) {
+        reportError(trace)
+    }
+
+    private fun reportError(trace: BindingTrace) {
+        trace.report(Errors.EXPLICIT_DELEGATION_CALL_REQUIRED.on(delegationCall))
+    }
+
+    // Underlying methods should not be called because such errors are impossible
+    // when resolving delegation call
+    override fun <D : CallableDescriptor?> cannotCompleteResolve(trace: BindingTrace, descriptors: MutableCollection<out ResolvedCall<D>>) {
+        unexpectedError("cannotCompleteResolve")
+    }
+
+    override fun instantiationOfAbstractClass(trace: BindingTrace) {
+        unexpectedError("instantiationOfAbstractClass")
+    }
+
+    override fun abstractSuperCall(trace: BindingTrace) {
+        unexpectedError("abstractSuperCall")
+    }
+
+    override fun nestedClassAccessViaInstanceReference(
+            trace: BindingTrace, classDescriptor: ClassDescriptor, explicitReceiverKind: ExplicitReceiverKind
+    ) {
+        unexpectedError("nestedClassAccessViaInstanceReference")
+    }
+
+    override fun unsafeCall(trace: BindingTrace, type: JetType, isCallForImplicitInvoke: Boolean) {
+        unexpectedError("unsafeCall")
+    }
+
+    override fun unnecessarySafeCall(trace: BindingTrace, type: JetType) {
+        unexpectedError("unnecessarySafeCall")
+    }
+
+    override fun danglingFunctionLiteralArgumentSuspected(
+            trace: BindingTrace, functionLiteralArguments: MutableList<JetFunctionLiteralArgument>
+    ) {
+        unexpectedError("danglingFunctionLiteralArgumentSuspected")
+    }
+
+    override fun missingReceiver(trace: BindingTrace, expectedReceiver: ReceiverParameterDescriptor) {
+        unexpectedError("missingReceiver")
+    }
+
+    override fun wrongReceiverType(trace: BindingTrace, receiverParameter: ReceiverParameterDescriptor, receiverArgument: ReceiverValue) {
+        unexpectedError("wrongReceiverType")
+    }
+
+    override fun noReceiverAllowed(trace: BindingTrace) {
+        unexpectedError("noReceiverAllowed")
+    }
+
+    override fun wrongNumberOfTypeArguments(trace: BindingTrace, expectedTypeArgumentCount: Int) {
+        unexpectedError("wrongNumberOfTypeArguments")
+    }
+
+    override fun typeInferenceFailed(trace: BindingTrace, data: InferenceErrorData) {
+        unexpectedError("typeInferenceFailed")
+    }
+
+    private fun unexpectedError(type: String) {
+        throw AssertionError("Unexpected error type: $type")
+    }
+}

compiler/frontend/src/org/jetbrains/kotlin/types/reflect/ReflectionTypes.kt

@@ -22,6 +22,8 @@ import org.jetbrains.kotlin.descriptors.ModuleDescriptor
 import org.jetbrains.kotlin.descriptors.annotations.Annotations
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
+import org.jetbrains.kotlin.name.isSubpackageOf
+import org.jetbrains.kotlin.resolve.DescriptorUtils
 import org.jetbrains.kotlin.resolve.scopes.JetScope
 import org.jetbrains.kotlin.types.*
 import org.jetbrains.kotlin.types.TypeUtils.makeStarProjection
@@ -125,4 +127,12 @@ public class ReflectionTypes(private val module: ModuleDescriptor) {
         arguments.add(TypeProjectionImpl(returnType))
         return JetTypeImpl(annotations, classDescriptor.getTypeConstructor(), false, arguments, classDescriptor.getMemberScope(arguments))
     }
+
+    companion object {
+        public fun isReflectionType(type: JetType): Boolean {
+            val descriptor = type.getConstructor().getDeclarationDescriptor() ?: return false
+            val fqName = DescriptorUtils.getFqName(descriptor)
+            return fqName.isSafe() && fqName.toSafe().isSubpackageOf(KOTLIN_REFLECT_FQ_NAME)
+        }
+    }
 }

compiler/testData/cli/js/diagnosticForUnhandledElements.kt

@@ -9,10 +9,3 @@ class Foo {
         return [fancy] 1
     }
 }
-
-fun test() {
-
-    class A {
-        fun foo(){}
-    }
-}

compiler/testData/cli/js/diagnosticForUnhandledElements.out

@@ -1,4 +1,3 @@
 WARNING: compiler/testData/cli/js/diagnosticForUnhandledElements.kt: (8, 21) Parameter 'foo' is never used
 ERROR: compiler/testData/cli/js/diagnosticForUnhandledElements.kt: (9, 16) Cannot translate (not supported yet): '[fancy] 1'
-ERROR: compiler/testData/cli/js/diagnosticForUnhandledElements.kt: (15, 5) Cannot translate (not supported yet): 'class A {...'
-COMPILATION_ERROR
+COMPILATION_ERROR

compiler/testData/cli/jvm/androidPlugin/fakeAppwidgetPackage.kt

@@ -0,0 +1 @@
+package android.appwidget

compiler/testData/cli/jvm/androidPlugin/fakeInputMethodServicePackage.kt

@@ -0,0 +1 @@
+package android.inputmethodservice

compiler/testData/cli/jvm/androidPlugin/fakeOpenglPackage.kt

@@ -0,0 +1 @@
+package android.opengl

compiler/testData/cli/jvm/androidPlugin/fakeWebkitPackage.kt

@@ -0,0 +1 @@
+package android.webkit

compiler/testData/cli/jvm/pluginSimple.args

@@ -9,4 +9,8 @@ plugin\:org.jetbrains.kotlin.android\:androidRes=$TESTDATA_DIR$/androidPlugin/re
 $TESTDATA_DIR$/pluginSimple.kt
 $TESTDATA_DIR$/androidPlugin/androidApp.kt
 $TESTDATA_DIR$/androidPlugin/androidView.kt
-$TESTDATA_DIR$/androidPlugin/androidWidget.kt
+$TESTDATA_DIR$/androidPlugin/androidWidget.kt
+$TESTDATA_DIR$/androidPlugin/fakeAppwidgetPackage.kt
+$TESTDATA_DIR$/androidPlugin/fakeInputMethodServicePackage.kt
+$TESTDATA_DIR$/androidPlugin/fakeOpenglPackage.kt
+$TESTDATA_DIR$/androidPlugin/fakeWebkitPackage.kt

compiler/testData/cli/jvm/pluginSimpleUsage.args

@@ -7,4 +7,8 @@ plugin\:org.jetbrains.kotlin.android\:androidManifest=$TESTDATA_DIR$/androidPlug
 $TESTDATA_DIR$/pluginSimple.kt
 $TESTDATA_DIR$/androidPlugin/androidApp.kt
 $TESTDATA_DIR$/androidPlugin/androidView.kt
-$TESTDATA_DIR$/androidPlugin/androidWidget.kt
+$TESTDATA_DIR$/androidPlugin/androidWidget.kt
+$TESTDATA_DIR$/androidPlugin/fakeAppwidgetPackage.kt
+$TESTDATA_DIR$/androidPlugin/fakeInputMethodServicePackage.kt
+$TESTDATA_DIR$/androidPlugin/fakeOpenglPackage.kt
+$TESTDATA_DIR$/androidPlugin/fakeWebkitPackage.kt

compiler/testData/codegen/box/secondaryConstructors/accessToCompanion.kt

@@ -11,7 +11,7 @@ class A(val result: Int) {
     object C {
     }
 
-    constructor() : this(foo() + prop + B.bar() + B.prop + C) {}
+    constructor() : this(foo() + prop + B.bar() + B.prop + C)
 }
 
 fun box(): String {

compiler/testData/codegen/box/secondaryConstructors/clashingDefaultConstructors.kt

@@ -1,13 +1,13 @@
 open class A(val x: String = "abc", val y: String = "efg") {
-    constructor(x: String, y: String, z: Int): this(x, y + "#" + z.toString()) {}
+    constructor(x: String, y: String, z: Int): this(x, y + "#" + z.toString())
     
     override fun toString() = "$x#$y"
 }
 
 class B : A {
-    constructor(x: String, y: String, z: Int): super(x, y + z.toString()) {}
-    constructor(x: String = "xyz", y: String = "123") : super(x, y)  {}
-    constructor(x: Double): super(x.toString()) {}
+    constructor(x: String, y: String, z: Int): super(x, y + z.toString())
+    constructor(x: String = "xyz", y: String = "123") : super(x, y)
+    constructor(x: Double): super(x.toString())
 }
 
 fun box(): String {

compiler/testData/codegen/box/secondaryConstructors/delegationWithPrimary.kt

@@ -9,7 +9,7 @@ class B : A {
 val global = B()
 
 class C(x: Int) : A by global {
-    constructor(): this(1) {}
+    constructor(): this(1)
 }
 
 fun box(): String {

compiler/testData/codegen/box/secondaryConstructors/generics.kt

@@ -1,11 +1,11 @@
 open class B<T>(val x: T, val y: T) {
-    constructor(x: T): this(x, x) {}
+    constructor(x: T): this(x, x)
     override fun toString() = "$x#$y"
 }
 
 class A : B<String> {
-    constructor(): super("default") {}
-    constructor(x: String): super(x, "default") {}
+    constructor(): super("default")
+    constructor(x: String): super(x, "default")
 }
 
 fun box(): String {

compiler/testData/codegen/boxWithStdlib/reflection/classLiterals/localClassSimpleName.kt

@@ -0,0 +1,39 @@
+import kotlin.reflect.KClass
+import kotlin.test.assertEquals
+
+fun check(klass: KClass<*>, expectedName: String) {
+    assertEquals(expectedName, klass.simpleName)
+}
+
+fun localInMethod() {
+    fun localInMethod(unused: Any?) {
+        class Local
+        check(Local::class, "Local")
+
+        class `Local$With$Dollars`
+        check(`Local$With$Dollars`::class, "Local\$With\$Dollars")
+    }
+    localInMethod(null)
+
+    class Local
+    check(Local::class, "Local")
+
+    class `Local$With$Dollars`
+    check(`Local$With$Dollars`::class, "Local\$With\$Dollars")
+}
+
+class LocalInConstructor {
+    init {
+        class Local
+        check(Local::class, "Local")
+
+        class `Local$With$Dollars`
+        check(`Local$With$Dollars`::class, "Local\$With\$Dollars")
+    }
+}
+
+fun box(): String {
+    localInMethod()
+    LocalInConstructor()
+    return "OK"
+}

compiler/testData/codegen/boxWithStdlib/reflection/mapping/syntheticFields.kt

@@ -0,0 +1,14 @@
+import kotlin.reflect.jvm.kotlin
+
+class A {
+    // There's a synthetic "$kotlinClass" field here
+}
+
+fun box(): String {
+    for (field in javaClass<A>().getDeclaredFields()) {
+        val prop = field.kotlin
+        if (prop != null) return "Fail, property found: $prop"
+    }
+
+    return "OK"
+}

compiler/testData/diagnostics/tests/modifiers/IllegalModifiers.kt

@@ -30,7 +30,13 @@ annotation class annotated(val text: String = "not given")
 class LegalModifier(val a: Int, annotated private var b: String, annotated vararg <!UNUSED_PARAMETER!>v<!>: Int)
 
 //Check illegal modifier in constructor parameters
-class IllegalModifiers1(<!ILLEGAL_MODIFIER!>private<!> <!UNUSED_PARAMETER!>a<!>: Int)
+class IllegalModifiers1(
+        <!ILLEGAL_MODIFIER!>in<!>
+        <!ILLEGAL_MODIFIER!>out<!>
+        <!ILLEGAL_MODIFIER!>reified<!>
+        <!ILLEGAL_MODIFIER!>enum<!>
+        <!ILLEGAL_MODIFIER!>private<!>
+        <!UNUSED_PARAMETER!>a<!>: Int)
 
 //Check multiple illegal modifiers in constructor
 class IllegalModifiers2(<!ILLEGAL_MODIFIER!>private<!> <!ILLEGAL_MODIFIER!>abstract<!> <!UNUSED_PARAMETER!>a<!>: Int)
@@ -57,10 +63,10 @@ abstract class IllegalModifiers5() {
   private fun qux() {
 
     //Check illegal modifier in catch block
-    try {} catch (<!ILLEGAL_MODIFIER!>public<!> e: Exception) {}
+    try {} catch (<!ILLEGAL_MODIFIER!>in<!> <!ILLEGAL_MODIFIER!>out<!> <!ILLEGAL_MODIFIER!>reified<!> <!ILLEGAL_MODIFIER!>enum<!> <!ILLEGAL_MODIFIER!>public<!> e: Exception) {}
 
     //Check multiple illegal modifiers in catch block
-    try {} catch (<!ILLEGAL_MODIFIER!>abstract<!> <!ILLEGAL_MODIFIER!>public<!> e: Exception) {}
+    try {} catch (<!ILLEGAL_MODIFIER!>in<!> <!ILLEGAL_MODIFIER!>out<!> <!ILLEGAL_MODIFIER!>reified<!> <!ILLEGAL_MODIFIER!>enum<!> <!ILLEGAL_MODIFIER!>abstract<!> <!ILLEGAL_MODIFIER!>public<!> e: Exception) {}
 
     //Check annotations with illegal modifiers
     try {} catch (annotated("a text") <!ILLEGAL_MODIFIER!>abstract<!> <!ILLEGAL_MODIFIER!>public<!> e: Exception) {}
@@ -80,4 +86,52 @@ abstract class IllegalModifiers6() {
     <!ILLEGAL_MODIFIER!>public<!> annotated init {}
 
     <!ILLEGAL_MODIFIER!>private<!> <!NOT_AN_ANNOTATION_CLASS!>IllegalModifiers6()<!> init {}
-}
+}
+
+// strange inappropriate modifiers usages
+<!ILLEGAL_MODIFIER!>override<!>
+<!ILLEGAL_MODIFIER!>out<!>
+<!ILLEGAL_MODIFIER!>in<!>
+<!ILLEGAL_MODIFIER!>vararg<!>
+<!ILLEGAL_MODIFIER!>reified<!>
+class IllegalModifiers7() {
+    <!ILLEGAL_ENUM_ANNOTATION!>enum<!>
+    <!ILLEGAL_MODIFIER!>inner<!>
+    <!ILLEGAL_ANNOTATION_KEYWORD!>annotation<!>
+    <!ILLEGAL_MODIFIER!>out<!>
+    <!ILLEGAL_MODIFIER!>in<!>
+    <!ILLEGAL_MODIFIER!>vararg<!>
+    <!ILLEGAL_MODIFIER!>reified<!>
+    val x = 1
+    <!ILLEGAL_ENUM_ANNOTATION!>enum<!>
+    <!ILLEGAL_MODIFIER!>inner<!>
+    <!ILLEGAL_ANNOTATION_KEYWORD!>annotation<!>
+    <!ILLEGAL_MODIFIER!>out<!>
+    <!ILLEGAL_MODIFIER!>in<!>
+    <!ILLEGAL_MODIFIER!>vararg<!>
+    <!ILLEGAL_MODIFIER!>reified<!>
+    fun foo() {}
+}
+
+// Secondary constructors
+class IllegalModifiers8 {
+    <!ILLEGAL_MODIFIER, INCOMPATIBLE_MODIFIERS!>abstract<!>
+    <!ILLEGAL_ENUM_ANNOTATION!>enum<!>
+    <!ILLEGAL_MODIFIER, REDUNDANT_MODIFIER, REDUNDANT_MODIFIER, INCOMPATIBLE_MODIFIERS!>open<!>
+    <!ILLEGAL_MODIFIER!>inner<!>
+    <!ILLEGAL_ANNOTATION_KEYWORD!>annotation<!>
+    <!ILLEGAL_MODIFIER!>override<!>
+    <!ILLEGAL_MODIFIER!>out<!>
+    <!ILLEGAL_MODIFIER!>in<!>
+    <!ILLEGAL_MODIFIER, INCOMPATIBLE_MODIFIERS!>final<!>
+    <!ILLEGAL_MODIFIER!>vararg<!>
+    <!ILLEGAL_MODIFIER!>reified<!>
+    constructor() {}
+
+    constructor(<!ILLEGAL_MODIFIER!>private<!> <!ILLEGAL_MODIFIER!>enum<!> <!ILLEGAL_MODIFIER!>abstract<!> <!UNUSED_PARAMETER!>x<!>: Int) {}
+}
+
+class IllegalModifiers9 {
+    <!INCOMPATIBLE_MODIFIERS!>private<!> <!INCOMPATIBLE_MODIFIERS!>protected<!> constructor() {}
+    <!INCOMPATIBLE_MODIFIERS!>private<!> <!INCOMPATIBLE_MODIFIERS!>internal<!> constructor(<!UNUSED_PARAMETER!>x<!>: Int) {}
+}

compiler/testData/diagnostics/tests/modifiers/IllegalModifiers.txt

@@ -84,6 +84,31 @@ package illegal_modifiers {
         public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
     }
 
+    internal open class IllegalModifiers7 {
+        public constructor IllegalModifiers7()
+        internal final val x: kotlin.Int = 1
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        internal final fun foo(): kotlin.Unit
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    internal final class IllegalModifiers8 {
+        public constructor IllegalModifiers8()
+        public constructor IllegalModifiers8(/*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
+    }
+
+    internal final class IllegalModifiers9 {
+        private constructor IllegalModifiers9()
+        private constructor IllegalModifiers9(/*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
+    }
+
     internal final class LegalModifier {
         public constructor LegalModifier(/*0*/ a: kotlin.Int, /*1*/ illegal_modifiers.annotated() b: kotlin.String, /*2*/ illegal_modifiers.annotated() vararg v: kotlin.Int /*kotlin.IntArray*/)
         internal final val a: kotlin.Int

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

@@ -1,4 +1,4 @@
 class A {
-    constructor() {}
+    constructor()
     init {}
 }

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

@@ -12,6 +12,6 @@ class A {
     object C {
     }
 
-    constructor(x: Int) {}
-    constructor() : this(foo() + prop + B.bar() + B.prop + C) {}
+    constructor(x: Int)
+    constructor() : this(foo() + prop + B.bar() + B.prop + C)
 }

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

@@ -1,15 +1,15 @@
 // !DIAGNOSTICS: -UNUSED_PARAMETER
 class A(x: Int) {
-    constructor(x: Double): this(1) {}
-    constructor(x: String): this(1) {}
+    constructor(x: Double): this(1)
+    constructor(x: String): this(1)
 }
 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) {}
+    constructor(x: String)
+    constructor(x: R)
 }
 
 val y1: B<Int> = B(1)

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

@@ -1,20 +1,20 @@
 object A {
-    <!SECONDARY_CONSTRUCTOR_IN_OBJECT!>constructor() {}<!>
-    init {}
+    <!SECONDARY_CONSTRUCTOR_IN_OBJECT!>constructor()
+    <!>init {}
 }
 
 enum class B {
     X : B() {
-        <!SECONDARY_CONSTRUCTOR_IN_OBJECT!>constructor() {}<!>
-    }
+        <!SECONDARY_CONSTRUCTOR_IN_OBJECT!>constructor()
+ <!>}
 }
 
 class C {
     companion object {
-        <!SECONDARY_CONSTRUCTOR_IN_OBJECT!>constructor() {}<!>
-    }
+    <!SECONDARY_CONSTRUCTOR_IN_OBJECT!>constructor()
+ <!>}
 }
 
 val anonObject = object {
-    <!SECONDARY_CONSTRUCTOR_IN_OBJECT!>constructor() {}<!>
-}
+    <!SECONDARY_CONSTRUCTOR_IN_OBJECT!>constructor()
+<!>}

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

@@ -1,3 +1,3 @@
 trait A {
-    <!CONSTRUCTOR_IN_TRAIT!>constructor() {}<!>
-}
+    <!CONSTRUCTOR_IN_TRAIT!>constructor()
+<!>}

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

@@ -3,7 +3,7 @@ annotation class Ann1
 annotation class Ann2(val x: Int)
 
 class A {
-    Ann1 constructor() {}
-    <!NO_VALUE_FOR_PARAMETER!>Ann2<!> constructor(x1: Int) {}
-    Ann2(2) constructor(x1: Int, x2: Int) {}
+    Ann1 constructor()
+    <!NO_VALUE_FOR_PARAMETER!>Ann2<!> constructor(x1: Int)
+    Ann2(2) constructor(x1: Int, x2: Int)
 }

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

@@ -1,39 +1,39 @@
 // !DIAGNOSTICS: -UNUSED_PARAMETER
 class A1 {
-    constructor(): <!CYCLIC_CONSTRUCTOR_DELEGATION_CALL!>this<!>() {}
+    constructor(): <!CYCLIC_CONSTRUCTOR_DELEGATION_CALL!>this<!>()
 }
 
 class A2(x: Byte) {
-    constructor(x1: Int): <!CYCLIC_CONSTRUCTOR_DELEGATION_CALL!>this<!>(x1, 1) {}
-    constructor(x1: Int, x2: Int): <!CYCLIC_CONSTRUCTOR_DELEGATION_CALL!>this<!>(x1, x2, 2) {}
-    constructor(x1: Int, x2: Int, x3: Int): <!CYCLIC_CONSTRUCTOR_DELEGATION_CALL!>this<!>(x1) {}
+    constructor(x1: Int): <!CYCLIC_CONSTRUCTOR_DELEGATION_CALL!>this<!>(x1, 1)
+    constructor(x1: Int, x2: Int): <!CYCLIC_CONSTRUCTOR_DELEGATION_CALL!>this<!>(x1, x2, 2)
+    constructor(x1: Int, x2: Int, x3: Int): <!CYCLIC_CONSTRUCTOR_DELEGATION_CALL!>this<!>(x1)
 
     // delegating to previously declared cycle
-    constructor(x1: Double): this(1) {}
+    constructor(x1: Double): this(1)
 
 
     // delegating to cycle declared after
-    constructor(x1: String): this(1L) {}
+    constructor(x1: String): this(1L)
 
-    constructor(x1: Long): <!CYCLIC_CONSTRUCTOR_DELEGATION_CALL!>this<!>(x1, 1L) {}
-    constructor(x1: Long, x2: Long): <!CYCLIC_CONSTRUCTOR_DELEGATION_CALL!>this<!>(x1, x2, 2L) {}
-    constructor(x1: Long, x2: Long, x3: Long): <!CYCLIC_CONSTRUCTOR_DELEGATION_CALL!>this<!>(x1) {}
+    constructor(x1: Long): <!CYCLIC_CONSTRUCTOR_DELEGATION_CALL!>this<!>(x1, 1L)
+    constructor(x1: Long, x2: Long): <!CYCLIC_CONSTRUCTOR_DELEGATION_CALL!>this<!>(x1, x2, 2L)
+    constructor(x1: Long, x2: Long, x3: Long): <!CYCLIC_CONSTRUCTOR_DELEGATION_CALL!>this<!>(x1)
 
     // no cycle, just call to primary constuctor
-    constructor(x1: Double, x2: Double): this(x1, x2, 1.0) {}
-    constructor(x1: Double, x2: Double, x3: Double): this(x1, x2, x3, 1.0)  {}
-    constructor(x1: Double, x2: Double, x3: Double, x4: Double): this(1.toByte())  {}
+    constructor(x1: Double, x2: Double): this(x1, x2, 1.0)
+    constructor(x1: Double, x2: Double, x3: Double): this(x1, x2, x3, 1.0)
+    constructor(x1: Double, x2: Double, x3: Double, x4: Double): this(1.toByte())
 
-    constructor(): this("x", "y") {}
+    constructor(): this("x", "y")
 
-    constructor(x1: String, x2: String): <!CYCLIC_CONSTRUCTOR_DELEGATION_CALL!>this<!>(x1, x2, "") {}
-    constructor(x1: String, x2: String, x3: String): <!CYCLIC_CONSTRUCTOR_DELEGATION_CALL!>this<!>(x1, x2) {}
+    constructor(x1: String, x2: String): <!CYCLIC_CONSTRUCTOR_DELEGATION_CALL!>this<!>(x1, x2, "")
+    constructor(x1: String, x2: String, x3: String): <!CYCLIC_CONSTRUCTOR_DELEGATION_CALL!>this<!>(x1, x2)
 }
 
 open class B(x: Byte)
 class A : B {
     // no cycle, just call to super constuctor
-    constructor(x1: Double, x2: Double): this(x1, x2, 1.0) {}
-    constructor(x1: Double, x2: Double, x3: Double): this(x1, x2, x3, 1.0)  {}
-    constructor(x1: Double, x2: Double, x3: Double, x4: Double): super(1.toByte())  {}
+    constructor(x1: Double, x2: Double): this(x1, x2, 1.0)
+    constructor(x1: Double, x2: Double, x3: Double): this(x1, x2, x3, 1.0)
+    constructor(x1: Double, x2: Double, x3: Double, x4: Double): super(1.toByte())
 }

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

@@ -1,12 +1,12 @@
 // !DIAGNOSTICS: -UNUSED_PARAMETER
 data class A1(val x: String) {
-    constructor(): this("") {}
+    constructor(): this("")
 }
 
 data class A2() {
-    constructor(x: String): this() {}
+    constructor(x: String): this()
 }
 
 data class <!PRIMARY_CONSTRUCTOR_REQUIRED_FOR_DATA_CLASS!>A3<!> {
-    constructor() {}
+    constructor()
 }

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

@@ -1,6 +1,6 @@
 // !DIAGNOSTICS: -UNUSED_PARAMETER
 class A {
-    constructor(x: Any, y: Any, z: Any) {}
+    constructor(x: Any, y: Any, z: Any)
     constructor(x: String?, y: String?): this(x!!, <!DEBUG_INFO_SMARTCAST!>x<!>.length().toString() + y!!, "") {
         <!DEBUG_INFO_SMARTCAST!>x<!>.length() + <!DEBUG_INFO_SMARTCAST!>y<!>.length()
     }

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

@@ -2,5 +2,5 @@ trait A
 class AImpl : A
 
 class B : <!UNSUPPORTED!>A by AImpl()<!> {
-    constructor() {}
+    constructor()
 }

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

@@ -2,24 +2,24 @@
 enum class A {
     W: A(1) X: A(1, 2) Y: A(3.0) Z: A("") E: A()
 
-    constructor() {}
-    constructor(x: Int) {}
-    constructor(x: Int, y: Int): this(x+y) {}
-    constructor(x: Double): this(x.toInt(), 1) {}
-    constructor(x: String): <!DELEGATION_SUPER_CALL_IN_ENUM_CONSTRUCTOR!>super<!>(x, 1) {}
+    constructor()
+    constructor(x: Int)
+    constructor(x: Int, y: Int): this(x+y)
+    constructor(x: Double): this(x.toInt(), 1)
+    constructor(x: String): <!DELEGATION_SUPER_CALL_IN_ENUM_CONSTRUCTOR!>super<!>(x, 1)
 }
 
 enum class B(x: Int) {
     W: B(1) X: B(1, 2) Y: B(3.0) Z: B("")
 
-    constructor(x: Int, y: Int): this(x+y) {}
-    constructor(x: Double): this(x.toInt(), 1) {}
-    constructor(x: String): <!DELEGATION_SUPER_CALL_IN_ENUM_CONSTRUCTOR!>super<!>(x, 1) {}
+    constructor(x: Int, y: Int): this(x+y)
+    constructor(x: Double): this(x.toInt(), 1)
+    constructor(x: String): <!DELEGATION_SUPER_CALL_IN_ENUM_CONSTRUCTOR!>super<!>(x, 1)
 }
 
 enum class C {
     EMPTY: C() // may be we should avoid explicit call here
-    constructor() {}
+    constructor()
 }
 
 enum class D(val prop: Int) {
@@ -33,8 +33,8 @@ enum class D(val prop: Int) {
         override fun f() = prop
     }
 
-    constructor(): this(1) {}
-    constructor(x: String): this(x.length()) {}
+    constructor(): this(1)
+    constructor(x: String): this(x.length())
 
     abstract fun f(): Int
 }

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

@@ -0,0 +1,42 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+open class B0(x: Int)
+
+class A0 : B0 {
+    <!EXPLICIT_DELEGATION_CALL_REQUIRED!>constructor()<!>
+    constructor(x: Int) : super(<!NO_VALUE_FOR_PARAMETER!>)<!>
+}
+
+// --------------------------
+
+open class B1 {
+    constructor(x: Int = 1)
+    constructor()
+}
+
+class A1 : B1 {
+    <!EXPLICIT_DELEGATION_CALL_REQUIRED!>constructor()<!>
+    constructor(x: Int) : <!OVERLOAD_RESOLUTION_AMBIGUITY!>super<!>()
+}
+
+// --------------------------
+
+open class B2 {
+    constructor(x: Int)
+    constructor(x: String)
+}
+
+class A2 : B2 {
+    <!EXPLICIT_DELEGATION_CALL_REQUIRED!>constructor()<!>
+    constructor(x: Int) : <!NONE_APPLICABLE!>super<!>()
+}
+
+// --------------------------
+
+open class B3 {
+    private constructor()
+}
+
+class A3 : B3 {
+    <!EXPLICIT_DELEGATION_CALL_REQUIRED!>constructor()<!>
+    constructor(x: Int) : <!INVISIBLE_MEMBER!>super<!>()
+}

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

@@ -0,0 +1,63 @@
+package
+
+internal final class A0 : B0 {
+    public constructor A0()
+    public constructor A0(/*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
+}
+
+internal final class A1 : B1 {
+    public constructor A1()
+    public constructor A1(/*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
+}
+
+internal final class A2 : B2 {
+    public constructor A2()
+    public constructor A2(/*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
+}
+
+internal final class A3 : B3 {
+    public constructor A3()
+    public constructor A3(/*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
+}
+
+internal open class B0 {
+    public constructor B0(/*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
+}
+
+internal open class B1 {
+    public constructor B1()
+    public constructor B1(/*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
+}
+
+internal open class B2 {
+    public constructor B2(/*0*/ x: kotlin.Int)
+    public constructor B2(/*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 open class B3 {
+    private constructor B3()
+    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/expectedPrimaryConstructorCall.kt

@@ -1,8 +1,8 @@
 // !DIAGNOSTICS: -UNUSED_PARAMETER
 class A(x: Int) {
-    <!PRIMARY_CONSTRUCTOR_DELEGATION_CALL_EXPECTED!>constructor<!>() {}
+    <!PRIMARY_CONSTRUCTOR_DELEGATION_CALL_EXPECTED!>constructor()<!>
 }
 open class B(x: Int)
 class C(x: Int) : B(x) {
-    constructor(): <!PRIMARY_CONSTRUCTOR_DELEGATION_CALL_EXPECTED!>super<!>(1) {}
+    constructor(): <!PRIMARY_CONSTRUCTOR_DELEGATION_CALL_EXPECTED!>super<!>(1)
 }

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

@@ -1,21 +1,21 @@
 // !DIAGNOSTICS: -UNUSED_PARAMETER -UNREACHABLE_CODE
 open class B<T>(x: T, y: T) {
-    constructor(x: T): this(x, x) {}
-    constructor(): this(null!!, null!!) {}
+    constructor(x: T): this(x, x)
+    constructor(): this(null!!, null!!)
 }
 
 class A0 : B<String?> {
-    constructor() {}
-    constructor(x: String): super(x) {}
-    constructor(x: String, y: String): super(x, y) {}
+    constructor()
+    constructor(x: String): super(x)
+    constructor(x: String, y: String): super(x, y)
 }
 
 class A1<R> : B<R> {
-    constructor() {}
-    constructor(x: R): super(x) {}
-    constructor(x: R, y: R): super(x, y) {}
+    constructor()
+    constructor(x: R): super(x)
+    constructor(x: R, y: R): super(x, y)
 }
 
 class A2<R> {
-    constructor(t: R, i: Int) : <!CYCLIC_CONSTRUCTOR_DELEGATION_CALL!>this<!>(<!TYPE_MISMATCH!>i<!>, 1) {}
+    constructor(t: R, i: Int) : this(<!TYPE_MISMATCH!>i<!>, 1)
 }

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

@@ -2,25 +2,25 @@
 open class B<R1, R2>(x: R1, y: R2)
 
 class A0<T1, T2> {
-    constructor(x: T1, y: T2): <!CYCLIC_CONSTRUCTOR_DELEGATION_CALL!>this<!>(x, y) {}
+    constructor(x: T1, y: T2): <!CYCLIC_CONSTRUCTOR_DELEGATION_CALL!>this<!>(x, y)
 
-    constructor(x: T1, y: T2, z: T2): this(x, 1) {} // ok, delegates to constructor(x: T1, y: Int)
+    constructor(x: T1, y: T2, z: T2): this(x, 1) // ok, delegates to constructor(x: T1, y: Int)
 
-    constructor(x: T1, y: Int): <!NONE_APPLICABLE!>this<!>(x, "") {}
-    constructor(x: T1): this(x, 1) {}
-    constructor(x: T1, y: T2, z: String): <!NONE_APPLICABLE!>this<!>(y, x) {}
+    constructor(x: T1, y: Int): <!NONE_APPLICABLE!>this<!>(x, "")
+    constructor(x: T1): this(x, 1)
+    constructor(x: T1, y: T2, z: String): <!NONE_APPLICABLE!>this<!>(y, x)
 }
 
 class A1<T1, T2> : B<T1, T2> {
-    constructor(x: T1, y: T2): super(x, y) {}
-    constructor(x: T1, y: Int): super(x, <!TYPE_MISMATCH(T2; kotlin.Int)!>y<!>) {}
-    constructor(x: T1, y: T1, z: T1): super(x, <!TYPE_MISMATCH(T2; T1)!>y<!>) {}
+    constructor(x: T1, y: T2): super(x, y)
+    constructor(x: T1, y: Int): super(x, <!TYPE_MISMATCH(T2; kotlin.Int)!>y<!>)
+    constructor(x: T1, y: T1, z: T1): super(x, <!TYPE_MISMATCH(T2; T1)!>y<!>)
 }
 
 class A2<T1, T2> : B<T1, Int> {
-    constructor(x: T1, y: T2): super(x, <!TYPE_MISMATCH(kotlin.Int; T2)!>y<!>) {}
-    constructor(x: T1, y: Int): super(x, y) {}
-    constructor(x: T1, y: T1, z: T1): super(x, <!TYPE_MISMATCH(kotlin.Int; T1)!>y<!>) {}
-    constructor(x: T1, y: T2, z: String): super(<!TYPE_MISMATCH(T1; T2)!>y<!>, 1) {}
+    constructor(x: T1, y: T2): super(x, <!TYPE_MISMATCH(kotlin.Int; T2)!>y<!>)
+    constructor(x: T1, y: Int): super(x, y)
+    constructor(x: T1, y: T1, z: T1): super(x, <!TYPE_MISMATCH(kotlin.Int; T1)!>y<!>)
+    constructor(x: T1, y: T2, z: String): super(<!TYPE_MISMATCH(T1; T2)!>y<!>, 1)
 }
 

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

@@ -1,16 +1,16 @@
 // !DIAGNOSTICS: -UNUSED_PARAMETER
 open class B<X, Y : X> {
-    constructor(x: X, y: Y) {}
-    constructor(x: X, s: String) {}
-    constructor(y: Y, i: Int) : this(y, "") {}
+    constructor(x: X, y: Y)
+    constructor(x: X, s: String)
+    constructor(y: Y, i: Int) : this(y, "")
 }
 
 class A<T1, T2 : T1> : B<T1, T2> {
-    constructor(x: T1, y: T2): super(x, y) {}
-    constructor(x: T2, y: T2, z: String): super(x, y) {}
+    constructor(x: T1, y: T2): super(x, y)
+    constructor(x: T2, y: T2, z: String): super(x, y)
 
-    constructor(x: T2, z: String, z1: String): super(x, "") {}
-    constructor(x: T2, z: String, z1: String, z2: String): super(x, 1) {}
-    constructor(x: T1, z: String, z1: String, z2: String, z3: String): super(x, "") {}
-    constructor(x: T1, z: String, z1: String, z2: String, z3: String, z4: String): <!NONE_APPLICABLE!>super<!>(x, 1) {}
+    constructor(x: T2, z: String, z1: String): super(x, "")
+    constructor(x: T2, z: String, z1: String, z2: String): super(x, 1)
+    constructor(x: T1, z: String, z1: String, z2: String, z3: String): super(x, "")
+    constructor(x: T1, z: String, z1: String, z2: String, z3: String, z4: String): <!NONE_APPLICABLE!>super<!>(x, 1)
 }

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

@@ -1,5 +1,5 @@
 // !DIAGNOSTICS: -UNUSED_PARAMETER
 open class B(x: Int)
 class A : <!SUPERTYPE_INITIALIZED_WITHOUT_PRIMARY_CONSTRUCTOR!>B(1)<!> {
-    constructor(): super(1) {}
+    constructor(): super(1)
 }

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

@@ -11,5 +11,5 @@ class A {
     }
 }
 class A1(val x: Int, val y: Int) {
-    constructor(other: A1): this(other.x, other.y) {}
+    constructor(other: A1): this(other.x, other.y)
 }

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

@@ -1,3 +1,3 @@
 class X<T>(val t: T) {
-    constructor(t: String): <!CYCLIC_CONSTRUCTOR_DELEGATION_CALL!>this<!>(t) {}
+    constructor(t: String): <!CYCLIC_CONSTRUCTOR_DELEGATION_CALL!>this<!>(t)
 }

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

@@ -1,5 +1,4 @@
 // !DIAGNOSTICS: -UNUSED_PARAMETER
 class X<T>(val t: T) {
-    constructor(t: T, i: Int) : <!NONE_APPLICABLE!>this<!>(i) {
-    }
+    constructor(t: T, i: Int) : <!NONE_APPLICABLE!>this<!>(i)
 }

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

@@ -1,5 +1,4 @@
 // !DIAGNOSTICS: -UNUSED_PARAMETER
 class X<T> {
-    constructor(t: T, i: Int): <!CYCLIC_CONSTRUCTOR_DELEGATION_CALL!>this<!>(<!TYPE_MISMATCH!>i<!>, 1) { // no error
-    }
+    constructor(t: T, i: Int): this(<!TYPE_MISMATCH!>i<!>, 1)
 }

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

@@ -1,5 +1,5 @@
 // !DIAGNOSTICS: -UNUSED_PARAMETER
 class A<T1, T2> {
-    constructor(block: (T1) -> T2) {}
-    constructor(x: T2): this({ x }) {}
+    constructor(block: (T1) -> T2)
+    constructor(x: T2): this({ x })
 }

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

@@ -3,11 +3,11 @@ open class B(open val parentProperty: String)
 class A : B {
     val myProp: String = ""
     override val parentProperty: String = ""
-    constructor(arg: String = <!UNRESOLVED_REFERENCE!>myProp<!>): super(<!UNRESOLVED_REFERENCE!>myProp<!>) {}
-    constructor(x1: String, arg: String = <!NO_THIS!>this<!>.<!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>myProp<!>): super(<!NO_THIS!>this<!>.<!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>myProp<!>) {}
-    constructor(x1: String, x2: String, arg: String = <!UNRESOLVED_REFERENCE!>parentProperty<!>): super(<!UNRESOLVED_REFERENCE!>parentProperty<!>) {}
-    constructor(x1: String, x2: String, x3: String, arg: String = <!SUPER_NOT_AVAILABLE!>super<!>.<!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>parentProperty<!>): super(<!SUPER_NOT_AVAILABLE!>super<!>.<!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>parentProperty<!>) {}
-    constructor(x1: String, x2: String, x3: String, x4: String, arg: String = foo(<!NO_THIS!>this<!>)): super(foo(<!NO_THIS!>this<!>)) {}
-    constructor(x1: String, x2: String, x3: String, x4: String, x5: String, arg: String = foo(this<!UNRESOLVED_REFERENCE!>@A<!>)): super(foo(this<!UNRESOLVED_REFERENCE!>@A<!>)) {}
+    constructor(arg: String = <!UNRESOLVED_REFERENCE!>myProp<!>): super(<!UNRESOLVED_REFERENCE!>myProp<!>)
+    constructor(x1: String, arg: String = <!NO_THIS!>this<!>.<!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>myProp<!>): super(<!NO_THIS!>this<!>.<!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>myProp<!>)
+    constructor(x1: String, x2: String, arg: String = <!UNRESOLVED_REFERENCE!>parentProperty<!>): super(<!UNRESOLVED_REFERENCE!>parentProperty<!>)
+    constructor(x1: String, x2: String, x3: String, arg: String = <!SUPER_NOT_AVAILABLE!>super<!>.<!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>parentProperty<!>): super(<!SUPER_NOT_AVAILABLE!>super<!>.<!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>parentProperty<!>)
+    constructor(x1: String, x2: String, x3: String, x4: String, arg: String = foo(<!NO_THIS!>this<!>)): super(foo(<!NO_THIS!>this<!>))
+    constructor(x1: String, x2: String, x3: String, x4: String, x5: String, arg: String = foo(this<!UNRESOLVED_REFERENCE!>@A<!>)): super(foo(this<!UNRESOLVED_REFERENCE!>@A<!>))
 }
 fun foo(x: A) = ""

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

@@ -0,0 +1,7 @@
+class A {
+    open inner class Inner
+
+    class Nested : Inner {
+        <!INACCESSIBLE_OUTER_CLASS_EXPRESSION!>constructor()<!>
+    }
+}

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

@@ -0,0 +1,22 @@
+package
+
+internal final class A {
+    public constructor A()
+    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 open inner class Inner {
+        public constructor Inner()
+        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 Nested : A.Inner {
+        public constructor Nested()
+        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/noDefaultIfEmptySecondary.kt

@@ -1,4 +1,4 @@
 // do not report generate empty synthetic constructor by primary as it leads to CONFLICTING_JVM_DECLARATIONS
 class A(val x: Int = 1, val y: Int = 2) {
-    constructor(): this(0, 0) {}
+    constructor(): this(0, 0)
 }

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

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

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

@@ -2,5 +2,5 @@ open class B
 trait C
 trait D
 class A : C, B, D {
-    constructor() {}
+    constructor()
 }

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

@@ -1,27 +1,26 @@
 // !DIAGNOSTICS: -UNUSED_PARAMETER
 
 class <!CONFLICTING_OVERLOADS!>A(x: String = "", y: String = "")<!> {
-    <!CONFLICTING_OVERLOADS!>constructor(x: String, y: String)<!>: <!OVERLOAD_RESOLUTION_AMBIGUITY!>this<!>(x, y) {}
-    <!CONFLICTING_OVERLOADS!>constructor()<!>: <!OVERLOAD_RESOLUTION_AMBIGUITY!>this<!>("", "") {}
-    <!CONFLICTING_OVERLOADS!>constructor()<!>: <!OVERLOAD_RESOLUTION_AMBIGUITY!>this<!>("", "") {}
+    <!CONFLICTING_OVERLOADS!>constructor(x: String, y: String)<!>: <!OVERLOAD_RESOLUTION_AMBIGUITY!>this<!>(x, y)
+    <!CONFLICTING_OVERLOADS!>constructor()<!>: <!OVERLOAD_RESOLUTION_AMBIGUITY!>this<!>("", "")
+    <!CONFLICTING_OVERLOADS!>constructor()<!>: <!OVERLOAD_RESOLUTION_AMBIGUITY!>this<!>("", "")
 }
 
 class B {
-    <!CONFLICTING_OVERLOADS!>constructor(x: Int)<!> {}
+    <!CONFLICTING_OVERLOADS!>constructor(x: Int)<!>
 }
 
 <!CONFLICTING_OVERLOADS!>fun B(x: Int)<!> {}
 
 class Outer {
     class <!CONFLICTING_OVERLOADS!>A(x: String = "", y: String = "")<!> {
-        <!CONFLICTING_OVERLOADS!>constructor(x: String, y: String)<!>: <!OVERLOAD_RESOLUTION_AMBIGUITY!>this<!>(x, y) {}
-        <!CONFLICTING_OVERLOADS!>constructor()<!>: <!OVERLOAD_RESOLUTION_AMBIGUITY!>this<!>("", "") {}
-        <!CONFLICTING_OVERLOADS!>constructor()<!>: <!OVERLOAD_RESOLUTION_AMBIGUITY!>this<!>("", "") {}
+        <!CONFLICTING_OVERLOADS!>constructor(x: String, y: String)<!>: <!OVERLOAD_RESOLUTION_AMBIGUITY!>this<!>(x, y)
+        <!CONFLICTING_OVERLOADS!>constructor()<!>: <!OVERLOAD_RESOLUTION_AMBIGUITY!>this<!>("", "")
+        <!CONFLICTING_OVERLOADS!>constructor()<!>: <!OVERLOAD_RESOLUTION_AMBIGUITY!>this<!>("", "")
     }
 
     class B {
-        <!CONFLICTING_OVERLOADS!>constructor(x: Int)<!> {
-        }
+        <!CONFLICTING_OVERLOADS!>constructor(x: Int)<!>
     }
 
     <!CONFLICTING_OVERLOADS!>fun B(x: Int)<!> {}

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

@@ -1,11 +1,11 @@
 class <!REDECLARATION!>A<!>
 class <!REDECLARATION!>A<!> {
-    constructor() {}
+    constructor()
 }
 
 class B
 class Outer {
     class B {
-        constructor() {}
+        constructor()
     }
 }

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

@@ -1,4 +1,4 @@
 class A {
     val prop: Int = <!TYPE_MISMATCH!>""<!>
-    constructor() {}
+    constructor()
 }

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

@@ -1,4 +1,4 @@
 // !DIAGNOSTICS: -UNUSED_PARAMETER
 class A {
-    constructor(): super(<!TOO_MANY_ARGUMENTS!>1<!>) { }
+    constructor(): super(<!TOO_MANY_ARGUMENTS!>1<!>)
 }

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

@@ -1,10 +1,10 @@
 // !DIAGNOSTICS: -UNUSED_PARAMETER
 open class B(x: Double) {
-    constructor(x: Int): this(1.0) {}
-    constructor(x: String): this(1.0) {}
+    constructor(x: Int): this(1.0)
+    constructor(x: String): this(1.0)
 }
 trait C
 class A : B, C {
-    constructor(): <!NONE_APPLICABLE!>super<!>(' ') { }
-    <!NONE_APPLICABLE!>constructor<!>(x: Int) { }
+    constructor(): <!NONE_APPLICABLE!>super<!>(' ')
+    <!EXPLICIT_DELEGATION_CALL_REQUIRED!>constructor(x: Int)<!>
 }

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

@@ -3,5 +3,5 @@ class A {
     constructor(
         <!VAL_OR_VAR_ON_SECONDARY_CONSTRUCTOR_PARAMETER!>val<!> x: Int, y: Int,
         <!VAL_OR_VAR_ON_SECONDARY_CONSTRUCTOR_PARAMETER!>var<!> z: Int,
-        <!ILLEGAL_MODIFIER!>public<!> a: Int) {}
+        <!ILLEGAL_MODIFIER!>public<!> a: Int)
 }

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

@@ -2,11 +2,11 @@
 fun <T> array(vararg x: T): Array<T> = null!!
 
 open class B(vararg y: String) {
-    constructor(x: Int): this(x.toString(), *array("1"), "2") {}
+    constructor(x: Int): this(x.toString(), *array("1"), "2")
 }
 
 class A : B {
-    constructor(x: String, y: String): super(x, *array("3"), y) {}
-    constructor(x: String): super(x) {}
-    constructor(): super() {}
+    constructor(x: String, y: String): super(x, *array("3"), y)
+    constructor(x: String): super(x)
+    constructor(): super()
 }

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

@@ -2,13 +2,13 @@
 fun <T> array(vararg x: T): Array<T> = null!!
 
 open class B(x: Int) {
-    constructor(vararg y: String): this(y[0].length()) {}
+    constructor(vararg y: String): this(y[0].length())
 }
 
 class A : B {
-    constructor(x: String, y: String): super(x, *array("q"), y) {}
-    constructor(x: String): super(x) {}
-    constructor(): super() {}
+    constructor(x: String, y: String): super(x, *array("q"), y)
+    constructor(x: String): super(x)
+    constructor(): super()
 }
 
 val b1 = B()

compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/conventions.kt

@@ -1,3 +1,4 @@
+// !DIAGNOSTICS: -NON_TOPLEVEL_CLASS_DECLARATION
 // !MARK_DYNAMIC_CALLS
 
 fun test(d: dynamic) {
@@ -97,4 +98,4 @@ fun test(d: dynamic) {
 
 val dyn: dynamic = null
 val foo : Int <!DEBUG_INFO_DYNAMIC, DEBUG_INFO_DYNAMIC!>by dyn<!>
-var bar : Int <!DEBUG_INFO_DYNAMIC, DEBUG_INFO_DYNAMIC, DEBUG_INFO_DYNAMIC!>by dyn<!>
+var bar : Int <!DEBUG_INFO_DYNAMIC, DEBUG_INFO_DYNAMIC, DEBUG_INFO_DYNAMIC!>by dyn<!>

compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/noUnsupportedInLocals.kt

@@ -1,7 +1,9 @@
+// !DIAGNOSTICS: -NON_TOPLEVEL_CLASS_DECLARATION
+
 val foo: dynamic = 1
 
 fun foo() {
     class C {
         val foo: dynamic = 1
     }
-}
+}

compiler/testData/diagnostics/testsWithJsStdLib/jsCode/noJavaScriptProduced.kt

@@ -0,0 +1,16 @@
+fun test() {
+    js(<!JSCODE_NO_JAVASCRIPT_PRODUCED!>""<!>)
+    js(<!JSCODE_NO_JAVASCRIPT_PRODUCED!>" "<!>)
+    js(<!JSCODE_NO_JAVASCRIPT_PRODUCED!>"""
+               """<!>)
+
+    val empty = ""
+    js(<!JSCODE_NO_JAVASCRIPT_PRODUCED!>empty<!>)
+
+    val whitespace = "  "
+    js(<!JSCODE_NO_JAVASCRIPT_PRODUCED!>whitespace<!>)
+
+    val multiline = """
+    """
+    js(<!JSCODE_NO_JAVASCRIPT_PRODUCED!>multiline<!>)
+}

compiler/testData/diagnostics/testsWithJsStdLib/jsCode/noJavaScriptProduced.txt

@@ -0,0 +1,3 @@
+package
+
+internal fun test(): kotlin.Unit

compiler/testData/diagnostics/testsWithJsStdLib/native/nativeGetter/onLocalNonNativeClassMembers.kt

@@ -1,4 +1,4 @@
-// !DIAGNOSTICS: -UNUSED_PARAMETER
+// !DIAGNOSTICS: -UNUSED_PARAMETER -NON_TOPLEVEL_CLASS_DECLARATION
 
 fun foo() {
     class A {
@@ -42,4 +42,4 @@ fun foo() {
         <!NATIVE_ANNOTATIONS_ALLOWED_ONLY_ON_MEMBER_OR_EXTENSION_FUN!>nativeGetter
         fun baz(<!NATIVE_INDEXER_CAN_NOT_HAVE_DEFAULT_ARGUMENTS!>a: Int = 0<!>): Int?<!> = 0
     }
-}
+}

compiler/testData/diagnostics/testsWithJsStdLib/native/nativeGetter/onLocalOtherDeclarations.kt

@@ -1,4 +1,4 @@
-// !DIAGNOSTICS: -UNUSED_PARAMETER -UNUSED_VARIABLE
+// !DIAGNOSTICS: -UNUSED_PARAMETER -UNUSED_VARIABLE -NON_TOPLEVEL_CLASS_DECLARATION
 
 fun foo() {
     <!NATIVE_ANNOTATIONS_ALLOWED_ONLY_ON_MEMBER_OR_EXTENSION_FUN, NATIVE_INDEXER_WRONG_PARAMETER_COUNT!>[nativeGetter]

compiler/testData/diagnostics/testsWithJsStdLib/native/nativeGetter/onNestedDeclarationsInsideNonNativeClass.kt

@@ -1,4 +1,4 @@
-// !DIAGNOSTICS: -UNUSED_PARAMETER
+// !DIAGNOSTICS: -UNUSED_PARAMETER -NON_TOPLEVEL_CLASS_DECLARATION
 
 class A {
     class B {
@@ -109,4 +109,4 @@ class A {
             fun baz(<!NATIVE_INDEXER_CAN_NOT_HAVE_DEFAULT_ARGUMENTS!>a: String = "foo"<!>): Int?<!> = 0
         }
     }
-}
+}

compiler/testData/diagnostics/testsWithJsStdLib/native/nativeInvoke/onLocalNonNativeClassMembers.kt

@@ -1,4 +1,4 @@
-// !DIAGNOSTICS: -UNUSED_PARAMETER
+// !DIAGNOSTICS: -UNUSED_PARAMETER -NON_TOPLEVEL_CLASS_DECLARATION
 
 fun foo() {
     class A {
@@ -22,4 +22,4 @@ fun foo() {
             fun invoke(a: String): Int<!> = 0
         }
     }
-}
+}

compiler/testData/diagnostics/testsWithJsStdLib/native/nativeInvoke/onLocalOtherDeclarations.kt

@@ -1,4 +1,4 @@
-// !DIAGNOSTICS: -UNUSED_PARAMETER -UNUSED_VARIABLE
+// !DIAGNOSTICS: -UNUSED_PARAMETER -UNUSED_VARIABLE -NON_TOPLEVEL_CLASS_DECLARATION
 
 fun foo() {
     <!NATIVE_ANNOTATIONS_ALLOWED_ONLY_ON_MEMBER_OR_EXTENSION_FUN!>[nativeInvoke]

compiler/testData/diagnostics/testsWithJsStdLib/native/nativeInvoke/onNestedDeclarationsInsideNonNativeClass.kt

@@ -1,4 +1,4 @@
-// !DIAGNOSTICS: -UNUSED_PARAMETER
+// !DIAGNOSTICS: -UNUSED_PARAMETER -NON_TOPLEVEL_CLASS_DECLARATION
 
 class A {
     class B {
@@ -40,4 +40,4 @@ class A {
             fun invoke(a: String): Int<!> = 0
         }
     }
-}
+}

compiler/testData/diagnostics/testsWithJsStdLib/native/nativeSetter/onLocalNonNativeClassMembers.kt

@@ -1,4 +1,4 @@
-// !DIAGNOSTICS: -UNUSED_PARAMETER
+// !DIAGNOSTICS: -UNUSED_PARAMETER -NON_TOPLEVEL_CLASS_DECLARATION
 
 fun foo() {
     class A {
@@ -42,4 +42,4 @@ fun foo() {
         <!NATIVE_ANNOTATIONS_ALLOWED_ONLY_ON_MEMBER_OR_EXTENSION_FUN!>[nativeSetter]
         fun foo(<!NATIVE_INDEXER_CAN_NOT_HAVE_DEFAULT_ARGUMENTS!>a: Int = 0<!>, v: String)<!> = "OK"
     }
-}
+}

compiler/testData/diagnostics/testsWithJsStdLib/native/nativeSetter/onLocalOtherDeclarations.kt

@@ -1,4 +1,4 @@
-// !DIAGNOSTICS: -UNUSED_PARAMETER -UNUSED_VARIABLE
+// !DIAGNOSTICS: -UNUSED_PARAMETER -UNUSED_VARIABLE -NON_TOPLEVEL_CLASS_DECLARATION
 
 fun foo() {
     <!NATIVE_ANNOTATIONS_ALLOWED_ONLY_ON_MEMBER_OR_EXTENSION_FUN, NATIVE_INDEXER_WRONG_PARAMETER_COUNT!>[nativeSetter]
@@ -9,4 +9,4 @@ fun foo() {
 
     [nativeSetter]
     class <!NATIVE_ANNOTATIONS_ALLOWED_ONLY_ON_MEMBER_OR_EXTENSION_FUN!>Foo<!> {}
-}
+}

compiler/testData/diagnostics/testsWithJsStdLib/native/nativeSetter/onNestedDeclarationsInsideNonNativeClass.kt

@@ -1,4 +1,4 @@
-// !DIAGNOSTICS: -UNUSED_PARAMETER
+// !DIAGNOSTICS: -UNUSED_PARAMETER -NON_TOPLEVEL_CLASS_DECLARATION
 
 class A {
     class B {
@@ -127,4 +127,4 @@ class A {
             fun foo(<!NATIVE_INDEXER_CAN_NOT_HAVE_DEFAULT_ARGUMENTS!>a: Number = 0.0<!>, v: String)<!> = "OK"
         }
     }
-}
+}

compiler/testData/diagnostics/testsWithJsStdLib/unsupportedFeatures/localClassifier.kt

@@ -0,0 +1,12 @@
+// !DIAGNOSTICS: -UNUSED_VARIABLE
+
+fun foo() {
+    <!NON_TOPLEVEL_CLASS_DECLARATION!>class A<!> {
+        inner <!NON_TOPLEVEL_CLASS_DECLARATION!>class E<!> {
+            <!NESTED_CLASS_NOT_ALLOWED, NON_TOPLEVEL_CLASS_DECLARATION!>trait T<!>
+        }
+    }
+
+    <!NON_TOPLEVEL_CLASS_DECLARATION!>trait T<!> {
+    }
+}

compiler/testData/diagnostics/testsWithJsStdLib/unsupportedFeatures/localClassifier.txt

@@ -0,0 +1,3 @@
+package
+
+internal fun foo(): kotlin.Unit