Working on patterns + Constructor for Array

idea/src/jet/Library.jet

@@ -17,7 +17,7 @@ class Iterable<out T> {
   fun iterator() : Iterator<T>
 }
 
-class Array<T> {
+class Array<T>(val size : Int) {
   fun get(index : Int) : T
   fun set(index : Int, value : T) : Unit
 

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

@@ -117,13 +117,13 @@ public interface JetNodeTypes {
     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 EXPRESSION_PATTERN        = new JetNodeType("EXPRESSION_PATTERN", JetExpressionPattern.class);
     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 BINDING_PATTERN           = new JetNodeType("BINDING_PATTERN", JetBindingPattern.class);
+    JetNodeType TUPLE_PATTERN             = new JetNodeType("TUPLE_PATTERN", JetTuplePattern.class);
+    JetNodeType TUPLE_PATTERN_ENTRY       = new JetNodeType("TUPLE_PATTERN_ENTRY", JetTuplePatternEntry.class);
+    JetNodeType DECOMPOSER_PATTERN        = new JetNodeType("DECOMPOSER_PATTERN", JetDecomposerPattern.class);
     JetNodeType DECOMPOSER_ARGUMENT_LIST  = new JetNodeType("DECOMPOSER_ARGUMENT_LIST");
     JetNodeType DECOMPOSER_ARGUMENT       = new JetNodeType("DECOMPOSER_ARGUMENT");
 

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

@@ -662,6 +662,16 @@ public class JetControlFlowProcessor {
                                         // TODO
                                     }
 
+                                    @Override
+                                    public void visitExpressionPattern(JetExpressionPattern pattern) {
+                                        value(pattern.getExpression(), false, inCondition);
+                                    }
+
+                                    @Override
+                                    public void visitTuplePattern(JetTuplePattern pattern) {
+                                        // TODO
+                                    }
+
                                     @Override
                                     public void visitJetElement(JetElement elem) {
                                         throw new UnsupportedOperationException("[JetControlFlowProcessor] " + elem.toString());

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

@@ -0,0 +1,21 @@
+package org.jetbrains.jet.lang.psi;
+
+import com.intellij.lang.ASTNode;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.lexer.JetTokens;
+
+/**
+ * @author abreslav
+ */
+public class JetBindingPattern extends JetPattern {
+    public JetBindingPattern(@NotNull ASTNode node) {
+        super(node);
+    }
+
+    public boolean isVar() {
+        return findChildByType(JetTokens.VAR_KEYWORD) != null;
+    }
+
+
+
+}

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

@@ -0,0 +1,13 @@
+package org.jetbrains.jet.lang.psi;
+
+import com.intellij.lang.ASTNode;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * @author abreslav
+ */
+public class JetDecomposerPattern extends JetPattern {
+    public JetDecomposerPattern(@NotNull ASTNode node) {
+        super(node);
+    }
+}

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

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

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

@@ -0,0 +1,26 @@
+package org.jetbrains.jet.lang.psi;
+
+import com.intellij.lang.ASTNode;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.JetNodeTypes;
+
+import java.util.List;
+
+/**
+ * @author abreslav
+ */
+public class JetTuplePattern extends JetPattern {
+    public JetTuplePattern(@NotNull ASTNode node) {
+        super(node);
+    }
+
+    @Override
+    public void accept(@NotNull JetVisitor visitor) {
+        visitor.visitTuplePattern(this);
+    }
+
+    @NotNull
+    public List<JetTuplePatternEntry> getEntries() {
+        return findChildrenByType(JetNodeTypes.TUPLE_PATTERN_ENTRY);
+    }
+}

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

@@ -0,0 +1,31 @@
+package org.jetbrains.jet.lang.psi;
+
+import com.intellij.lang.ASTNode;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.jetbrains.jet.lexer.JetTokens;
+
+/**
+ * @author abreslav
+ */
+public class JetTuplePatternEntry extends JetElement {
+    public JetTuplePatternEntry(@NotNull ASTNode node) {
+        super(node);
+    }
+
+    @Nullable
+    public ASTNode getNameLabelNode() {
+        return getNode().findChildByType(JetTokens.IDENTIFIER);
+    }
+
+    @Nullable
+    public String getNameLabel() {
+        ASTNode nameLabelNode = getNameLabelNode();
+        return nameLabelNode == null ? null : nameLabelNode.getText();
+    }
+
+    @Nullable @IfNotParsed
+    public JetPattern getPattern() {
+        return findChildByClass(JetPattern.class);
+    }
+}

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

@@ -366,15 +366,23 @@ public class JetVisitor extends PsiElementVisitor {
         visitJetElement(condition);
     }
 
-    public void visitTypePattern(JetTypePattern typePattern) {
-        visitPattern(typePattern);
-    }
-
-    public void visitPattern(JetPattern pattern) {
-        visitJetElement(pattern);
+    public void visitTypePattern(JetTypePattern pattern) {
+        visitPattern(pattern);
     }
 
     public void visitWildcardPattern(JetWildcardPattern pattern) {
         visitPattern(pattern);
     }
+
+    public void visitExpressionPattern(JetExpressionPattern pattern) {
+        visitPattern(pattern);
+    }
+
+    public void visitTuplePattern(JetTuplePattern pattern) {
+        visitPattern(pattern);
+    }
+
+    private void visitPattern(JetPattern pattern) {
+        visitJetElement(pattern);
+    }
 }

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

@@ -1038,6 +1038,24 @@ public class JetTypeInferrer {
                                         // Nothing
                                     }
 
+                                    @Override
+                                    public void visitExpressionPattern(JetExpressionPattern pattern) {
+                                        getType(scope, pattern.getExpression(), false); // TODO : check type compatibility
+                                        trace.getErrorHandler().genericWarning(pattern.getNode(), "TODO : Types not checked");
+                                    }
+
+                                    @Override
+                                    public void visitTuplePattern(JetTuplePattern pattern) {
+                                        for (JetTuplePatternEntry entry : pattern.getEntries()) {
+                                            // TODO : is a name always allowed, ie for tuple patterns, not decomposer arg lists?
+                                            String nameLabel = entry.getNameLabel();
+                                            JetPattern entryPattern = entry.getPattern();
+                                            if (entryPattern != null) {
+                                                entryPattern.accept(this); // TODO : type checking
+                                            }
+                                        }
+                                    }
+
                                     @Override
                                     public void visitJetElement(JetElement elem) {
                                         trace.getErrorHandler().genericError(elem.getNode(), "Unsupported [JetTypeInferrer]");