From 009e983b4133ed6cd639f05b481b86a8f13393f5 Mon Sep 17 00:00:00 2001
From: Andrey Breslav <abreslav@abreslav-mac.labs.intellij.net>
Date: Thu, 26 May 2011 19:55:36 +0400
Subject: [PATCH] JET-58 Make 'as never succeeds' a warning, or even never
 check for Java (external) types

---
 .../jet/lang/types/JetTypeInferrer.java       | 33 +++++++++++++------
 idea/testData/checker/ResolveToJava.jet       |  4 +++
 .../jet/types/JetTypeCheckerTest.java         |  2 ++
 3 files changed, 29 insertions(+), 10 deletions(-)

diff --git a/idea/src/org/jetbrains/jet/lang/types/JetTypeInferrer.java b/idea/src/org/jetbrains/jet/lang/types/JetTypeInferrer.java
index 8f601937604..79b696921f7 100644
--- a/idea/src/org/jetbrains/jet/lang/types/JetTypeInferrer.java
+++ b/idea/src/org/jetbrains/jet/lang/types/JetTypeInferrer.java
@@ -1,6 +1,7 @@
 package org.jetbrains.jet.lang.types;
 
 import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.Maps;
 import com.google.common.collect.Sets;
 import com.intellij.lang.ASTNode;
 import com.intellij.psi.PsiElement;
@@ -465,21 +466,32 @@ public class JetTypeInferrer {
             if (resolutionResult.isSuccess()) {
                 final FunctionDescriptor functionDescriptor = resolutionResult.getFunctionDescriptor();
 
-                List<TypeParameterDescriptor> typeParameters = functionDescriptor.getOriginal().getTypeParameters();
-                for (int i = 0, typeParametersSize = typeParameters.size(); i < typeParametersSize; i++) {
-                    TypeParameterDescriptor typeParameterDescriptor = typeParameters.get(i);
-                    final JetType typeArgument = typeArguments.get(i);
-                    if (!semanticServices.getTypeChecker().isSubtypeOf(typeArgument, typeParameterDescriptor.getBoundsAsType())) {
-                        trace.getErrorHandler().genericError(jetTypeArguments.get(i).getNode(), "Bound of the type parameter " + DescriptorRenderer.TEXT.render(typeParameterDescriptor) + " is not respected by the type " + typeArgument);
-                    }
-
-                }
+                checkGenericBoundsInAFunctionCall(jetTypeArguments, typeArguments, functionDescriptor);
                 return functionDescriptor.getUnsubstitutedReturnType();
             }
         }
         return null;
     }
 
+    private void checkGenericBoundsInAFunctionCall(List<JetTypeProjection> jetTypeArguments, List<JetType> typeArguments, FunctionDescriptor functionDescriptor) {
+        Map<TypeConstructor, TypeProjection> context = Maps.newHashMap();
+
+        List<TypeParameterDescriptor> typeParameters = functionDescriptor.getOriginal().getTypeParameters();
+        for (int i = 0, typeParametersSize = typeParameters.size(); i < typeParametersSize; i++) {
+            TypeParameterDescriptor typeParameter = typeParameters.get(i);
+            JetType typeArgument = typeArguments.get(i);
+            context.put(typeParameter.getTypeConstructor(), new TypeProjection(typeArgument));
+        }
+        TypeSubstitutor substitutor = TypeSubstitutor.create(context);
+        for (int i = 0, typeParametersSize = typeParameters.size(); i < typeParametersSize; i++) {
+            TypeParameterDescriptor typeParameterDescriptor = typeParameters.get(i);
+            JetType typeArgument = typeArguments.get(i);
+            JetTypeReference typeReference = jetTypeArguments.get(i).getTypeReference();
+            assert typeReference != null;
+            classDescriptorResolver.checkBounds(typeReference, typeArgument, typeParameterDescriptor, substitutor);
+        }
+    }
+
     @Nullable
     public JetType checkConstructorCall(JetScope scope, @NotNull JetTypeReference typeReference, @NotNull JetCall call) {
         JetTypeElement typeElement = typeReference.getTypeElement();
@@ -891,7 +903,8 @@ public class JetTypeInferrer {
                     trace.getErrorHandler().genericWarning(expression.getOperationSign().getNode(), "No cast needed, use ':' instead");
                 }
                 else {
-                    trace.getErrorHandler().genericError(expression.getOperationSign().getNode(), "This cast can never succeed");
+                    // See JET-58 Make 'as never succeeds' a warning, or even never check for Java (external) types
+                    trace.getErrorHandler().genericWarning(expression.getOperationSign().getNode(), "This cast can never succeed");
                 }
             }
             else {
diff --git a/idea/testData/checker/ResolveToJava.jet b/idea/testData/checker/ResolveToJava.jet
index 5ae9aaba181..4641fca97bb 100644
--- a/idea/testData/checker/ResolveToJava.jet
+++ b/idea/testData/checker/ResolveToJava.jet
@@ -22,4 +22,8 @@ fun test(l : java.util.List<Int>) {
   Collections.singleton<Int><error>(1.0)</error>
 
   <error>new List<Int></error>
+
+//  Collections.sort<Integer>(new ArrayList<Integer>())
+
+  val o = "sdf" <warning>as</warning> Object
 }
diff --git a/idea/tests/org/jetbrains/jet/types/JetTypeCheckerTest.java b/idea/tests/org/jetbrains/jet/types/JetTypeCheckerTest.java
index 77e1747ab53..b26d8056b48 100644
--- a/idea/tests/org/jetbrains/jet/types/JetTypeCheckerTest.java
+++ b/idea/tests/org/jetbrains/jet/types/JetTypeCheckerTest.java
@@ -277,6 +277,8 @@ public class JetTypeCheckerTest extends LightDaemonAnalyzerTestCase {
         assertSubtype("Derived_T<Int>", "Base_T<in Int>");
         assertSubtype("MDerived_T<Int>", "Base_T<in Int>");
         assertSubtype("ArrayList<Int>", "List<in Int>");
+
+        assertSubtype("Integer", "java.lang.Comparable<Integer>?");
     }
 
     public void testNullable() throws Exception {