resolve delegated expression always using completer

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

@@ -30,10 +30,6 @@ 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.ResolutionResultsCacheImpl;
 import org.jetbrains.jet.lang.resolve.calls.context.SimpleResolutionContext;
-import org.jetbrains.jet.lang.resolve.calls.inference.ConstraintPosition;
-import org.jetbrains.jet.lang.resolve.calls.inference.ConstraintSystem;
-import org.jetbrains.jet.lang.resolve.calls.inference.ConstraintSystemCompleter;
-import org.jetbrains.jet.lang.resolve.calls.model.ResolvedCall;
 import org.jetbrains.jet.lang.resolve.calls.results.OverloadResolutionResults;
 import org.jetbrains.jet.lang.resolve.calls.util.CallMaker;
 import org.jetbrains.jet.lang.resolve.constants.CompileTimeConstant;
@@ -44,7 +40,6 @@ import org.jetbrains.jet.lang.types.expressions.DataFlowUtils;
 import org.jetbrains.jet.lang.types.expressions.DelegatedPropertyResolver;
 import org.jetbrains.jet.lang.types.expressions.ExpressionTypingServices;
 import org.jetbrains.jet.lang.types.expressions.LabelResolver;
-import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
 import org.jetbrains.jet.lexer.JetTokens;
 import org.jetbrains.jet.util.Box;
 import org.jetbrains.jet.util.slicedmap.WritableSlice;
@@ -55,9 +50,7 @@ import java.util.*;
 
 import static org.jetbrains.jet.lang.descriptors.ReceiverParameterDescriptor.NO_RECEIVER_PARAMETER;
 import static org.jetbrains.jet.lang.diagnostics.Errors.*;
-import static org.jetbrains.jet.lang.resolve.BindingContext.CONSTRAINT_SYSTEM_COMPLETER;
 import static org.jetbrains.jet.lang.resolve.BindingContext.DEFERRED_TYPE;
