Merge remote-tracking branch 'origin/master'

idea/src/org/jetbrains/jet/JetNodeTypes.java

@@ -49,6 +49,8 @@ public interface JetNodeTypes {
     JetNodeType TUPLE_TYPE    = new JetNodeType("TUPLE_TYPE", JetTupleType.class);
     JetNodeType FUNCTION_TYPE = new JetNodeType("FUNCTION_TYPE", JetFunctionType.class);
     JetNodeType SELF_TYPE     = new JetNodeType("SELF_TYPE", JetSelfType.class);
+    JetNodeType NULLABLE_TYPE             = new JetNodeType("NULLABLE_TYPE", JetNullableType.class);
+    JetNodeType TYPE_PROJECTION           = new JetNodeType("TYPE_PROJECTION", JetTypeProjection.class);
 
     // TODO: review
     JetNodeType PROPERTY_ACCESSOR        = new JetNodeType("PROPERTY_ACCESSOR", JetPropertyAccessor.class);
@@ -111,25 +113,27 @@ public interface JetNodeTypes {
     JetNodeType HASH_QUALIFIED_EXPRESSION = new JetNodeType("HASH_QUALIFIED_EXPRESSION", JetHashQualifiedExpression.class);
     JetNodeType SAFE_ACCESS_EXPRESSION    = new JetNodeType("SAFE_ACCESS_EXPRESSION", JetSafeQualifiedExpression.class);
     JetNodeType PREDICATE_EXPRESSION       = new JetNodeType("PREDICATE_EXPRESSION", JetPredicateExpression.class);
-    JetNodeType DECOMPOSER_PATTERN        = new JetNodeType("DECOMPOSER_PATTERN", JetPattern.class); // TODO
-    JetNodeType TUPLE_PATTERN             = new JetNodeType("TUPLE_PATTERN", JetPattern.class); // TODO
+
     JetNodeType OBJECT_LITERAL            = new JetNodeType("OBJECT_LITERAL", JetObjectLiteralExpression.class);
     JetNodeType ROOT_NAMESPACE            = new JetNodeType("ROOT_NAMESPACE", JetRootNamespaceExpression.class);
+
+    JetNodeType EXPRESSION_PATTERN        = new JetNodeType("EXPRESSION_PATTERN", JetPattern.class); // TODO
+    JetNodeType TYPE_PATTERN              = new JetNodeType("TYPE_PATTERN", JetTypePattern.class);
+    JetNodeType WILDCARD_PATTERN          = new JetNodeType("WILDCARD_PATTERN", JetWildcardPattern.class);
+    JetNodeType BINDING_PATTERN           = new JetNodeType("BINDING_PATTERN", JetPattern.class); // TODO
+    JetNodeType TUPLE_PATTERN             = new JetNodeType("TUPLE_PATTERN", JetPattern.class); // TODO
+    JetNodeType TUPLE_PATTERN_ENTRY       = new JetNodeType("TUPLE_PATTERN_ENTRY");
+    JetNodeType DECOMPOSER_PATTERN        = new JetNodeType("DECOMPOSER_PATTERN", JetPattern.class); // TODO
     JetNodeType DECOMPOSER_ARGUMENT_LIST  = new JetNodeType("DECOMPOSER_ARGUMENT_LIST");
     JetNodeType DECOMPOSER_ARGUMENT       = new JetNodeType("DECOMPOSER_ARGUMENT");
-    JetNodeType TYPE_PATTERN              = new JetNodeType("TYPE_PATTERN", JetTypePattern.class);
-    JetNodeType EXPRESSION_PATTERN        = new JetNodeType("EXPRESSION_PATTERN", JetPattern.class); // TODO
-    JetNodeType BINDING_PATTERN           = new JetNodeType("BINDING_PATTERN", JetPattern.class); // TODO
-    JetNodeType WILDCARD_PATTERN          = new JetNodeType("WILDCARD_PATTERN", JetPattern.class); // TODO
+
     JetNodeType WHEN                      = new JetNodeType("WHEN", JetWhenExpression.class);
     JetNodeType WHEN_ENTRY                = new JetNodeType("WHEN_ENTRY", JetWhenEntry.class);
+
     JetNodeType WHEN_CONDITION_IN_RANGE   = new JetNodeType("WHEN_CONDITION_IN_RANGE", JetWhenConditionInRange.class);
     JetNodeType WHEN_CONDITION_IS_PATTERN = new JetNodeType("WHEN_CONDITION_IS_PATTERN", JetWhenConditionIsPattern.class);
     JetNodeType WHEN_CONDITION_CALL       = new JetNodeType("WHEN_CONDITION_CALL", JetWhenConditionCall.class);
     JetNodeType WHEN_CONDITION_EXPRESSION = new JetNodeType("WHEN_CONDITION_EXPRESSION", JetWhenConditionWithExpression.class);
-    JetNodeType TUPLE_PATTERN_ENTRY       = new JetNodeType("TUPLE_PATTERN_ENTRY");
-    JetNodeType NULLABLE_TYPE             = new JetNodeType("NULLABLE_TYPE", JetNullableType.class);
-    JetNodeType TYPE_PROJECTION           = new JetNodeType("TYPE_PROJECTION", JetTypeProjection.class);
 
     JetNodeType NAMESPACE_NAME = new JetNodeType("NAMESPACE_NAME", JetContainerNode.class);
 }

idea/src/org/jetbrains/jet/lang/cfg/JetControlFlowProcessor.java

@@ -649,12 +649,30 @@ public class JetControlFlowProcessor {
 
                         @Override
                         public void visitWhenConditionIsPattern(JetWhenConditionIsPattern condition) {
-                            super.visitWhenConditionIsPattern(condition); // TODO
+                            JetPattern pattern = condition.getPattern();
+                            if (pattern != null) {
+                                pattern.accept(new JetVisitor() {
+                                    @Override
+                                    public void visitTypePattern(JetTypePattern typePattern) {
+                                        // TODO
+                                    }
+
+                                    @Override
+                                    public void visitWildcardPattern(JetWildcardPattern pattern) {
+                                        // TODO
+                                    }
+
+                                    @Override
+                                    public void visitJetElement(JetElement elem) {
+                                        throw new UnsupportedOperationException("[JetControlFlowProcessor] " + elem.toString());
+                                    }
+                                });
+                            }
                         }
 
                         @Override
                         public void visitJetElement(JetElement elem) {
-                            throw new UnsupportedOperationException();
+                            throw new UnsupportedOperationException("[JetControlFlowProcessor] " + elem.toString());
                         }
                     });
                 }

