FIR checker: introduce FunctionChecker alias

and use it to add support diagnostic FUNCTION_DECLARATION_WITH_NO_NAME

compiler/fir/analysis-tests/testData/resolve/diagnostics/conflictingOverloads.kt

@@ -63,6 +63,6 @@ fun mest()
 
 class mest
 
-fun() {}
+<!FUNCTION_DECLARATION_WITH_NO_NAME!>fun()<!> {}
 
-private fun() {}
+<!FUNCTION_DECLARATION_WITH_NO_NAME!>private fun()<!> {}

compiler/fir/checkers/checkers-component-generator/src/org/jetbrains/kotlin/fir/checkers/generator/Main.kt

@@ -27,6 +27,7 @@ fun main(args: Array<String>) {
     generateCheckersComponents(generationPath, declarationPackage, "FirDeclarationChecker") {
         alias<FirDeclaration>("BasicDeclarationChecker")
         alias<FirMemberDeclaration>("MemberDeclarationChecker")
+        alias<FirFunction<*>>("FunctionChecker")
         alias<FirProperty>("PropertyChecker")
         alias<FirRegularClass>("RegularClassChecker")
         alias<FirConstructor>("ConstructorChecker")

compiler/fir/checkers/gen/org/jetbrains/kotlin/fir/analysis/checkers/declaration/ComposedDeclarationCheckers.kt

@@ -19,6 +19,8 @@ internal class ComposedDeclarationCheckers : DeclarationCheckers() {
         get() = _basicDeclarationCheckers
     override val memberDeclarationCheckers: Set<FirMemberDeclarationChecker>
         get() = _memberDeclarationCheckers
+    override val functionCheckers: Set<FirFunctionChecker>
+        get() = _functionCheckers
     override val propertyCheckers: Set<FirPropertyChecker>
         get() = _propertyCheckers
     override val regularClassCheckers: Set<FirRegularClassChecker>
@@ -34,6 +36,7 @@ internal class ComposedDeclarationCheckers : DeclarationCheckers() {
 
     private val _basicDeclarationCheckers: MutableSet<FirBasicDeclarationChecker> = mutableSetOf()
     private val _memberDeclarationCheckers: MutableSet<FirMemberDeclarationChecker> = mutableSetOf()
+    private val _functionCheckers: MutableSet<FirFunctionChecker> = mutableSetOf()
     private val _propertyCheckers: MutableSet<FirPropertyChecker> = mutableSetOf()
     private val _regularClassCheckers: MutableSet<FirRegularClassChecker> = mutableSetOf()
     private val _constructorCheckers: MutableSet<FirConstructorChecker> = mutableSetOf()
@@ -45,6 +48,7 @@ internal class ComposedDeclarationCheckers : DeclarationCheckers() {
     internal fun register(checkers: DeclarationCheckers) {
         _basicDeclarationCheckers += checkers.allBasicDeclarationCheckers
         _memberDeclarationCheckers += checkers.allMemberDeclarationCheckers
+        _functionCheckers += checkers.allFunctionCheckers
         _propertyCheckers += checkers.allPropertyCheckers
         _regularClassCheckers += checkers.allRegularClassCheckers
         _constructorCheckers += checkers.allConstructorCheckers

compiler/fir/checkers/gen/org/jetbrains/kotlin/fir/analysis/checkers/declaration/DeclarationCheckers.kt

@@ -21,6 +21,7 @@ abstract class DeclarationCheckers {
 
     open val basicDeclarationCheckers: Set<FirBasicDeclarationChecker> = emptySet()
     open val memberDeclarationCheckers: Set<FirMemberDeclarationChecker> = emptySet()
+    open val functionCheckers: Set<FirFunctionChecker> = emptySet()
     open val propertyCheckers: Set<FirPropertyChecker> = emptySet()
     open val regularClassCheckers: Set<FirRegularClassChecker> = emptySet()
     open val constructorCheckers: Set<FirConstructorChecker> = emptySet()
@@ -31,8 +32,9 @@ abstract class DeclarationCheckers {
 
     @CheckersComponentInternal internal val allBasicDeclarationCheckers: Set<FirBasicDeclarationChecker> get() = basicDeclarationCheckers
     @CheckersComponentInternal internal val allMemberDeclarationCheckers: Set<FirMemberDeclarationChecker> get() = memberDeclarationCheckers + allBasicDeclarationCheckers
+    @CheckersComponentInternal internal val allFunctionCheckers: Set<FirFunctionChecker> get() = functionCheckers + allBasicDeclarationCheckers
     @CheckersComponentInternal internal val allPropertyCheckers: Set<FirPropertyChecker> get() = propertyCheckers + allMemberDeclarationCheckers
     @CheckersComponentInternal internal val allRegularClassCheckers: Set<FirRegularClassChecker> get() = regularClassCheckers + allMemberDeclarationCheckers
-    @CheckersComponentInternal internal val allConstructorCheckers: Set<FirConstructorChecker> get() = constructorCheckers + allMemberDeclarationCheckers
+    @CheckersComponentInternal internal val allConstructorCheckers: Set<FirConstructorChecker> get() = constructorCheckers + allFunctionCheckers
     @CheckersComponentInternal internal val allFileCheckers: Set<FirFileChecker> get() = fileCheckers + allBasicDeclarationCheckers
 }

compiler/fir/checkers/gen/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirDeclarationCheckerAliases.kt

@@ -13,12 +13,14 @@ package org.jetbrains.kotlin.fir.analysis.checkers.declaration
 import org.jetbrains.kotlin.fir.declarations.FirConstructor
 import org.jetbrains.kotlin.fir.declarations.FirDeclaration
 import org.jetbrains.kotlin.fir.declarations.FirFile
+import org.jetbrains.kotlin.fir.declarations.FirFunction
 import org.jetbrains.kotlin.fir.declarations.FirMemberDeclaration
 import org.jetbrains.kotlin.fir.declarations.FirProperty
 import org.jetbrains.kotlin.fir.declarations.FirRegularClass
 
 typealias FirBasicDeclarationChecker = FirDeclarationChecker<FirDeclaration>
 typealias FirMemberDeclarationChecker = FirDeclarationChecker<FirMemberDeclaration>
+typealias FirFunctionChecker = FirDeclarationChecker<FirFunction<*>>
 typealias FirPropertyChecker = FirDeclarationChecker<FirProperty>
 typealias FirRegularClassChecker = FirDeclarationChecker<FirRegularClass>
 typealias FirConstructorChecker = FirDeclarationChecker<FirConstructor>

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirFunctionNameChecker.kt

+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.fir.analysis.checkers.declaration
+
+import org.jetbrains.kotlin.fir.FirFakeSourceElementKind
+import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
+import org.jetbrains.kotlin.fir.analysis.checkers.extended.report
+import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter
+import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors
+import org.jetbrains.kotlin.fir.declarations.FirClass
+import org.jetbrains.kotlin.fir.declarations.FirFile
+import org.jetbrains.kotlin.fir.declarations.FirFunction
+import org.jetbrains.kotlin.fir.declarations.FirSimpleFunction
+import org.jetbrains.kotlin.name.SpecialNames
+
+object FirFunctionNameChecker : FirFunctionChecker() {
+    override fun check(declaration: FirFunction<*>, context: CheckerContext, reporter: DiagnosticReporter) {
+        val source = declaration.source
+        if (source == null || source.kind is FirFakeSourceElementKind) return
+        val containingDeclaration = context.containingDeclarations.lastOrNull()
+        val isNonLocal = containingDeclaration is FirFile || containingDeclaration is FirClass<*>
+        if (declaration is FirSimpleFunction && declaration.name == SpecialNames.NO_NAME_PROVIDED && isNonLocal) {
+            reporter.report(source, FirErrors.FUNCTION_DECLARATION_WITH_NO_NAME)
+        }
+    }
+}

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/collectors/components/DeclarationCheckersDiagnosticComponent.kt

@@ -30,7 +30,7 @@ class DeclarationCheckersDiagnosticComponent(
     }
 
     override fun visitSimpleFunction(simpleFunction: FirSimpleFunction, data: CheckerContext) {
-        checkers.memberDeclarationCheckers.check(simpleFunction, data, reporter)
+        (checkers.memberDeclarationCheckers + checkers.functionCheckers).check(simpleFunction, data, reporter)
     }
 
     override fun visitTypeAlias(typeAlias: FirTypeAlias, data: CheckerContext) {
@@ -38,7 +38,7 @@ class DeclarationCheckersDiagnosticComponent(
     }
 
     override fun visitConstructor(constructor: FirConstructor, data: CheckerContext) {
-        checkers.constructorCheckers.check(constructor, data, reporter)
+        (checkers.memberDeclarationCheckers + checkers.constructorCheckers).check(constructor, data, reporter)
     }
 
     override fun visitAnonymousFunction(anonymousFunction: FirAnonymousFunction, data: CheckerContext) {

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/FirDefaultErrorMessages.kt

@@ -54,6 +54,7 @@ import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.EXPOSED_SUPER_CLA
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.EXPOSED_SUPER_INTERFACE
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.EXPOSED_TYPEALIAS_EXPANDED_TYPE
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.EXPOSED_TYPE_PARAMETER_BOUND
+import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.FUNCTION_DECLARATION_WITH_NO_NAME
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.HIDDEN
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.ILLEGAL_CONST_EXPRESSION
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.ILLEGAL_UNDERSCORE
@@ -353,6 +354,8 @@ class FirDefaultErrorMessages : DefaultErrorMessages.Extension {
             map.put(NON_ABSTRACT_FUNCTION_WITH_NO_BODY, "Function ''{0}'' without a body must be abstract", DECLARATION_NAME)
             map.put(PRIVATE_FUNCTION_WITH_NO_BODY, "Function ''{0}'' without body cannot be private", DECLARATION_NAME)
 
+            map.put(FUNCTION_DECLARATION_WITH_NO_NAME, "Function declaration must have a name")
+
             // Properties & accessors
             map.put(
                 ABSTRACT_PROPERTY_IN_NON_ABSTRACT_CLASS,

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/FirErrors.kt

@@ -153,6 +153,8 @@ object FirErrors {
     val NON_ABSTRACT_FUNCTION_WITH_NO_BODY by error1<FirSourceElement, KtFunction, FirMemberDeclaration>(SourceElementPositioningStrategies.DECLARATION_SIGNATURE)
     val PRIVATE_FUNCTION_WITH_NO_BODY by error1<FirSourceElement, KtFunction, FirMemberDeclaration>(SourceElementPositioningStrategies.VISIBILITY_MODIFIER)
 
+    val FUNCTION_DECLARATION_WITH_NO_NAME by error0<FirSourceElement, KtFunction>(SourceElementPositioningStrategies.DECLARATION_SIGNATURE)
+
     // Properties & accessors
     val ABSTRACT_PROPERTY_IN_NON_ABSTRACT_CLASS by error2<FirSourceElement, KtModifierListOwner, FirMemberDeclaration, FirMemberDeclaration>(SourceElementPositioningStrategies.MODALITY_MODIFIER)
     val PRIVATE_PROPERTY_IN_INTERFACE by error0<FirSourceElement, KtProperty>(SourceElementPositioningStrategies.VISIBILITY_MODIFIER)

compiler/fir/entrypoint/src/org/jetbrains/kotlin/fir/checkers/CommonDeclarationCheckers.kt

@@ -28,6 +28,10 @@ object CommonDeclarationCheckers : DeclarationCheckers() {
         FirSealedSupertypeChecker,
     )
 
+    override val functionCheckers: Set<FirFunctionChecker> = setOf(
+        FirFunctionNameChecker,
+    )
+
     override val propertyCheckers: Set<FirPropertyChecker> = setOf(
         FirInapplicableLateinitChecker,
         FirDestructuringDeclarationInitializerChecker,

compiler/testData/diagnostics/tests/declarationChecks/FunctionWithMissingNames.fir.kt

@@ -3,18 +3,18 @@ annotation class a
 interface A
 interface B
 
-fun () {}
-fun A.() {}
+<!FUNCTION_DECLARATION_WITH_NO_NAME!>fun ()<!> {}
+<!FUNCTION_DECLARATION_WITH_NO_NAME!>fun A.()<!> {}
 
-@a fun () {}
-fun @a A.() {}
+<!FUNCTION_DECLARATION_WITH_NO_NAME!>@a fun ()<!> {}
+<!FUNCTION_DECLARATION_WITH_NO_NAME!>fun @a A.()<!> {}
 
 class Outer {
-    fun () {}
-    fun B.() {}
+    <!FUNCTION_DECLARATION_WITH_NO_NAME!>fun ()<!> {}
+    <!FUNCTION_DECLARATION_WITH_NO_NAME!>fun B.()<!> {}
 
-    @a fun () {}
-    fun @a A.() {}
+    <!FUNCTION_DECLARATION_WITH_NO_NAME!>@a fun ()<!> {}
+    <!FUNCTION_DECLARATION_WITH_NO_NAME!>fun @a A.()<!> {}
 }
 
 fun outerFun() {

compiler/testData/diagnostics/tests/duplicateJvmSignature/missingNames.fir.kt

 // !DIAGNOSTICS: -DUPLICATE_CLASS_NAMES
-fun () {
+<!FUNCTION_DECLARATION_WITH_NO_NAME!>fun ()<!> {
 
 }
 
-fun Outer.() {
+<!FUNCTION_DECLARATION_WITH_NO_NAME!>fun Outer.()<!> {
 
 }
 
@@ -30,7 +30,7 @@ annotation class<!SYNTAX!><!> {
 }
 
 class Outer {
-    fun () {
+    <!FUNCTION_DECLARATION_WITH_NO_NAME!>fun ()<!> {
 
     }
 

compiler/testData/diagnostics/tests/recovery/namelessInJava.fir.kt

-// SKIP_JAVAC
-// FILE: p/Nameless.java
-
-package p;
-
-public class Nameless {
-    void () {}
-    int ;
-}
-
-// FILE: k.kt
-
-import p.*
-
-class K : Nameless() {
-    fun () {}
-    val<!SYNTAX!><!> : Int = 1
-}

compiler/testData/diagnostics/tests/recovery/namelessInJava.kt

+// FIR_IDENTICAL
 // SKIP_JAVAC
 // FILE: p/Nameless.java
 

compiler/testData/diagnostics/tests/recovery/namelessMembers.fir.kt

-// !DIAGNOSTICS: -REDECLARATION -DUPLICATE_CLASS_NAMES
-
-class C {
-    fun () {
-
-    }
-
-    val<!SYNTAX!><!> : Int = 1
-
-    class<!SYNTAX!><!> {}
-
-    enum class<!SYNTAX!><!> {}
-}
-
-class C1<<!SYNTAX!>in<!>> {}
-
-class C2(val<!SYNTAX!><!>) {}
\ No newline at end of file

compiler/testData/diagnostics/tests/recovery/namelessMembers.kt

+// FIR_IDENTICAL
 // !DIAGNOSTICS: -REDECLARATION -DUPLICATE_CLASS_NAMES
 
 class C {

compiler/testData/diagnostics/tests/recovery/namelessToplevelDeclarations.fir.kt

@@ -2,7 +2,7 @@
 
 package<!SYNTAX!><!>
 
-fun () {
+<!FUNCTION_DECLARATION_WITH_NO_NAME!>fun ()<!> {
 
 }