'hasUnknownTypeParameters' method added

to detect 'DIRTY' status

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

@@ -17,12 +17,14 @@
 package org.jetbrains.jet.lang.resolve.calls;
 
 import com.google.common.collect.Maps;
+import com.google.common.collect.Sets;
 import com.intellij.util.Function;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.descriptors.CallableDescriptor;
 import org.jetbrains.jet.lang.descriptors.TypeParameterDescriptor;
 import org.jetbrains.jet.lang.descriptors.ValueParameterDescriptor;
 import org.jetbrains.jet.lang.resolve.TemporaryBindingTrace;
+import org.jetbrains.jet.lang.resolve.calls.inference.TypeBounds;
 import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
 import org.jetbrains.jet.lang.types.JetType;
 
@@ -64,11 +66,13 @@ public class ResolvedCallImpl<D extends CallableDescriptor> implements ResolvedC
     private final boolean isSafeCall;
 
     private final Map<TypeParameterDescriptor, JetType> typeArguments = Maps.newLinkedHashMap();
+    private final Map<TypeParameterDescriptor, TypeBounds> typeArgumentBounds = Maps.newLinkedHashMap();
     private final Map<ValueParameterDescriptor, JetType> autoCasts = Maps.newHashMap();
     private final Map<ValueParameterDescriptor, ResolvedValueArgument> valueArguments = Maps.newLinkedHashMap();
     private boolean someArgumentHasNoType = false;
     private TemporaryBindingTrace trace;
     private ResolutionStatus status = UNKNOWN_STATUS;
+    private boolean hasUnknownTypeParameters = false;
 
     private ResolvedCallImpl(@NotNull ResolutionCandidate<D> candidate, @NotNull TemporaryBindingTrace trace) {
         this.candidateDescriptor = candidate.getDescriptor();
@@ -89,6 +93,15 @@ public class ResolvedCallImpl<D extends CallableDescriptor> implements ResolvedC
         this.status = this.status.combine(status);
     }
 
+    @Override
+    public boolean hasUnknownTypeParameters() {
+        return hasUnknownTypeParameters;
+    }
+
+    public void setHasUnknownTypeParameters(boolean hasUnknownTypeParameters) {
+        this.hasUnknownTypeParameters = hasUnknownTypeParameters;
+    }
+
     @Override
     @NotNull
     public TemporaryBindingTrace getTrace() {
@@ -117,6 +130,15 @@ public class ResolvedCallImpl<D extends CallableDescriptor> implements ResolvedC
         typeArguments.put(typeParameter, typeArgument);
     }
 
+    public void recordTypeBounds(@NotNull TypeParameterDescriptor typeParameter, @NotNull TypeBounds typeBounds) {
+        //assert !typeArgumentBounds.containsKey(typeParameter) : typeParameter;
+        typeArgumentBounds.put(typeParameter, typeBounds);
+    }
+
+    public Map<TypeParameterDescriptor, TypeBounds> getTypeArgumentBounds() {
+        return typeArgumentBounds;
+    }
+
     public void recordValueArgument(@NotNull ValueParameterDescriptor valueParameter, @NotNull ResolvedValueArgument valueArgument) {
         assert !valueArguments.containsKey(valueParameter) : valueParameter + " -> " + valueArgument;
         valueArguments.put(valueParameter, valueArgument);

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

@@ -28,6 +28,8 @@ public interface ResolvedCallWithTrace<D extends CallableDescriptor> extends Res
     @NotNull
     ResolutionStatus getStatus();
 
+    boolean hasUnknownTypeParameters();
+
     boolean isDirty();
 
     TemporaryBindingTrace getTrace();

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

@@ -121,4 +121,9 @@ public class VariableAsFunctionResolvedCall implements ResolvedCallWithTrace<Fun
     public boolean isSafeCall() {
         return variableCall.isSafeCall();
     }
+
+    @Override
+    public boolean hasUnknownTypeParameters() {
+        return variableCall.hasUnknownTypeParameters();
+    }
 }