Extracted 'deparenthesizeArgument', used it where necessary

#KT-6176 Fixed

compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/ArgumentTypeResolver.java

@@ -139,6 +139,15 @@ public class ArgumentTypeResolver {
 
     @Nullable
     private static JetFunctionLiteralExpression getFunctionLiteralArgumentIfAny(@NotNull JetExpression expression) {
+        JetExpression deparenthesizedExpression = deparenthesizeArgument(expression);
+        if (deparenthesizedExpression instanceof JetFunctionLiteralExpression) {
+            return (JetFunctionLiteralExpression) deparenthesizedExpression;
+        }
+        return null;
+    }
+
+    @Nullable
+    public static JetExpression deparenthesizeArgument(@Nullable JetExpression expression) {
         JetExpression deparenthesizedExpression = JetPsiUtil.deparenthesize(expression, false);
         if (deparenthesizedExpression instanceof JetBlockExpression) {
             // todo
@@ -147,13 +156,10 @@ public class ArgumentTypeResolver {
             // (no arguments and no receiver) and therefore analyze them straight away (not in the 'complete' phase).
             JetElement lastStatementInABlock = JetPsiUtil.getLastStatementInABlock((JetBlockExpression) deparenthesizedExpression);
             if (lastStatementInABlock instanceof JetExpression) {
-                deparenthesizedExpression = JetPsiUtil.deparenthesize((JetExpression) lastStatementInABlock, false);
+                return deparenthesizeArgument((JetExpression) lastStatementInABlock);
             }
         }
-        if (deparenthesizedExpression instanceof JetFunctionLiteralExpression) {
-            return (JetFunctionLiteralExpression) deparenthesizedExpression;
-        }
-        return null;
+        return deparenthesizedExpression;
     }
 
     @NotNull
@@ -263,7 +269,7 @@ public class ArgumentTypeResolver {
         return type;
     }
 
-    public static <D extends CallableDescriptor> void updateNumberType(
+    public static void updateNumberType(
             @NotNull JetType numberType,
             @Nullable JetExpression expression,
             @NotNull BindingTrace trace
@@ -272,16 +278,10 @@ public class ArgumentTypeResolver {
         BindingContextUtils.updateRecordedType(numberType, expression, trace, false);
 
         if (!(expression instanceof JetConstantExpression)) {
-            JetExpression deparenthesized = JetPsiUtil.deparenthesize(expression, false);
+            JetExpression deparenthesized = deparenthesizeArgument(expression);
             if (deparenthesized != expression) {
                 updateNumberType(numberType, deparenthesized, trace);
             }
-            if (deparenthesized instanceof JetBlockExpression) {
-                JetElement lastStatement = JetPsiUtil.getLastStatementInABlock((JetBlockExpression) deparenthesized);
-                if (lastStatement instanceof JetExpression) {
-                    updateNumberType(numberType, (JetExpression) lastStatement, trace);
-                }
-            }
             return;
         }
 

compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallCompleter.kt

@@ -229,12 +229,13 @@ public class CallCompleter(
         if (valueArgument.isExternal()) return
 
         val expression = valueArgument.getArgumentExpression()
-        if (expression == null) return
+        val deparenthesized = ArgumentTypeResolver.deparenthesizeArgument(expression)
+        if (deparenthesized == null) return
 
         val recordedType = context.trace[BindingContext.EXPRESSION_TYPE, expression]
         var updatedType: JetType? = recordedType
 
-        val results = completeCallForArgument(expression, context)
+        val results = completeCallForArgument(deparenthesized, context)
         if (results != null && results.isSingleResult()) {
             val resolvedCall = results.getResultingCall()
             updatedType = if (resolvedCall.hasInferredReturnType()) resolvedCall.getResultingDescriptor()?.getReturnType() else null
@@ -256,14 +257,16 @@ public class CallCompleter(
                     context as CallResolutionContext<*>, RESOLVE_FUNCTION_ARGUMENTS)
         }
 
-        DataFlowUtils.checkType(updatedType, expression, context as ResolutionContext<*>)
+        DataFlowUtils.checkType(updatedType, deparenthesized, context as ResolutionContext<*>)
     }
 
     private fun completeCallForArgument(
             expression: JetExpression,
             context: BasicCallResolutionContext
     ): OverloadResolutionResultsImpl<*>? {
-        val argumentCall = getCallForArgument(expression, context.trace.getBindingContext())
+        if (!ExpressionTypingUtils.dependsOnExpectedType(expression)) return null
+
+        val argumentCall = expression.getCall(context.trace.getBindingContext())
         if (argumentCall == null) return null
 
         val cachedDataForCall = context.resolutionResultsCache[argumentCall]
@@ -278,17 +281,6 @@ public class CallCompleter(
         return completeCall(contextForArgument, cachedResults, tracing)
     }
 
-    private fun getCallForArgument(argument: JetExpression?, bindingContext: BindingContext): Call? {
-        if (!ExpressionTypingUtils.dependsOnExpectedType(argument)) {
-            return null
-        }
-        if (argument is JetBlockExpression) {
-            val lastStatement = JetPsiUtil.getLastStatementInABlock(argument)
-            return getCallForArgument(lastStatement as? JetExpression, bindingContext)
-        }
-        return argument?.getCall(bindingContext)
-    }
-
     private fun updateRecordedTypeForArgument(
             updatedType: JetType?,
             recordedType: JetType?,

compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CandidateResolver.java

@@ -52,6 +52,7 @@ import java.util.*;
 
 import static org.jetbrains.jet.lang.diagnostics.Errors.PROJECTION_ON_NON_CLASS_TYPE_ARGUMENT;
 import static org.jetbrains.jet.lang.diagnostics.Errors.SUPER_IS_NOT_AN_EXPRESSION;
+import static org.jetbrains.jet.lang.resolve.calls.ArgumentTypeResolver.deparenthesizeArgument;
 import static org.jetbrains.jet.lang.resolve.calls.CallResolverUtil.ResolveArgumentsMode.RESOLVE_FUNCTION_ARGUMENTS;
 import static org.jetbrains.jet.lang.resolve.calls.CallResolverUtil.ResolveArgumentsMode.SHAPE_FUNCTION_ARGUMENTS;
 import static org.jetbrains.jet.lang.resolve.calls.CallTransformer.CallForImplicitInvoke;
@@ -396,10 +397,10 @@ public class CandidateResolver {
             @NotNull DataFlowInfo dataFlowInfoForArgument,
             @NotNull BindingTrace trace
     ) {
-        if (argumentExpression == null || type == null) return type;
+        JetExpression deparenthesizedArgument = deparenthesizeArgument(argumentExpression);
+        if (deparenthesizedArgument == null || type == null) return type;
 
-        DataFlowValue dataFlowValue = DataFlowValueFactory.createDataFlowValue(
-                argumentExpression, type, trace.getBindingContext());
+        DataFlowValue dataFlowValue = DataFlowValueFactory.createDataFlowValue(deparenthesizedArgument, type, trace.getBindingContext());
         if (!dataFlowValue.isStableIdentifier()) return type;
 
         Set<JetType> possibleTypes = dataFlowInfoForArgument.getPossibleTypes(dataFlowValue);

compiler/testData/codegen/box/diagnostics/functions/inference/kt6176.kt

@@ -0,0 +1,25 @@
+// !DIAGNOSTICS: -DEBUG_INFO_SMARTCAST
+
+fun <R> foo(f: () -> R): R = f()
+
+fun <T : Any> some(v: T?, b: T): T {
+    return foo {
+        if (v != null) {
+            v
+        }
+        else {
+            b
+        }
+    }
+}
+
+fun <T : Any> some1(v: T?, b: T): T {
+    return foo { if (v != null) v else b }
+}
+
+fun box() = when {
+    some(1, 2) != 1 -> "fail 1"
+    some(null, 2) != 2 -> "fail 2"
+    some1(1, 2) != 1 -> "fail 3"
+    else -> "OK"
+}

compiler/testData/codegen/box/diagnostics/functions/inference/kt6176.lazy.log

@@ -0,0 +1,63 @@
+DescriptorResolver@0 {
+    <name not found> = JetTypeImpl@1['String']
+}
+
+LazyJavaPackageFragmentProvider@2 {
+    packageFragments('<root>': FqName@3) = LazyJavaPackageFragment@4['<root>']
+    packageFragments('Any': FqName@5) = null
+    packageFragments('R': FqName@6) = null
+    packageFragments('T': FqName@7) = null
+    packageFragments('java': FqName@8) = LazyJavaPackageFragment@9['java']
+    packageFragments('java.lang': FqName@10) = LazyJavaPackageFragment@11['lang']
+    packageFragments('java.lang.Any': FqName@12) = null
+    packageFragments('java.lang.R': FqName@13) = null
+    packageFragments('java.lang.T': FqName@14) = null
+    packageFragments('kotlin': FqName@15) = null
+    packageFragments('kotlin.Any': FqName@16) = null
+    packageFragments('kotlin.R': FqName@17) = null
+    packageFragments('kotlin.T': FqName@18) = null
+    packageFragments('kotlin.io': FqName@19) = null
+    packageFragments('kotlin.jvm': FqName@20) = null
+}
+
+LazyJavaPackageFragment@4['<root>'] {
+    classes('Any': Name@21) = null // through LazyPackageFragmentScopeForJavaPackage@22
+    classes('equals': Name@23) = null // through LazyPackageFragmentScopeForJavaPackage@22
+    classes('f': Name@24) = null // through LazyPackageFragmentScopeForJavaPackage@22
+    classes('foo': Name@25) = null // through LazyPackageFragmentScopeForJavaPackage@22
+    classes('invoke': Name@26) = null // through LazyPackageFragmentScopeForJavaPackage@22
+    classes('some': Name@27) = null // through LazyPackageFragmentScopeForJavaPackage@22
+    classes('some1': Name@28) = null // through LazyPackageFragmentScopeForJavaPackage@22
+    deserializedPackageScope = Empty@29 // through LazyPackageFragmentScopeForJavaPackage@22
+    functions('equals': Name@23) = EmptyList@30[empty] // through LazyPackageFragmentScopeForJavaPackage@22
+    functions('f': Name@24) = EmptyList@30[empty] // through LazyPackageFragmentScopeForJavaPackage@22
+    functions('foo': Name@25) = EmptyList@30[empty] // through LazyPackageFragmentScopeForJavaPackage@22
+    functions('invoke': Name@26) = EmptyList@30[empty] // through LazyPackageFragmentScopeForJavaPackage@22
+    functions('some': Name@27) = EmptyList@30[empty] // through LazyPackageFragmentScopeForJavaPackage@22
+    functions('some1': Name@28) = EmptyList@30[empty] // through LazyPackageFragmentScopeForJavaPackage@22
+    memberIndex = computeMemberIndex$1@31 // through LazyPackageFragmentScopeForJavaPackage@22
+}
+
+LazyJavaPackageFragment@9['java'] {
+    classes('lang': Name@32) = null // through LazyPackageFragmentScopeForJavaPackage@33
+    deserializedPackageScope = Empty@29 // through LazyPackageFragmentScopeForJavaPackage@33
+    functions('lang': Name@34) = EmptyList@30[empty] // through LazyPackageFragmentScopeForJavaPackage@33
+    memberIndex = computeMemberIndex$1@35 // through LazyPackageFragmentScopeForJavaPackage@33
+}
+
+LazyJavaPackageFragment@11['lang'] {
+    classes('equals': Name@23) = null // through LazyPackageFragmentScopeForJavaPackage@36
+    classes('f': Name@24) = null // through LazyPackageFragmentScopeForJavaPackage@36
+    classes('foo': Name@25) = null // through LazyPackageFragmentScopeForJavaPackage@36
+    classes('invoke': Name@26) = null // through LazyPackageFragmentScopeForJavaPackage@36
+    classes('some': Name@27) = null // through LazyPackageFragmentScopeForJavaPackage@36
+    classes('some1': Name@28) = null // through LazyPackageFragmentScopeForJavaPackage@36
+    deserializedPackageScope = Empty@29 // through LazyPackageFragmentScopeForJavaPackage@36
+    functions('equals': Name@23) = EmptyList@30[empty] // through LazyPackageFragmentScopeForJavaPackage@36
+    functions('f': Name@24) = EmptyList@30[empty] // through LazyPackageFragmentScopeForJavaPackage@36
+    functions('foo': Name@25) = EmptyList@30[empty] // through LazyPackageFragmentScopeForJavaPackage@36
+    functions('invoke': Name@26) = EmptyList@30[empty] // through LazyPackageFragmentScopeForJavaPackage@36
+    functions('some': Name@27) = EmptyList@30[empty] // through LazyPackageFragmentScopeForJavaPackage@36
+    functions('some1': Name@28) = EmptyList@30[empty] // through LazyPackageFragmentScopeForJavaPackage@36
+    memberIndex = computeMemberIndex$1@37 // through LazyPackageFragmentScopeForJavaPackage@36
+}

compiler/testData/codegen/box/diagnostics/functions/inference/kt6176.txt

@@ -0,0 +1,6 @@
+package
+
+internal fun box(): kotlin.String
+internal fun </*0*/ R> foo(/*0*/ f: () -> R): R
+internal fun </*0*/ T : kotlin.Any> some(/*0*/ v: T?, /*1*/ b: T): T
+internal fun </*0*/ T : kotlin.Any> some1(/*0*/ v: T?, /*1*/ b: T): T

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

@@ -0,0 +1,15 @@
+// !DIAGNOSTICS: -UNUSED_VARIABLE -UNUSED_EXPRESSION
+
+import java.util.HashSet
+
+fun test123() {
+    val g: (Int) -> Unit = if (true) {
+        val set = HashSet<Int>();
+        { i ->
+            set.add(i)
+        }
+    }
+    else {
+        { it -> it }
+    }
+}

compiler/testData/diagnostics/tests/functionLiterals/functionLiteralInIf.lazy.log

@@ -0,0 +1,359 @@
+LazyJavaClassDescriptor@0['AbstractCollection'] {
+    defaultType = JetTypeImpl@1['AbstractCollection<1>']
+    functions('add': Name@2) = ArrayList@3[1] { JavaMethodDescriptor@4['add'] } // through LazyJavaClassMemberScope@5
+    memberIndex = computeMemberIndex$1@6 // through LazyJavaClassMemberScope@5
+    properties('add': Name@7) = EmptyList@8[empty] // through LazyJavaClassMemberScope@5
+    thisAsReceiverParameter = LazyClassReceiverParameterDescriptor@9['<this>']
+    typeConstructor = LazyJavaClassTypeConstructor@10['AbstractCollection']
+}
+
+LazyJavaClassDescriptor@11['AbstractSet'] {
+    defaultType = JetTypeImpl@12['AbstractSet<1>']
+    functions('add': Name@2) = ArrayList@13[1] { DeserializedSimpleFunctionDescriptor@14['add'] } // through LazyJavaClassMemberScope@15
+    memberIndex = computeMemberIndex$1@16 // through LazyJavaClassMemberScope@15
+    properties('add': Name@7) = EmptyList@8[empty] // through LazyJavaClassMemberScope@15
+    typeConstructor = LazyJavaClassTypeConstructor@17['AbstractSet']
+}
+
+LazyJavaClassDescriptor@18['HashSet'] {
+    constructors = ArrayList@19[5] { JavaConstructorDescriptor@20['<init>'], JavaConstructorDescriptor@21['<init>'], JavaConstructorDescriptor@22['<init>'], ... } // through LazyJavaClassMemberScope@23
+    defaultType = JetTypeImpl@24['HashSet<1>']
+    enumEntryIndex = LinkedHashMap@25 // through LazyJavaClassMemberScope@23
+    functionTypeForSamInterface = null
+    functions('add': Name@7) = ArrayList@26[1] { JavaMethodDescriptor@27['add'] } // through LazyJavaClassMemberScope@23
+    memberIndex = computeMemberIndex$1@28 // through LazyJavaClassMemberScope@23
+    nestedClassIndex = LinkedHashMap@29 // through LazyJavaClassMemberScope@23
+    nestedClasses('add': Name@7) = null // through LazyJavaClassMemberScope@23
+    properties('add': Name@7) = EmptyList@8[empty] // through LazyJavaClassMemberScope@23
+    thisAsReceiverParameter = LazyClassReceiverParameterDescriptor@30['<this>']
+    typeConstructor = LazyJavaClassTypeConstructor@31['HashSet']
+}
+
+LazyJavaClassDescriptor@32['Serializable'] {
+    functions('add': Name@2) = EmptyList@8[empty] // through LazyJavaClassMemberScope@33
+    memberIndex = computeMemberIndex$1@34 // through LazyJavaClassMemberScope@33
+    properties('add': Name@7) = EmptyList@8[empty] // through LazyJavaClassMemberScope@33
+    typeConstructor = LazyJavaClassTypeConstructor@35['Serializable']
+}
+
+LazyJavaClassTypeConstructor@10['AbstractCollection'] {
+    parameters = ArrayList@36[1] { LazyJavaTypeParameterDescriptor@37['E'] }
+    supertypes = ArrayList@38[1] { LazyJavaClassifierType@39['Collection<E>'] }
+}
+
+LazyJavaClassTypeConstructor@17['AbstractSet'] {
+    parameters = ArrayList@40[1] { LazyJavaTypeParameterDescriptor@41['E'] }
+    supertypes = ArrayList@42[2] { LazyJavaClassifierType@43['AbstractCollection<E>'], LazyJavaClassifierType@44['Set<E>'] }
+}
+
+LazyJavaClassTypeConstructor@31['HashSet'] {
+    parameters = ArrayList@45[1] { LazyJavaTypeParameterDescriptor@46['E'] }
+    supertypes = ArrayList@47[4] { LazyJavaClassifierType@48['AbstractSet<E>'], LazyJavaClassifierType@49['Set<E>'], LazyJavaClassifierType@50['Cloneable'], ... }
+}
+
+LazyJavaClassTypeConstructor@35['Serializable'] {
+    parameters = ArrayList@51[empty]
+    supertypes = ArrayList@52[1] { JetTypeImpl@53['Any'] }
+}
+
+LazyJavaClassifierType@43['AbstractCollection<E>'] {
+    arguments = ArrayList@54[1] { TypeProjectionImpl@55 }
+    classifier = JavaClassImpl@56['AbstractCollection']
+    memberScope = SubstitutingScope@57
+    nullable = 'false': Boolean@58
+    typeConstructor = LazyJavaClassTypeConstructor@10['AbstractCollection']
+}
+
+LazyJavaClassifierType@48['AbstractSet<E>'] {
+    arguments = ArrayList@59[1] { TypeProjectionImpl@60 }
+    classifier = JavaClassImpl@61['AbstractSet']
+    memberScope = SubstitutingScope@62
+    typeConstructor = LazyJavaClassTypeConstructor@17['AbstractSet']
+}
+
+LazyJavaClassifierType@50['Cloneable'] {
+    arguments = ArrayList@63[empty]
+    classifier = JavaClassImpl@64['Cloneable']
+    memberScope = DeserializedClassMemberScope@65
+    typeConstructor = DeserializedClassTypeConstructor@66
+}
+
+LazyJavaClassifierType@67['Collection<? extends E>'] {
+    arguments = ArrayList@68[1] { TypeProjectionImpl@69 }
+    classifier = JavaClassImpl@70['Collection']
+    memberScope = SubstitutingScope@71
+    nullable = 'false': Boolean@58
+    typeConstructor = DeserializedClassTypeConstructor@72
+}
+
+LazyJavaClassifierType@73['Collection<? extends E>'] {
+    arguments = ArrayList@74[1] { TypeProjectionImpl@75 }
+    classifier = JavaClassImpl@70['Collection']
+    memberScope = SubstitutingScope@76
+    nullable = 'true': Boolean@77
+    typeConstructor = DeserializedClassTypeConstructor@78
+}
+
+LazyJavaClassifierType@39['Collection<E>'] {
+    arguments = ArrayList@79[1] { TypeProjectionImpl@80 }
+    classifier = JavaClassImpl@81['Collection']
+    memberScope = SubstitutingScope@82
+    typeConstructor = DeserializedClassTypeConstructor@72
+}
+
+LazyJavaClassifierType@83['E'] {
+    arguments = ArrayList@84[empty]
+    classifier = JavaTypeParameterImpl@85['E']
+    nullable = 'false': Boolean@58
+    typeConstructor = AbstractLazyTypeParameterDescriptor$1@86
+}
+
+LazyJavaClassifierType@87['E'] {
+    arguments = ArrayList@88[empty]
+    classifier = JavaTypeParameterImpl@89['E']
+    nullable = 'false': Boolean@58
+    typeConstructor = AbstractLazyTypeParameterDescriptor$1@86
+}
+
+LazyJavaClassifierType@90['E'] {
+    arguments = ArrayList@91[empty]
+    classifier = JavaTypeParameterImpl@92['E']
+    nullable = 'false': Boolean@58
+    typeConstructor = AbstractLazyTypeParameterDescriptor$1@86
+}
+
+LazyJavaClassifierType@93['E'] {
+    arguments = ArrayList@94[empty]
+    classifier = JavaTypeParameterImpl@95['E']
+    nullable = 'false': Boolean@58
+    typeConstructor = AbstractLazyTypeParameterDescriptor$1@86
+}
+
+LazyJavaClassifierType@96['E'] {
+    arguments = ArrayList@97[empty]
+    classifier = JavaTypeParameterImpl@98['E']
+    nullable = 'false': Boolean@58
+    typeConstructor = AbstractLazyTypeParameterDescriptor$1@99
+}
+
+LazyJavaClassifierType@100['E'] {
+    arguments = ArrayList@101[empty]
+    classifier = JavaTypeParameterImpl@102['E']
+    nullable = 'false': Boolean@58
+    typeConstructor = AbstractLazyTypeParameterDescriptor$1@103
+}
+
+LazyJavaClassifierType@104['E'] {
+    arguments = ArrayList@105[empty]
+    classifier = JavaTypeParameterImpl@106['E']
+    nullable = 'false': Boolean@58
+    typeConstructor = AbstractLazyTypeParameterDescriptor$1@103
+}
+
+LazyJavaClassifierType@107['E'] {
+    arguments = ArrayList@108[empty]
+    classifier = JavaTypeParameterImpl@109['E']
+    nullable = 'false': Boolean@58
+    typeConstructor = AbstractLazyTypeParameterDescriptor$1@86
+}
+
+LazyJavaClassifierType@110['E'] {
+    arguments = ArrayList@111[empty]
+    classifier = JavaTypeParameterImpl@112['E']
+    nullable = 'false': Boolean@58
+    typeConstructor = AbstractLazyTypeParameterDescriptor$1@99
+}
+
+LazyJavaClassifierType@113['E'] {
+    arguments = ArrayList@114[empty]
+    classifier = JavaTypeParameterImpl@112['E']
+    nullable = 'true': Boolean@77
+    typeConstructor = AbstractLazyTypeParameterDescriptor$1@99
+}
+
+LazyJavaClassifierType@115['E'] {
+    arguments = ArrayList@116[empty]
+    classifier = JavaTypeParameterImpl@85['E']
+    nullable = 'true': Boolean@77
+    typeConstructor = AbstractLazyTypeParameterDescriptor$1@86
+}
+
+LazyJavaClassifierType@117['E'] {
+    arguments = ArrayList@118[empty]
+    classifier = JavaTypeParameterImpl@109['E']
+    nullable = 'true': Boolean@77
+    typeConstructor = AbstractLazyTypeParameterDescriptor$1@86
+}
+
+LazyJavaClassifierType@119['E'] {
+    arguments = ArrayList@120[empty]
+    classifier = JavaTypeParameterImpl@106['E']
+    nullable = 'true': Boolean@77
+    typeConstructor = AbstractLazyTypeParameterDescriptor$1@103
+}
+
+LazyJavaClassifierType@121['E'] {
+    arguments = ArrayList@122[empty]
+    classifier = JavaTypeParameterImpl@98['E']
+    nullable = 'true': Boolean@77
+    typeConstructor = AbstractLazyTypeParameterDescriptor$1@99
+}
+
+LazyJavaClassifierType@123['E'] {
+    arguments = ArrayList@124[empty]
+    classifier = JavaTypeParameterImpl@102['E']
+    nullable = 'true': Boolean@77
+    typeConstructor = AbstractLazyTypeParameterDescriptor$1@103
+}
+
+LazyJavaClassifierType@125['E'] {
+    arguments = ArrayList@126[empty]
+    classifier = JavaTypeParameterImpl@95['E']
+    nullable = 'true': Boolean@77
+    typeConstructor = AbstractLazyTypeParameterDescriptor$1@86
+}
+
+LazyJavaClassifierType@127['E'] {
+    arguments = ArrayList@128[empty]
+    classifier = JavaTypeParameterImpl@92['E']
+    nullable = 'true': Boolean@77
+    typeConstructor = AbstractLazyTypeParameterDescriptor$1@86
+}
+
+LazyJavaClassifierType@129['E'] {
+    arguments = ArrayList@130[empty]
+    classifier = JavaTypeParameterImpl@89['E']
+    nullable = 'true': Boolean@77
+    typeConstructor = AbstractLazyTypeParameterDescriptor$1@86
+}
+
+LazyJavaClassifierType@131['Object'] {
+    classifier = JavaClassImpl@132['Object']
+    typeConstructor = DeserializedClassTypeConstructor@133
+}
+
+LazyJavaClassifierType@134['Object'] {
+    classifier = JavaClassImpl@135['Object']
+    typeConstructor = DeserializedClassTypeConstructor@133
+}
+
+LazyJavaClassifierType@136['Serializable'] {
+    arguments = ArrayList@137[empty]
+    classifier = JavaClassImpl@138['Serializable']
+    memberScope = LazyJavaClassMemberScope@33
+    typeConstructor = LazyJavaClassTypeConstructor@35['Serializable']
+}
+
+LazyJavaClassifierType@44['Set<E>'] {
+    arguments = ArrayList@139[1] { TypeProjectionImpl@140 }
+    classifier = JavaClassImpl@141['Set']
+    memberScope = SubstitutingScope@142
+    nullable = 'false': Boolean@58
+    typeConstructor = DeserializedClassTypeConstructor@143
+}
+
+LazyJavaClassifierType@49['Set<E>'] {
+    arguments = ArrayList@144[1] { TypeProjectionImpl@145 }
+    classifier = JavaClassImpl@146['Set']
+    memberScope = SubstitutingScope@147
+    typeConstructor = DeserializedClassTypeConstructor@143
+}
+
+LazyJavaPackageFragmentProvider@148 {
+    packageFragments('<root>': FqName@149) = LazyJavaPackageFragment@150['<root>']
+    packageFragments('Int': FqName@151) = null
+    packageFragments('Unit': FqName@152) = null
+    packageFragments('java': FqName@153) = LazyJavaPackageFragment@154['java']
+    packageFragments('java.io': FqName@155) = LazyJavaPackageFragment@156['io']
+    packageFragments('java.lang': FqName@157) = LazyJavaPackageFragment@158['lang']
+    packageFragments('java.lang.Int': FqName@159) = null
+    packageFragments('java.lang.Unit': FqName@160) = null
+    packageFragments('java.util': FqName@161) = LazyJavaPackageFragment@162['util']
+    packageFragments('java.util.HashSet': FqName@163) = null
+    packageFragments('kotlin': FqName@164) = null
+    packageFragments('kotlin.Int': FqName@165) = null
+    packageFragments('kotlin.Unit': FqName@166) = null
+    packageFragments('kotlin.io': FqName@167) = null
+    packageFragments('kotlin.jvm': FqName@168) = null
+    topLevelClasses(JavaClassImpl@56['AbstractCollection']) = LazyJavaClassDescriptor@0['AbstractCollection']
+    topLevelClasses(JavaClassImpl@61['AbstractSet']) = LazyJavaClassDescriptor@11['AbstractSet']
+    topLevelClasses(JavaClassImpl@169['HashSet']) = LazyJavaClassDescriptor@18['HashSet']
+    topLevelClasses(JavaClassImpl@138['Serializable']) = LazyJavaClassDescriptor@32['Serializable']
+}
+
+LazyJavaPackageFragment@150['<root>'] {
+    classes('HashSet': Name@170) = null // through LazyPackageFragmentScopeForJavaPackage@171
+    classes('Int': Name@172) = null // through LazyPackageFragmentScopeForJavaPackage@171
+    classes('Unit': Name@173) = null // through LazyPackageFragmentScopeForJavaPackage@171
+    classes('add': Name@7) = null // through LazyPackageFragmentScopeForJavaPackage@171
+    classes('java': Name@174) = null // through LazyPackageFragmentScopeForJavaPackage@171
+    deserializedPackageScope = Empty@175 // through LazyPackageFragmentScopeForJavaPackage@171
+    functions('HashSet': Name@176) = EmptyList@8[empty] // through LazyPackageFragmentScopeForJavaPackage@171
+    functions('add': Name@7) = EmptyList@8[empty] // through LazyPackageFragmentScopeForJavaPackage@171
+    functions('java': Name@177) = EmptyList@8[empty] // through LazyPackageFragmentScopeForJavaPackage@171
+    memberIndex = computeMemberIndex$1@178 // through LazyPackageFragmentScopeForJavaPackage@171
+}
+
+LazyJavaPackageFragment@154['java'] {
+    classes('lang': Name@179) = null // through LazyPackageFragmentScopeForJavaPackage@180
+    classes('util': Name@181) = null // through LazyPackageFragmentScopeForJavaPackage@180
+    deserializedPackageScope = Empty@175 // through LazyPackageFragmentScopeForJavaPackage@180
+    functions('lang': Name@182) = EmptyList@8[empty] // through LazyPackageFragmentScopeForJavaPackage@180
+    functions('util': Name@183) = EmptyList@8[empty] // through LazyPackageFragmentScopeForJavaPackage@180
+    memberIndex = computeMemberIndex$1@184 // through LazyPackageFragmentScopeForJavaPackage@180
+}
+
+LazyJavaPackageFragment@158['lang'] {
+    classes('HashSet': Name@176) = null // through LazyPackageFragmentScopeForJavaPackage@185
+    classes('add': Name@7) = null // through LazyPackageFragmentScopeForJavaPackage@185
+    deserializedPackageScope = Empty@175 // through LazyPackageFragmentScopeForJavaPackage@185
+    functions('HashSet': Name@176) = EmptyList@8[empty] // through LazyPackageFragmentScopeForJavaPackage@185
+    functions('add': Name@7) = EmptyList@8[empty] // through LazyPackageFragmentScopeForJavaPackage@185
+    memberIndex = computeMemberIndex$1@186 // through LazyPackageFragmentScopeForJavaPackage@185
+}
+
+LazyJavaPackageFragment@162['util'] {
+    classes('HashSet': Name@187) = LazyJavaClassDescriptor@18['HashSet'] // through LazyPackageFragmentScopeForJavaPackage@188
+    deserializedPackageScope = Empty@175 // through LazyPackageFragmentScopeForJavaPackage@188
+    functions('HashSet': Name@189) = EmptyList@8[empty] // through LazyPackageFragmentScopeForJavaPackage@188
+    memberIndex = computeMemberIndex$1@190 // through LazyPackageFragmentScopeForJavaPackage@188
+}
+
+LazyJavaTypeParameterDescriptor@37['E'] {
+    defaultType = JetTypeImpl@191['E']
+    typeConstructor = AbstractLazyTypeParameterDescriptor$1@99
+    upperBounds = LinkedHashSet@192[1] { NullableType@193 }
+    upperBoundsAsType = NullableType@193
+}
+
+LazyJavaTypeParameterDescriptor@46['E'] {
+    defaultType = JetTypeImpl@194['E']
+    typeConstructor = AbstractLazyTypeParameterDescriptor$1@86
+    upperBounds = LinkedHashSet@195[1] { NullableType@196 }
+    upperBoundsAsType = NullableType@196
+}
+
+LazyJavaTypeParameterDescriptor@41['E'] {
+    defaultType = JetTypeImpl@197['E']
+    typeConstructor = AbstractLazyTypeParameterDescriptor$1@103
+}
+
+LazyJavaTypeParameterResolver@198 {
+    resolve(JavaTypeParameterImpl@199['E']) = LazyJavaTypeParameterDescriptor@37['E']
+}
+
+LazyJavaTypeParameterResolver@200 {
+    resolve(JavaTypeParameterImpl@201['E']) = LazyJavaTypeParameterDescriptor@41['E']
+}
+
+LazyJavaTypeParameterResolver@202 {
+    resolve(JavaTypeParameterImpl@203['E']) = LazyJavaTypeParameterDescriptor@46['E']
+}
+
+LazyJavaTypeParameterResolver@204 {
+    resolve(JavaTypeParameterImpl@92['E']) = null
+}
+
+LazyJavaTypeParameterResolver@205 {
+    resolve(JavaTypeParameterImpl@98['E']) = null
+}

compiler/testData/diagnostics/tests/functionLiterals/functionLiteralInIf.txt

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

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

@@ -28,7 +28,7 @@ import java.util.regex.Pattern;
 
 /** This class is generated by {@link org.jetbrains.jet.generators.tests.TestsPackage}. DO NOT MODIFY MANUALLY */
 @SuppressWarnings("all")
-@InnerTestClasses({JetDiagnosticsTestGenerated.Tests.class, JetDiagnosticsTestGenerated.Script.class, JetDiagnosticsTestGenerated.TailRecursion.class, JetDiagnosticsTestGenerated.OnObjects.class})
+@InnerTestClasses({JetDiagnosticsTestGenerated.Tests.class, JetDiagnosticsTestGenerated.Script.class, JetDiagnosticsTestGenerated.TailRecursion.class, JetDiagnosticsTestGenerated.OnObjects.class, JetDiagnosticsTestGenerated.Diagnostics.class})
 @RunWith(JUnit3RunnerWithInners.class)
 public class JetDiagnosticsTestGenerated extends AbstractJetDiagnosticsTest {
     @TestMetadata("compiler/testData/diagnostics/tests")
@@ -4246,6 +4246,12 @@ public class JetDiagnosticsTestGenerated extends AbstractJetDiagnosticsTest {
                 doTest(fileName);
             }
 
+            @TestMetadata("functionLiteralInIf.kt")
+            public void testFunctionLiteralInIf() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/functionLiterals/functionLiteralInIf.kt");
+                doTest(fileName);
+            }
+
             @TestMetadata("functionLiteralWithoutArgumentList.kt")
             public void testFunctionLiteralWithoutArgumentList() throws Exception {
                 String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/functionLiterals/functionLiteralWithoutArgumentList.kt");
@@ -10488,4 +10494,39 @@ public class JetDiagnosticsTestGenerated extends AbstractJetDiagnosticsTest {
             doTest(fileName);
         }
     }
+
+    @TestMetadata("compiler/testData/codegen/box/diagnostics")
+    @TestDataPath("$PROJECT_ROOT")
+    @InnerTestClasses({Diagnostics.Functions.class})
+    @RunWith(JUnit3RunnerWithInners.class)
+    public static class Diagnostics extends AbstractJetDiagnosticsTest {
+        public void testAllFilesPresentInDiagnostics() throws Exception {
+            JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/codegen/box/diagnostics"), Pattern.compile("^(.+)\\.kt$"), true);
+        }
+
+        @TestMetadata("compiler/testData/codegen/box/diagnostics/functions")
+        @TestDataPath("$PROJECT_ROOT")
+        @InnerTestClasses({Functions.Inference.class})
+        @RunWith(JUnit3RunnerWithInners.class)
+        public static class Functions extends AbstractJetDiagnosticsTest {
+            public void testAllFilesPresentInFunctions() throws Exception {
+                JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/codegen/box/diagnostics/functions"), Pattern.compile("^(.+)\\.kt$"), true);
+            }
+
+            @TestMetadata("compiler/testData/codegen/box/diagnostics/functions/inference")
+            @TestDataPath("$PROJECT_ROOT")
+            @RunWith(JUnit3RunnerWithInners.class)
+            public static class Inference extends AbstractJetDiagnosticsTest {
+                public void testAllFilesPresentInInference() throws Exception {
+                    JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/codegen/box/diagnostics/functions/inference"), Pattern.compile("^(.+)\\.kt$"), true);
+                }
+
+                @TestMetadata("kt6176.kt")
+                public void testKt6176() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("compiler/testData/codegen/box/diagnostics/functions/inference/kt6176.kt");
+                    doTest(fileName);
+                }
+            }
+        }
+    }
 }

compiler/tests/org/jetbrains/jet/codegen/generated/BlackBoxCodegenTestGenerated.java

@@ -30,7 +30,7 @@ import java.util.regex.Pattern;
 @SuppressWarnings("all")
 @TestMetadata("compiler/testData/codegen/box")
 @TestDataPath("$PROJECT_ROOT")
-@InnerTestClasses({BlackBoxCodegenTestGenerated.Arrays.class, BlackBoxCodegenTestGenerated.BinaryOp.class, BlackBoxCodegenTestGenerated.Bridges.class, BlackBoxCodegenTestGenerated.BuiltinStubMethods.class, BlackBoxCodegenTestGenerated.Casts.class, BlackBoxCodegenTestGenerated.Classes.class, BlackBoxCodegenTestGenerated.Closures.class, BlackBoxCodegenTestGenerated.Constants.class, BlackBoxCodegenTestGenerated.ControlStructures.class, BlackBoxCodegenTestGenerated.DefaultArguments.class, BlackBoxCodegenTestGenerated.DelegatedProperty.class, BlackBoxCodegenTestGenerated.Elvis.class, BlackBoxCodegenTestGenerated.Enum.class, BlackBoxCodegenTestGenerated.ExclExcl.class, BlackBoxCodegenTestGenerated.ExtensionFunctions.class, BlackBoxCodegenTestGenerated.ExtensionProperties.class, BlackBoxCodegenTestGenerated.FakeOverride.class, BlackBoxCodegenTestGenerated.FieldRename.class, BlackBoxCodegenTestGenerated.Finally.class, BlackBoxCodegenTestGenerated.Functions.class, BlackBoxCodegenTestGenerated.InnerNested.class, BlackBoxCodegenTestGenerated.Instructions.class, BlackBoxCodegenTestGenerated.Intrinsics.class, BlackBoxCodegenTestGenerated.JavaInterop.class, BlackBoxCodegenTestGenerated.Labels.class, BlackBoxCodegenTestGenerated.LocalClasses.class, BlackBoxCodegenTestGenerated.MultiDecl.class, BlackBoxCodegenTestGenerated.Objects.class, BlackBoxCodegenTestGenerated.OperatorConventions.class, BlackBoxCodegenTestGenerated.Package.class, BlackBoxCodegenTestGenerated.PlatformTypes.class, BlackBoxCodegenTestGenerated.PrimitiveTypes.class, BlackBoxCodegenTestGenerated.Properties.class, BlackBoxCodegenTestGenerated.Reflection.class, BlackBoxCodegenTestGenerated.Regressions.class, BlackBoxCodegenTestGenerated.SafeCall.class, BlackBoxCodegenTestGenerated.SamConstructors.class, BlackBoxCodegenTestGenerated.StaticFields.class, BlackBoxCodegenTestGenerated.Strings.class, BlackBoxCodegenTestGenerated.Super.class, BlackBoxCodegenTestGenerated.SuperConstructorCall.class, BlackBoxCodegenTestGenerated.ToArray.class, BlackBoxCodegenTestGenerated.Traits.class, BlackBoxCodegenTestGenerated.TypeInfo.class, BlackBoxCodegenTestGenerated.TypeMapping.class, BlackBoxCodegenTestGenerated.UnaryOp.class, BlackBoxCodegenTestGenerated.Unit.class, BlackBoxCodegenTestGenerated.Vararg.class, BlackBoxCodegenTestGenerated.When.class})
+@InnerTestClasses({BlackBoxCodegenTestGenerated.Arrays.class, BlackBoxCodegenTestGenerated.BinaryOp.class, BlackBoxCodegenTestGenerated.Bridges.class, BlackBoxCodegenTestGenerated.BuiltinStubMethods.class, BlackBoxCodegenTestGenerated.Casts.class, BlackBoxCodegenTestGenerated.Classes.class, BlackBoxCodegenTestGenerated.Closures.class, BlackBoxCodegenTestGenerated.Constants.class, BlackBoxCodegenTestGenerated.ControlStructures.class, BlackBoxCodegenTestGenerated.DefaultArguments.class, BlackBoxCodegenTestGenerated.DelegatedProperty.class, BlackBoxCodegenTestGenerated.Diagnostics.class, BlackBoxCodegenTestGenerated.Elvis.class, BlackBoxCodegenTestGenerated.Enum.class, BlackBoxCodegenTestGenerated.ExclExcl.class, BlackBoxCodegenTestGenerated.ExtensionFunctions.class, BlackBoxCodegenTestGenerated.ExtensionProperties.class, BlackBoxCodegenTestGenerated.FakeOverride.class, BlackBoxCodegenTestGenerated.FieldRename.class, BlackBoxCodegenTestGenerated.Finally.class, BlackBoxCodegenTestGenerated.Functions.class, BlackBoxCodegenTestGenerated.InnerNested.class, BlackBoxCodegenTestGenerated.Instructions.class, BlackBoxCodegenTestGenerated.Intrinsics.class, BlackBoxCodegenTestGenerated.JavaInterop.class, BlackBoxCodegenTestGenerated.Labels.class, BlackBoxCodegenTestGenerated.LocalClasses.class, BlackBoxCodegenTestGenerated.MultiDecl.class, BlackBoxCodegenTestGenerated.Objects.class, BlackBoxCodegenTestGenerated.OperatorConventions.class, BlackBoxCodegenTestGenerated.Package.class, BlackBoxCodegenTestGenerated.PlatformTypes.class, BlackBoxCodegenTestGenerated.PrimitiveTypes.class, BlackBoxCodegenTestGenerated.Properties.class, BlackBoxCodegenTestGenerated.Reflection.class, BlackBoxCodegenTestGenerated.Regressions.class, BlackBoxCodegenTestGenerated.SafeCall.class, BlackBoxCodegenTestGenerated.SamConstructors.class, BlackBoxCodegenTestGenerated.StaticFields.class, BlackBoxCodegenTestGenerated.Strings.class, BlackBoxCodegenTestGenerated.Super.class, BlackBoxCodegenTestGenerated.SuperConstructorCall.class, BlackBoxCodegenTestGenerated.ToArray.class, BlackBoxCodegenTestGenerated.Traits.class, BlackBoxCodegenTestGenerated.TypeInfo.class, BlackBoxCodegenTestGenerated.TypeMapping.class, BlackBoxCodegenTestGenerated.UnaryOp.class, BlackBoxCodegenTestGenerated.Unit.class, BlackBoxCodegenTestGenerated.Vararg.class, BlackBoxCodegenTestGenerated.When.class})
 @RunWith(JUnit3RunnerWithInners.class)
 public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest {
     public void testAllFilesPresentInBox() throws Exception {
@@ -2634,6 +2634,41 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest {
         }
     }
 
+    @TestMetadata("compiler/testData/codegen/box/diagnostics")
+    @TestDataPath("$PROJECT_ROOT")
+    @InnerTestClasses({Diagnostics.Functions.class})
+    @RunWith(JUnit3RunnerWithInners.class)
+    public static class Diagnostics extends AbstractBlackBoxCodegenTest {
+        public void testAllFilesPresentInDiagnostics() throws Exception {
+            JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/codegen/box/diagnostics"), Pattern.compile("^(.+)\\.kt$"), true);
+        }
+
+        @TestMetadata("compiler/testData/codegen/box/diagnostics/functions")
+        @TestDataPath("$PROJECT_ROOT")
+        @InnerTestClasses({Functions.Inference.class})
+        @RunWith(JUnit3RunnerWithInners.class)
+        public static class Functions extends AbstractBlackBoxCodegenTest {
+            public void testAllFilesPresentInFunctions() throws Exception {
+                JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/codegen/box/diagnostics/functions"), Pattern.compile("^(.+)\\.kt$"), true);
+            }
+
+            @TestMetadata("compiler/testData/codegen/box/diagnostics/functions/inference")
+            @TestDataPath("$PROJECT_ROOT")
+            @RunWith(JUnit3RunnerWithInners.class)
+            public static class Inference extends AbstractBlackBoxCodegenTest {
+                public void testAllFilesPresentInInference() throws Exception {
+                    JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/codegen/box/diagnostics/functions/inference"), Pattern.compile("^(.+)\\.kt$"), true);
+                }
+
+                @TestMetadata("kt6176.kt")
+                public void testKt6176() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("compiler/testData/codegen/box/diagnostics/functions/inference/kt6176.kt");
+                    doTest(fileName);
+                }
+            }
+        }
+    }
+
     @TestMetadata("compiler/testData/codegen/box/elvis")
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)

generators/src/org/jetbrains/jet/generators/tests/GenerateTests.kt

@@ -142,6 +142,7 @@ fun main(args: Array<String>) {
             model("diagnostics/tests/script", extension = "kts")
             model("codegen/box/functions/tailRecursion")
             model("codegen/box/functions/invoke/onObjects")
+            model("codegen/box/diagnostics")
         }
 
         testClass(javaClass<AbstractJetDiagnosticsTestWithStdLib>()) {