resolve default values for parameters for local functions

moved method 'resolveValueParameters'

#KT-3978 In progress

compiler/frontend/src/org/jetbrains/jet/lang/resolve/BodyResolver.java

@@ -392,8 +392,8 @@ public class BodyResolver {
                     parameterScope.addVariableDescriptor(valueParameterDescriptor);
                 }
                 parameterScope.changeLockLevel(WritableScope.LockLevel.READING);
-                resolveValueParameter(klass.getPrimaryConstructorParameters(), unsubstitutedPrimaryConstructor.getValueParameters(),
+                expressionTypingServices.resolveValueParameters(klass.getPrimaryConstructorParameters(), unsubstitutedPrimaryConstructor.getValueParameters(),
-                                      parameterScope);
+                                       parameterScope, context.getOuterDataFlowInfo(), trace);
             }
         }
     }
@@ -682,46 +682,11 @@ public class BodyResolver {
         List<JetParameter> valueParameters = function.getValueParameters();
         List<ValueParameterDescriptor> valueParameterDescriptors = functionDescriptor.getValueParameters();
 
-        resolveValueParameter(valueParameters, valueParameterDescriptors, functionInnerScope);
+        expressionTypingServices.resolveValueParameters(valueParameters, valueParameterDescriptors, functionInnerScope, context.getOuterDataFlowInfo(), trace);
 
         assert functionDescriptor.getReturnType() != null;
     }
 
-    private void resolveValueParameter(
-            @NotNull List<JetParameter> valueParameters,
-            @NotNull List<ValueParameterDescriptor> valueParameterDescriptors,
-            @NotNull JetScope declaringScope
-    ) {
-        for (int i = 0; i < valueParameters.size(); i++) {
-            ValueParameterDescriptor valueParameterDescriptor = valueParameterDescriptors.get(i);
-            JetParameter jetParameter = valueParameters.get(i);
-
-            resolveAnnotationArguments(declaringScope, jetParameter);
-
-            resolveDefaultValue(declaringScope, valueParameterDescriptor, jetParameter);
-        }
-    }
-
-    private void resolveDefaultValue(
-            @NotNull JetScope declaringScope,
-            @NotNull ValueParameterDescriptor valueParameterDescriptor,
-            @NotNull JetParameter jetParameter
-    ) {
-        if (valueParameterDescriptor.hasDefaultValue()) {
-            JetExpression defaultValue = jetParameter.getDefaultValue();
-            if (defaultValue != null) {
-                expressionTypingServices.getType(declaringScope, defaultValue, valueParameterDescriptor.getType(), context.getOuterDataFlowInfo(), trace);
-                if (DescriptorUtils.isAnnotationClass(DescriptorUtils.getContainingClass(declaringScope))) {
-                    CompileTimeConstant<?> constant =
-                            annotationResolver.resolveExpressionToCompileTimeValue(defaultValue, valueParameterDescriptor.getType(), trace);
-                    if (constant != null) {
-                        trace.record(BindingContext.COMPILE_TIME_VALUE, defaultValue, constant);
-                    }
-                }
-            }
-        }
-    }
-
     private void resolveAnnotationArguments(@NotNull JetScope scope, @NotNull JetModifierListOwner owner) {
         annotationResolver.resolveAnnotationsArguments(scope, owner.getModifierList(), trace);
     }

compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingServices.java

@@ -25,6 +25,7 @@ import org.jetbrains.jet.lang.PlatformToKotlinClassMap;
 import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
 import org.jetbrains.jet.lang.descriptors.FunctionDescriptor;
 import org.jetbrains.jet.lang.descriptors.ScriptDescriptor;
+import org.jetbrains.jet.lang.descriptors.ValueParameterDescriptor;
 import org.jetbrains.jet.lang.descriptors.impl.FunctionDescriptorUtil;
 import org.jetbrains.jet.lang.psi.*;
 import org.jetbrains.jet.lang.resolve.*;
@@ -34,6 +35,7 @@ import org.jetbrains.jet.lang.resolve.calls.autocasts.DataFlowInfo;
 import org.jetbrains.jet.lang.resolve.calls.context.ContextDependency;
 import org.jetbrains.jet.lang.resolve.calls.context.ExpressionPosition;
 import org.jetbrains.jet.lang.resolve.calls.context.ResolutionContext;
