Proper errors for cases like 'is Map' supported in 'when'

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

@@ -143,7 +143,7 @@ public class TypeResolver {
                         else {
                             if (actualArgumentCount != expectedArgumentCount) {
                                 if (actualArgumentCount == 0) {
-                                    if (rhsOfIsExpression(type)) {
+                                    if (rhsOfIsExpression(type) || rhsOfIsPattern(type)) {
                                         trace.report(NO_TYPE_ARGUMENTS_ON_RHS_OF_IS_EXPRESSION.on(type, expectedArgumentCount, allStarProjectionsString(typeConstructor)));
                                     }
                                     else {
@@ -252,6 +252,14 @@ public class TypeResolver {
         return false;
     }
 
+    private static boolean rhsOfIsPattern(@NotNull JetUserType type) {
+        // Look for the is-pattern containing this type
+        JetWhenConditionIsPattern outerPattern = PsiTreeUtil.getParentOfType(type, JetWhenConditionIsPattern.class, false, JetExpression.class);
+        if (outerPattern == null) return false;
+        // We are interested only in the outermost type on the RHS
+        return type.getParent() == outerPattern.getTypeRef();
+    }
+
     private JetScope getScopeForTypeParameter(final TypeParameterDescriptor typeParameterDescriptor, boolean checkBounds) {
         if (checkBounds) {
             return typeParameterDescriptor.getUpperBoundsAsType().getMemberScope();

compiler/testData/diagnostics/tests/generics/RawTypeInIsPattern.kt

@@ -0,0 +1,13 @@
+public fun foo(a: Any, <!UNUSED_PARAMETER!>b<!>: <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>Map<!>) {
+    when (a) {
+        is Map<!WRONG_NUMBER_OF_TYPE_ARGUMENTS!><Int><!> -> {}
+        is <!NO_TYPE_ARGUMENTS_ON_RHS_OF_IS_EXPRESSION!>Map<!> -> {}
+        is Map<out Any?, Any?> -> {}
+        is Map<*, *> -> {}
+        is Map<<!SYNTAX!><!>> -> {}
+        is <!CANNOT_CHECK_FOR_ERASED!>List<<!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>Map<!>><!> -> {}
+        is <!NO_TYPE_ARGUMENTS_ON_RHS_OF_IS_EXPRESSION!>List<!> -> {}
+        is Int -> {}
+        else -> {}
+    }
+}

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

@@ -1774,6 +1774,11 @@ public class JetDiagnosticsTestGenerated extends AbstractDiagnosticsTestWithEage
                 doTest("compiler/testData/diagnostics/tests/generics/RawTypeInIsExpression.kt");
             }
             
+            @TestMetadata("RawTypeInIsPattern.kt")
+            public void testRawTypeInIsPattern() throws Exception {
+                doTest("compiler/testData/diagnostics/tests/generics/RawTypeInIsPattern.kt");
+            }
+            
             @TestMetadata("RecursiveUpperBoundCheck.kt")
             public void testRecursiveUpperBoundCheck() throws Exception {
                 doTest("compiler/testData/diagnostics/tests/generics/RecursiveUpperBoundCheck.kt");

idea/testData/quickfix/addStarProjections/when/afterQualifiedArrayList.kt

@@ -0,0 +1,7 @@
+// "Add '<*>'" "true"
+public fun foo(a: Any) {
+    when (a) {
+        is java.util.ArrayList<*> -> {}
+        else -> {}
+    }
+}

idea/testData/quickfix/addStarProjections/when/afterQualifiedList.kt

@@ -0,0 +1,7 @@
+// "Add '<*>'" "true"
+public fun foo(a: Any) {
+    when (a) {
+        is jet.List<*> -> {}
+        else -> {}
+    }
+}

idea/testData/quickfix/addStarProjections/when/afterQualifiedMap.kt

@@ -0,0 +1,7 @@
+// "Add '<*, *>'" "true"
+public fun foo(a: Any) {
+    when (a) {
+        is jet.Map<*, *> -> {}
+        else -> {}
+    }
+}

idea/testData/quickfix/addStarProjections/when/afterUnqualifiedList.kt

@@ -0,0 +1,7 @@
+// "Add '<*>'" "true"
+public fun foo(a: Any) {
+    when (a) {
+        is List<*> -> {}
+        else -> {}
+    }
+}

idea/testData/quickfix/addStarProjections/when/afterUnqualifiedMap.kt

@@ -0,0 +1,7 @@
+// "Add '<*, *>'" "true"
+public fun foo(a: Any) {
+    when (a) {
+        is Map<*, *> -> {}
+        else -> {}
+    }
+}

idea/testData/quickfix/addStarProjections/when/afterUnqualifiedMapOneArg.kt

@@ -0,0 +1,9 @@
+// "Add '<*, *>'" "false"
+// "Add '<*>'" "false"
+// ERROR: 2 type arguments expected
+public fun foo(a: Any) {
+    when (a) {
+        is Map<Int> -> {}
+        else -> {}
+    }
+}

idea/testData/quickfix/addStarProjections/when/beforeQualifiedArrayList.kt

@@ -0,0 +1,7 @@
+// "Add '<*>'" "true"
+public fun foo(a: Any) {
+    when (a) {
+        is java.util.Array<caret>List -> {}
+        else -> {}
+    }
+}

idea/testData/quickfix/addStarProjections/when/beforeQualifiedList.kt

@@ -0,0 +1,7 @@
+// "Add '<*>'" "true"
+public fun foo(a: Any) {
+    when (a) {
+        is jet.List<caret> -> {}
+        else -> {}
+    }
+}

idea/testData/quickfix/addStarProjections/when/beforeQualifiedMap.kt

@@ -0,0 +1,7 @@
+// "Add '<*, *>'" "true"
+public fun foo(a: Any) {
+    when (a) {
+        is jet.Map<caret> -> {}
+        else -> {}
+    }
+}

idea/testData/quickfix/addStarProjections/when/beforeUnqualifiedList.kt

@@ -0,0 +1,7 @@
+// "Add '<*>'" "true"
+public fun foo(a: Any) {
+    when (a) {
+        is List<caret> -> {}
+        else -> {}
+    }
+}

idea/testData/quickfix/addStarProjections/when/beforeUnqualifiedMap.kt

@@ -0,0 +1,7 @@
+// "Add '<*, *>'" "true"
+public fun foo(a: Any) {
+    when (a) {
+        is Map<caret> -> {}
+        else -> {}
+    }
+}

idea/testData/quickfix/addStarProjections/when/beforeUnqualifiedMapOneArg.kt

@@ -0,0 +1,9 @@
+// "Add '<*, *>'" "false"
+// "Add '<*>'" "false"
+// ERROR: 2 type arguments expected
+public fun foo(a: Any) {
+    when (a) {
+        is <caret>Map<Int> -> {}
+        else -> {}
+    }
+}