-import static org.jetbrains.jet.lang.resolve.calls.results.OverloadResolutionResults.Code;
 import static org.jetbrains.jet.lang.types.TypeUtils.NO_EXPECTED_TYPE;
 
 public class BodyResolver {
@@ -531,24 +524,12 @@ public class BodyResolver {
 
         JetScope propertyDeclarationInnerScope = descriptorResolver.getPropertyDeclarationInnerScopeForInitializer(
                 propertyScope, propertyDescriptor.getTypeParameters(), NO_RECEIVER_PARAMETER, trace);
-        TemporaryBindingTrace traceToResolveDelegatedProperty = TemporaryBindingTrace.create(trace, "Trace to resolve delegated property");
         JetScope accessorScope = JetScopeUtils.makeScopeForPropertyAccessor(
                 propertyDescriptor, parentScopeForAccessor, descriptorResolver, trace);
 
-        JetExpression calleeExpression = JetPsiUtil.getCalleeExpressionIfAny(delegateExpression);
+        JetType delegateType = delegatedPropertyResolver.resolveDelegateExpression(
-        ConstraintSystemCompleter completer = delegatedPropertyResolver.createConstraintSystemCompleter(
+                delegateExpression, jetProperty, propertyDescriptor, propertyDeclarationInnerScope, accessorScope, trace,
-                jetProperty, propertyDescriptor, delegateExpression, accessorScope, trace);
+                context.getOuterDataFlowInfo());
-        if (calleeExpression != null) {
-            traceToResolveDelegatedProperty.record(CONSTRAINT_SYSTEM_COMPLETER, calleeExpression, completer);
-        }
-        JetType delegateType = expressionTypingServices.safeGetType(propertyDeclarationInnerScope, delegateExpression, NO_EXPECTED_TYPE,
-                                                                    context.getOuterDataFlowInfo(), traceToResolveDelegatedProperty);
-        traceToResolveDelegatedProperty.commit(new TraceEntryFilter() {
-            @Override
-            public boolean accept(@NotNull WritableSlice<?, ?> slice, Object key) {
-                return slice != CONSTRAINT_SYSTEM_COMPLETER;
-            }
-        }, true);
 
         delegatedPropertyResolver.resolveDelegatedPropertyGetMethod(propertyDescriptor, delegateExpression, delegateType,
                                                                     trace, accessorScope);

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

@@ -1041,7 +1041,8 @@ public class DescriptorResolver {
             final JetExpression initializer = variable.getInitializer();
             if (initializer == null) {
                 if (hasDelegate && variableDescriptor instanceof PropertyDescriptor) {
-                    final JetExpression propertyDelegateExpression = ((JetProperty) variable).getDelegateExpression();
+                    final JetProperty property = (JetProperty) variable;
+                    final JetExpression propertyDelegateExpression = property.getDelegateExpression();
                     if (propertyDelegateExpression != null) {
                         return DeferredType.create(
                                 trace,
@@ -1050,7 +1051,7 @@ public class DescriptorResolver {
                                         new Function0<JetType>() {
                                             @Override
                                             public JetType invoke() {
-                                                return resolveDelegatedPropertyType((PropertyDescriptor) variableDescriptor, scope,
+                                                return resolveDelegatedPropertyType(property, (PropertyDescriptor) variableDescriptor, scope,
                                                                                     propertyDelegateExpression, dataFlowInfo, trace);
                                             }
                                         }));
@@ -1090,19 +1091,24 @@ public class DescriptorResolver {
 
     @NotNull
     private JetType resolveDelegatedPropertyType(
+            @NotNull JetProperty property,
             @NotNull PropertyDescriptor propertyDescriptor,
             @NotNull JetScope scope,
             @NotNull JetExpression delegateExpression,
             @NotNull DataFlowInfo dataFlowInfo,
             @NotNull BindingTrace trace
     ) {
-        JetType type = expressionTypingServices.safeGetType(scope, delegateExpression, TypeUtils.NO_EXPECTED_TYPE, dataFlowInfo, trace);
-
         JetScope accessorScope = JetScopeUtils.makeScopeForPropertyAccessor(propertyDescriptor, scope, this, trace);
-        JetType getterReturnType = delegatedPropertyResolver
+
-                .getDelegatedPropertyGetMethodReturnType(propertyDescriptor, delegateExpression, type, trace, accessorScope);
+        JetType type = delegatedPropertyResolver.resolveDelegateExpression(
-        if (getterReturnType != null) {
+                delegateExpression, property, propertyDescriptor, scope, accessorScope, trace, dataFlowInfo);
-            return getterReturnType;
+
+        if (type != null) {
+            JetType getterReturnType = delegatedPropertyResolver
+                    .getDelegatedPropertyGetMethodReturnType(propertyDescriptor, delegateExpression, type, trace, accessorScope);
+            if (getterReturnType != null) {
+                return getterReturnType;
+            }
         }
         return ErrorUtils.createErrorType("Type from delegate");
     }

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

@@ -26,6 +26,7 @@ import org.jetbrains.jet.lang.psi.*;
 import org.jetbrains.jet.lang.resolve.BindingContext;
 import org.jetbrains.jet.lang.resolve.BindingTrace;
 import org.jetbrains.jet.lang.resolve.TemporaryBindingTrace;
+import org.jetbrains.jet.lang.resolve.TraceEntryFilter;
 import org.jetbrains.jet.lang.resolve.calls.autocasts.DataFlowInfo;
 import org.jetbrains.jet.lang.resolve.calls.context.ExpressionPosition;
 import org.jetbrains.jet.lang.resolve.calls.inference.ConstraintPosition;
@@ -42,6 +43,7 @@ import org.jetbrains.jet.lang.types.JetType;
 import org.jetbrains.jet.lang.types.TypeUtils;
 import org.jetbrains.jet.lang.types.checker.JetTypeChecker;
 import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
+import org.jetbrains.jet.util.slicedmap.WritableSlice;
 
 import javax.inject.Inject;
 import java.util.List;
@@ -207,8 +209,36 @@ public class DelegatedPropertyResolver {
         return builder.toString();
     }
 
+    @Nullable
+    public JetType resolveDelegateExpression(
+            @NotNull JetExpression delegateExpression,
+            @NotNull JetProperty jetProperty,
+            @NotNull PropertyDescriptor propertyDescriptor,
+            @NotNull JetScope propertyDeclarationInnerScope,
+            @NotNull JetScope accessorScope,
+            @NotNull BindingTrace trace,
+            @NotNull DataFlowInfo dataFlowInfo
+    ) {
+        TemporaryBindingTrace traceToResolveDelegatedProperty = TemporaryBindingTrace.create(trace, "Trace to resolve delegated property");
+        JetExpression calleeExpression = JetPsiUtil.getCalleeExpressionIfAny(delegateExpression);
+        ConstraintSystemCompleter completer = createConstraintSystemCompleter(
+                jetProperty, propertyDescriptor, delegateExpression, accessorScope, trace);
+        if (calleeExpression != null) {
+            traceToResolveDelegatedProperty.record(CONSTRAINT_SYSTEM_COMPLETER, calleeExpression, completer);
+        }
+        JetType delegateType = expressionTypingServices.safeGetType(propertyDeclarationInnerScope, delegateExpression, NO_EXPECTED_TYPE,
+                                                                    dataFlowInfo, traceToResolveDelegatedProperty);
+        traceToResolveDelegatedProperty.commit(new TraceEntryFilter() {
+            @Override
+            public boolean accept(@NotNull WritableSlice<?, ?> slice, Object key) {
+                return slice != CONSTRAINT_SYSTEM_COMPLETER;
+            }
+        }, true);
+        return delegateType;
+    }
+
     @NotNull
-    public ConstraintSystemCompleter createConstraintSystemCompleter(
+    private ConstraintSystemCompleter createConstraintSystemCompleter(
             @NotNull JetProperty property,
             @NotNull final PropertyDescriptor propertyDescriptor,
             @NotNull final JetExpression delegateExpression,

compiler/testData/diagnostics/tests/delegatedProperty/inference/useCompleterWithoutExpectedType.kt

@@ -0,0 +1,11 @@
+class A {
+    val a by MyProperty()
+
+    fun test() {
+        a: Int
+    }
+}
+
+class MyProperty<R> {
+    public fun get(thisRef: R, desc: PropertyMetadata): Int = throw Exception("$thisRef $desc")
+}

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

@@ -2444,6 +2444,11 @@ public class JetDiagnosticsTestGenerated extends AbstractDiagnosticsTestWithEage
                     doTest("compiler/testData/diagnostics/tests/delegatedProperty/inference/noErrorsForImplicitConstraints.kt");
                 }
                 
+                @TestMetadata("useCompleterWithoutExpectedType.kt")
+                public void testUseCompleterWithoutExpectedType() throws Exception {
+                    doTest("compiler/testData/diagnostics/tests/delegatedProperty/inference/useCompleterWithoutExpectedType.kt");
+                }
+                
                 @TestMetadata("useExpectedType.kt")
                 public void testUseExpectedType() throws Exception {
                     doTest("compiler/testData/diagnostics/tests/delegatedProperty/inference/useExpectedType.kt");