KT-627 Drop Predicate expression

compiler/frontend/src/org/jetbrains/jet/JetNodeTypes.java

@@ -138,7 +138,7 @@ public interface JetNodeTypes {
     JetNodeType DOT_QUALIFIED_EXPRESSION  = new JetNodeType("DOT_QUALIFIED_EXPRESSION", JetDotQualifiedExpression.class);
     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 PREDICATE_EXPRESSION      = new JetNodeType("PREDICATE_EXPRESSION", JetPredicateExpression.class);
 
     JetNodeType OBJECT_LITERAL            = new JetNodeType("OBJECT_LITERAL", JetObjectLiteralExpression.class);
     JetNodeType ROOT_NAMESPACE            = new JetNodeType("ROOT_NAMESPACE", JetRootNamespaceExpression.class);

compiler/frontend/src/org/jetbrains/jet/lang/parsing/JetExpressionParsing.java

@@ -385,13 +385,13 @@ public class JetExpressionParsing extends AbstractJetParsing {
 
                 expression.done(SAFE_ACCESS_EXPRESSION);
             }
-            else if (at(QUEST)) {
+//            else if (at(QUEST)) {
-                advance(); // QUEST
+//                advance(); // QUEST
-
+//
-                parseCallExpression();
+//                parseCallExpression();
-
+//
-                expression.done(PREDICATE_EXPRESSION);
+//                expression.done(PREDICATE_EXPRESSION);
-            }
+//            }
 //            else if (at(HASH)) {
 //                advance(); // HASH
 //

compiler/testData/diagnostics/tests/QualifiedExpressions.jet

@@ -7,7 +7,7 @@ fun test(s: String?) {
    val <!UNUSED_VARIABLE!>d<!>: Int = s?.length ?: <!TYPE_MISMATCH!>"empty"<!>
    val e: String = <!TYPE_MISMATCH!>s?.length<!> ?: "empty"
    val <!UNUSED_VARIABLE!>f<!>: Int = s?.length ?: b ?: 1
-   val <!UNUSED_VARIABLE!>g<!>: Int? = e? startsWith("s")?.length
+   val <!UNUSED_VARIABLE!>g<!>: Boolean? = e.startsWith("s")//?.length
 }
 
 fun String.startsWith(<!UNUSED_PARAMETER!>s<!>: String): Boolean = true

compiler/testData/psi/PredicateExpression.jet

@@ -1,3 +0,0 @@
-fun foo() {
-  a?f.foo
-}

compiler/testData/psi/PredicateExpression.txt

@@ -1,26 +0,0 @@
-JetFile: PredicateExpression.jet
-  NAMESPACE_HEADER
-    <empty list>
-  FUN
-    PsiElement(fun)('fun')
-    PsiWhiteSpace(' ')
-    PsiElement(IDENTIFIER)('foo')
-    VALUE_PARAMETER_LIST
-      PsiElement(LPAR)('(')
-      PsiElement(RPAR)(')')
-    PsiWhiteSpace(' ')
-    BLOCK
-      PsiElement(LBRACE)('{')
-      PsiWhiteSpace('\n  ')
-      DOT_QUALIFIED_EXPRESSION
-        PREDICATE_EXPRESSION
-          REFERENCE_EXPRESSION
-            PsiElement(IDENTIFIER)('a')
-          PsiElement(QUEST)('?')
-          REFERENCE_EXPRESSION
-            PsiElement(IDENTIFIER)('f')
-        PsiElement(DOT)('.')
-        REFERENCE_EXPRESSION
-          PsiElement(IDENTIFIER)('foo')
-      PsiWhiteSpace('\n')
-      PsiElement(RBRACE)('}')

compiler/tests/org/jetbrains/jet/codegen/StdlibTest.java

@@ -88,19 +88,19 @@ public class StdlibTest extends CodegenTestCase {
     }
 
     //from NamespaceGenTest
-    public void testPredicateOperator() throws Exception {
+//    public void testPredicateOperator() throws Exception {
-        loadText("fun foo(s: String) = s?startsWith(\"J\")");
+//        loadText("fun foo(s: String) = s?startsWith(\"J\")");
-        final Method main = generateFunction();
+//        final Method main = generateFunction();
-        try {
+//        try {
-            assertEquals("JetBrains", main.invoke(null, "JetBrains"));
+//            assertEquals("JetBrains", main.invoke(null, "JetBrains"));
-            assertNull(main.invoke(null, "IntelliJ"));
+//            assertNull(main.invoke(null, "IntelliJ"));
-        } catch (Throwable t) {
+//        } catch (Throwable t) {
-//            System.out.println(generateToText());
+////            System.out.println(generateToText());
-            t.printStackTrace();
+//            t.printStackTrace();
-            throw t instanceof Exception ? (Exception)t : new RuntimeException(t);
+//            throw t instanceof Exception ? (Exception)t : new RuntimeException(t);
-        }
+//        }
-    }
+//    }
-
+//
     public void testForInString() throws Exception {
         loadText("fun foo() : Int {        var sum = 0\n" +
                  "        for(c in \"239\")\n" +

compiler/tests/org/jetbrains/jet/types/JetTypeCheckerTest.java

@@ -460,9 +460,9 @@ public class JetTypeCheckerTest extends JetLiteFixture {
         assertType("true && false", "Boolean");
         assertType("true || false", "Boolean");
         assertType("null ?: false", "Boolean");
-        assertType("WithPredicate()?isValid()", "WithPredicate?");
+//        assertType("WithPredicate()?isValid()", "WithPredicate?");
-        assertType("WithPredicate()?isValid(1)", "WithPredicate?");
+//        assertType("WithPredicate()?isValid(1)", "WithPredicate?");
-        assertType("WithPredicate()?p", "WithPredicate?");
+//        assertType("WithPredicate()?p", "WithPredicate?");
     }
 
     public void testSupertypes() throws Exception {

idea/testData/checker/QualifiedExpressions.jet

@@ -7,7 +7,7 @@ fun test(s: String?) {
    val <warning>d</warning>: Int = s?.length ?: <error>"empty"</error>
    val e: String = <error>s?.length</error> ?: "empty"
    val <warning>f</warning>: Int = s?.length ?: b ?: 1
-   val <warning>g</warning>: Int? = e? startsWith("s")?.length
+   val <warning>g</warning>: Boolean? = e.startsWith("s")//?.length
 }
 
 fun String.startsWith(<warning>s</warning>: String): Boolean = true