+import org.jetbrains.jet.lang.resolve.constants.CompileTimeConstant;
 import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 import org.jetbrains.jet.lang.resolve.scopes.WritableScope;
 import org.jetbrains.jet.lang.resolve.scopes.WritableScopeImpl;
@@ -360,4 +362,43 @@ public class ExpressionTypingServices {
             }
         });
     }
+
+    public void resolveValueParameters(
+            @NotNull List<JetParameter> valueParameters,
+            @NotNull List<ValueParameterDescriptor> valueParameterDescriptors,
+            @NotNull JetScope declaringScope,
+            @NotNull DataFlowInfo dataFlowInfo,
+            @NotNull BindingTrace trace
+    ) {
+        for (int i = 0; i < valueParameters.size(); i++) {
+            ValueParameterDescriptor valueParameterDescriptor = valueParameterDescriptors.get(i);
+            JetParameter jetParameter = valueParameters.get(i);
+
+            annotationResolver.resolveAnnotationsArguments(declaringScope, jetParameter.getModifierList(), trace);
+
+            resolveDefaultValue(declaringScope, valueParameterDescriptor, jetParameter, dataFlowInfo, trace);
+        }
+    }
+
+    private void resolveDefaultValue(
+            @NotNull JetScope declaringScope,
+            @NotNull ValueParameterDescriptor valueParameterDescriptor,
+            @NotNull JetParameter jetParameter,
+            @NotNull DataFlowInfo dataFlowInfo,
+            @NotNull BindingTrace trace
+    ) {
+        if (valueParameterDescriptor.hasDefaultValue()) {
+            JetExpression defaultValue = jetParameter.getDefaultValue();
+            if (defaultValue != null) {
+                getType(declaringScope, defaultValue, valueParameterDescriptor.getType(), dataFlowInfo, trace);
+                if (DescriptorUtils.isAnnotationClass(DescriptorUtils.getContainingClass(declaringScope))) {
+                    CompileTimeConstant<?> constant =
+                            annotationResolver.resolveExpressionToCompileTimeValue(defaultValue, valueParameterDescriptor.getType(), trace);
+                    if (constant != null) {
+                        trace.record(BindingContext.COMPILE_TIME_VALUE, defaultValue, constant);
+                    }
+                }
+            }
+        }
+    }
 }

compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingVisitorForStatements.java

@@ -171,6 +171,10 @@ public class ExpressionTypingVisitorForStatements extends ExpressionTypingVisito
         scope.addFunctionDescriptor(functionDescriptor);
         JetScope functionInnerScope = FunctionDescriptorUtil.getFunctionInnerScope(context.scope, functionDescriptor, context.trace);
         context.expressionTypingServices.checkFunctionReturnType(functionInnerScope, function, functionDescriptor, context.dataFlowInfo, null, context.trace);
+
+        context.expressionTypingServices.resolveValueParameters(
+                function.getValueParameters(), functionDescriptor.getValueParameters(), scope, context.dataFlowInfo, context.trace);
+
         ModifiersChecker.create(context.trace).checkModifiersForLocalDeclaration(function);
         return DataFlowUtils.checkStatementType(function, context, context.dataFlowInfo);
     }

compiler/testData/resolve/DefaultParamsOfLocalFunctions.resolve

@@ -0,0 +1,23 @@
+package m
+
+~zzz~annotation class zzz
+
+~y~val y = 23
+
+~bar~fun bar() = 354
+~baz~fun baz(i: Int) = i
+
+fun test() {
+    ~x~val x = 2
+
+    [`zzz`zzz] fun local(
+            `zzz`zzz i: Int = `x`x,
+            j: Int = 3,
+            s: String = "$`x`x",
+            k: Int = `y`y,
+            l: Int = `bar`bar(),
+            m: Int = `baz`baz(`x`x)
+    ) {
+
+    }
+}

compiler/tests/org/jetbrains/jet/resolve/JetResolveTestGenerated.java

@@ -52,6 +52,11 @@ public class JetResolveTestGenerated extends AbstractResolveTest {
         doTest("compiler/testData/resolve/Classifiers.resolve");
     }
     
+    @TestMetadata("DefaultParamsOfLocalFunctions.resolve")
+    public void testDefaultParamsOfLocalFunctions() throws Exception {
+        doTest("compiler/testData/resolve/DefaultParamsOfLocalFunctions.resolve");
+    }
+    
     @TestMetadata("ErrorSupertype.resolve")
     public void testErrorSupertype() throws Exception {
         doTest("compiler/testData/resolve/ErrorSupertype.resolve");