idea/src/org/jetbrains/jet/lang/psi/JetTypePattern.java

@@ -16,4 +16,9 @@ public class JetTypePattern extends JetPattern {
     public JetTypeReference getTypeReference() {
         return findChildByClass(JetTypeReference.class);
     }
+
+    @Override
+    public void accept(@NotNull JetVisitor visitor) {
+        visitor.visitTypePattern(this);
+    }
 }

idea/src/org/jetbrains/jet/lang/psi/JetVisitor.java

@@ -365,4 +365,16 @@ public class JetVisitor extends PsiElementVisitor {
     public void visitWhenConditionInRange(JetWhenConditionInRange condition) {
         visitJetElement(condition);
     }
+
+    public void visitTypePattern(JetTypePattern typePattern) {
+        visitPattern(typePattern);
+    }
+
+    public void visitPattern(JetPattern pattern) {
+        visitJetElement(pattern);
+    }
+
+    public void visitWildcardPattern(JetWildcardPattern pattern) {
+        visitPattern(pattern);
+    }
 }

idea/src/org/jetbrains/jet/lang/psi/JetWildcardPattern.java

@@ -0,0 +1,18 @@
+package org.jetbrains.jet.lang.psi;
+
+import com.intellij.lang.ASTNode;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * @author abreslav
+ */
+public class JetWildcardPattern extends JetPattern {
+    public JetWildcardPattern(@NotNull ASTNode node) {
+        super(node);
+    }
+
+    @Override
+    public void accept(@NotNull JetVisitor visitor) {
+        visitor.visitWildcardPattern(this);
+    }
+}

idea/src/org/jetbrains/jet/lang/types/JetTypeInferrer.java

@@ -1019,7 +1019,31 @@ public class JetTypeInferrer {
 
                         @Override
                         public void visitWhenConditionIsPattern(JetWhenConditionIsPattern condition) {
-                            super.visitWhenConditionIsPattern(condition); // TODO
+                            JetPattern pattern = condition.getPattern();
+                            if (pattern != null) {
+                                pattern.accept(new JetVisitor() {
+                                    @Override
+                                    public void visitTypePattern(JetTypePattern typePattern) {
+                                        JetTypeReference typeReference = typePattern.getTypeReference();
+                                        if (typeReference != null) {
+                                            JetType type = typeResolver.resolveType(scope, typeReference);
+                                            if (TypeUtils.intersect(semanticServices.getTypeChecker(), Sets.newHashSet(type, finalSubjectType)) == null) {
+                                                trace.getErrorHandler().genericError(typePattern.getNode(), "Incompatible types"); // TODO : message
+                                            }
+                                        }
+                                    }
+
+                                    @Override
+                                    public void visitWildcardPattern(JetWildcardPattern pattern) {
+                                        // Nothing
+                                    }
+
+                                    @Override
+                                    public void visitJetElement(JetElement elem) {
+                                        trace.getErrorHandler().genericError(elem.getNode(), "Unsupported [JetTypeInferrer]");
+                                    }
+                                });
+                            }
                         }
 
                         @Override

idea/testData/checker/When.jet

@@ -2,6 +2,10 @@ fun foo() {
     val s = ""
     val x = 1
     when (x) {
+      is * => 1
+      is <error>String</error> => 1
+      !is Int => 1
+      is Any? => 1
       <error>s</error> => 1
       1 => 1
       1 + <error>a</error> => 1