use terms "lambda expression" and "anonymous function" instead of "function literal" and "function expression"

compiler/testData/diagnostics/tests/annotations/options/functions.kt

@@ -20,8 +20,8 @@ fun foo(arg: Int) {
     // Literal is annotatable
     bar @FunAnn { arg }
     // Annotatable in principle but useless, fast is inline
-    fast <!NON_SOURCE_ANNOTATION_ON_INLINED_FUNCTION_LITERAL!>@FunAnn<!> { arg }
-    fast2(1, <!NON_SOURCE_ANNOTATION_ON_INLINED_FUNCTION_LITERAL!>@FunAnn<!> { arg })
+    fast <!NON_SOURCE_ANNOTATION_ON_INLINED_LAMBDA_EXPRESSION!>@FunAnn<!> { arg }
+    fast2(1, <!NON_SOURCE_ANNOTATION_ON_INLINED_LAMBDA_EXPRESSION!>@FunAnn<!> { arg })
     // Source annotation, ok
     fast @SourceAnn { arg }
     fast2(1, @SourceAnn { arg })

compiler/testData/diagnostics/tests/checkArguments/kt1897_diagnostic_part.kt

@@ -24,5 +24,5 @@ fun test() {
 
     foo(<!TYPE_MISMATCH!>""<!>, <!CONSTANT_EXPECTED_TYPE_MISMATCH!>1<!>) <!TOO_MANY_ARGUMENTS!>{}<!>
 
-    foo(<!TYPE_MISMATCH!>""<!>, <!CONSTANT_EXPECTED_TYPE_MISMATCH!>1<!>) <!TOO_MANY_ARGUMENTS!>{}<!> <!MANY_FUNCTION_LITERAL_ARGUMENTS!>{}<!>
+    foo(<!TYPE_MISMATCH!>""<!>, <!CONSTANT_EXPECTED_TYPE_MISMATCH!>1<!>) <!TOO_MANY_ARGUMENTS!>{}<!> <!MANY_LAMBDA_EXPRESSION_ARGUMENTS!>{}<!>
 }

compiler/testData/diagnostics/tests/controlFlowAnalysis/kt1977.kt

@@ -29,7 +29,7 @@ fun test2(s : String) : Int? {
         Integer.parseInt(s)
         22
     } finally {
-            <!UNUSED_FUNCTION_LITERAL!>{
+            <!UNUSED_LAMBDA_EXPRESSION!>{
             x : Int -> x
             }<!>
     }

compiler/testData/diagnostics/tests/controlStructures/lambdasInExclExclAndElvis.kt

@@ -3,13 +3,13 @@
 fun use(a: Any?) = a
 
 fun test() {
-    { }<!NOT_NULL_ASSERTION_ON_FUNCTION_LITERAL!>!!<!>
-    use({ }<!NOT_NULL_ASSERTION_ON_FUNCTION_LITERAL!>!!<!>);
+    { }<!NOT_NULL_ASSERTION_ON_LAMBDA_EXPRESSION!>!!<!>
+    use({ }<!NOT_NULL_ASSERTION_ON_LAMBDA_EXPRESSION!>!!<!>);
 
     // KT-KT-9070
-    <!TYPE_MISMATCH!>{ }<!> <!USELESS_ELVIS!><!USELESS_ELVIS_ON_FUNCTION_LITERAL!>?:<!> 1<!>
-    use({ 2 } <!USELESS_ELVIS_ON_FUNCTION_LITERAL!>?:<!> 1);
+    <!TYPE_MISMATCH!>{ }<!> <!USELESS_ELVIS!><!USELESS_ELVIS_ON_LAMBDA_EXPRESSION!>?:<!> 1<!>
+    use({ 2 } <!USELESS_ELVIS_ON_LAMBDA_EXPRESSION!>?:<!> 1);
 
-    1 <!USELESS_ELVIS!>?: <!TYPE_MISMATCH, UNUSED_FUNCTION_LITERAL!>{ }<!><!>
+    1 <!USELESS_ELVIS!>?: <!TYPE_MISMATCH, UNUSED_LAMBDA_EXPRESSION!>{ }<!><!>
     use(1 <!USELESS_ELVIS!>?: { }<!>)
 }

compiler/testData/diagnostics/tests/functionAsExpression/NameDeprecation.kt

@@ -3,9 +3,9 @@ fun foo() {
 
     class A
     fun bar() {}
-    (fun <!FUNCTION_EXPRESSION_WITH_NAME!>bar<!>() {})
+    (fun <!ANONYMOUS_FUNCTION_WITH_NAME!>bar<!>() {})
     fun A.foo() {}
-    (fun A.<!FUNCTION_EXPRESSION_WITH_NAME!>foo<!>() {})
+    (fun A.<!ANONYMOUS_FUNCTION_WITH_NAME!>foo<!>() {})
 
-    run(fun <!FUNCTION_EXPRESSION_WITH_NAME!>foo<!>() {})
+    run(fun <!ANONYMOUS_FUNCTION_WITH_NAME!>foo<!>() {})
 }

compiler/testData/diagnostics/tests/functionAsExpression/Parameters.kt

@@ -1,18 +1,18 @@
 // !DIAGNOSTICS: -UNUSED_PARAMETER -UNUSED_VARIABLE
 
-val bar = fun(p: Int = <!FUNCTION_EXPRESSION_PARAMETER_WITH_DEFAULT_VALUE!>3<!>) {}
+val bar = fun(p: Int = <!ANONYMOUS_FUNCTION_PARAMETER_WITH_DEFAULT_VALUE!>3<!>) {}
 val bas = fun(<!USELESS_VARARG_ON_PARAMETER!>vararg p: Int<!>) {}
 
-fun gar() = fun(p: Int = <!FUNCTION_EXPRESSION_PARAMETER_WITH_DEFAULT_VALUE!>3<!>) {}
+fun gar() = fun(p: Int = <!ANONYMOUS_FUNCTION_PARAMETER_WITH_DEFAULT_VALUE!>3<!>) {}
 fun gas() = fun(<!USELESS_VARARG_ON_PARAMETER!>vararg p: Int<!>) {}
 
 fun outer(b: Any?) {
-    val bar = fun(p: Int = <!FUNCTION_EXPRESSION_PARAMETER_WITH_DEFAULT_VALUE!>3<!>) {}
+    val bar = fun(p: Int = <!ANONYMOUS_FUNCTION_PARAMETER_WITH_DEFAULT_VALUE!>3<!>) {}
     val bas = fun(<!USELESS_VARARG_ON_PARAMETER!>vararg p: Int<!>) {}
 
-    fun gar() = fun(p: Int = <!FUNCTION_EXPRESSION_PARAMETER_WITH_DEFAULT_VALUE!>3<!>) {}
+    fun gar() = fun(p: Int = <!ANONYMOUS_FUNCTION_PARAMETER_WITH_DEFAULT_VALUE!>3<!>) {}
     fun gas() = fun(<!USELESS_VARARG_ON_PARAMETER!>vararg p: Int<!>) {}
 
-    outer(fun(p: Int = <!FUNCTION_EXPRESSION_PARAMETER_WITH_DEFAULT_VALUE!>3<!>) {})
+    outer(fun(p: Int = <!ANONYMOUS_FUNCTION_PARAMETER_WITH_DEFAULT_VALUE!>3<!>) {})
     outer(fun(<!USELESS_VARARG_ON_PARAMETER!>vararg p: Int<!>) {})
 }

compiler/testData/diagnostics/tests/functionLiterals/unusedLiteral.kt

@@ -1,12 +1,12 @@
 fun unusedLiteral(){
-    <!UNUSED_FUNCTION_LITERAL!>{ ->
+    <!UNUSED_LAMBDA_EXPRESSION!>{ ->
         val <!UNUSED_VARIABLE!>i<!> = 1
     }<!>
 }
 
 
 fun unusedLiteralInDoWhile(){
-    do<!UNUSED_FUNCTION_LITERAL!>{ ->
+    do<!UNUSED_LAMBDA_EXPRESSION!>{ ->
             val <!UNUSED_VARIABLE!>i<!> = 1
     }<!> while(false)
 }

compiler/testData/diagnostics/tests/functionLiterals/unusedLiteralInsideUnitLiteral.kt

@@ -1,6 +1,6 @@
 fun main(args: Array<String>) {
     "".run {
-        <!UNUSED_FUNCTION_LITERAL!>{}<!>
+        <!UNUSED_LAMBDA_EXPRESSION!>{}<!>
     }
 }
 

compiler/testData/diagnostics/tests/incompleteCode/pseudocodeTraverseNextInstructions.kt

@@ -2,7 +2,7 @@ package b
 
 fun foo() {
     for (i in <!UNRESOLVED_REFERENCE!>collection<!>) {
-        <!UNUSED_FUNCTION_LITERAL!>{
+        <!UNUSED_LAMBDA_EXPRESSION!>{
          <!BREAK_OR_CONTINUE_JUMPS_ACROSS_FUNCTION_BOUNDARY!>break<!>
     }<!>
 }<!SYNTAX!><!>

compiler/testData/diagnostics/tests/labels/kt361.kt

@@ -1,5 +1,5 @@
 fun nonlocals(b : Boolean) {
-    a@<!UNUSED_FUNCTION_LITERAL!>{
+    a@<!UNUSED_LAMBDA_EXPRESSION!>{
         fun foo() {
             if (b) {
                 <!RETURN_NOT_ALLOWED!>return@a 1<!> // The label must be resolved, but an error should be reported for a non-local return

compiler/testData/diagnostics/tests/regressions/kt402.kt

@@ -1,7 +1,7 @@
 package kt402
 
 fun getTypeChecker() : (Any)->Boolean {
-  <!UNUSED_FUNCTION_LITERAL!>{ a : Any -> a is <!UNRESOLVED_REFERENCE!>T<!> }<!> // reports unsupported
+  <!UNUSED_LAMBDA_EXPRESSION!>{ a : Any -> a is <!UNRESOLVED_REFERENCE!>T<!> }<!> // reports unsupported
 <!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
 fun f() : (Any) -> Boolean {
   return { a : Any -> a is String }

compiler/testData/diagnostics/tests/shadowing/ShadowParameterInNestedBlockInFor.kt

@@ -1,6 +1,6 @@
 fun f(<!UNUSED_PARAMETER!>i<!>: Int) {
     for (j in 1..100) {
-        <!UNUSED_FUNCTION_LITERAL!>{
+        <!UNUSED_LAMBDA_EXPRESSION!>{
             var <!NAME_SHADOWING, UNUSED_VARIABLE!>i<!> = 12
         }<!>
     }

compiler/testData/diagnostics/tests/shadowing/ShadowVariableInNestedBlock.kt

@@ -1,6 +1,6 @@
 fun ff(): Int {
     var i = 1
-    <!UNUSED_FUNCTION_LITERAL!>{
+    <!UNUSED_LAMBDA_EXPRESSION!>{
         val <!NAME_SHADOWING, UNUSED_VARIABLE!>i<!> = 2
     }<!>
     return i

compiler/testData/diagnostics/tests/shadowing/ShadowVariableInNestedClosure.kt

@@ -1,5 +1,5 @@
 fun f(): Int {
     var i = 17
-    <!UNUSED_FUNCTION_LITERAL!>{ var <!NAME_SHADOWING, UNUSED_VARIABLE!>i<!> = 18 }<!>
+    <!UNUSED_LAMBDA_EXPRESSION!>{ var <!NAME_SHADOWING, UNUSED_VARIABLE!>i<!> = 18 }<!>
     return i
 }

compiler/testData/diagnostics/tests/shadowing/ShadowVariableInNestedClosureParam.kt

@@ -1,5 +1,5 @@
 fun ff(): Int {
     var i = 1
-    <!UNUSED_FUNCTION_LITERAL!>{ i: Int -> i }<!>
+    <!UNUSED_LAMBDA_EXPRESSION!>{ i: Int -> i }<!>
     return i
 }

compiler/testData/diagnostics/tests/smartCasts/loops/doWhileLiteral.kt

@@ -2,7 +2,7 @@ fun x(): Boolean { return true }
 
 public fun foo(p: String?): Int {
     // Exotic variant with unused literal
-    do <!UNUSED_FUNCTION_LITERAL!>{ ->
+    do <!UNUSED_LAMBDA_EXPRESSION!>{ ->
         p!!.length
     }<!> while (!x())
     // Literal is not called so p.length is unsafe