From 197c4a6fee152bdbc419f4ad779def4a38b60785 Mon Sep 17 00:00:00 2001 From: Andrey Breslav Date: Thu, 19 May 2011 21:12:09 +0400 Subject: [PATCH 1/2] Basic type patterns supported in when() expressions --- .../jet/lang/cfg/JetControlFlowProcessor.java | 17 +++++++++++++-- .../jet/lang/psi/JetTypePattern.java | 5 +++++ .../jetbrains/jet/lang/psi/JetVisitor.java | 8 +++++++ .../jet/lang/types/JetTypeInferrer.java | 21 ++++++++++++++++++- idea/testData/checker/When.jet | 3 +++ 5 files changed, 51 insertions(+), 3 deletions(-) diff --git a/idea/src/org/jetbrains/jet/lang/cfg/JetControlFlowProcessor.java b/idea/src/org/jetbrains/jet/lang/cfg/JetControlFlowProcessor.java index 3b62afcb70a..be753b341f1 100644 --- a/idea/src/org/jetbrains/jet/lang/cfg/JetControlFlowProcessor.java +++ b/idea/src/org/jetbrains/jet/lang/cfg/JetControlFlowProcessor.java @@ -649,12 +649,25 @@ 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 visitJetElement(JetElement elem) { + throw new UnsupportedOperationException(elem.toString()); + } + }); + } } @Override public void visitJetElement(JetElement elem) { - throw new UnsupportedOperationException(); + throw new UnsupportedOperationException(elem.toString()); } }); } diff --git a/idea/src/org/jetbrains/jet/lang/psi/JetTypePattern.java b/idea/src/org/jetbrains/jet/lang/psi/JetTypePattern.java index acec30077f3..08bb92a47cd 100644 --- a/idea/src/org/jetbrains/jet/lang/psi/JetTypePattern.java +++ b/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); + } } diff --git a/idea/src/org/jetbrains/jet/lang/psi/JetVisitor.java b/idea/src/org/jetbrains/jet/lang/psi/JetVisitor.java index 1f9d202dcc9..b347d15176a 100644 --- a/idea/src/org/jetbrains/jet/lang/psi/JetVisitor.java +++ b/idea/src/org/jetbrains/jet/lang/psi/JetVisitor.java @@ -365,4 +365,12 @@ 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); + } } diff --git a/idea/src/org/jetbrains/jet/lang/types/JetTypeInferrer.java b/idea/src/org/jetbrains/jet/lang/types/JetTypeInferrer.java index 1e48186c714..4263ef7523a 100644 --- a/idea/src/org/jetbrains/jet/lang/types/JetTypeInferrer.java +++ b/idea/src/org/jetbrains/jet/lang/types/JetTypeInferrer.java @@ -1019,7 +1019,26 @@ 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 visitJetElement(JetElement elem) { + trace.getErrorHandler().genericError(elem.getNode(), "Unsupported [JetTypeInferrer]"); + } + }); + } } @Override diff --git a/idea/testData/checker/When.jet b/idea/testData/checker/When.jet index 7eb6e6b582f..13a68794b33 100644 --- a/idea/testData/checker/When.jet +++ b/idea/testData/checker/When.jet @@ -2,6 +2,9 @@ fun foo() { val s = "" val x = 1 when (x) { + is String => 1 + !is Int => 1 + is Any? => 1 s => 1 1 => 1 1 + a => 1 From 1c6dadb36afae3daca74c918c56bc25f788a63b0 Mon Sep 17 00:00:00 2001 From: Andrey Breslav Date: Thu, 19 May 2011 21:24:21 +0400 Subject: [PATCH 2/2] Support for wildcard patterns --- idea/src/org/jetbrains/jet/JetNodeTypes.java | 22 +++++++++++-------- .../jet/lang/cfg/JetControlFlowProcessor.java | 9 ++++++-- .../jetbrains/jet/lang/psi/JetVisitor.java | 4 ++++ .../jet/lang/psi/JetWildcardPattern.java | 18 +++++++++++++++ .../jet/lang/types/JetTypeInferrer.java | 5 +++++ idea/testData/checker/When.jet | 1 + 6 files changed, 48 insertions(+), 11 deletions(-) create mode 100644 idea/src/org/jetbrains/jet/lang/psi/JetWildcardPattern.java diff --git a/idea/src/org/jetbrains/jet/JetNodeTypes.java b/idea/src/org/jetbrains/jet/JetNodeTypes.java index 638892a60d3..32ab360a69c 100644 --- a/idea/src/org/jetbrains/jet/JetNodeTypes.java +++ b/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); } diff --git a/idea/src/org/jetbrains/jet/lang/cfg/JetControlFlowProcessor.java b/idea/src/org/jetbrains/jet/lang/cfg/JetControlFlowProcessor.java index be753b341f1..69ed7f05f88 100644 --- a/idea/src/org/jetbrains/jet/lang/cfg/JetControlFlowProcessor.java +++ b/idea/src/org/jetbrains/jet/lang/cfg/JetControlFlowProcessor.java @@ -657,9 +657,14 @@ public class JetControlFlowProcessor { // TODO } + @Override + public void visitWildcardPattern(JetWildcardPattern pattern) { + // TODO + } + @Override public void visitJetElement(JetElement elem) { - throw new UnsupportedOperationException(elem.toString()); + throw new UnsupportedOperationException("[JetControlFlowProcessor] " + elem.toString()); } }); } @@ -667,7 +672,7 @@ public class JetControlFlowProcessor { @Override public void visitJetElement(JetElement elem) { - throw new UnsupportedOperationException(elem.toString()); + throw new UnsupportedOperationException("[JetControlFlowProcessor] " + elem.toString()); } }); } diff --git a/idea/src/org/jetbrains/jet/lang/psi/JetVisitor.java b/idea/src/org/jetbrains/jet/lang/psi/JetVisitor.java index b347d15176a..fd1178cae14 100644 --- a/idea/src/org/jetbrains/jet/lang/psi/JetVisitor.java +++ b/idea/src/org/jetbrains/jet/lang/psi/JetVisitor.java @@ -373,4 +373,8 @@ public class JetVisitor extends PsiElementVisitor { public void visitPattern(JetPattern pattern) { visitJetElement(pattern); } + + public void visitWildcardPattern(JetWildcardPattern pattern) { + visitPattern(pattern); + } } diff --git a/idea/src/org/jetbrains/jet/lang/psi/JetWildcardPattern.java b/idea/src/org/jetbrains/jet/lang/psi/JetWildcardPattern.java new file mode 100644 index 00000000000..dece9f0f43b --- /dev/null +++ b/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); + } +} diff --git a/idea/src/org/jetbrains/jet/lang/types/JetTypeInferrer.java b/idea/src/org/jetbrains/jet/lang/types/JetTypeInferrer.java index 4263ef7523a..655d33dca3f 100644 --- a/idea/src/org/jetbrains/jet/lang/types/JetTypeInferrer.java +++ b/idea/src/org/jetbrains/jet/lang/types/JetTypeInferrer.java @@ -1033,6 +1033,11 @@ public class JetTypeInferrer { } } + @Override + public void visitWildcardPattern(JetWildcardPattern pattern) { + // Nothing + } + @Override public void visitJetElement(JetElement elem) { trace.getErrorHandler().genericError(elem.getNode(), "Unsupported [JetTypeInferrer]"); diff --git a/idea/testData/checker/When.jet b/idea/testData/checker/When.jet index 13a68794b33..5aafb51023e 100644 --- a/idea/testData/checker/When.jet +++ b/idea/testData/checker/When.jet @@ -2,6 +2,7 @@ fun foo() { val s = "" val x = 1 when (x) { + is * => 1 is String => 1 !is Int => 1 is Any? => 1