0-ary tuples

grammar/src/expressions.grm

@@ -56,9 +56,8 @@ elvisOperation
   : infixFunctionCall ("?:" infixFunctionCall)*
   ;
 
-// ATTENTION
 infixFunctionCall
-  : rangeExpression (SimpleName (typeArguments | rangeExpression))*
+  : rangeExpression (SimpleName rangeExpression)*
   ;
 
 rangeExpression
@@ -198,7 +197,7 @@ jump
 
 tupleLiteral // Ambiguity when after a SimpleName (infix call). In this case (e) is treated as an expression in parentheses
              // to put a tuple, write write ((e))
-  : "(" expression{","} ")"
+  : "(" ((SimpleName "=")? expression){","} ")"
   ;
 
 functionLiteral  // one can use "it" as a parameter name

idea/src/org/jetbrains/jet/lang/parsing/JetExpressionParsing.java

@@ -61,7 +61,6 @@ public class JetExpressionParsing extends AbstractJetParsing {
         RANGE(JetTokens.RANGE),
         SIMPLE_NAME(IDENTIFIER),
         ELVIS(JetTokens.ELVIS),
-        // TODO: RHS (type parameters)
         NAMED_INFIX_OR_TYPE(IN_KEYWORD, NOT_IN, IS_KEYWORD, NOT_IS, AS_KEYWORD, COLON),
         COMPARISON(LT, GT, LTEQ, GTEQ),
         EQUALITY(EQEQ, EXCLEQ, EQEQEQ, EXCLEQEQEQ),
@@ -1019,7 +1018,7 @@ public class JetExpressionParsing extends AbstractJetParsing {
     /*
      * "(" expression ")" // see tupleLiteral
      * "(" expression{","} ")"
-     * TODO: Labels in tuple literals?
+     * TODO: duplication with valueArguments (but for the error messages)
      */
     private void parseParenthesizedExpressionOrTuple() {
         assert at(LPAR);
@@ -1029,12 +1028,17 @@ public class JetExpressionParsing extends AbstractJetParsing {
         myBuilder.disableEols();
         advance(); // LPAR
 
-
+        if (!at(RPAR)) {
-        while (true) {
+            while (true) {
-            if (at(COMMA)) errorAndAdvance("Expecting a tuple entry (expression)");
+                while (at(COMMA)) errorAndAdvance("Expecting a tuple entry (expression)");
-            parseExpression();
+                parseExpression();
-            if (!at(COMMA)) break;
+                if (!at(COMMA)) break;
-            advance(); // COMMA
+                advance(); // COMMA
+                if (at(RPAR)) {
+                    error("Expecting a tuple entry (expression)");
+                    break;
+                }
+            }
         }
 
         expect(RPAR, "Expecting ')'");
@@ -1078,13 +1082,18 @@ public class JetExpressionParsing extends AbstractJetParsing {
         PsiBuilder.Marker list = mark();
 
         myBuilder.disableEols();
-        expect(LPAR, "Expecting a parameter list", TokenSet.create(RPAR));
+        expect(LPAR, "Expecting an argument list", TokenSet.create(RPAR));
 
         if (!at(RPAR)) {
             while (true) {
+                while (at(COMMA)) errorAndAdvance("Expecting an argument");
                 parseValueArgument();
                 if (!at(COMMA)) break;
                 advance(); // COMMA
+                if (at(RPAR)) {
+                    error("Expecting an argument");
+                    break;
+                }
             }
         }
 

idea/src/org/jetbrains/jet/lang/parsing/JetParsing.java

@@ -1368,7 +1368,7 @@ public class JetParsing extends AbstractJetParsing {
      *   : "(" functionParameter{","}? ")" // default values
      *   ;
      *
-     * functionParameter
+     * functionParameter                                         Машка Юдина Неееет! Зимой сельдерей не растет на улице!!! Как же так?
      *   : modifiers functionParameterRest
      *   ;
      *
@@ -1377,8 +1377,6 @@ public class JetParsing extends AbstractJetParsing {
      *   ;
      */
     public void parseValueParameterList(boolean isFunctionTypeContents, TokenSet recoverySet) {
-        // TODO: val a, b, c : Int
-
         PsiBuilder.Marker parameters = mark();
 
         myBuilder.disableEols();

idea/testData/psi/SimpleExpressions.jet

@@ -1,5 +1,6 @@
 
 fun a(
+    a : foo = (),
     a : foo = 10,
     a : foo = 0x10,
     a : foo = '1',

idea/testData/psi/SimpleExpressions.txt

@@ -9,6 +9,22 @@ JetFile: SimpleExpressions.jet
       VALUE_PARAMETER_LIST
         PsiElement(LPAR)('(')
         PsiWhiteSpace('\n    ')
+        VALUE_PARAMETER
+          PsiElement(IDENTIFIER)('a')
+          PsiWhiteSpace(' ')
+          PsiElement(COLON)(':')
+          PsiWhiteSpace(' ')
+          TYPE_REFERENCE
+            USER_TYPE
+              PsiElement(IDENTIFIER)('foo')
+          PsiWhiteSpace(' ')
+          PsiElement(EQ)('=')
+          PsiWhiteSpace(' ')
+          TUPLE
+            PsiElement(LPAR)('(')
+            PsiElement(RPAR)(')')
+        PsiElement(COMMA)(',')
+        PsiWhiteSpace('\n    ')
         VALUE_PARAMETER
           PsiElement(IDENTIFIER)('a')
           PsiWhiteSpace(' ')

idea/tests/org/jetbrains/jet/parsing/JetParsingTest.java

@@ -10,6 +10,10 @@ import junit.framework.TestSuite;
 import java.io.File;
 import java.io.FileFilter;
 import java.io.FilenameFilter;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
 
 public class JetParsingTest extends ParsingTestCase {
     static {
@@ -70,11 +74,15 @@ public class JetParsingTest extends ParsingTestCase {
             }
         };
         if (recursive) {
-            for (File subDir : dir.listFiles(dirFilter)) {
+            List<File> subdirs = Arrays.asList(dir.listFiles(dirFilter));
-                suite.addTest(suiteForDirectory(dataPath + "/" + subDir.getName(), recursive));
+            Collections.sort(subdirs);
+            for (File subdir : subdirs) {
+                suite.addTest(suiteForDirectory(dataPath + "/" + subdir.getName(), recursive));
             }
         }
-        for (File file : dir.listFiles(extensionFilter)) {
+        List<File> files = Arrays.asList(dir.listFiles(extensionFilter));
+        Collections.sort(files);
+        for (File file : files) {
             String fileName = file.getName();
             suite.addTest(new JetParsingTest(dataPath, fileName.substring(0, fileName.length() - extension.length())));
         }