JET-121 Extension closure scope, empty?

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

@@ -13,7 +13,7 @@ public interface JetNodeTypes {
     JetNodeType NAMESPACE  = new JetNodeType("NAMESPACE", JetNamespace.class);
     JetNodeType CLASS      = new JetNodeType("CLASS", JetClass.class);
     JetNodeType PROPERTY   = new JetNodeType("PROPERTY", JetProperty.class);
-    JetNodeType FUN        = new JetNodeType("FUN", JetFunction.class);
+    JetNodeType FUN        = new JetNodeType("FUN", JetNamedFunction.class);
     JetNodeType EXTENSION  = new JetNodeType("EXTENSION", JetExtension.class);
     JetNodeType TYPEDEF    = new JetNodeType("TYPEDEF", JetTypedef.class);
     JetNodeType OBJECT_DECLARATION = new JetNodeType("OBJECT_DECLARATION", JetObjectDeclaration.class);
@@ -93,7 +93,8 @@ public interface JetNodeTypes {
     JetNodeType LOOP_RANGE                = new JetNodeType("LOOP_RANGE", JetContainerNode.class);
     JetNodeType BODY                      = new JetNodeType("BODY", JetContainerNode.class);
     JetNodeType BLOCK                     = new JetNodeType("BLOCK", JetBlockExpression.class);
-    JetNodeType FUNCTION_LITERAL          = new JetNodeType("FUNCTION_LITERAL", JetFunctionLiteralExpression.class);
+    JetNodeType FUNCTION_LITERAL_EXPRESSION = new JetNodeType("FUNCTION_LITERAL_EXPRESSION", JetFunctionLiteralExpression.class);
+    JetNodeType FUNCTION_LITERAL          = new JetNodeType("FUNCTION_LITERAL", JetFunctionLiteral.class);
     JetNodeType ANNOTATED_EXPRESSION      = new JetNodeType("ANNOTATED_EXPRESSION", JetAnnotatedExpression.class);
 
     JetNodeType REFERENCE_EXPRESSION      = new JetNodeType("REFERENCE_EXPRESSION", JetSimpleNameExpression.class);

idea/src/org/jetbrains/jet/codegen/ClassBodyCodegen.java

@@ -66,9 +66,9 @@ public abstract class ClassBodyCodegen {
         if (declaration instanceof JetProperty) {
             propertyCodegen.gen((JetProperty) declaration, kind);
         }
-        else if (declaration instanceof JetFunction) {
+        else if (declaration instanceof JetNamedFunction) {
             try {
-                functionCodegen.gen((JetFunction) declaration, kind);
+                functionCodegen.gen((JetNamedFunction) declaration, kind);
             } catch (RuntimeException e) {
                 throw new RuntimeException("Error generating method " + myClass.getName() + "." + declaration.getName() + " in " + kind, e);
             }

idea/src/org/jetbrains/jet/codegen/ClosureCodegen.java

@@ -90,7 +90,7 @@ public class ClosureCodegen {
         final Method constructor = generateConstructor(cv, funClass);
 
         generateBridge(name, funDescriptor, cv);
-        generateBody(name, funDescriptor, cv, container.getProject(), fun.getBody());
+        generateBody(name, funDescriptor, cv, container.getProject(), fun.getFunctionLiteral().getBodyExpression().getStatements());
 
         cv.visitEnd();
 

idea/src/org/jetbrains/jet/codegen/ExpressionCodegen.java

@@ -478,7 +478,7 @@ public class ExpressionCodegen extends JetVisitor {
     @Override
     public void visitFunctionLiteralExpression(JetFunctionLiteralExpression expression) {
         if (bindingContext.isBlock(expression)) {
-            generateBlock(expression.getBody());
+            generateBlock(expression.getFunctionLiteral().getBodyExpression().getStatements());
         }
         else {
             final GeneratedClosureDescriptor closure = new ClosureCodegen(bindingContext, typeMapper, factory).gen(expression);
@@ -757,8 +757,8 @@ public class ExpressionCodegen extends JetVisitor {
                             methodDescriptor.getName(),
                             methodDescriptor.getDescriptor());
                 }
-                else if(declarationPsiElement instanceof JetFunction) {
-                    final JetFunction jetFunction = (JetFunction) declarationPsiElement;
+                else if(declarationPsiElement instanceof JetNamedFunction) {
+                    final JetNamedFunction jetFunction = (JetNamedFunction) declarationPsiElement;
                     methodDescriptor = typeMapper.mapSignature(jetFunction);
                     if (functionParent instanceof NamespaceDescriptorImpl) {
                         if (jetFunction.getReceiverTypeRef() != null) {

idea/src/org/jetbrains/jet/codegen/FunctionCodegen.java

@@ -35,7 +35,7 @@ public class FunctionCodegen {
         typeMapper = new JetTypeMapper(standardLibrary, bindingContext);
     }
 
-    public void gen(JetFunction f, OwnerKind kind) {
+    public void gen(JetNamedFunction f, OwnerKind kind) {
         final JetTypeReference receiverTypeRef = f.getReceiverTypeRef();
         final JetType receiverType = receiverTypeRef == null ? null : bindingContext.resolveTypeReference(receiverTypeRef);
         Method method = typeMapper.mapSignature(f);

idea/src/org/jetbrains/jet/codegen/ImplementationBodyCodegen.java

@@ -153,8 +153,8 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
 
         HashSet<FunctionDescriptor> overridden = new HashSet<FunctionDescriptor>();
         for (JetDeclaration declaration : myClass.getDeclarations()) {
-            if (declaration instanceof JetFunction) {
-                overridden.addAll(bindingContext.getFunctionDescriptor((JetFunction) declaration).getOverriddenFunctions());
+            if (declaration instanceof JetNamedFunction) {
+                overridden.addAll(bindingContext.getFunctionDescriptor((JetNamedFunction) declaration).getOverriddenFunctions());
             }
         }
 
@@ -362,9 +362,9 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
             if (declaration instanceof JetProperty) {
                 propertyCodegen.gen((JetProperty) declaration, kind);
             }
-            else if (declaration instanceof JetFunction) {
-                if (!overriden.contains(bindingContext.getFunctionDescriptor((JetFunction) declaration))) {
-                    functionCodegen.gen((JetFunction) declaration, kind);
+            else if (declaration instanceof JetNamedFunction) {
+                if (!overriden.contains(bindingContext.getFunctionDescriptor((JetNamedFunction) declaration))) {
+                    functionCodegen.gen((JetNamedFunction) declaration, kind);
                 }
             }
         }

idea/src/org/jetbrains/jet/codegen/JetTypeMapper.java

@@ -251,7 +251,7 @@ public class JetTypeMapper {
         return type;
     }
 
-    public Method mapSignature(JetFunction f) {
+    public Method mapSignature(JetNamedFunction f) {
         final JetTypeReference receiverTypeRef = f.getReceiverTypeRef();
         final JetType receiverType = receiverTypeRef == null ? null : bindingContext.resolveTypeReference(receiverTypeRef);
         final List<JetParameter> parameters = f.getValueParameters();

idea/src/org/jetbrains/jet/codegen/NamespaceCodegen.java

@@ -57,9 +57,9 @@ public class NamespaceCodegen {
             if (declaration instanceof JetProperty) {
                 propertyCodegen.gen((JetProperty) declaration, OwnerKind.NAMESPACE);
             }
-            else if (declaration instanceof JetFunction) {
+            else if (declaration instanceof JetNamedFunction) {
                 try {
-                    functionCodegen.gen((JetFunction) declaration, OwnerKind.NAMESPACE);
+                    functionCodegen.gen((JetNamedFunction) declaration, OwnerKind.NAMESPACE);
                 } catch (Exception e) {
                     throw new RuntimeException("Failed to generate function " + declaration.getName(), e);
                 }

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

@@ -492,7 +492,7 @@ public class JetControlFlowProcessor {
         }
 
         @Override
-        public void visitFunction(JetFunction function) {
+        public void visitNamedFunction(JetNamedFunction function) {
             JetExpression bodyExpression = function.getBodyExpression();
             if (bodyExpression != null) {
                 generate(function, bodyExpression);
@@ -501,13 +501,14 @@ public class JetControlFlowProcessor {
 
         @Override
         public void visitFunctionLiteralExpression(JetFunctionLiteralExpression expression) {
-            if (preferBlock && !expression.hasParameterSpecification()) {
-                for (JetElement statement : expression.getBody()) {
+            JetFunctionLiteral functionLiteral = expression.getFunctionLiteral();
+            if (preferBlock && !functionLiteral.hasParameterSpecification()) {
+                for (JetElement statement : functionLiteral.getBodyExpression().getStatements()) {
                     value(statement, true, false);
                 }
             }
             else {
-                generateSubroutineControlFlow(expression, expression.getBody(), true);
+                generateSubroutineControlFlow(expression, functionLiteral.getBodyExpression().getStatements(), true);
             }
         }
 
@@ -766,7 +767,7 @@ public class JetControlFlowProcessor {
 
     private final CFPVisitor FOR_LOCAL_CLASSES = new CFPVisitor(false, false) {
         @Override
-        public void visitFunction(JetFunction function) {
+        public void visitNamedFunction(JetNamedFunction function) {
             // Nothing
         }
     };

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

@@ -993,6 +993,8 @@ public class JetExpressionParsing extends AbstractJetParsing {
     private void parseFunctionLiteral() {
         assert _at(LBRACE);
 
+        PsiBuilder.Marker literalExpression = mark();
+
         PsiBuilder.Marker literal = mark();
 
         myBuilder.enableNewlines();
@@ -1066,12 +1068,13 @@ public class JetExpressionParsing extends AbstractJetParsing {
 
         PsiBuilder.Marker body = mark();
         parseStatements();
-        body.done(BODY);
+        body.done(BLOCK);
 
         expect(RBRACE, "Expecting '}'");
         myBuilder.restoreNewlinesState();
 
         literal.done(FUNCTION_LITERAL);
+        literalExpression.done(FUNCTION_LITERAL_EXPRESSION);
     }
 
     /*

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

@@ -40,7 +40,7 @@ public class JetCallExpression extends JetExpression implements JetCall {
     @Override
     @NotNull
     public List<JetExpression> getFunctionLiteralArguments() {
-        return findChildrenByType(JetNodeTypes.FUNCTION_LITERAL);
+        return findChildrenByType(JetNodeTypes.FUNCTION_LITERAL_EXPRESSION);
     }
 
     @NotNull

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

@@ -55,7 +55,7 @@ public class JetChangeUtil {
         return createProperty(project, name, null).getNameIdentifier();
     }
 
-    public static JetFunction createFunction(Project project, String funDecl) {
-        return createDeclaration(project, funDecl, JetFunction.class);
+    public static JetNamedFunction createFunction(Project project, String funDecl) {
+        return createDeclaration(project, funDecl, JetNamedFunction.class);
     }
 }

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

@@ -12,31 +12,14 @@ import java.util.Collections;
 import java.util.List;
 
 /**
- * @author max
+ * @author abreslav
  */
-public class JetFunction extends JetTypeParameterListOwner implements JetDeclarationWithBody {
+abstract public class JetFunction extends JetTypeParameterListOwner implements JetDeclarationWithBody {
     public JetFunction(@NotNull ASTNode node) {
         super(node);
     }
 
-    @Override
-    public void accept(@NotNull JetVisitor visitor) {
-        visitor.visitFunction(this);
-    }
-
-    public boolean hasTypeParameterListBeforeFunctionName() {
-        JetTypeParameterList typeParameterList = getTypeParameterList();
-        if (typeParameterList == null) {
-            return false;
-        }
-        PsiElement nameIdentifier = getNameIdentifier();
-        if (nameIdentifier == null) {
-            return false;
-        }
-        return nameIdentifier.getTextOffset() > typeParameterList.getTextOffset();
-    }
-
-    @Nullable @IfNotParsed
+    @Nullable
     public JetParameterList getValueParameterList() {
         return (JetParameterList) findChildByType(JetNodeTypes.VALUE_PARAMETER_LIST);
     }
@@ -86,11 +69,6 @@ public class JetFunction extends JetTypeParameterListOwner implements JetDeclara
         return null;
     }
 
-    @Override
-    public boolean hasBlockBody() {
-        return findChildByType(JetTokens.EQ) == null;
-    }
-
     @NotNull
     @Override
     public JetElement asElement() {

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

@@ -0,0 +1,39 @@
+package org.jetbrains.jet.lang.psi;
+
+import com.intellij.lang.ASTNode;
+import com.intellij.psi.PsiElement;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.lexer.JetTokens;
+
+/**
+ * @author abreslav
+ */
+public class JetFunctionLiteral extends JetFunction {
+    public JetFunctionLiteral(@NotNull ASTNode node) {
+        super(node);
+    }
+
+    @Override
+    public boolean hasBlockBody() {
+        return false;
+    }
+
+    @Override
+    public String getName() {
+        return "<anonymous>";
+    }
+
+    @Override
+    public PsiElement getNameIdentifier() {
+        return null;
+    }
+
+    public boolean hasParameterSpecification() {
+        return findChildByType(JetTokens.DOUBLE_ARROW) != null;
+    }
+
+    @Override
+    public JetBlockExpression getBodyExpression() {
+        return (JetBlockExpression) super.getBodyExpression();
+    }
+}

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

@@ -1,21 +1,13 @@
 package org.jetbrains.jet.lang.psi;
 
 import com.intellij.lang.ASTNode;
-import com.intellij.psi.PsiElement;
-import com.intellij.psi.tree.IElementType;
-import com.intellij.psi.util.PsiTreeUtil;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.JetNodeTypes;
-import org.jetbrains.jet.lexer.JetTokens;
-
-import java.util.Collections;
-import java.util.List;
 
 /**
  * @author max
  */
-public class JetFunctionLiteralExpression extends JetExpression {
+public class JetFunctionLiteralExpression extends JetExpression implements JetDeclarationWithBody {
     public JetFunctionLiteralExpression(@NotNull ASTNode node) {
         super(node);
     }
@@ -25,64 +17,81 @@ public class JetFunctionLiteralExpression extends JetExpression {
         visitor.visitFunctionLiteralExpression(this);
     }
 
-    //TODO: Due to the lack of multiple implementation inheritance these getters are copied from JetFunction
-    @Nullable
-    public JetParameterList getParameterList() {
-        return (JetParameterList) findChildByType(JetNodeTypes.VALUE_PARAMETER_LIST);
+    @NotNull
+    public JetFunctionLiteral getFunctionLiteral() {
+        return (JetFunctionLiteral) findChildByType(JetNodeTypes.FUNCTION_LITERAL);
+    }
+
+//    //TODO: Due to the lack of multiple implementation inheritance these getters are copied from JetNamedFunction
+//    @Nullable
+//    public JetParameterList getValueParameterList() {
+//        return (JetParameterList) findChildByType(JetNodeTypes.VALUE_PARAMETER_LIST);
+//    }
+//
+//    @NotNull
+//    public List<JetParameter> getValueParameters() {
+//        JetParameterList list = getValueParameterList();
+//        return list != null ? list.getParameters() : Collections.<JetParameter>emptyList();
+//    }
+//
+//    @NotNull
+//    public ASTNode getBodyNode() {
+//        ASTNode answer = getNode().findChildByType(JetNodeTypes.BODY);
+//        assert answer != null;
+//        return answer;
+//    }
+//
+//    @NotNull
+//    public List<JetElement> getBody() {
+//        return PsiTreeUtil.getChildrenOfTypeAsList(getBodyNode().getPsi(), JetElement.class);
+//    }
+//
+//    @Nullable
+//    public JetTypeReference getReceiverTypeRef() {
+//        PsiElement child = getFirstChild();
+//        while (child != null) {
+//            IElementType tt = child.getNode().getElementType();
+//            if (tt == JetTokens.LPAR || tt == JetTokens.COLON) break;
+//            if (child instanceof JetTypeReference) {
+//                return (JetTypeReference) child;
+//            }
+//            child = child.getNextSibling();
+//        }
+//
+//        return null;
+//    }
+//
+//    @Nullable
+//    public JetTypeReference getReturnTypeRef() {
+//        boolean colonPassed = false;
+//        PsiElement child = getFirstChild();
+//        while (child != null) {
+//            IElementType tt = child.getNode().getElementType();
+//            if (tt == JetTokens.COLON) {
+//                colonPassed = true;
+//            }
+//            if (colonPassed && child instanceof JetTypeReference) {
+//                return (JetTypeReference) child;
+//            }
+//            child = child.getNextSibling();
+//        }
+//
+//        return null;
+//    }
+
+    @Override
+    public JetExpression getBodyExpression() {
+        return getFunctionLiteral().getBodyExpression();
+    }
+
+    @Override
+    public boolean hasBlockBody() {
+        return getFunctionLiteral().hasBlockBody();
     }
 
     @NotNull
-    public List<JetParameter> getParameters() {
-        JetParameterList list = getParameterList();
-        return list != null ? list.getParameters() : Collections.<JetParameter>emptyList();
-    }
-
-    @NotNull
-    public ASTNode getBodyNode() {
-        ASTNode answer = getNode().findChildByType(JetNodeTypes.BODY);
-        assert answer != null;
-        return answer;
-    }
-
-    @NotNull
-    public List<JetElement> getBody() {
-        return PsiTreeUtil.getChildrenOfTypeAsList(getBodyNode().getPsi(), JetElement.class);
-    }
-
-    @Nullable
-    public JetTypeReference getReceiverTypeRef() {
-        PsiElement child = getFirstChild();
-        while (child != null) {
-            IElementType tt = child.getNode().getElementType();
-            if (tt == JetTokens.LPAR || tt == JetTokens.COLON) break;
-            if (child instanceof JetTypeReference) {
-                return (JetTypeReference) child;
-            }
-            child = child.getNextSibling();
-        }
-
-        return null;
-    }
-
-    @Nullable
-    public JetTypeReference getReturnTypeRef() {
-        boolean colonPassed = false;
-        PsiElement child = getFirstChild();
-        while (child != null) {
-            IElementType tt = child.getNode().getElementType();
-            if (tt == JetTokens.COLON) {
-                colonPassed = true;
-            }
-            if (colonPassed && child instanceof JetTypeReference) {
-                return (JetTypeReference) child;
-            }
-            child = child.getNextSibling();
-        }
-
-        return null;
-    }
-
-    public boolean hasParameterSpecification() {
-        return findChildByType(JetTokens.DOUBLE_ARROW) != null;
+    @Override
+    public JetElement asElement() {
+        return this;
     }
 }

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

@@ -0,0 +1,38 @@
+package org.jetbrains.jet.lang.psi;
+
+import com.intellij.lang.ASTNode;
+import com.intellij.psi.PsiElement;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.lexer.JetTokens;
+
+/**
+ * @author max
+ */
+public class JetNamedFunction extends JetFunction {
+    public JetNamedFunction(@NotNull ASTNode node) {
+        super(node);
+    }
+
+    @Override
+    public void accept(@NotNull JetVisitor visitor) {
+        visitor.visitNamedFunction(this);
+    }
+
+    public boolean hasTypeParameterListBeforeFunctionName() {
+        JetTypeParameterList typeParameterList = getTypeParameterList();
+        if (typeParameterList == null) {
+            return false;
+        }
+        PsiElement nameIdentifier = getNameIdentifier();
+        if (nameIdentifier == null) {
+            return false;
+        }
+        return nameIdentifier.getTextOffset() > typeParameterList.getTextOffset();
+    }
+
+    @Override
+    public boolean hasBlockBody() {
+        return findChildByType(JetTokens.EQ) == null;
+    }
+
+}

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

@@ -34,7 +34,7 @@ package org.jetbrains.jet.lang.psi;
 //    @Override
 //    @NotNull
 //    public List<JetExpression> getFunctionLiteralArguments() {
-//        return findChildrenByType(JetNodeTypes.FUNCTION_LITERAL);
+//        return findChildrenByType(JetNodeTypes.FUNCTION_LITERAL_EXPRESSION);
 //    }
 //
 //    @NotNull

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

@@ -34,7 +34,7 @@ public class JetVisitor extends PsiElementVisitor {
         visitNamedDeclaration(extension);
     }
 
-    public void visitFunction(JetFunction function) {
+    public void visitNamedFunction(JetNamedFunction function) {
         visitNamedDeclaration(function);
     }
 

idea/src/org/jetbrains/jet/lang/resolve/BindingContext.java

@@ -20,7 +20,7 @@ public interface BindingContext {
     NamespaceDescriptor getNamespaceDescriptor(JetNamespace declaration);
     ClassDescriptor getClassDescriptor(JetClassOrObject declaration);
     TypeParameterDescriptor getTypeParameterDescriptor(JetTypeParameter declaration);
-    FunctionDescriptor getFunctionDescriptor(JetFunction declaration);
+    FunctionDescriptor getFunctionDescriptor(JetNamedFunction declaration);
     ConstructorDescriptor getConstructorDescriptor(JetElement declaration);
 
     VariableDescriptor getVariableDescriptor(JetProperty declaration);

idea/src/org/jetbrains/jet/lang/resolve/BindingTraceContext.java

@@ -195,7 +195,7 @@ public class BindingTraceContext implements BindingContext, BindingTrace {
     }
 
     @Override
-    public FunctionDescriptor getFunctionDescriptor(JetFunction declaration) {
+    public FunctionDescriptor getFunctionDescriptor(JetNamedFunction declaration) {
         return (FunctionDescriptor) declarationsToDescriptors.get(declaration);
     }
 
@@ -264,7 +264,7 @@ public class BindingTraceContext implements BindingContext, BindingTrace {
 
     @Override
     public boolean isBlock(JetFunctionLiteralExpression expression) {
-        return !expression.hasParameterSpecification() && blocks.contains(expression);
+        return !expression.getFunctionLiteral().hasParameterSpecification() && blocks.contains(expression);
     }
 
     @Override

idea/src/org/jetbrains/jet/lang/resolve/ClassDescriptorResolver.java

@@ -79,7 +79,7 @@ public class ClassDescriptorResolver {
                 }
 
                 @Override
-                public void visitFunction(JetFunction function) {
+                public void visitNamedFunction(JetNamedFunction function) {
                     if (function.getReturnTypeRef() != null) {
                         memberDeclarations.addFunctionDescriptor(resolveFunctionDescriptor(classDescriptor, parameterScope, function));
                     } else {
@@ -158,7 +158,7 @@ public class ClassDescriptorResolver {
     }
 
     @NotNull
-    public FunctionDescriptorImpl resolveFunctionDescriptor(DeclarationDescriptor containingDescriptor, final JetScope scope, final JetFunction function) {
+    public FunctionDescriptorImpl resolveFunctionDescriptor(DeclarationDescriptor containingDescriptor, final JetScope scope, final JetNamedFunction function) {
         final FunctionDescriptorImpl functionDescriptor = new FunctionDescriptorImpl(
                 containingDescriptor,
                 AnnotationResolver.INSTANCE.resolveAnnotations(function.getModifierList()),

idea/src/org/jetbrains/jet/lang/resolve/TopDownAnalyzer.java

@@ -28,7 +28,7 @@ public class TopDownAnalyzer {
     private final Map<JetNamespace, WritableScope> namespaceScopes = Maps.newHashMap();
     private final Map<JetNamespace, NamespaceDescriptorImpl> namespaceDescriptors = Maps.newHashMap();
 
-    private final Map<JetFunction, FunctionDescriptorImpl> functions = Maps.newLinkedHashMap();
+    private final Map<JetNamedFunction, FunctionDescriptorImpl> functions = Maps.newLinkedHashMap();
     private final Map<JetDeclaration, ConstructorDescriptor> constructors = Maps.newLinkedHashMap();
     private final Map<JetProperty, PropertyDescriptor> properties = new LinkedHashMap<JetProperty, PropertyDescriptor>();
     private final Map<JetDeclaration, JetScope> declaringScopes = Maps.newHashMap();
@@ -417,7 +417,7 @@ public class TopDownAnalyzer {
         for (JetDeclaration declaration : declarations) {
             declaration.accept(new JetVisitor() {
                 @Override
-                public void visitFunction(JetFunction function) {
+                public void visitNamedFunction(JetNamedFunction function) {
                     FunctionDescriptorImpl functionDescriptor = classDescriptorResolver.resolveFunctionDescriptor(namespaceLike, scope, function);
                     namespaceLike.addFunctionDescriptor(functionDescriptor);
                     functions.put(function, functionDescriptor);
@@ -880,14 +880,14 @@ public class TopDownAnalyzer {
     }
 
     private void resolveFunctionBodies() {
-        for (Map.Entry<JetFunction, FunctionDescriptorImpl> entry : functions.entrySet()) {
+        for (Map.Entry<JetNamedFunction, FunctionDescriptorImpl> entry : functions.entrySet()) {
             JetDeclaration declaration = entry.getKey();
             FunctionDescriptor descriptor = entry.getValue();
 
             JetScope declaringScope = declaringScopes.get(declaration);
             assert declaringScope != null;
 
-            resolveFunctionBody(traceForMembers, (JetFunction) declaration, (FunctionDescriptorImpl) descriptor, declaringScope);
+            resolveFunctionBody(traceForMembers, (JetNamedFunction) declaration, (FunctionDescriptorImpl) descriptor, declaringScope);
 
             assert descriptor.getUnsubstitutedReturnType() != null;
         }

idea/src/org/jetbrains/jet/lang/resolve/WritableScopeImpl.java

@@ -154,6 +154,14 @@ public class WritableScopeImpl extends WritableScopeWithImports {
         if (descriptor instanceof VariableDescriptor) {
             return (VariableDescriptor) descriptor;
         }
+
+        if (thisType != null) {
+            VariableDescriptor variable = getThisType().getMemberScope().getVariable(name);
+            if (variable != null) {
+                return variable;
+            }
+        }
+
         VariableDescriptor variableDescriptor = getWorkerScope().getVariable(name);
         if (variableDescriptor != null) {
             return variableDescriptor;
@@ -214,6 +222,13 @@ public class WritableScopeImpl extends WritableScopeWithImports {
             return constructors;
         }
 
+        if (thisType != null) {
+            functionGroup = getThisType().getMemberScope().getFunctionGroup(name);
+            if (!functionGroup.isEmpty()) {
+                return functionGroup;
+            }
+        }
+
         // TODO : this logic is questionable
         functionGroup = getWorkerScope().getFunctionGroup(name);
         if (!functionGroup.isEmpty()) return functionGroup;

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

@@ -380,5 +380,14 @@ public class JetStandardClasses {
         List<TypeProjection> arguments = type.getArguments();
         return arguments.get(arguments.size() - 1).getType();
     }
-
+}
+
+class A {
+
+    class B {
+        @Override
+        public boolean equals(Object obj) {
+            return A.super.equals(obj); // TODO
+        }
+    }
 }

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

@@ -947,13 +947,14 @@ public class JetTypeInferrer {
 
         @Override
         public void visitFunctionLiteralExpression(JetFunctionLiteralExpression expression) {
-            if (context.preferBlock && !expression.hasParameterSpecification()) {
+            JetFunctionLiteral functionLiteral = expression.getFunctionLiteral();
+            if (context.preferBlock && !functionLiteral.hasParameterSpecification()) {
                 context.trace.recordBlock(expression);
-                result = getBlockReturnedType(context.scope, expression.getBody(), context.dataFlowInfo, context.expectedReturnType);
+                result = getBlockReturnedType(context.scope, functionLiteral.getBodyExpression().getStatements(), context.dataFlowInfo, context.expectedReturnType);
                 return;
             }
 
-            JetTypeReference receiverTypeRef = expression.getReceiverTypeRef();
+            JetTypeReference receiverTypeRef = functionLiteral.getReceiverTypeRef();
             final JetType receiverType;
             if (receiverTypeRef != null) {
                 receiverType = context.typeResolver.resolveType(context.scope, receiverTypeRef);
@@ -966,7 +967,7 @@ public class JetTypeInferrer {
 
             List<JetType> parameterTypes = new ArrayList<JetType>();
             List<ValueParameterDescriptor> valueParameterDescriptors = Lists.newArrayList();
-            List<JetParameter> parameters = expression.getParameters();
+            List<JetParameter> parameters = functionLiteral.getValueParameters();
             for (int i = 0, parametersSize = parameters.size(); i < parametersSize; i++) {
                 JetParameter parameter = parameters.get(i);
                 JetTypeReference typeReference = parameter.getTypeReference();
@@ -988,17 +989,16 @@ public class JetTypeInferrer {
             functionDescriptor.initialize(effectiveReceiverType, Collections.<TypeParameterDescriptor>emptyList(), valueParameterDescriptors, null);
             context.trace.recordDeclarationResolution(expression, functionDescriptor);
 
-            JetTypeReference returnTypeRef = expression.getReturnTypeRef();
+            JetTypeReference returnTypeRef = functionLiteral.getReturnTypeRef();
             JetType returnType;
             if (returnTypeRef != null) {
                 returnType = context.typeResolver.resolveType(context.scope, returnTypeRef);
-            } else {
-                WritableScope writableScope = new WritableScopeImpl(context.scope, functionDescriptor, context.trace.getErrorHandler()).setDebugName("Inner scope of a function literal");
-                for (VariableDescriptor variableDescriptor : valueParameterDescriptors) {
-                    writableScope.addVariableDescriptor(variableDescriptor);
-                }
-                writableScope.setThisType(receiverType);
-                returnType = getBlockReturnedType(writableScope, expression.getBody(), context.dataFlowInfo, context.expectedReturnType);
+                JetScope functionInnerScope = FunctionDescriptorUtil.getFunctionInnerScope(context.scope, functionDescriptor, context.trace);
+                services.checkFunctionReturnType(functionInnerScope, expression, functionDescriptor, returnType);
+            }
+            else {
+                JetScope functionInnerScope = FunctionDescriptorUtil.getFunctionInnerScope(context.scope, functionDescriptor, context.trace);
+                returnType = getBlockReturnedType(functionInnerScope, functionLiteral.getBodyExpression().getStatements(), context.dataFlowInfo, context.expectedReturnType);
             }
             JetType safeReturnType = returnType == null ? ErrorUtils.createErrorType("<return type>") : returnType;
             functionDescriptor.setReturnType(safeReturnType);
@@ -1723,10 +1723,10 @@ public class JetTypeInferrer {
             JetScope conditionScope = context.scope;
             if (body instanceof JetFunctionLiteralExpression) {
                 JetFunctionLiteralExpression function = (JetFunctionLiteralExpression) body;
-                if (!function.hasParameterSpecification()) {
+                if (!function.getFunctionLiteral().hasParameterSpecification()) {
                     WritableScope writableScope = newWritableScopeImpl().setDebugName("do..while body scope");
                     conditionScope = writableScope;
-                    services.getBlockReturnedTypeWithWritableScope(writableScope, function.getBody(), context.dataFlowInfo, context.expectedReturnType);
+                    services.getBlockReturnedTypeWithWritableScope(writableScope, function.getFunctionLiteral().getBodyExpression().getStatements(), context.dataFlowInfo, context.expectedReturnType);
                     context.trace.recordBlock(function);
                 } else {
                     getType(context.scope, body, true);
@@ -2514,7 +2514,7 @@ public class JetTypeInferrer {
         }
 
         @Override
-        public void visitFunction(JetFunction function) {
+        public void visitNamedFunction(JetNamedFunction function) {
             scope.addFunctionDescriptor(context.classDescriptorResolver.resolveFunctionDescriptor(scope.getContainingDeclaration(), scope, function));
         }
 

idea/src/org/jetbrains/jet/plugin/JetIconProvider.java

@@ -22,7 +22,7 @@ public class JetIconProvider extends IconProvider {
         if (psiElement instanceof JetNamespace) {
             return (flags & Iconable.ICON_FLAG_OPEN) != 0 ? Icons.PACKAGE_OPEN_ICON : Icons.PACKAGE_ICON;
         }
-        if (psiElement instanceof JetFunction) {
+        if (psiElement instanceof JetNamedFunction) {
             return PsiTreeUtil.getParentOfType(psiElement, JetNamedDeclaration.class) instanceof JetClass
                     ? Icons.METHOD_ICON
                     : Icons.FUNCTION_ICON;

idea/src/org/jetbrains/jet/plugin/annotations/JetLineMarkerProvider.java

@@ -62,18 +62,18 @@ public class JetLineMarkerProvider implements LineMarkerProvider {
             }
         }
 
-        if (element instanceof JetFunction) {
-            JetFunction jetFunction = (JetFunction) element;
+        if (element instanceof JetNamedFunction) {
+            JetNamedFunction jetFunction = (JetNamedFunction) element;
 
             final FunctionDescriptor functionDescriptor = bindingContext.getFunctionDescriptor(jetFunction);
             if (functionDescriptor == null) return null;
             final Set<? extends FunctionDescriptor> overriddenFunctions = functionDescriptor.getOverriddenFunctions();
             Icon icon = isMember(functionDescriptor) ? (overriddenFunctions.isEmpty() ? Icons.METHOD_ICON : OVERRIDING_FUNCTION) : Icons.FUNCTION_ICON;
-            return new LineMarkerInfo<JetFunction>(
+            return new LineMarkerInfo<JetNamedFunction>(
                     jetFunction, jetFunction.getTextOffset(), icon, Pass.UPDATE_ALL,
-                    new Function<JetFunction, String>() {
+                    new Function<JetNamedFunction, String>() {
                         @Override
-                        public String fun(JetFunction jetFunction) {
+                        public String fun(JetNamedFunction jetFunction) {
                             StringBuilder builder = new StringBuilder();
                             builder.append(DescriptorRenderer.HTML.render(functionDescriptor));
                             int overrideCount = overriddenFunctions.size();
@@ -91,9 +91,9 @@ public class JetLineMarkerProvider implements LineMarkerProvider {
                             return builder.toString();
                         }
                     },
-                    new GutterIconNavigationHandler<JetFunction>() {
+                    new GutterIconNavigationHandler<JetNamedFunction>() {
                         @Override
-                        public void navigate(MouseEvent event, JetFunction elt) {
+                        public void navigate(MouseEvent event, JetNamedFunction elt) {
                             if (overriddenFunctions.isEmpty()) return;
                             final List<PsiElement> list = Lists.newArrayList();
                             for (FunctionDescriptor overriddenFunction : overriddenFunctions) {
@@ -116,8 +116,8 @@ public class JetLineMarkerProvider implements LineMarkerProvider {
                                 final JBPopup popup = NavigationUtil.getPsiElementPopup(PsiUtilBase.toPsiElementArray(list), new DefaultPsiElementCellRenderer() {
                                             @Override
                                             public String getElementText(PsiElement element) {
-                                                if (element instanceof JetFunction) {
-                                                    JetFunction function = (JetFunction) element;
+                                                if (element instanceof JetNamedFunction) {
+                                                    JetNamedFunction function = (JetNamedFunction) element;
                                                     return DescriptorRenderer.HTML.render(bindingContext.getFunctionDescriptor(function));
                                                 }
                                                 return super.getElementText(element);

idea/src/org/jetbrains/jet/plugin/findUsages/JetFindUsagesProvider.java

@@ -30,7 +30,7 @@ public class JetFindUsagesProvider implements FindUsagesProvider {
     @NotNull
     @Override
     public String getType(@NotNull PsiElement psiElement) {
-        if (psiElement instanceof JetFunction) {
+        if (psiElement instanceof JetNamedFunction) {
             return "function";
         }
         if (psiElement instanceof JetClass) {

idea/src/org/jetbrains/jet/plugin/formatter/JetBlock.java

@@ -29,7 +29,7 @@ public class JetBlock implements ASTBlock {
     private static final TokenSet CODE_BLOCKS = TokenSet.create(
             JetNodeTypes.BLOCK,
             JetNodeTypes.CLASS_BODY,
-            JetNodeTypes.FUNCTION_LITERAL);
+            JetNodeTypes.FUNCTION_LITERAL_EXPRESSION);
 
     private static final TokenSet STATEMENT_PARTS = TokenSet.create(
             JetNodeTypes.THEN,

idea/src/org/jetbrains/jet/plugin/run/JetRunConfigurationProducer.java

@@ -47,8 +47,8 @@ public class JetRunConfigurationProducer extends RuntimeConfigurationProducer im
 
     private boolean hasMain(List<JetDeclaration> declarations) {
         for (JetDeclaration declaration : declarations) {
-            if (declaration instanceof JetFunction) {
-                JetFunction function = (JetFunction) declaration;
+            if (declaration instanceof JetNamedFunction) {
+                JetNamedFunction function = (JetNamedFunction) declaration;
                 if ("main".equals(function.getName())) {
                     List<JetParameter> parameters = function.getValueParameters();
                     if (parameters.size() == 1) {

idea/testData/checker/regression/Jet121.jet

@@ -0,0 +1,14 @@
+namespace jet121 {
+  fun box() : String {
+    val answer = apply("OK") { String.() : Int =>
+      length
+      get(0)
+    }
+
+    return if (answer == 2) "OK" else "FAIL"
+  }
+
+  fun apply(arg:String, f : {String.() : Int}) : Int {
+      return arg.f()
+  }
+}

idea/testData/codegen/classes/extensionClosure.jet

@@ -1,6 +1,6 @@
 fun box() : String {
     val answer = apply("OK", { String.() : Int =>
-        length()
+        length
     })
 
     return if (answer == 2) "OK" else "FAIL"

idea/testData/psi/ByCaluses.txt

@@ -153,11 +153,12 @@ JetFile: ByCaluses.jet
               REFERENCE_EXPRESSION
                 PsiElement(IDENTIFIER)('a')
               PsiWhiteSpace(' ')
-              FUNCTION_LITERAL
-                PsiElement(LBRACE)('{')
-                BODY
-                  <empty list>
-                PsiElement(RBRACE)('}')
+              FUNCTION_LITERAL_EXPRESSION
+                FUNCTION_LITERAL
+                  PsiElement(LBRACE)('{')
+                  BLOCK
+                    <empty list>
+                  PsiElement(RBRACE)('}')
             PsiElement(RPAR)(')')
       PsiWhiteSpace(' ')
       CLASS_BODY
@@ -202,11 +203,12 @@ JetFile: ByCaluses.jet
                 REFERENCE_EXPRESSION
                   PsiElement(IDENTIFIER)('a')
                 PsiWhiteSpace(' ')
-                FUNCTION_LITERAL
-                  PsiElement(LBRACE)('{')
-                  BODY
-                    <empty list>
-                  PsiElement(RBRACE)('}')
+                FUNCTION_LITERAL_EXPRESSION
+                  FUNCTION_LITERAL
+                    PsiElement(LBRACE)('{')
+                    BLOCK
+                      <empty list>
+                    PsiElement(RBRACE)('}')
               PsiElement(RBRACKET)(']')
       PsiWhiteSpace(' ')
       CLASS_BODY
@@ -252,11 +254,12 @@ JetFile: ByCaluses.jet
                   REFERENCE_EXPRESSION
                     PsiElement(IDENTIFIER)('a')
                   PsiWhiteSpace(' ')
-                  FUNCTION_LITERAL
-                    PsiElement(LBRACE)('{')
-                    BODY
-                      <empty list>
-                    PsiElement(RBRACE)('}')
+                  FUNCTION_LITERAL_EXPRESSION
+                    FUNCTION_LITERAL
+                      PsiElement(LBRACE)('{')
+                      BLOCK
+                        <empty list>
+                      PsiElement(RBRACE)('}')
               PsiElement(RPAR)(')')
       PsiWhiteSpace(' ')
       CLASS_BODY
@@ -313,11 +316,12 @@ JetFile: ByCaluses.jet
                     REFERENCE_EXPRESSION
                       PsiElement(IDENTIFIER)('a')
                     PsiWhiteSpace(' ')
-                    FUNCTION_LITERAL
-                      PsiElement(LBRACE)('{')
-                      BODY
-                        <empty list>
-                      PsiElement(RBRACE)('}')
+                    FUNCTION_LITERAL_EXPRESSION
+                      FUNCTION_LITERAL
+                        PsiElement(LBRACE)('{')
+                        BLOCK
+                          <empty list>
+                        PsiElement(RBRACE)('}')
                 PsiWhiteSpace('\n')
                 PsiElement(RBRACE)('}')
       PsiWhiteSpace(' ')

idea/testData/psi/CallWithManyClosures.txt

@@ -14,23 +14,26 @@ JetFile: CallWithManyClosures.jet
           PsiElement(LPAR)('(')
           PsiElement(RPAR)(')')
         PsiWhiteSpace(' ')
-        FUNCTION_LITERAL
-          PsiElement(LBRACE)('{')
-          BODY
-            <empty list>
-          PsiElement(RBRACE)('}')
+        FUNCTION_LITERAL_EXPRESSION
+          FUNCTION_LITERAL
+            PsiElement(LBRACE)('{')
+            BLOCK
+              <empty list>
+            PsiElement(RBRACE)('}')
         PsiWhiteSpace(' ')
-        FUNCTION_LITERAL
-          PsiElement(LBRACE)('{')
-          BODY
-            <empty list>
-          PsiElement(RBRACE)('}')
+        FUNCTION_LITERAL_EXPRESSION
+          FUNCTION_LITERAL
+            PsiElement(LBRACE)('{')
+            BLOCK
+              <empty list>
+            PsiElement(RBRACE)('}')
         PsiWhiteSpace(' ')
-        FUNCTION_LITERAL
-          PsiElement(LBRACE)('{')
-          BODY
-            <empty list>
-          PsiElement(RBRACE)('}')
+        FUNCTION_LITERAL_EXPRESSION
+          FUNCTION_LITERAL
+            PsiElement(LBRACE)('{')
+            BLOCK
+              <empty list>
+            PsiElement(RBRACE)('}')
     PsiWhiteSpace('\n')
     PROPERTY
       PsiElement(val)('val')
@@ -43,23 +46,26 @@ JetFile: CallWithManyClosures.jet
         REFERENCE_EXPRESSION
           PsiElement(IDENTIFIER)('f')
         PsiWhiteSpace(' ')
-        FUNCTION_LITERAL
-          PsiElement(LBRACE)('{')
-          BODY
-            <empty list>
-          PsiElement(RBRACE)('}')
+        FUNCTION_LITERAL_EXPRESSION
+          FUNCTION_LITERAL
+            PsiElement(LBRACE)('{')
+            BLOCK
+              <empty list>
+            PsiElement(RBRACE)('}')
         PsiWhiteSpace(' ')
-        FUNCTION_LITERAL
-          PsiElement(LBRACE)('{')
-          BODY
-            <empty list>
-          PsiElement(RBRACE)('}')
+        FUNCTION_LITERAL_EXPRESSION
+          FUNCTION_LITERAL
+            PsiElement(LBRACE)('{')
+            BLOCK
+              <empty list>
+            PsiElement(RBRACE)('}')
         PsiWhiteSpace(' ')
-        FUNCTION_LITERAL
-          PsiElement(LBRACE)('{')
-          BODY
-            <empty list>
-          PsiElement(RBRACE)('}')
+        FUNCTION_LITERAL_EXPRESSION
+          FUNCTION_LITERAL
+            PsiElement(LBRACE)('{')
+            BLOCK
+              <empty list>
+            PsiElement(RBRACE)('}')
     PsiWhiteSpace('\n')
     PROPERTY
       PsiElement(val)('val')
@@ -72,11 +78,12 @@ JetFile: CallWithManyClosures.jet
         REFERENCE_EXPRESSION
           PsiElement(IDENTIFIER)('f')
         PsiWhiteSpace(' ')
-        FUNCTION_LITERAL
-          PsiElement(LBRACE)('{')
-          BODY
-            <empty list>
-          PsiElement(RBRACE)('}')
+        FUNCTION_LITERAL_EXPRESSION
+          FUNCTION_LITERAL
+            PsiElement(LBRACE)('{')
+            BLOCK
+              <empty list>
+            PsiElement(RBRACE)('}')
     PsiWhiteSpace('\n')
     PROPERTY
       PsiElement(val)('val')
@@ -92,11 +99,12 @@ JetFile: CallWithManyClosures.jet
           PsiElement(LPAR)('(')
           PsiElement(RPAR)(')')
         PsiWhiteSpace(' ')
-        FUNCTION_LITERAL
-          PsiElement(LBRACE)('{')
-          BODY
-            <empty list>
-          PsiElement(RBRACE)('}')
+        FUNCTION_LITERAL_EXPRESSION
+          FUNCTION_LITERAL
+            PsiElement(LBRACE)('{')
+            BLOCK
+              <empty list>
+            PsiElement(RBRACE)('}')
     PsiWhiteSpace('\n')
     PROPERTY
       PsiElement(val)('val')
@@ -112,23 +120,26 @@ JetFile: CallWithManyClosures.jet
             PsiElement(IDENTIFIER)('f')
           PsiElement(RPAR)(')')
         PsiWhiteSpace(' ')
-        FUNCTION_LITERAL
-          PsiElement(LBRACE)('{')
-          BODY
-            <empty list>
-          PsiElement(RBRACE)('}')
+        FUNCTION_LITERAL_EXPRESSION
+          FUNCTION_LITERAL
+            PsiElement(LBRACE)('{')
+            BLOCK
+              <empty list>
+            PsiElement(RBRACE)('}')
         PsiWhiteSpace(' ')
-        FUNCTION_LITERAL
-          PsiElement(LBRACE)('{')
-          BODY
-            <empty list>
-          PsiElement(RBRACE)('}')
+        FUNCTION_LITERAL_EXPRESSION
+          FUNCTION_LITERAL
+            PsiElement(LBRACE)('{')
+            BLOCK
+              <empty list>
+            PsiElement(RBRACE)('}')
         PsiWhiteSpace(' ')
-        FUNCTION_LITERAL
-          PsiElement(LBRACE)('{')
-          BODY
-            <empty list>
-          PsiElement(RBRACE)('}')
+        FUNCTION_LITERAL_EXPRESSION
+          FUNCTION_LITERAL
+            PsiElement(LBRACE)('{')
+            BLOCK
+              <empty list>
+            PsiElement(RBRACE)('}')
     PsiWhiteSpace('\n')
     PROPERTY
       PsiElement(val)('val')
@@ -147,23 +158,26 @@ JetFile: CallWithManyClosures.jet
           PsiElement(LPAR)('(')
           PsiElement(RPAR)(')')
         PsiWhiteSpace(' ')
-        FUNCTION_LITERAL
-          PsiElement(LBRACE)('{')
-          BODY
-            <empty list>
-          PsiElement(RBRACE)('}')
+        FUNCTION_LITERAL_EXPRESSION
+          FUNCTION_LITERAL
+            PsiElement(LBRACE)('{')
+            BLOCK
+              <empty list>
+            PsiElement(RBRACE)('}')
         PsiWhiteSpace(' ')
-        FUNCTION_LITERAL
-          PsiElement(LBRACE)('{')
-          BODY
-            <empty list>
-          PsiElement(RBRACE)('}')
+        FUNCTION_LITERAL_EXPRESSION
+          FUNCTION_LITERAL
+            PsiElement(LBRACE)('{')
+            BLOCK
+              <empty list>
+            PsiElement(RBRACE)('}')
         PsiWhiteSpace(' ')
-        FUNCTION_LITERAL
-          PsiElement(LBRACE)('{')
-          BODY
-            <empty list>
-          PsiElement(RBRACE)('}')
+        FUNCTION_LITERAL_EXPRESSION
+          FUNCTION_LITERAL
+            PsiElement(LBRACE)('{')
+            BLOCK
+              <empty list>
+            PsiElement(RBRACE)('}')
     PsiWhiteSpace('\n')
     PROPERTY
       PsiElement(val)('val')
@@ -190,20 +204,23 @@ JetFile: CallWithManyClosures.jet
           PsiElement(LPAR)('(')
           PsiElement(RPAR)(')')
         PsiWhiteSpace(' ')
-        FUNCTION_LITERAL
-          PsiElement(LBRACE)('{')
-          BODY
-            <empty list>
-          PsiElement(RBRACE)('}')
+        FUNCTION_LITERAL_EXPRESSION
+          FUNCTION_LITERAL
+            PsiElement(LBRACE)('{')
+            BLOCK
+              <empty list>
+            PsiElement(RBRACE)('}')
         PsiWhiteSpace(' ')
-        FUNCTION_LITERAL
-          PsiElement(LBRACE)('{')
-          BODY
-            <empty list>
-          PsiElement(RBRACE)('}')
+        FUNCTION_LITERAL_EXPRESSION
+          FUNCTION_LITERAL
+            PsiElement(LBRACE)('{')
+            BLOCK
+              <empty list>
+            PsiElement(RBRACE)('}')
         PsiWhiteSpace(' ')
-        FUNCTION_LITERAL
-          PsiElement(LBRACE)('{')
-          BODY
-            <empty list>
-          PsiElement(RBRACE)('}')
+        FUNCTION_LITERAL_EXPRESSION
+          FUNCTION_LITERAL
+            PsiElement(LBRACE)('{')
+            BLOCK
+              <empty list>
+            PsiElement(RBRACE)('}')

idea/testData/psi/CallsInWhen.txt

@@ -127,12 +127,13 @@ JetFile: CallsInWhen.jet
           WHEN_ENTRY
             WHEN_CONDITION_CALL
               PsiElement(DOT)('.')
-              FUNCTION_LITERAL
-                PsiElement(LBRACE)('{')
-                BODY
-                  REFERENCE_EXPRESSION
-                    PsiElement(IDENTIFIER)('bar')
-                PsiElement(RBRACE)('}')
+              FUNCTION_LITERAL_EXPRESSION
+                FUNCTION_LITERAL
+                  PsiElement(LBRACE)('{')
+                  BLOCK
+                    REFERENCE_EXPRESSION
+                      PsiElement(IDENTIFIER)('bar')
+                  PsiElement(RBRACE)('}')
             PsiWhiteSpace(' ')
             PsiElement(DOUBLE_ARROW)('=>')
             PsiWhiteSpace(' ')
@@ -142,15 +143,16 @@ JetFile: CallsInWhen.jet
           WHEN_ENTRY
             WHEN_CONDITION_CALL
               PsiElement(DOT)('.')
-              FUNCTION_LITERAL
-                PsiElement(LBRACE)('{')
-                BODY
-                  PREFIX_EXPRESSION
-                    OPERATION_REFERENCE
-                      PsiElement(EXCL)('!')
-                    REFERENCE_EXPRESSION
-                      PsiElement(IDENTIFIER)('bar')
-                PsiElement(RBRACE)('}')
+              FUNCTION_LITERAL_EXPRESSION
+                FUNCTION_LITERAL
+                  PsiElement(LBRACE)('{')
+                  BLOCK
+                    PREFIX_EXPRESSION
+                      OPERATION_REFERENCE
+                        PsiElement(EXCL)('!')
+                      REFERENCE_EXPRESSION
+                        PsiElement(IDENTIFIER)('bar')
+                  PsiElement(RBRACE)('}')
             PsiWhiteSpace(' ')
             PsiElement(DOUBLE_ARROW)('=>')
             PsiWhiteSpace(' ')
@@ -160,21 +162,22 @@ JetFile: CallsInWhen.jet
           WHEN_ENTRY
             WHEN_CONDITION_CALL
               PsiElement(DOT)('.')
-              FUNCTION_LITERAL
-                PsiElement(LBRACE)('{')
-                VALUE_PARAMETER_LIST
-                  PsiElement(LPAR)('(')
-                  PsiElement(RPAR)(')')
-                PsiWhiteSpace(' ')
-                PsiElement(DOUBLE_ARROW)('=>')
-                PsiWhiteSpace(' ')
-                BODY
-                  PREFIX_EXPRESSION
-                    OPERATION_REFERENCE
-                      PsiElement(EXCL)('!')
-                    REFERENCE_EXPRESSION
-                      PsiElement(IDENTIFIER)('bar')
-                PsiElement(RBRACE)('}')
+              FUNCTION_LITERAL_EXPRESSION
+                FUNCTION_LITERAL
+                  PsiElement(LBRACE)('{')
+                  VALUE_PARAMETER_LIST
+                    PsiElement(LPAR)('(')
+                    PsiElement(RPAR)(')')
+                  PsiWhiteSpace(' ')
+                  PsiElement(DOUBLE_ARROW)('=>')
+                  PsiWhiteSpace(' ')
+                  BLOCK
+                    PREFIX_EXPRESSION
+                      OPERATION_REFERENCE
+                        PsiElement(EXCL)('!')
+                      REFERENCE_EXPRESSION
+                        PsiElement(IDENTIFIER)('bar')
+                  PsiElement(RBRACE)('}')
             PsiWhiteSpace(' ')
             PsiElement(DOUBLE_ARROW)('=>')
             PsiWhiteSpace(' ')

idea/testData/psi/ControlStructures.txt

@@ -535,11 +535,12 @@ JetFile: ControlStructures.jet
           PsiElement(RPAR)(')')
           PsiWhiteSpace(' ')
           BODY
-            FUNCTION_LITERAL
-              PsiElement(LBRACE)('{')
-              BODY
-                <empty list>
-              PsiElement(RBRACE)('}')
+            FUNCTION_LITERAL_EXPRESSION
+              FUNCTION_LITERAL
+                PsiElement(LBRACE)('{')
+                BLOCK
+                  <empty list>
+                PsiElement(RBRACE)('}')
         PsiWhiteSpace('\n\n  ')
         WHILE
           PsiElement(while)('while')
@@ -551,22 +552,24 @@ JetFile: ControlStructures.jet
           PsiElement(RPAR)(')')
           PsiWhiteSpace(' ')
           BODY
-            FUNCTION_LITERAL
-              PsiElement(LBRACE)('{')
-              BODY
-                <empty list>
-              PsiElement(RBRACE)('}')
+            FUNCTION_LITERAL_EXPRESSION
+              FUNCTION_LITERAL
+                PsiElement(LBRACE)('{')
+                BLOCK
+                  <empty list>
+                PsiElement(RBRACE)('}')
         PsiWhiteSpace('\n\n  ')
         DO_WHILE
           PsiElement(do)('do')
           PsiWhiteSpace(' ')
           BODY
-            FUNCTION_LITERAL
-              PsiElement(LBRACE)('{')
-              PsiWhiteSpace('\n\n  ')
-              BODY
-                <empty list>
-              PsiElement(RBRACE)('}')
+            FUNCTION_LITERAL_EXPRESSION
+              FUNCTION_LITERAL
+                PsiElement(LBRACE)('{')
+                PsiWhiteSpace('\n\n  ')
+                BLOCK
+                  <empty list>
+                PsiElement(RBRACE)('}')
           PsiWhiteSpace(' ')
           PsiElement(while)('while')
           PsiWhiteSpace(' ')
@@ -622,11 +625,12 @@ JetFile: ControlStructures.jet
           PsiElement(RPAR)(')')
           PsiWhiteSpace(' ')
           BODY
-            FUNCTION_LITERAL
-              PsiElement(LBRACE)('{')
-              BODY
-                <empty list>
-              PsiElement(RBRACE)('}')
+            FUNCTION_LITERAL_EXPRESSION
+              FUNCTION_LITERAL
+                PsiElement(LBRACE)('{')
+                BLOCK
+                  <empty list>
+                PsiElement(RBRACE)('}')
         PsiWhiteSpace('\n\n    ')
         FOR
           PsiElement(for)('for')
@@ -643,14 +647,15 @@ JetFile: ControlStructures.jet
           PsiElement(RPAR)(')')
           PsiWhiteSpace(' ')
           BODY
-            FUNCTION_LITERAL
-              PsiElement(LBRACE)('{')
-              PsiWhiteSpace('\n      ')
-              BODY
-                REFERENCE_EXPRESSION
-                  PsiElement(IDENTIFIER)('b')
-              PsiWhiteSpace('\n    ')
-              PsiElement(RBRACE)('}')
+            FUNCTION_LITERAL_EXPRESSION
+              FUNCTION_LITERAL
+                PsiElement(LBRACE)('{')
+                PsiWhiteSpace('\n      ')
+                BLOCK
+                  REFERENCE_EXPRESSION
+                    PsiElement(IDENTIFIER)('b')
+                PsiWhiteSpace('\n    ')
+                PsiElement(RBRACE)('}')
         PsiWhiteSpace('\n\n    ')
         FOR
           PsiElement(for)('for')
@@ -709,14 +714,15 @@ JetFile: ControlStructures.jet
           PsiElement(RPAR)(')')
           PsiWhiteSpace(' ')
           BODY
-            FUNCTION_LITERAL
-              PsiElement(LBRACE)('{')
-              PsiWhiteSpace('\n      ')
-              BODY
-                REFERENCE_EXPRESSION
-                  PsiElement(IDENTIFIER)('b')
-              PsiWhiteSpace('\n    ')
-              PsiElement(RBRACE)('}')
+            FUNCTION_LITERAL_EXPRESSION
+              FUNCTION_LITERAL
+                PsiElement(LBRACE)('{')
+                PsiWhiteSpace('\n      ')
+                BLOCK
+                  REFERENCE_EXPRESSION
+                    PsiElement(IDENTIFIER)('b')
+                PsiWhiteSpace('\n    ')
+                PsiElement(RBRACE)('}')
         PsiWhiteSpace('\n\n    ')
         WHILE
           PsiElement(while)('while')
@@ -750,11 +756,12 @@ JetFile: ControlStructures.jet
           PsiElement(RPAR)(')')
           PsiWhiteSpace(' ')
           BODY
-            FUNCTION_LITERAL
-              PsiElement(LBRACE)('{')
-              BODY
-                <empty list>
-              PsiElement(RBRACE)('}')
+            FUNCTION_LITERAL_EXPRESSION
+              FUNCTION_LITERAL
+                PsiElement(LBRACE)('{')
+                BLOCK
+                  <empty list>
+                PsiElement(RBRACE)('}')
         PsiWhiteSpace('\n\n    ')
         IF
           PsiElement(if)('if')
@@ -973,23 +980,24 @@ JetFile: ControlStructures.jet
           PsiElement(do)('do')
           PsiWhiteSpace(' ')
           BODY
-            FUNCTION_LITERAL
-              PsiElement(LBRACE)('{')
-              BODY
-                PsiElement(SEMICOLON)(';')
-                PsiElement(SEMICOLON)(';')
-                PsiElement(SEMICOLON)(';')
-                REFERENCE_EXPRESSION
-                  PsiElement(IDENTIFIER)('foo')
-                PsiElement(SEMICOLON)(';')
-                REFERENCE_EXPRESSION
-                  PsiElement(IDENTIFIER)('bar')
-                PsiElement(SEMICOLON)(';')
-                PsiElement(SEMICOLON)(';')
-                PsiElement(SEMICOLON)(';')
-                PsiElement(SEMICOLON)(';')
-              PsiWhiteSpace(' ')
-              PsiElement(RBRACE)('}')
+            FUNCTION_LITERAL_EXPRESSION
+              FUNCTION_LITERAL
+                PsiElement(LBRACE)('{')
+                BLOCK
+                  PsiElement(SEMICOLON)(';')
+                  PsiElement(SEMICOLON)(';')
+                  PsiElement(SEMICOLON)(';')
+                  REFERENCE_EXPRESSION
+                    PsiElement(IDENTIFIER)('foo')
+                  PsiElement(SEMICOLON)(';')
+                  REFERENCE_EXPRESSION
+                    PsiElement(IDENTIFIER)('bar')
+                  PsiElement(SEMICOLON)(';')
+                  PsiElement(SEMICOLON)(';')
+                  PsiElement(SEMICOLON)(';')
+                  PsiElement(SEMICOLON)(';')
+                PsiWhiteSpace(' ')
+                PsiElement(RBRACE)('}')
           PsiWhiteSpace(' ')
           PsiElement(while)('while')
           PsiWhiteSpace(' ')

idea/testData/psi/Expressions_ERR.txt

@@ -23,36 +23,37 @@ JetFile: Expressions_ERR.jet
         PsiElement(else)('else')
         PsiWhiteSpace(' ')
         ELSE
-          FUNCTION_LITERAL
-            PsiElement(LBRACE)('{')
-            PsiWhiteSpace('\n  ')
-            BODY
-              REFERENCE_EXPRESSION
-                PsiElement(IDENTIFIER)('dfsd')
+          FUNCTION_LITERAL_EXPRESSION
+            FUNCTION_LITERAL
+              PsiElement(LBRACE)('{')
               PsiWhiteSpace('\n  ')
-              PsiErrorElement:Expecting an element
-                PsiElement(RPAR)(')')
-              PsiElement(SEMICOLON)(';')
-              PsiElement(SEMICOLON)(';')
-              PsiElement(SEMICOLON)(';')
-              PsiErrorElement:Expecting an element
-                PsiElement(RPAR)(')')
-              PsiElement(SEMICOLON)(';')
-              PsiElement(SEMICOLON)(';')
-              PsiElement(SEMICOLON)(';')
-              PsiErrorElement:Expecting an element
-                PsiElement(BAD_CHARACTER)('~')
-              PsiElement(SEMICOLON)(';')
-              PsiElement(SEMICOLON)(';')
-              PsiElement(SEMICOLON)(';')
-              PsiWhiteSpace('\n  ')
-              REFERENCE_EXPRESSION
-                PsiElement(IDENTIFIER)('srgsdfg')
-              PsiWhiteSpace('\n\n  ')
-              PsiErrorElement:Expecting an element
-                PsiElement(BAD_CHARACTER)('~')
-              PsiWhiteSpace('\n\n  ')
-              PsiErrorElement:Expecting an element
-                PsiElement(RBRACKET)(']')
-            PsiWhiteSpace('\n')
-            PsiElement(RBRACE)('}')
+              BLOCK
+                REFERENCE_EXPRESSION
+                  PsiElement(IDENTIFIER)('dfsd')
+                PsiWhiteSpace('\n  ')
+                PsiErrorElement:Expecting an element
+                  PsiElement(RPAR)(')')
+                PsiElement(SEMICOLON)(';')
+                PsiElement(SEMICOLON)(';')
+                PsiElement(SEMICOLON)(';')
+                PsiErrorElement:Expecting an element
+                  PsiElement(RPAR)(')')
+                PsiElement(SEMICOLON)(';')
+                PsiElement(SEMICOLON)(';')
+                PsiElement(SEMICOLON)(';')
+                PsiErrorElement:Expecting an element
+                  PsiElement(BAD_CHARACTER)('~')
+                PsiElement(SEMICOLON)(';')
+                PsiElement(SEMICOLON)(';')
+                PsiElement(SEMICOLON)(';')
+                PsiWhiteSpace('\n  ')
+                REFERENCE_EXPRESSION
+                  PsiElement(IDENTIFIER)('srgsdfg')
+                PsiWhiteSpace('\n\n  ')
+                PsiErrorElement:Expecting an element
+                  PsiElement(BAD_CHARACTER)('~')
+                PsiWhiteSpace('\n\n  ')
+                PsiErrorElement:Expecting an element
+                  PsiElement(RBRACKET)(']')
+              PsiWhiteSpace('\n')
+              PsiElement(RBRACE)('}')

idea/testData/psi/FunctionCalls.txt

@@ -61,36 +61,39 @@ JetFile: FunctionCalls.jet
           REFERENCE_EXPRESSION
             PsiElement(IDENTIFIER)('f')
           PsiWhiteSpace(' ')
-          FUNCTION_LITERAL
-            PsiElement(LBRACE)('{')
-            BODY
-              REFERENCE_EXPRESSION
-                PsiElement(IDENTIFIER)('s')
-            PsiElement(RBRACE)('}')
+          FUNCTION_LITERAL_EXPRESSION
+            FUNCTION_LITERAL
+              PsiElement(LBRACE)('{')
+              BLOCK
+                REFERENCE_EXPRESSION
+                  PsiElement(IDENTIFIER)('s')
+              PsiElement(RBRACE)('}')
         PsiWhiteSpace('\n  ')
         REFERENCE_EXPRESSION
           PsiElement(IDENTIFIER)('f')
         PsiWhiteSpace('\n  ')
-        FUNCTION_LITERAL
-          PsiElement(LBRACE)('{')
-          BODY
-            REFERENCE_EXPRESSION
-              PsiElement(IDENTIFIER)('s')
-          PsiElement(RBRACE)('}')
-        PsiWhiteSpace('\n  ')
-        CALL_EXPRESSION
-          REFERENCE_EXPRESSION
-            PsiElement(IDENTIFIER)('f')
-          PsiWhiteSpace(' ')
+        FUNCTION_LITERAL_EXPRESSION
           FUNCTION_LITERAL
             PsiElement(LBRACE)('{')
-            PsiWhiteSpace('\n    ')
-            BODY
+            BLOCK
               REFERENCE_EXPRESSION
                 PsiElement(IDENTIFIER)('s')
-            PsiWhiteSpace('\n  ')
             PsiElement(RBRACE)('}')
         PsiWhiteSpace('\n  ')
+        CALL_EXPRESSION
+          REFERENCE_EXPRESSION
+            PsiElement(IDENTIFIER)('f')
+          PsiWhiteSpace(' ')
+          FUNCTION_LITERAL_EXPRESSION
+            FUNCTION_LITERAL
+              PsiElement(LBRACE)('{')
+              PsiWhiteSpace('\n    ')
+              BLOCK
+                REFERENCE_EXPRESSION
+                  PsiElement(IDENTIFIER)('s')
+              PsiWhiteSpace('\n  ')
+              PsiElement(RBRACE)('}')
+        PsiWhiteSpace('\n  ')
         CALL_EXPRESSION
           REFERENCE_EXPRESSION
             PsiElement(IDENTIFIER)('f')
@@ -101,14 +104,15 @@ JetFile: FunctionCalls.jet
                 PsiElement(IDENTIFIER)('a')
             PsiElement(RPAR)(')')
           PsiWhiteSpace(' ')
-          FUNCTION_LITERAL
-            PsiElement(LBRACE)('{')
-            PsiWhiteSpace('\n    ')
-            BODY
-              REFERENCE_EXPRESSION
-                PsiElement(IDENTIFIER)('s')
-            PsiWhiteSpace('\n  ')
-            PsiElement(RBRACE)('}')
+          FUNCTION_LITERAL_EXPRESSION
+            FUNCTION_LITERAL
+              PsiElement(LBRACE)('{')
+              PsiWhiteSpace('\n    ')
+              BLOCK
+                REFERENCE_EXPRESSION
+                  PsiElement(IDENTIFIER)('s')
+              PsiWhiteSpace('\n  ')
+              PsiElement(RBRACE)('}')
         PsiWhiteSpace('\n  ')
         CALL_EXPRESSION
           REFERENCE_EXPRESSION
@@ -120,37 +124,11 @@ JetFile: FunctionCalls.jet
                 PsiElement(IDENTIFIER)('a')
             PsiElement(RPAR)(')')
         PsiWhiteSpace('\n  ')
-        FUNCTION_LITERAL
-          PsiElement(LBRACE)('{')
-          PsiWhiteSpace('\n    ')
-          BODY
-            REFERENCE_EXPRESSION
-              PsiElement(IDENTIFIER)('s')
-          PsiWhiteSpace('\n  ')
-          PsiElement(RBRACE)('}')
-        PsiWhiteSpace('\n  ')
-        CALL_EXPRESSION
-          REFERENCE_EXPRESSION
-            PsiElement(IDENTIFIER)('f')
-          TYPE_ARGUMENT_LIST
-            PsiElement(LT)('<')
-            TYPE_PROJECTION
-              TYPE_REFERENCE
-                USER_TYPE
-                  REFERENCE_EXPRESSION
-                    PsiElement(IDENTIFIER)('a')
-            PsiElement(GT)('>')
-          VALUE_ARGUMENT_LIST
-            PsiElement(LPAR)('(')
-            VALUE_ARGUMENT
-              REFERENCE_EXPRESSION
-                PsiElement(IDENTIFIER)('a')
-            PsiElement(RPAR)(')')
-          PsiWhiteSpace(' ')
+        FUNCTION_LITERAL_EXPRESSION
           FUNCTION_LITERAL
             PsiElement(LBRACE)('{')
             PsiWhiteSpace('\n    ')
-            BODY
+            BLOCK
               REFERENCE_EXPRESSION
                 PsiElement(IDENTIFIER)('s')
             PsiWhiteSpace('\n  ')
@@ -173,15 +151,44 @@ JetFile: FunctionCalls.jet
               REFERENCE_EXPRESSION
                 PsiElement(IDENTIFIER)('a')
             PsiElement(RPAR)(')')
+          PsiWhiteSpace(' ')
+          FUNCTION_LITERAL_EXPRESSION
+            FUNCTION_LITERAL
+              PsiElement(LBRACE)('{')
+              PsiWhiteSpace('\n    ')
+              BLOCK
+                REFERENCE_EXPRESSION
+                  PsiElement(IDENTIFIER)('s')
+              PsiWhiteSpace('\n  ')
+              PsiElement(RBRACE)('}')
         PsiWhiteSpace('\n  ')
-        FUNCTION_LITERAL
-          PsiElement(LBRACE)('{')
-          PsiWhiteSpace('\n    ')
-          BODY
-            REFERENCE_EXPRESSION
-              PsiElement(IDENTIFIER)('s')
-          PsiWhiteSpace('\n  ')
-          PsiElement(RBRACE)('}')
+        CALL_EXPRESSION
+          REFERENCE_EXPRESSION
+            PsiElement(IDENTIFIER)('f')
+          TYPE_ARGUMENT_LIST
+            PsiElement(LT)('<')
+            TYPE_PROJECTION
+              TYPE_REFERENCE
+                USER_TYPE
+                  REFERENCE_EXPRESSION
+                    PsiElement(IDENTIFIER)('a')
+            PsiElement(GT)('>')
+          VALUE_ARGUMENT_LIST
+            PsiElement(LPAR)('(')
+            VALUE_ARGUMENT
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('a')
+            PsiElement(RPAR)(')')
+        PsiWhiteSpace('\n  ')
+        FUNCTION_LITERAL_EXPRESSION
+          FUNCTION_LITERAL
+            PsiElement(LBRACE)('{')
+            PsiWhiteSpace('\n    ')
+            BLOCK
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('s')
+            PsiWhiteSpace('\n  ')
+            PsiElement(RBRACE)('}')
         PsiWhiteSpace('\n  ')
         CALL_EXPRESSION
           REFERENCE_EXPRESSION

idea/testData/psi/FunctionLiterals.txt

@@ -11,410 +11,429 @@ JetFile: FunctionLiterals.jet
       BLOCK
         PsiElement(LBRACE)('{')
         PsiWhiteSpace('\n    ')
-        FUNCTION_LITERAL
-          PsiElement(LBRACE)('{')
-          BODY
-            <empty list>
-          PsiElement(RBRACE)('}')
+        FUNCTION_LITERAL_EXPRESSION
+          FUNCTION_LITERAL
+            PsiElement(LBRACE)('{')
+            BLOCK
+              <empty list>
+            PsiElement(RBRACE)('}')
         PsiWhiteSpace('\n\n    ')
-        FUNCTION_LITERAL
-          PsiElement(LBRACE)('{')
-          BODY
-            REFERENCE_EXPRESSION
-              PsiElement(IDENTIFIER)('foo')
-          PsiElement(RBRACE)('}')
-        PsiWhiteSpace('\n\n    ')
-        FUNCTION_LITERAL
-          PsiElement(LBRACE)('{')
-          VALUE_PARAMETER_LIST
-            VALUE_PARAMETER
-              PsiElement(IDENTIFIER)('a')
-          PsiWhiteSpace(' ')
-          PsiElement(DOUBLE_ARROW)('=>')
-          PsiWhiteSpace(' ')
-          BODY
-            REFERENCE_EXPRESSION
-              PsiElement(IDENTIFIER)('a')
-          PsiElement(RBRACE)('}')
-        PsiWhiteSpace('\n\n    ')
-        FUNCTION_LITERAL
-          PsiElement(LBRACE)('{')
-          VALUE_PARAMETER_LIST
-            PsiElement(LPAR)('(')
-            VALUE_PARAMETER
-              PsiElement(IDENTIFIER)('a')
-            PsiElement(RPAR)(')')
-          PsiWhiteSpace(' ')
-          PsiElement(DOUBLE_ARROW)('=>')
-          PsiWhiteSpace(' ')
-          BODY
-            REFERENCE_EXPRESSION
-              PsiElement(IDENTIFIER)('a')
-          PsiElement(RBRACE)('}')
-        PsiWhiteSpace('\n    ')
-        FUNCTION_LITERAL
-          PsiElement(LBRACE)('{')
-          VALUE_PARAMETER_LIST
-            PsiElement(LPAR)('(')
-            VALUE_PARAMETER
-              PsiElement(IDENTIFIER)('a')
-              PsiWhiteSpace(' ')
-              PsiElement(COLON)(':')
-              PsiWhiteSpace(' ')
-              TYPE_REFERENCE
-                USER_TYPE
-                  REFERENCE_EXPRESSION
-                    PsiElement(IDENTIFIER)('A')
-            PsiElement(RPAR)(')')
-          PsiWhiteSpace(' ')
-          PsiElement(DOUBLE_ARROW)('=>')
-          PsiWhiteSpace(' ')
-          BODY
-            REFERENCE_EXPRESSION
-              PsiElement(IDENTIFIER)('a')
-          PsiElement(RBRACE)('}')
-        PsiWhiteSpace('\n    ')
-        FUNCTION_LITERAL
-          PsiElement(LBRACE)('{')
-          VALUE_PARAMETER_LIST
-            PsiElement(LPAR)('(')
-            VALUE_PARAMETER
-              PsiElement(IDENTIFIER)('a')
-              PsiWhiteSpace(' ')
-              PsiElement(COLON)(':')
-              PsiWhiteSpace(' ')
-              TYPE_REFERENCE
-                USER_TYPE
-                  REFERENCE_EXPRESSION
-                    PsiElement(IDENTIFIER)('A')
-            PsiElement(RPAR)(')')
-          PsiWhiteSpace(' ')
-          PsiElement(COLON)(':')
-          PsiWhiteSpace(' ')
-          TYPE_REFERENCE
-            USER_TYPE
+        FUNCTION_LITERAL_EXPRESSION
+          FUNCTION_LITERAL
+            PsiElement(LBRACE)('{')
+            BLOCK
               REFERENCE_EXPRESSION
-                PsiElement(IDENTIFIER)('T')
-          PsiWhiteSpace(' ')
-          PsiElement(DOUBLE_ARROW)('=>')
-          PsiWhiteSpace(' ')
-          BODY
-            REFERENCE_EXPRESSION
-              PsiElement(IDENTIFIER)('a')
-          PsiElement(RBRACE)('}')
-        PsiWhiteSpace('\n    ')
-        FUNCTION_LITERAL
-          PsiElement(LBRACE)('{')
-          VALUE_PARAMETER_LIST
-            PsiElement(LPAR)('(')
-            VALUE_PARAMETER
-              PsiElement(IDENTIFIER)('a')
-            PsiElement(RPAR)(')')
-          PsiWhiteSpace(' ')
-          PsiElement(COLON)(':')
-          PsiWhiteSpace(' ')
-          TYPE_REFERENCE
-            USER_TYPE
-              REFERENCE_EXPRESSION
-                PsiElement(IDENTIFIER)('T')
-          PsiWhiteSpace(' ')
-          PsiElement(DOUBLE_ARROW)('=>')
-          PsiWhiteSpace(' ')
-          BODY
-            REFERENCE_EXPRESSION
-              PsiElement(IDENTIFIER)('a')
-          PsiElement(RBRACE)('}')
+                PsiElement(IDENTIFIER)('foo')
+            PsiElement(RBRACE)('}')
         PsiWhiteSpace('\n\n    ')
-        FUNCTION_LITERAL
-          PsiElement(LBRACE)('{')
-          VALUE_PARAMETER_LIST
-            PsiElement(LPAR)('(')
-            VALUE_PARAMETER
-              PsiElement(IDENTIFIER)('a')
-            PsiElement(COMMA)(',')
+        FUNCTION_LITERAL_EXPRESSION
+          FUNCTION_LITERAL
+            PsiElement(LBRACE)('{')
+            VALUE_PARAMETER_LIST
+              VALUE_PARAMETER
+                PsiElement(IDENTIFIER)('a')
             PsiWhiteSpace(' ')
-            VALUE_PARAMETER
-              PsiElement(IDENTIFIER)('a')
-            PsiElement(RPAR)(')')
-          PsiWhiteSpace(' ')
-          PsiElement(DOUBLE_ARROW)('=>')
-          PsiWhiteSpace(' ')
-          BODY
-            REFERENCE_EXPRESSION
-              PsiElement(IDENTIFIER)('a')
-          PsiElement(RBRACE)('}')
-        PsiWhiteSpace('\n    ')
-        FUNCTION_LITERAL
-          PsiElement(LBRACE)('{')
-          VALUE_PARAMETER_LIST
-            PsiElement(LPAR)('(')
-            VALUE_PARAMETER
-              PsiElement(IDENTIFIER)('a')
-              PsiWhiteSpace(' ')
-              PsiElement(COLON)(':')
-              PsiWhiteSpace(' ')
-              TYPE_REFERENCE
-                USER_TYPE
-                  REFERENCE_EXPRESSION
-                    PsiElement(IDENTIFIER)('A')
-            PsiElement(COMMA)(',')
+            PsiElement(DOUBLE_ARROW)('=>')
             PsiWhiteSpace(' ')
-            VALUE_PARAMETER
-              PsiElement(IDENTIFIER)('a')
-              PsiWhiteSpace(' ')
-              PsiElement(COLON)(':')
-              PsiWhiteSpace(' ')
-              TYPE_REFERENCE
-                USER_TYPE
-                  REFERENCE_EXPRESSION
-                    PsiElement(IDENTIFIER)('B')
-            PsiElement(RPAR)(')')
-          PsiWhiteSpace(' ')
-          PsiElement(DOUBLE_ARROW)('=>')
-          PsiWhiteSpace(' ')
-          BODY
-            REFERENCE_EXPRESSION
-              PsiElement(IDENTIFIER)('a')
-          PsiElement(RBRACE)('}')
-        PsiWhiteSpace('\n    ')
-        FUNCTION_LITERAL
-          PsiElement(LBRACE)('{')
-          VALUE_PARAMETER_LIST
-            PsiElement(LPAR)('(')
-            VALUE_PARAMETER
-              PsiElement(IDENTIFIER)('a')
-              PsiWhiteSpace(' ')
-              PsiElement(COLON)(':')
-              PsiWhiteSpace(' ')
-              TYPE_REFERENCE
-                USER_TYPE
-                  REFERENCE_EXPRESSION
-                    PsiElement(IDENTIFIER)('A')
-            PsiElement(COMMA)(',')
-            PsiWhiteSpace(' ')
-            VALUE_PARAMETER
-              PsiElement(IDENTIFIER)('a')
-            PsiElement(RPAR)(')')
-          PsiWhiteSpace(' ')
-          PsiElement(COLON)(':')
-          PsiWhiteSpace(' ')
-          TYPE_REFERENCE
-            USER_TYPE
+            BLOCK
               REFERENCE_EXPRESSION
-                PsiElement(IDENTIFIER)('T')
-          PsiWhiteSpace(' ')
-          PsiElement(DOUBLE_ARROW)('=>')
-          PsiWhiteSpace(' ')
-          BODY
-            REFERENCE_EXPRESSION
-              PsiElement(IDENTIFIER)('a')
-          PsiElement(RBRACE)('}')
-        PsiWhiteSpace('\n    ')
-        FUNCTION_LITERAL
-          PsiElement(LBRACE)('{')
-          VALUE_PARAMETER_LIST
-            PsiElement(LPAR)('(')
-            VALUE_PARAMETER
-              PsiElement(IDENTIFIER)('a')
-            PsiElement(COMMA)(',')
-            PsiWhiteSpace(' ')
-            VALUE_PARAMETER
-              PsiElement(IDENTIFIER)('a')
-              PsiWhiteSpace(' ')
-              PsiElement(COLON)(':')
-              PsiWhiteSpace(' ')
-              TYPE_REFERENCE
-                USER_TYPE
-                  REFERENCE_EXPRESSION
-                    PsiElement(IDENTIFIER)('B')
-            PsiElement(RPAR)(')')
-          PsiWhiteSpace(' ')
-          PsiElement(COLON)(':')
-          PsiWhiteSpace(' ')
-          TYPE_REFERENCE
-            USER_TYPE
-              REFERENCE_EXPRESSION
-                PsiElement(IDENTIFIER)('T')
-          PsiWhiteSpace(' ')
-          PsiElement(DOUBLE_ARROW)('=>')
-          PsiWhiteSpace(' ')
-          BODY
-            REFERENCE_EXPRESSION
-              PsiElement(IDENTIFIER)('a')
-          PsiElement(RBRACE)('}')
+                PsiElement(IDENTIFIER)('a')
+            PsiElement(RBRACE)('}')
         PsiWhiteSpace('\n\n    ')
-        FUNCTION_LITERAL
-          PsiElement(LBRACE)('{')
-          VALUE_PARAMETER_LIST
-            PsiElement(LPAR)('(')
-            PsiElement(RPAR)(')')
-          PsiWhiteSpace(' ')
-          PsiElement(DOUBLE_ARROW)('=>')
-          PsiWhiteSpace(' ')
-          BODY
-            REFERENCE_EXPRESSION
-              PsiElement(IDENTIFIER)('a')
-          PsiElement(RBRACE)('}')
-        PsiWhiteSpace('\n    ')
-        FUNCTION_LITERAL
-          PsiElement(LBRACE)('{')
-          VALUE_PARAMETER_LIST
-            PsiElement(LPAR)('(')
-            PsiElement(RPAR)(')')
-          PsiWhiteSpace(' ')
-          PsiElement(DOUBLE_ARROW)('=>')
-          PsiWhiteSpace(' ')
-          BODY
-            REFERENCE_EXPRESSION
-              PsiElement(IDENTIFIER)('a')
-          PsiElement(RBRACE)('}')
-        PsiWhiteSpace('\n    ')
-        FUNCTION_LITERAL
-          PsiElement(LBRACE)('{')
-          VALUE_PARAMETER_LIST
-            PsiElement(LPAR)('(')
-            PsiElement(RPAR)(')')
-          PsiWhiteSpace(' ')
-          PsiElement(COLON)(':')
-          PsiWhiteSpace(' ')
-          TYPE_REFERENCE
-            USER_TYPE
+        FUNCTION_LITERAL_EXPRESSION
+          FUNCTION_LITERAL
+            PsiElement(LBRACE)('{')
+            VALUE_PARAMETER_LIST
+              PsiElement(LPAR)('(')
+              VALUE_PARAMETER
+                PsiElement(IDENTIFIER)('a')
+              PsiElement(RPAR)(')')
+            PsiWhiteSpace(' ')
+            PsiElement(DOUBLE_ARROW)('=>')
+            PsiWhiteSpace(' ')
+            BLOCK
               REFERENCE_EXPRESSION
-                PsiElement(IDENTIFIER)('T')
-          PsiWhiteSpace(' ')
-          PsiElement(DOUBLE_ARROW)('=>')
-          PsiWhiteSpace(' ')
-          BODY
-            REFERENCE_EXPRESSION
-              PsiElement(IDENTIFIER)('a')
-          PsiElement(RBRACE)('}')
+                PsiElement(IDENTIFIER)('a')
+            PsiElement(RBRACE)('}')
         PsiWhiteSpace('\n    ')
-        FUNCTION_LITERAL
-          PsiElement(LBRACE)('{')
-          VALUE_PARAMETER_LIST
-            PsiElement(LPAR)('(')
-            PsiElement(RPAR)(')')
-          PsiWhiteSpace(' ')
-          PsiElement(COLON)(':')
-          PsiWhiteSpace(' ')
-          TYPE_REFERENCE
-            USER_TYPE
+        FUNCTION_LITERAL_EXPRESSION
+          FUNCTION_LITERAL
+            PsiElement(LBRACE)('{')
+            VALUE_PARAMETER_LIST
+              PsiElement(LPAR)('(')
+              VALUE_PARAMETER
+                PsiElement(IDENTIFIER)('a')
+                PsiWhiteSpace(' ')
+                PsiElement(COLON)(':')
+                PsiWhiteSpace(' ')
+                TYPE_REFERENCE
+                  USER_TYPE
+                    REFERENCE_EXPRESSION
+                      PsiElement(IDENTIFIER)('A')
+              PsiElement(RPAR)(')')
+            PsiWhiteSpace(' ')
+            PsiElement(DOUBLE_ARROW)('=>')
+            PsiWhiteSpace(' ')
+            BLOCK
               REFERENCE_EXPRESSION
-                PsiElement(IDENTIFIER)('T')
-          PsiWhiteSpace(' ')
-          PsiElement(DOUBLE_ARROW)('=>')
-          PsiWhiteSpace(' ')
-          BODY
-            REFERENCE_EXPRESSION
-              PsiElement(IDENTIFIER)('a')
-          PsiElement(RBRACE)('}')
+                PsiElement(IDENTIFIER)('a')
+            PsiElement(RBRACE)('}')
+        PsiWhiteSpace('\n    ')
+        FUNCTION_LITERAL_EXPRESSION
+          FUNCTION_LITERAL
+            PsiElement(LBRACE)('{')
+            VALUE_PARAMETER_LIST
+              PsiElement(LPAR)('(')
+              VALUE_PARAMETER
+                PsiElement(IDENTIFIER)('a')
+                PsiWhiteSpace(' ')
+                PsiElement(COLON)(':')
+                PsiWhiteSpace(' ')
+                TYPE_REFERENCE
+                  USER_TYPE
+                    REFERENCE_EXPRESSION
+                      PsiElement(IDENTIFIER)('A')
+              PsiElement(RPAR)(')')
+            PsiWhiteSpace(' ')
+            PsiElement(COLON)(':')
+            PsiWhiteSpace(' ')
+            TYPE_REFERENCE
+              USER_TYPE
+                REFERENCE_EXPRESSION
+                  PsiElement(IDENTIFIER)('T')
+            PsiWhiteSpace(' ')
+            PsiElement(DOUBLE_ARROW)('=>')
+            PsiWhiteSpace(' ')
+            BLOCK
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('a')
+            PsiElement(RBRACE)('}')
+        PsiWhiteSpace('\n    ')
+        FUNCTION_LITERAL_EXPRESSION
+          FUNCTION_LITERAL
+            PsiElement(LBRACE)('{')
+            VALUE_PARAMETER_LIST
+              PsiElement(LPAR)('(')
+              VALUE_PARAMETER
+                PsiElement(IDENTIFIER)('a')
+              PsiElement(RPAR)(')')
+            PsiWhiteSpace(' ')
+            PsiElement(COLON)(':')
+            PsiWhiteSpace(' ')
+            TYPE_REFERENCE
+              USER_TYPE
+                REFERENCE_EXPRESSION
+                  PsiElement(IDENTIFIER)('T')
+            PsiWhiteSpace(' ')
+            PsiElement(DOUBLE_ARROW)('=>')
+            PsiWhiteSpace(' ')
+            BLOCK
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('a')
+            PsiElement(RBRACE)('}')
         PsiWhiteSpace('\n\n    ')
-        FUNCTION_LITERAL
-          PsiElement(LBRACE)('{')
-          TYPE_REFERENCE
-            USER_TYPE
+        FUNCTION_LITERAL_EXPRESSION
+          FUNCTION_LITERAL
+            PsiElement(LBRACE)('{')
+            VALUE_PARAMETER_LIST
+              PsiElement(LPAR)('(')
+              VALUE_PARAMETER
+                PsiElement(IDENTIFIER)('a')
+              PsiElement(COMMA)(',')
+              PsiWhiteSpace(' ')
+              VALUE_PARAMETER
+                PsiElement(IDENTIFIER)('a')
+              PsiElement(RPAR)(')')
+            PsiWhiteSpace(' ')
+            PsiElement(DOUBLE_ARROW)('=>')
+            PsiWhiteSpace(' ')
+            BLOCK
               REFERENCE_EXPRESSION
-                PsiElement(IDENTIFIER)('T')
-          PsiElement(DOT)('.')
-          VALUE_PARAMETER_LIST
-            PsiElement(LPAR)('(')
-            VALUE_PARAMETER
-              PsiElement(IDENTIFIER)('a')
-            PsiElement(RPAR)(')')
-          PsiWhiteSpace(' ')
-          PsiElement(DOUBLE_ARROW)('=>')
-          PsiWhiteSpace(' ')
-          BODY
-            REFERENCE_EXPRESSION
-              PsiElement(IDENTIFIER)('a')
-          PsiElement(RBRACE)('}')
+                PsiElement(IDENTIFIER)('a')
+            PsiElement(RBRACE)('}')
         PsiWhiteSpace('\n    ')
-        FUNCTION_LITERAL
-          PsiElement(LBRACE)('{')
-          TYPE_REFERENCE
-            USER_TYPE
+        FUNCTION_LITERAL_EXPRESSION
+          FUNCTION_LITERAL
+            PsiElement(LBRACE)('{')
+            VALUE_PARAMETER_LIST
+              PsiElement(LPAR)('(')
+              VALUE_PARAMETER
+                PsiElement(IDENTIFIER)('a')
+                PsiWhiteSpace(' ')
+                PsiElement(COLON)(':')
+                PsiWhiteSpace(' ')
+                TYPE_REFERENCE
+                  USER_TYPE
+                    REFERENCE_EXPRESSION
+                      PsiElement(IDENTIFIER)('A')
+              PsiElement(COMMA)(',')
+              PsiWhiteSpace(' ')
+              VALUE_PARAMETER
+                PsiElement(IDENTIFIER)('a')
+                PsiWhiteSpace(' ')
+                PsiElement(COLON)(':')
+                PsiWhiteSpace(' ')
+                TYPE_REFERENCE
+                  USER_TYPE
+                    REFERENCE_EXPRESSION
+                      PsiElement(IDENTIFIER)('B')
+              PsiElement(RPAR)(')')
+            PsiWhiteSpace(' ')
+            PsiElement(DOUBLE_ARROW)('=>')
+            PsiWhiteSpace(' ')
+            BLOCK
               REFERENCE_EXPRESSION
-                PsiElement(IDENTIFIER)('T')
-          PsiElement(DOT)('.')
-          VALUE_PARAMETER_LIST
-            PsiElement(LPAR)('(')
-            VALUE_PARAMETER
-              PsiElement(IDENTIFIER)('a')
-              PsiWhiteSpace(' ')
-              PsiElement(COLON)(':')
-              PsiWhiteSpace(' ')
-              TYPE_REFERENCE
-                USER_TYPE
-                  REFERENCE_EXPRESSION
-                    PsiElement(IDENTIFIER)('A')
-            PsiElement(RPAR)(')')
-          PsiWhiteSpace(' ')
-          PsiElement(DOUBLE_ARROW)('=>')
-          PsiWhiteSpace(' ')
-          BODY
-            REFERENCE_EXPRESSION
-              PsiElement(IDENTIFIER)('a')
-          PsiElement(RBRACE)('}')
+                PsiElement(IDENTIFIER)('a')
+            PsiElement(RBRACE)('}')
         PsiWhiteSpace('\n    ')
-        FUNCTION_LITERAL
-          PsiElement(LBRACE)('{')
-          TYPE_REFERENCE
-            USER_TYPE
-              REFERENCE_EXPRESSION
-                PsiElement(IDENTIFIER)('T')
-          PsiElement(DOT)('.')
-          VALUE_PARAMETER_LIST
-            PsiElement(LPAR)('(')
-            VALUE_PARAMETER
-              PsiElement(IDENTIFIER)('a')
+        FUNCTION_LITERAL_EXPRESSION
+          FUNCTION_LITERAL
+            PsiElement(LBRACE)('{')
+            VALUE_PARAMETER_LIST
+              PsiElement(LPAR)('(')
+              VALUE_PARAMETER
+                PsiElement(IDENTIFIER)('a')
+                PsiWhiteSpace(' ')
+                PsiElement(COLON)(':')
+                PsiWhiteSpace(' ')
+                TYPE_REFERENCE
+                  USER_TYPE
+                    REFERENCE_EXPRESSION
+                      PsiElement(IDENTIFIER)('A')
+              PsiElement(COMMA)(',')
               PsiWhiteSpace(' ')
-              PsiElement(COLON)(':')
-              PsiWhiteSpace(' ')
-              TYPE_REFERENCE
-                USER_TYPE
-                  REFERENCE_EXPRESSION
-                    PsiElement(IDENTIFIER)('A')
-            PsiElement(RPAR)(')')
-          PsiWhiteSpace(' ')
-          PsiElement(COLON)(':')
-          PsiWhiteSpace(' ')
-          TYPE_REFERENCE
-            USER_TYPE
+              VALUE_PARAMETER
+                PsiElement(IDENTIFIER)('a')
+              PsiElement(RPAR)(')')
+            PsiWhiteSpace(' ')
+            PsiElement(COLON)(':')
+            PsiWhiteSpace(' ')
+            TYPE_REFERENCE
+              USER_TYPE
+                REFERENCE_EXPRESSION
+                  PsiElement(IDENTIFIER)('T')
+            PsiWhiteSpace(' ')
+            PsiElement(DOUBLE_ARROW)('=>')
+            PsiWhiteSpace(' ')
+            BLOCK
               REFERENCE_EXPRESSION
-                PsiElement(IDENTIFIER)('T')
-          PsiWhiteSpace(' ')
-          PsiElement(DOUBLE_ARROW)('=>')
-          PsiWhiteSpace(' ')
-          BODY
-            REFERENCE_EXPRESSION
-              PsiElement(IDENTIFIER)('a')
-          PsiElement(RBRACE)('}')
+                PsiElement(IDENTIFIER)('a')
+            PsiElement(RBRACE)('}')
         PsiWhiteSpace('\n    ')
-        FUNCTION_LITERAL
-          PsiElement(LBRACE)('{')
-          TYPE_REFERENCE
-            USER_TYPE
+        FUNCTION_LITERAL_EXPRESSION
+          FUNCTION_LITERAL
+            PsiElement(LBRACE)('{')
+            VALUE_PARAMETER_LIST
+              PsiElement(LPAR)('(')
+              VALUE_PARAMETER
+                PsiElement(IDENTIFIER)('a')
+              PsiElement(COMMA)(',')
+              PsiWhiteSpace(' ')
+              VALUE_PARAMETER
+                PsiElement(IDENTIFIER)('a')
+                PsiWhiteSpace(' ')
+                PsiElement(COLON)(':')
+                PsiWhiteSpace(' ')
+                TYPE_REFERENCE
+                  USER_TYPE
+                    REFERENCE_EXPRESSION
+                      PsiElement(IDENTIFIER)('B')
+              PsiElement(RPAR)(')')
+            PsiWhiteSpace(' ')
+            PsiElement(COLON)(':')
+            PsiWhiteSpace(' ')
+            TYPE_REFERENCE
+              USER_TYPE
+                REFERENCE_EXPRESSION
+                  PsiElement(IDENTIFIER)('T')
+            PsiWhiteSpace(' ')
+            PsiElement(DOUBLE_ARROW)('=>')
+            PsiWhiteSpace(' ')
+            BLOCK
               REFERENCE_EXPRESSION
-                PsiElement(IDENTIFIER)('T')
-          PsiElement(DOT)('.')
-          VALUE_PARAMETER_LIST
-            PsiElement(LPAR)('(')
-            VALUE_PARAMETER
-              PsiElement(IDENTIFIER)('a')
-            PsiElement(RPAR)(')')
-          PsiWhiteSpace(' ')
-          PsiElement(COLON)(':')
-          PsiWhiteSpace(' ')
-          TYPE_REFERENCE
-            USER_TYPE
+                PsiElement(IDENTIFIER)('a')
+            PsiElement(RBRACE)('}')
+        PsiWhiteSpace('\n\n    ')
+        FUNCTION_LITERAL_EXPRESSION
+          FUNCTION_LITERAL
+            PsiElement(LBRACE)('{')
+            VALUE_PARAMETER_LIST
+              PsiElement(LPAR)('(')
+              PsiElement(RPAR)(')')
+            PsiWhiteSpace(' ')
+            PsiElement(DOUBLE_ARROW)('=>')
+            PsiWhiteSpace(' ')
+            BLOCK
               REFERENCE_EXPRESSION
-                PsiElement(IDENTIFIER)('T')
-          PsiWhiteSpace(' ')
-          PsiElement(DOUBLE_ARROW)('=>')
-          PsiWhiteSpace(' ')
-          BODY
-            REFERENCE_EXPRESSION
-              PsiElement(IDENTIFIER)('a')
-          PsiElement(RBRACE)('}')
+                PsiElement(IDENTIFIER)('a')
+            PsiElement(RBRACE)('}')
+        PsiWhiteSpace('\n    ')
+        FUNCTION_LITERAL_EXPRESSION
+          FUNCTION_LITERAL
+            PsiElement(LBRACE)('{')
+            VALUE_PARAMETER_LIST
+              PsiElement(LPAR)('(')
+              PsiElement(RPAR)(')')
+            PsiWhiteSpace(' ')
+            PsiElement(DOUBLE_ARROW)('=>')
+            PsiWhiteSpace(' ')
+            BLOCK
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('a')
+            PsiElement(RBRACE)('}')
+        PsiWhiteSpace('\n    ')
+        FUNCTION_LITERAL_EXPRESSION
+          FUNCTION_LITERAL
+            PsiElement(LBRACE)('{')
+            VALUE_PARAMETER_LIST
+              PsiElement(LPAR)('(')
+              PsiElement(RPAR)(')')
+            PsiWhiteSpace(' ')
+            PsiElement(COLON)(':')
+            PsiWhiteSpace(' ')
+            TYPE_REFERENCE
+              USER_TYPE
+                REFERENCE_EXPRESSION
+                  PsiElement(IDENTIFIER)('T')
+            PsiWhiteSpace(' ')
+            PsiElement(DOUBLE_ARROW)('=>')
+            PsiWhiteSpace(' ')
+            BLOCK
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('a')
+            PsiElement(RBRACE)('}')
+        PsiWhiteSpace('\n    ')
+        FUNCTION_LITERAL_EXPRESSION
+          FUNCTION_LITERAL
+            PsiElement(LBRACE)('{')
+            VALUE_PARAMETER_LIST
+              PsiElement(LPAR)('(')
+              PsiElement(RPAR)(')')
+            PsiWhiteSpace(' ')
+            PsiElement(COLON)(':')
+            PsiWhiteSpace(' ')
+            TYPE_REFERENCE
+              USER_TYPE
+                REFERENCE_EXPRESSION
+                  PsiElement(IDENTIFIER)('T')
+            PsiWhiteSpace(' ')
+            PsiElement(DOUBLE_ARROW)('=>')
+            PsiWhiteSpace(' ')
+            BLOCK
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('a')
+            PsiElement(RBRACE)('}')
+        PsiWhiteSpace('\n\n    ')
+        FUNCTION_LITERAL_EXPRESSION
+          FUNCTION_LITERAL
+            PsiElement(LBRACE)('{')
+            TYPE_REFERENCE
+              USER_TYPE
+                REFERENCE_EXPRESSION
+                  PsiElement(IDENTIFIER)('T')
+            PsiElement(DOT)('.')
+            VALUE_PARAMETER_LIST
+              PsiElement(LPAR)('(')
+              VALUE_PARAMETER
+                PsiElement(IDENTIFIER)('a')
+              PsiElement(RPAR)(')')
+            PsiWhiteSpace(' ')
+            PsiElement(DOUBLE_ARROW)('=>')
+            PsiWhiteSpace(' ')
+            BLOCK
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('a')
+            PsiElement(RBRACE)('}')
+        PsiWhiteSpace('\n    ')
+        FUNCTION_LITERAL_EXPRESSION
+          FUNCTION_LITERAL
+            PsiElement(LBRACE)('{')
+            TYPE_REFERENCE
+              USER_TYPE
+                REFERENCE_EXPRESSION
+                  PsiElement(IDENTIFIER)('T')
+            PsiElement(DOT)('.')
+            VALUE_PARAMETER_LIST
+              PsiElement(LPAR)('(')
+              VALUE_PARAMETER
+                PsiElement(IDENTIFIER)('a')
+                PsiWhiteSpace(' ')
+                PsiElement(COLON)(':')
+                PsiWhiteSpace(' ')
+                TYPE_REFERENCE
+                  USER_TYPE
+                    REFERENCE_EXPRESSION
+                      PsiElement(IDENTIFIER)('A')
+              PsiElement(RPAR)(')')
+            PsiWhiteSpace(' ')
+            PsiElement(DOUBLE_ARROW)('=>')
+            PsiWhiteSpace(' ')
+            BLOCK
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('a')
+            PsiElement(RBRACE)('}')
+        PsiWhiteSpace('\n    ')
+        FUNCTION_LITERAL_EXPRESSION
+          FUNCTION_LITERAL
+            PsiElement(LBRACE)('{')
+            TYPE_REFERENCE
+              USER_TYPE
+                REFERENCE_EXPRESSION
+                  PsiElement(IDENTIFIER)('T')
+            PsiElement(DOT)('.')
+            VALUE_PARAMETER_LIST
+              PsiElement(LPAR)('(')
+              VALUE_PARAMETER
+                PsiElement(IDENTIFIER)('a')
+                PsiWhiteSpace(' ')
+                PsiElement(COLON)(':')
+                PsiWhiteSpace(' ')
+                TYPE_REFERENCE
+                  USER_TYPE
+                    REFERENCE_EXPRESSION
+                      PsiElement(IDENTIFIER)('A')
+              PsiElement(RPAR)(')')
+            PsiWhiteSpace(' ')
+            PsiElement(COLON)(':')
+            PsiWhiteSpace(' ')
+            TYPE_REFERENCE
+              USER_TYPE
+                REFERENCE_EXPRESSION
+                  PsiElement(IDENTIFIER)('T')
+            PsiWhiteSpace(' ')
+            PsiElement(DOUBLE_ARROW)('=>')
+            PsiWhiteSpace(' ')
+            BLOCK
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('a')
+            PsiElement(RBRACE)('}')
+        PsiWhiteSpace('\n    ')
+        FUNCTION_LITERAL_EXPRESSION
+          FUNCTION_LITERAL
+            PsiElement(LBRACE)('{')
+            TYPE_REFERENCE
+              USER_TYPE
+                REFERENCE_EXPRESSION
+                  PsiElement(IDENTIFIER)('T')
+            PsiElement(DOT)('.')
+            VALUE_PARAMETER_LIST
+              PsiElement(LPAR)('(')
+              VALUE_PARAMETER
+                PsiElement(IDENTIFIER)('a')
+              PsiElement(RPAR)(')')
+            PsiWhiteSpace(' ')
+            PsiElement(COLON)(':')
+            PsiWhiteSpace(' ')
+            TYPE_REFERENCE
+              USER_TYPE
+                REFERENCE_EXPRESSION
+                  PsiElement(IDENTIFIER)('T')
+            PsiWhiteSpace(' ')
+            PsiElement(DOUBLE_ARROW)('=>')
+            PsiWhiteSpace(' ')
+            BLOCK
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('a')
+            PsiElement(RBRACE)('}')
         PsiWhiteSpace('\n')
         PsiElement(RBRACE)('}')

idea/testData/psi/FunctionLiterals_ERR.txt

@@ -11,307 +11,320 @@ JetFile: FunctionLiterals_ERR.jet
       BLOCK
         PsiElement(LBRACE)('{')
         PsiWhiteSpace('\n    ')
-        FUNCTION_LITERAL
-          PsiElement(LBRACE)('{')
-          PsiWhiteSpace(' ')
-          VALUE_PARAMETER_LIST
-            VALUE_PARAMETER
-              PsiErrorElement:Expecting parameter name
-                <empty list>
-          PsiElement(DOUBLE_ARROW)('=>')
-          PsiWhiteSpace(' ')
-          BODY
-            REFERENCE_EXPRESSION
-              PsiElement(IDENTIFIER)('a')
-          PsiElement(RBRACE)('}')
-        PsiWhiteSpace('\n    ')
-        FUNCTION_LITERAL
-          PsiElement(LBRACE)('{')
-          VALUE_PARAMETER_LIST
-            VALUE_PARAMETER
-              PsiElement(IDENTIFIER)('a')
-            PsiErrorElement:To specify many parameters, use the full notation: {(p1, p2, ...) => ...}
-              PsiElement(COMMA)(',')
-              PsiWhiteSpace(' ')
-              PsiElement(IDENTIFIER)('b')
-          PsiWhiteSpace(' ')
-          PsiElement(DOUBLE_ARROW)('=>')
-          PsiWhiteSpace(' ')
-          BODY
-            REFERENCE_EXPRESSION
-              PsiElement(IDENTIFIER)('a')
-          PsiElement(RBRACE)('}')
-        PsiWhiteSpace('\n\n    ')
-        FUNCTION_LITERAL
-          PsiElement(LBRACE)('{')
-          VALUE_PARAMETER_LIST
-            PsiElement(LPAR)('(')
-            VALUE_PARAMETER
-              PsiElement(IDENTIFIER)('a')
-            PsiErrorElement:Expecting ')
-              <empty list>
-          PsiWhiteSpace(' ')
-          PsiElement(DOUBLE_ARROW)('=>')
-          PsiWhiteSpace(' ')
-          BODY
-            REFERENCE_EXPRESSION
-              PsiElement(IDENTIFIER)('a')
-          PsiElement(RBRACE)('}')
-        PsiWhiteSpace('\n    ')
-        FUNCTION_LITERAL
-          PsiElement(LBRACE)('{')
-          VALUE_PARAMETER_LIST
-            PsiElement(LPAR)('(')
-            VALUE_PARAMETER
-              PsiElement(IDENTIFIER)('a')
-              PsiWhiteSpace(' ')
-              PsiElement(COLON)(':')
-              PsiWhiteSpace(' ')
-              TYPE_REFERENCE
-                PsiErrorElement:Type expected
+        FUNCTION_LITERAL_EXPRESSION
+          FUNCTION_LITERAL
+            PsiElement(LBRACE)('{')
+            PsiWhiteSpace(' ')
+            VALUE_PARAMETER_LIST
+              VALUE_PARAMETER
+                PsiErrorElement:Expecting parameter name
                   <empty list>
-            PsiElement(RPAR)(')')
-          PsiWhiteSpace(' ')
-          PsiElement(DOUBLE_ARROW)('=>')
-          PsiWhiteSpace(' ')
-          BODY
-            REFERENCE_EXPRESSION
-              PsiElement(IDENTIFIER)('a')
-          PsiElement(RBRACE)('}')
-        PsiWhiteSpace('\n    ')
-        FUNCTION_LITERAL
-          PsiElement(LBRACE)('{')
-          VALUE_PARAMETER_LIST
-            PsiElement(LPAR)('(')
-            VALUE_PARAMETER
-              PsiElement(IDENTIFIER)('a')
-              PsiWhiteSpace(' ')
-              PsiElement(COLON)(':')
-              PsiWhiteSpace(' ')
-              TYPE_REFERENCE
-                USER_TYPE
-                  REFERENCE_EXPRESSION
-                    PsiElement(IDENTIFIER)('A')
-            PsiElement(RPAR)(')')
-          PsiWhiteSpace(' ')
-          PsiElement(COLON)(':')
-          PsiErrorElement:Expecting a type
-            <empty list>
-          PsiWhiteSpace(' ')
-          PsiElement(DOUBLE_ARROW)('=>')
-          PsiWhiteSpace(' ')
-          BODY
-            REFERENCE_EXPRESSION
-              PsiElement(IDENTIFIER)('a')
-          PsiElement(RBRACE)('}')
-        PsiWhiteSpace('\n    ')
-        FUNCTION_LITERAL
-          PsiElement(LBRACE)('{')
-          VALUE_PARAMETER_LIST
-            PsiElement(LPAR)('(')
-            VALUE_PARAMETER
-              PsiElement(IDENTIFIER)('a')
-            PsiElement(RPAR)(')')
-          PsiWhiteSpace(' ')
-          PsiElement(COLON)(':')
-          PsiWhiteSpace(' ')
-          TYPE_REFERENCE
-            USER_TYPE
+            PsiElement(DOUBLE_ARROW)('=>')
+            PsiWhiteSpace(' ')
+            BLOCK
               REFERENCE_EXPRESSION
-                PsiElement(IDENTIFIER)('T')
-          PsiWhiteSpace(' ')
-          PsiElement(DOUBLE_ARROW)('=>')
-          PsiWhiteSpace(' ')
-          BODY
-            <empty list>
-          PsiElement(RBRACE)('}')
+                PsiElement(IDENTIFIER)('a')
+            PsiElement(RBRACE)('}')
+        PsiWhiteSpace('\n    ')
+        FUNCTION_LITERAL_EXPRESSION
+          FUNCTION_LITERAL
+            PsiElement(LBRACE)('{')
+            VALUE_PARAMETER_LIST
+              VALUE_PARAMETER
+                PsiElement(IDENTIFIER)('a')
+              PsiErrorElement:To specify many parameters, use the full notation: {(p1, p2, ...) => ...}
+                PsiElement(COMMA)(',')
+                PsiWhiteSpace(' ')
+                PsiElement(IDENTIFIER)('b')
+            PsiWhiteSpace(' ')
+            PsiElement(DOUBLE_ARROW)('=>')
+            PsiWhiteSpace(' ')
+            BLOCK
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('a')
+            PsiElement(RBRACE)('}')
         PsiWhiteSpace('\n\n    ')
-        FUNCTION_LITERAL
-          PsiElement(LBRACE)('{')
-          VALUE_PARAMETER_LIST
-            PsiElement(LPAR)('(')
-            VALUE_PARAMETER
-              PsiElement(IDENTIFIER)('a')
-            PsiElement(COMMA)(',')
-            PsiErrorElement:Expecting a parameter declaration
+        FUNCTION_LITERAL_EXPRESSION
+          FUNCTION_LITERAL
+            PsiElement(LBRACE)('{')
+            VALUE_PARAMETER_LIST
+              PsiElement(LPAR)('(')
+              VALUE_PARAMETER
+                PsiElement(IDENTIFIER)('a')
+              PsiErrorElement:Expecting ')
+                <empty list>
+            PsiWhiteSpace(' ')
+            PsiElement(DOUBLE_ARROW)('=>')
+            PsiWhiteSpace(' ')
+            BLOCK
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('a')
+            PsiElement(RBRACE)('}')
+        PsiWhiteSpace('\n    ')
+        FUNCTION_LITERAL_EXPRESSION
+          FUNCTION_LITERAL
+            PsiElement(LBRACE)('{')
+            VALUE_PARAMETER_LIST
+              PsiElement(LPAR)('(')
+              VALUE_PARAMETER
+                PsiElement(IDENTIFIER)('a')
+                PsiWhiteSpace(' ')
+                PsiElement(COLON)(':')
+                PsiWhiteSpace(' ')
+                TYPE_REFERENCE
+                  PsiErrorElement:Type expected
+                    <empty list>
+              PsiElement(RPAR)(')')
+            PsiWhiteSpace(' ')
+            PsiElement(DOUBLE_ARROW)('=>')
+            PsiWhiteSpace(' ')
+            BLOCK
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('a')
+            PsiElement(RBRACE)('}')
+        PsiWhiteSpace('\n    ')
+        FUNCTION_LITERAL_EXPRESSION
+          FUNCTION_LITERAL
+            PsiElement(LBRACE)('{')
+            VALUE_PARAMETER_LIST
+              PsiElement(LPAR)('(')
+              VALUE_PARAMETER
+                PsiElement(IDENTIFIER)('a')
+                PsiWhiteSpace(' ')
+                PsiElement(COLON)(':')
+                PsiWhiteSpace(' ')
+                TYPE_REFERENCE
+                  USER_TYPE
+                    REFERENCE_EXPRESSION
+                      PsiElement(IDENTIFIER)('A')
+              PsiElement(RPAR)(')')
+            PsiWhiteSpace(' ')
+            PsiElement(COLON)(':')
+            PsiErrorElement:Expecting a type
               <empty list>
             PsiWhiteSpace(' ')
-            PsiElement(RPAR)(')')
-          PsiWhiteSpace(' ')
-          PsiElement(DOUBLE_ARROW)('=>')
-          PsiWhiteSpace(' ')
-          BODY
-            REFERENCE_EXPRESSION
-              PsiElement(IDENTIFIER)('a')
-          PsiElement(RBRACE)('}')
-        PsiWhiteSpace('\n    ')
-        FUNCTION_LITERAL
-          PsiElement(LBRACE)('{')
-          VALUE_PARAMETER_LIST
-            PsiElement(LPAR)('(')
-            VALUE_PARAMETER
-              PsiElement(IDENTIFIER)('a')
-              PsiWhiteSpace(' ')
-              PsiElement(COLON)(':')
-              PsiWhiteSpace(' ')
-              TYPE_REFERENCE
-                USER_TYPE
-                  REFERENCE_EXPRESSION
-                    PsiElement(IDENTIFIER)('A')
-            PsiElement(COMMA)(',')
+            PsiElement(DOUBLE_ARROW)('=>')
             PsiWhiteSpace(' ')
-            PsiErrorElement:Expecting a parameter declaration
-              PsiElement(COMMA)(',')
-            PsiWhiteSpace(' ')
-            VALUE_PARAMETER
-              PsiElement(IDENTIFIER)('a')
-              PsiWhiteSpace(' ')
-              PsiElement(COLON)(':')
-              PsiWhiteSpace(' ')
-              TYPE_REFERENCE
-                USER_TYPE
-                  REFERENCE_EXPRESSION
-                    PsiElement(IDENTIFIER)('B')
-            PsiElement(RPAR)(')')
-          PsiWhiteSpace(' ')
-          PsiElement(DOUBLE_ARROW)('=>')
-          PsiWhiteSpace(' ')
-          BODY
-            REFERENCE_EXPRESSION
-              PsiElement(IDENTIFIER)('a')
-          PsiElement(RBRACE)('}')
-        PsiWhiteSpace('\n    ')
-        FUNCTION_LITERAL
-          PsiElement(LBRACE)('{')
-          VALUE_PARAMETER_LIST
-            PsiElement(LPAR)('(')
-            VALUE_PARAMETER
-              PsiElement(IDENTIFIER)('a')
-              PsiWhiteSpace(' ')
-              PsiElement(COLON)(':')
-              PsiWhiteSpace(' ')
-              TYPE_REFERENCE
-                USER_TYPE
-                  REFERENCE_EXPRESSION
-                    PsiElement(IDENTIFIER)('A')
-            PsiElement(COMMA)(',')
-            PsiWhiteSpace(' ')
-            PsiErrorElement:Expecting a parameter declaration
-              PsiElement(COMMA)(',')
-            PsiWhiteSpace(' ')
-            VALUE_PARAMETER
-              PsiErrorElement:Expecting parameter declaration
-                <empty list>
-            PsiElement(COMMA)(',')
-            PsiWhiteSpace(' ')
-            VALUE_PARAMETER
-              PsiElement(IDENTIFIER)('a')
-            PsiElement(RPAR)(')')
-          PsiWhiteSpace(' ')
-          PsiElement(COLON)(':')
-          PsiWhiteSpace(' ')
-          TYPE_REFERENCE
-            USER_TYPE
+            BLOCK
               REFERENCE_EXPRESSION
-                PsiElement(IDENTIFIER)('T')
-          PsiWhiteSpace(' ')
-          PsiElement(DOUBLE_ARROW)('=>')
-          PsiWhiteSpace(' ')
-          BODY
-            REFERENCE_EXPRESSION
-              PsiElement(IDENTIFIER)('a')
-          PsiElement(RBRACE)('}')
-        PsiWhiteSpace('\n\n    ')
-        FUNCTION_LITERAL
-          PsiElement(LBRACE)('{')
-          TYPE_REFERENCE
-            USER_TYPE
-              REFERENCE_EXPRESSION
-                PsiElement(IDENTIFIER)('T')
-          PsiElement(DOT)('.')
-          PsiErrorElement:Expecting '('
-            PsiElement(IDENTIFIER)('t')
-          VALUE_PARAMETER_LIST
-            PsiElement(LPAR)('(')
-            VALUE_PARAMETER
-              PsiElement(IDENTIFIER)('a')
-            PsiElement(RPAR)(')')
-          PsiWhiteSpace(' ')
-          PsiElement(DOUBLE_ARROW)('=>')
-          PsiWhiteSpace(' ')
-          BODY
-            REFERENCE_EXPRESSION
-              PsiElement(IDENTIFIER)('a')
-          PsiElement(RBRACE)('}')
+                PsiElement(IDENTIFIER)('a')
+            PsiElement(RBRACE)('}')
         PsiWhiteSpace('\n    ')
-        FUNCTION_LITERAL
-          PsiElement(LBRACE)('{')
-          TYPE_REFERENCE
-            USER_TYPE
-              REFERENCE_EXPRESSION
-                PsiElement(IDENTIFIER)('T')
-          PsiElement(DOT)('.')
-          PsiErrorElement:Expecting '('
-            PsiElement(IDENTIFIER)('t')
-            PsiWhiteSpace(' ')
-            PsiElement(MINUS)('-')
-          VALUE_PARAMETER_LIST
-            PsiElement(LPAR)('(')
-            VALUE_PARAMETER
-              PsiElement(IDENTIFIER)('a')
-              PsiWhiteSpace(' ')
-              PsiElement(COLON)(':')
-              PsiWhiteSpace(' ')
-              TYPE_REFERENCE
-                USER_TYPE
-                  REFERENCE_EXPRESSION
-                    PsiElement(IDENTIFIER)('A')
-            PsiElement(RPAR)(')')
-          PsiWhiteSpace(' ')
-          PsiElement(DOUBLE_ARROW)('=>')
-          PsiWhiteSpace(' ')
-          BODY
-            REFERENCE_EXPRESSION
-              PsiElement(IDENTIFIER)('a')
-          PsiElement(RBRACE)('}')
-        PsiWhiteSpace('\n\n    ')
-        FUNCTION_LITERAL
-          PsiElement(LBRACE)('{')
-          VALUE_PARAMETER_LIST
-            VALUE_PARAMETER
-              PsiElement(IDENTIFIER)('a')
-            PsiWhiteSpace(' ')
-            PsiErrorElement:To specify a type of a parameter or a return type, use the full notation: {(parameter : Type) : ReturnType => ...}
-              PsiElement(COLON)(':')
-              PsiWhiteSpace(' ')
-              PsiElement(IDENTIFIER)('b')
-          PsiWhiteSpace(' ')
-          PsiElement(DOUBLE_ARROW)('=>')
-          PsiWhiteSpace(' ')
-          BODY
-            REFERENCE_EXPRESSION
-              PsiElement(IDENTIFIER)('f')
-          PsiElement(RBRACE)('}')
-        PsiWhiteSpace('\n    ')
-        FUNCTION_LITERAL
-          PsiElement(LBRACE)('{')
-          TYPE_REFERENCE
-            USER_TYPE
-              REFERENCE_EXPRESSION
-                PsiElement(IDENTIFIER)('T')
-          PsiElement(DOT)('.')
-          PsiErrorElement:To specify a receiver type, use the full notation: {ReceiverType.(parameters) [: ReturnType] => ...}
-            PsiElement(IDENTIFIER)('a')
+        FUNCTION_LITERAL_EXPRESSION
+          FUNCTION_LITERAL
+            PsiElement(LBRACE)('{')
+            VALUE_PARAMETER_LIST
+              PsiElement(LPAR)('(')
+              VALUE_PARAMETER
+                PsiElement(IDENTIFIER)('a')
+              PsiElement(RPAR)(')')
             PsiWhiteSpace(' ')
             PsiElement(COLON)(':')
             PsiWhiteSpace(' ')
-            PsiElement(IDENTIFIER)('b')
-          PsiWhiteSpace(' ')
-          PsiElement(DOUBLE_ARROW)('=>')
-          PsiWhiteSpace(' ')
-          BODY
-            REFERENCE_EXPRESSION
-              PsiElement(IDENTIFIER)('f')
-          PsiElement(RBRACE)('}')
+            TYPE_REFERENCE
+              USER_TYPE
+                REFERENCE_EXPRESSION
+                  PsiElement(IDENTIFIER)('T')
+            PsiWhiteSpace(' ')
+            PsiElement(DOUBLE_ARROW)('=>')
+            PsiWhiteSpace(' ')
+            BLOCK
+              <empty list>
+            PsiElement(RBRACE)('}')
+        PsiWhiteSpace('\n\n    ')
+        FUNCTION_LITERAL_EXPRESSION
+          FUNCTION_LITERAL
+            PsiElement(LBRACE)('{')
+            VALUE_PARAMETER_LIST
+              PsiElement(LPAR)('(')
+              VALUE_PARAMETER
+                PsiElement(IDENTIFIER)('a')
+              PsiElement(COMMA)(',')
+              PsiErrorElement:Expecting a parameter declaration
+                <empty list>
+              PsiWhiteSpace(' ')
+              PsiElement(RPAR)(')')
+            PsiWhiteSpace(' ')
+            PsiElement(DOUBLE_ARROW)('=>')
+            PsiWhiteSpace(' ')
+            BLOCK
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('a')
+            PsiElement(RBRACE)('}')
+        PsiWhiteSpace('\n    ')
+        FUNCTION_LITERAL_EXPRESSION
+          FUNCTION_LITERAL
+            PsiElement(LBRACE)('{')
+            VALUE_PARAMETER_LIST
+              PsiElement(LPAR)('(')
+              VALUE_PARAMETER
+                PsiElement(IDENTIFIER)('a')
+                PsiWhiteSpace(' ')
+                PsiElement(COLON)(':')
+                PsiWhiteSpace(' ')
+                TYPE_REFERENCE
+                  USER_TYPE
+                    REFERENCE_EXPRESSION
+                      PsiElement(IDENTIFIER)('A')
+              PsiElement(COMMA)(',')
+              PsiWhiteSpace(' ')
+              PsiErrorElement:Expecting a parameter declaration
+                PsiElement(COMMA)(',')
+              PsiWhiteSpace(' ')
+              VALUE_PARAMETER
+                PsiElement(IDENTIFIER)('a')
+                PsiWhiteSpace(' ')
+                PsiElement(COLON)(':')
+                PsiWhiteSpace(' ')
+                TYPE_REFERENCE
+                  USER_TYPE
+                    REFERENCE_EXPRESSION
+                      PsiElement(IDENTIFIER)('B')
+              PsiElement(RPAR)(')')
+            PsiWhiteSpace(' ')
+            PsiElement(DOUBLE_ARROW)('=>')
+            PsiWhiteSpace(' ')
+            BLOCK
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('a')
+            PsiElement(RBRACE)('}')
+        PsiWhiteSpace('\n    ')
+        FUNCTION_LITERAL_EXPRESSION
+          FUNCTION_LITERAL
+            PsiElement(LBRACE)('{')
+            VALUE_PARAMETER_LIST
+              PsiElement(LPAR)('(')
+              VALUE_PARAMETER
+                PsiElement(IDENTIFIER)('a')
+                PsiWhiteSpace(' ')
+                PsiElement(COLON)(':')
+                PsiWhiteSpace(' ')
+                TYPE_REFERENCE
+                  USER_TYPE
+                    REFERENCE_EXPRESSION
+                      PsiElement(IDENTIFIER)('A')
+              PsiElement(COMMA)(',')
+              PsiWhiteSpace(' ')
+              PsiErrorElement:Expecting a parameter declaration
+                PsiElement(COMMA)(',')
+              PsiWhiteSpace(' ')
+              VALUE_PARAMETER
+                PsiErrorElement:Expecting parameter declaration
+                  <empty list>
+              PsiElement(COMMA)(',')
+              PsiWhiteSpace(' ')
+              VALUE_PARAMETER
+                PsiElement(IDENTIFIER)('a')
+              PsiElement(RPAR)(')')
+            PsiWhiteSpace(' ')
+            PsiElement(COLON)(':')
+            PsiWhiteSpace(' ')
+            TYPE_REFERENCE
+              USER_TYPE
+                REFERENCE_EXPRESSION
+                  PsiElement(IDENTIFIER)('T')
+            PsiWhiteSpace(' ')
+            PsiElement(DOUBLE_ARROW)('=>')
+            PsiWhiteSpace(' ')
+            BLOCK
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('a')
+            PsiElement(RBRACE)('}')
+        PsiWhiteSpace('\n\n    ')
+        FUNCTION_LITERAL_EXPRESSION
+          FUNCTION_LITERAL
+            PsiElement(LBRACE)('{')
+            TYPE_REFERENCE
+              USER_TYPE
+                REFERENCE_EXPRESSION
+                  PsiElement(IDENTIFIER)('T')
+            PsiElement(DOT)('.')
+            PsiErrorElement:Expecting '('
+              PsiElement(IDENTIFIER)('t')
+            VALUE_PARAMETER_LIST
+              PsiElement(LPAR)('(')
+              VALUE_PARAMETER
+                PsiElement(IDENTIFIER)('a')
+              PsiElement(RPAR)(')')
+            PsiWhiteSpace(' ')
+            PsiElement(DOUBLE_ARROW)('=>')
+            PsiWhiteSpace(' ')
+            BLOCK
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('a')
+            PsiElement(RBRACE)('}')
+        PsiWhiteSpace('\n    ')
+        FUNCTION_LITERAL_EXPRESSION
+          FUNCTION_LITERAL
+            PsiElement(LBRACE)('{')
+            TYPE_REFERENCE
+              USER_TYPE
+                REFERENCE_EXPRESSION
+                  PsiElement(IDENTIFIER)('T')
+            PsiElement(DOT)('.')
+            PsiErrorElement:Expecting '('
+              PsiElement(IDENTIFIER)('t')
+              PsiWhiteSpace(' ')
+              PsiElement(MINUS)('-')
+            VALUE_PARAMETER_LIST
+              PsiElement(LPAR)('(')
+              VALUE_PARAMETER
+                PsiElement(IDENTIFIER)('a')
+                PsiWhiteSpace(' ')
+                PsiElement(COLON)(':')
+                PsiWhiteSpace(' ')
+                TYPE_REFERENCE
+                  USER_TYPE
+                    REFERENCE_EXPRESSION
+                      PsiElement(IDENTIFIER)('A')
+              PsiElement(RPAR)(')')
+            PsiWhiteSpace(' ')
+            PsiElement(DOUBLE_ARROW)('=>')
+            PsiWhiteSpace(' ')
+            BLOCK
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('a')
+            PsiElement(RBRACE)('}')
+        PsiWhiteSpace('\n\n    ')
+        FUNCTION_LITERAL_EXPRESSION
+          FUNCTION_LITERAL
+            PsiElement(LBRACE)('{')
+            VALUE_PARAMETER_LIST
+              VALUE_PARAMETER
+                PsiElement(IDENTIFIER)('a')
+              PsiWhiteSpace(' ')
+              PsiErrorElement:To specify a type of a parameter or a return type, use the full notation: {(parameter : Type) : ReturnType => ...}
+                PsiElement(COLON)(':')
+                PsiWhiteSpace(' ')
+                PsiElement(IDENTIFIER)('b')
+            PsiWhiteSpace(' ')
+            PsiElement(DOUBLE_ARROW)('=>')
+            PsiWhiteSpace(' ')
+            BLOCK
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('f')
+            PsiElement(RBRACE)('}')
+        PsiWhiteSpace('\n    ')
+        FUNCTION_LITERAL_EXPRESSION
+          FUNCTION_LITERAL
+            PsiElement(LBRACE)('{')
+            TYPE_REFERENCE
+              USER_TYPE
+                REFERENCE_EXPRESSION
+                  PsiElement(IDENTIFIER)('T')
+            PsiElement(DOT)('.')
+            PsiErrorElement:To specify a receiver type, use the full notation: {ReceiverType.(parameters) [: ReturnType] => ...}
+              PsiElement(IDENTIFIER)('a')
+              PsiWhiteSpace(' ')
+              PsiElement(COLON)(':')
+              PsiWhiteSpace(' ')
+              PsiElement(IDENTIFIER)('b')
+            PsiWhiteSpace(' ')
+            PsiElement(DOUBLE_ARROW)('=>')
+            PsiWhiteSpace(' ')
+            BLOCK
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('f')
+            PsiElement(RBRACE)('}')
         PsiWhiteSpace('\n')
         PsiElement(RBRACE)('}')

idea/testData/psi/IfWithPropery.txt

@@ -16,32 +16,34 @@ JetFile: IfWithPropery.jet
         PsiElement(RPAR)(')')
         PsiWhiteSpace(' ')
         THEN
-          FUNCTION_LITERAL
-            PsiElement(LBRACE)('{')
-            BODY
-              PROPERTY
-                PsiElement(var)('var')
-                PsiWhiteSpace(' ')
-                PsiElement(IDENTIFIER)('f')
-                PsiWhiteSpace(' ')
-                PsiElement(EQ)('=')
-                PsiWhiteSpace(' ')
+          FUNCTION_LITERAL_EXPRESSION
+            FUNCTION_LITERAL
+              PsiElement(LBRACE)('{')
+              BLOCK
+                PROPERTY
+                  PsiElement(var)('var')
+                  PsiWhiteSpace(' ')
+                  PsiElement(IDENTIFIER)('f')
+                  PsiWhiteSpace(' ')
+                  PsiElement(EQ)('=')
+                  PsiWhiteSpace(' ')
+                  REFERENCE_EXPRESSION
+                    PsiElement(IDENTIFIER)('a')
+                PsiElement(SEMICOLON)(';')
                 REFERENCE_EXPRESSION
                   PsiElement(IDENTIFIER)('a')
-              PsiElement(SEMICOLON)(';')
-              REFERENCE_EXPRESSION
-                PsiElement(IDENTIFIER)('a')
-            PsiElement(RBRACE)('}')
+              PsiElement(RBRACE)('}')
         PsiWhiteSpace(' ')
         PsiElement(else)('else')
         PsiWhiteSpace(' ')
         ELSE
-          FUNCTION_LITERAL
-            PsiElement(LBRACE)('{')
-            BODY
-              NULL
-                PsiElement(null)('null')
-            PsiElement(RBRACE)('}')
+          FUNCTION_LITERAL_EXPRESSION
+            FUNCTION_LITERAL
+              PsiElement(LBRACE)('{')
+              BLOCK
+                NULL
+                  PsiElement(null)('null')
+              PsiElement(RBRACE)('}')
     PsiWhiteSpace('\n')
     PROPERTY
       PsiElement(val)('val')
@@ -59,32 +61,34 @@ JetFile: IfWithPropery.jet
         PsiElement(RPAR)(')')
         PsiWhiteSpace(' ')
         THEN
-          FUNCTION_LITERAL
-            PsiElement(LBRACE)('{')
-            PsiWhiteSpace('\n  ')
-            BODY
-              PROPERTY
-                PsiElement(var)('var')
-                PsiWhiteSpace(' ')
-                PsiElement(IDENTIFIER)('f')
-                PsiWhiteSpace(' ')
-                PsiElement(EQ)('=')
-                PsiWhiteSpace(' ')
+          FUNCTION_LITERAL_EXPRESSION
+            FUNCTION_LITERAL
+              PsiElement(LBRACE)('{')
+              PsiWhiteSpace('\n  ')
+              BLOCK
+                PROPERTY
+                  PsiElement(var)('var')
+                  PsiWhiteSpace(' ')
+                  PsiElement(IDENTIFIER)('f')
+                  PsiWhiteSpace(' ')
+                  PsiElement(EQ)('=')
+                  PsiWhiteSpace(' ')
+                  REFERENCE_EXPRESSION
+                    PsiElement(IDENTIFIER)('a')
+                PsiElement(SEMICOLON)(';')
+                PsiWhiteSpace('\n  ')
                 REFERENCE_EXPRESSION
                   PsiElement(IDENTIFIER)('a')
-              PsiElement(SEMICOLON)(';')
-              PsiWhiteSpace('\n  ')
-              REFERENCE_EXPRESSION
-                PsiElement(IDENTIFIER)('a')
-            PsiWhiteSpace('\n')
-            PsiElement(RBRACE)('}')
+              PsiWhiteSpace('\n')
+              PsiElement(RBRACE)('}')
         PsiWhiteSpace(' ')
         PsiElement(else)('else')
         PsiWhiteSpace(' ')
         ELSE
-          FUNCTION_LITERAL
-            PsiElement(LBRACE)('{')
-            BODY
-              NULL
-                PsiElement(null)('null')
-            PsiElement(RBRACE)('}')
+          FUNCTION_LITERAL_EXPRESSION
+            FUNCTION_LITERAL
+              PsiElement(LBRACE)('{')
+              BLOCK
+                NULL
+                  PsiElement(null)('null')
+              PsiElement(RBRACE)('}')

idea/testData/psi/Labels.txt

@@ -278,33 +278,34 @@ JetFile: Labels.jet
             PREFIX_EXPRESSION
               OPERATION_REFERENCE
                 PsiElement(LABEL_IDENTIFIER)('@f')
-              FUNCTION_LITERAL
-                PsiElement(LBRACE)('{')
-                PsiWhiteSpace('\n      ')
-                BODY
-                  IF
-                    PsiElement(if)('if')
-                    PsiWhiteSpace(' ')
-                    PsiElement(LPAR)('(')
-                    CONDITION
-                      INTEGER_CONSTANT
-                        PsiElement(INTEGER_LITERAL)('1')
-                    PsiElement(RPAR)(')')
-                    PsiWhiteSpace(' ')
-                    THEN
-                      RETURN
-                        PsiElement(return)('return')
+              FUNCTION_LITERAL_EXPRESSION
+                FUNCTION_LITERAL
+                  PsiElement(LBRACE)('{')
                   PsiWhiteSpace('\n      ')
-                  RETURN
-                    PsiElement(return)('return')
-                    LABEL_QUALIFIER
-                      LABEL_REFERENCE
-                        PsiElement(LABEL_IDENTIFIER)('@f')
-                    PsiWhiteSpace(' ')
-                    BOOLEAN_CONSTANT
-                      PsiElement(true)('true')
-                PsiWhiteSpace('\n  ')
-                PsiElement(RBRACE)('}')
+                  BLOCK
+                    IF
+                      PsiElement(if)('if')
+                      PsiWhiteSpace(' ')
+                      PsiElement(LPAR)('(')
+                      CONDITION
+                        INTEGER_CONSTANT
+                          PsiElement(INTEGER_LITERAL)('1')
+                      PsiElement(RPAR)(')')
+                      PsiWhiteSpace(' ')
+                      THEN
+                        RETURN
+                          PsiElement(return)('return')
+                    PsiWhiteSpace('\n      ')
+                    RETURN
+                      PsiElement(return)('return')
+                      LABEL_QUALIFIER
+                        LABEL_REFERENCE
+                          PsiElement(LABEL_IDENTIFIER)('@f')
+                      PsiWhiteSpace(' ')
+                      BOOLEAN_CONSTANT
+                        PsiElement(true)('true')
+                  PsiWhiteSpace('\n  ')
+                  PsiElement(RBRACE)('}')
         PsiWhiteSpace('\n\n  ')
         DOT_QUALIFIED_EXPRESSION
           REFERENCE_EXPRESSION
@@ -317,33 +318,34 @@ JetFile: Labels.jet
             PREFIX_EXPRESSION
               OPERATION_REFERENCE
                 PsiElement(AT)('@')
-              FUNCTION_LITERAL
-                PsiElement(LBRACE)('{')
-                PsiWhiteSpace('\n      ')
-                BODY
-                  IF
-                    PsiElement(if)('if')
-                    PsiWhiteSpace(' ')
-                    PsiElement(LPAR)('(')
-                    CONDITION
-                      INTEGER_CONSTANT
-                        PsiElement(INTEGER_LITERAL)('1')
-                    PsiElement(RPAR)(')')
-                    PsiWhiteSpace(' ')
-                    THEN
-                      RETURN
-                        PsiElement(return)('return')
+              FUNCTION_LITERAL_EXPRESSION
+                FUNCTION_LITERAL
+                  PsiElement(LBRACE)('{')
                   PsiWhiteSpace('\n      ')
-                  RETURN
-                    PsiElement(return)('return')
-                    LABEL_QUALIFIER
-                      LABEL_REFERENCE
-                        PsiElement(AT)('@')
-                    PsiWhiteSpace(' ')
-                    BOOLEAN_CONSTANT
-                      PsiElement(true)('true')
-                PsiWhiteSpace('\n  ')
-                PsiElement(RBRACE)('}')
+                  BLOCK
+                    IF
+                      PsiElement(if)('if')
+                      PsiWhiteSpace(' ')
+                      PsiElement(LPAR)('(')
+                      CONDITION
+                        INTEGER_CONSTANT
+                          PsiElement(INTEGER_LITERAL)('1')
+                      PsiElement(RPAR)(')')
+                      PsiWhiteSpace(' ')
+                      THEN
+                        RETURN
+                          PsiElement(return)('return')
+                    PsiWhiteSpace('\n      ')
+                    RETURN
+                      PsiElement(return)('return')
+                      LABEL_QUALIFIER
+                        LABEL_REFERENCE
+                          PsiElement(AT)('@')
+                      PsiWhiteSpace(' ')
+                      BOOLEAN_CONSTANT
+                        PsiElement(true)('true')
+                  PsiWhiteSpace('\n  ')
+                  PsiElement(RBRACE)('}')
         PsiWhiteSpace('\n\n  ')
         DOT_QUALIFIED_EXPRESSION
           REFERENCE_EXPRESSION
@@ -356,33 +358,34 @@ JetFile: Labels.jet
             PREFIX_EXPRESSION
               OPERATION_REFERENCE
                 PsiElement(ATAT)('@@')
-              FUNCTION_LITERAL
-                PsiElement(LBRACE)('{')
-                PsiWhiteSpace('\n      ')
-                BODY
-                  IF
-                    PsiElement(if)('if')
-                    PsiWhiteSpace(' ')
-                    PsiElement(LPAR)('(')
-                    CONDITION
-                      INTEGER_CONSTANT
-                        PsiElement(INTEGER_LITERAL)('1')
-                    PsiElement(RPAR)(')')
-                    PsiWhiteSpace(' ')
-                    THEN
-                      RETURN
-                        PsiElement(return)('return')
+              FUNCTION_LITERAL_EXPRESSION
+                FUNCTION_LITERAL
+                  PsiElement(LBRACE)('{')
                   PsiWhiteSpace('\n      ')
-                  RETURN
-                    PsiElement(return)('return')
-                    LABEL_QUALIFIER
-                      LABEL_REFERENCE
-                        PsiElement(ATAT)('@@')
-                    PsiWhiteSpace(' ')
-                    BOOLEAN_CONSTANT
-                      PsiElement(true)('true')
-                PsiWhiteSpace('\n  ')
-                PsiElement(RBRACE)('}')
+                  BLOCK
+                    IF
+                      PsiElement(if)('if')
+                      PsiWhiteSpace(' ')
+                      PsiElement(LPAR)('(')
+                      CONDITION
+                        INTEGER_CONSTANT
+                          PsiElement(INTEGER_LITERAL)('1')
+                      PsiElement(RPAR)(')')
+                      PsiWhiteSpace(' ')
+                      THEN
+                        RETURN
+                          PsiElement(return)('return')
+                    PsiWhiteSpace('\n      ')
+                    RETURN
+                      PsiElement(return)('return')
+                      LABEL_QUALIFIER
+                        LABEL_REFERENCE
+                          PsiElement(ATAT)('@@')
+                      PsiWhiteSpace(' ')
+                      BOOLEAN_CONSTANT
+                        PsiElement(true)('true')
+                  PsiWhiteSpace('\n  ')
+                  PsiElement(RBRACE)('}')
         PsiWhiteSpace('\n\n  ')
         THIS_EXPRESSION
           REFERENCE_EXPRESSION

idea/testData/psi/NewlinesInParentheses.txt

@@ -91,19 +91,20 @@ JetFile: NewlinesInParentheses.jet
           PsiWhiteSpace(' ')
           PARENTHESIZED
             PsiElement(LPAR)('(')
-            FUNCTION_LITERAL
-              PsiElement(LBRACE)('{')
-              BODY
-                REFERENCE_EXPRESSION
-                  PsiElement(IDENTIFIER)('a')
-                PsiWhiteSpace('\n  ')
-                PREFIX_EXPRESSION
-                  OPERATION_REFERENCE
-                    PsiElement(PLUS)('+')
-                  PsiWhiteSpace(' ')
+            FUNCTION_LITERAL_EXPRESSION
+              FUNCTION_LITERAL
+                PsiElement(LBRACE)('{')
+                BLOCK
                   REFERENCE_EXPRESSION
-                    PsiElement(IDENTIFIER)('b')
-              PsiElement(RBRACE)('}')
+                    PsiElement(IDENTIFIER)('a')
+                  PsiWhiteSpace('\n  ')
+                  PREFIX_EXPRESSION
+                    OPERATION_REFERENCE
+                      PsiElement(PLUS)('+')
+                    PsiWhiteSpace(' ')
+                    REFERENCE_EXPRESSION
+                      PsiElement(IDENTIFIER)('b')
+                PsiElement(RBRACE)('}')
             PsiElement(RPAR)(')')
         PsiWhiteSpace('\n  ')
         PROPERTY
@@ -116,19 +117,20 @@ JetFile: NewlinesInParentheses.jet
           PARENTHESIZED
             PsiElement(LPAR)('(')
             BINARY_EXPRESSION
-              FUNCTION_LITERAL
-                PsiElement(LBRACE)('{')
-                BODY
-                  REFERENCE_EXPRESSION
-                    PsiElement(IDENTIFIER)('a')
-                  PsiWhiteSpace('\n  ')
-                  PREFIX_EXPRESSION
-                    OPERATION_REFERENCE
-                      PsiElement(PLUS)('+')
-                    PsiWhiteSpace(' ')
+              FUNCTION_LITERAL_EXPRESSION
+                FUNCTION_LITERAL
+                  PsiElement(LBRACE)('{')
+                  BLOCK
                     REFERENCE_EXPRESSION
-                      PsiElement(IDENTIFIER)('b')
-                PsiElement(RBRACE)('}')
+                      PsiElement(IDENTIFIER)('a')
+                    PsiWhiteSpace('\n  ')
+                    PREFIX_EXPRESSION
+                      OPERATION_REFERENCE
+                        PsiElement(PLUS)('+')
+                      PsiWhiteSpace(' ')
+                      REFERENCE_EXPRESSION
+                        PsiElement(IDENTIFIER)('b')
+                  PsiElement(RBRACE)('}')
               PsiWhiteSpace('\n  ')
               OPERATION_REFERENCE
                 PsiElement(PLUS)('+')
@@ -172,19 +174,20 @@ JetFile: NewlinesInParentheses.jet
               PsiElement(IDENTIFIER)('b')
             INDICES
               PsiElement(LBRACKET)('[')
-              FUNCTION_LITERAL
-                PsiElement(LBRACE)('{')
-                BODY
-                  REFERENCE_EXPRESSION
-                    PsiElement(IDENTIFIER)('c')
-                  PsiWhiteSpace('\n    ')
-                  PREFIX_EXPRESSION
-                    OPERATION_REFERENCE
-                      PsiElement(PLUS)('+')
-                    PsiWhiteSpace(' ')
+              FUNCTION_LITERAL_EXPRESSION
+                FUNCTION_LITERAL
+                  PsiElement(LBRACE)('{')
+                  BLOCK
                     REFERENCE_EXPRESSION
-                      PsiElement(IDENTIFIER)('d')
-                PsiElement(RBRACE)('}')
+                      PsiElement(IDENTIFIER)('c')
+                    PsiWhiteSpace('\n    ')
+                    PREFIX_EXPRESSION
+                      OPERATION_REFERENCE
+                        PsiElement(PLUS)('+')
+                      PsiWhiteSpace(' ')
+                      REFERENCE_EXPRESSION
+                        PsiElement(IDENTIFIER)('d')
+                  PsiElement(RBRACE)('}')
               PsiElement(RBRACKET)(']')
         PsiWhiteSpace('\n  ')
         PROPERTY
@@ -200,19 +203,20 @@ JetFile: NewlinesInParentheses.jet
             INDICES
               PsiElement(LBRACKET)('[')
               BINARY_EXPRESSION
-                FUNCTION_LITERAL
-                  PsiElement(LBRACE)('{')
-                  BODY
-                    REFERENCE_EXPRESSION
-                      PsiElement(IDENTIFIER)('c')
-                    PsiWhiteSpace('\n    ')
-                    PREFIX_EXPRESSION
-                      OPERATION_REFERENCE
-                        PsiElement(PLUS)('+')
-                      PsiWhiteSpace(' ')
+                FUNCTION_LITERAL_EXPRESSION
+                  FUNCTION_LITERAL
+                    PsiElement(LBRACE)('{')
+                    BLOCK
                       REFERENCE_EXPRESSION
-                        PsiElement(IDENTIFIER)('d')
-                  PsiElement(RBRACE)('}')
+                        PsiElement(IDENTIFIER)('c')
+                      PsiWhiteSpace('\n    ')
+                      PREFIX_EXPRESSION
+                        OPERATION_REFERENCE
+                          PsiElement(PLUS)('+')
+                        PsiWhiteSpace(' ')
+                        REFERENCE_EXPRESSION
+                          PsiElement(IDENTIFIER)('d')
+                    PsiElement(RBRACE)('}')
                 PsiWhiteSpace('\n    ')
                 OPERATION_REFERENCE
                   PsiElement(PLUS)('+')

idea/testData/psi/RootNamespace.txt

@@ -115,11 +115,12 @@ JetFile: RootNamespace.jet
                 PsiWhiteSpace(' ')
                 PsiElement(DOUBLE_ARROW)('=>')
                 PsiWhiteSpace(' ')
-                FUNCTION_LITERAL
-                  PsiElement(LBRACE)('{')
-                  BODY
-                    <empty list>
-                  PsiElement(RBRACE)('}')
+                FUNCTION_LITERAL_EXPRESSION
+                  FUNCTION_LITERAL
+                    PsiElement(LBRACE)('{')
+                    BLOCK
+                      <empty list>
+                    PsiElement(RBRACE)('}')
               PsiWhiteSpace('\n    ')
               PsiElement(RBRACE)('}')
             PsiWhiteSpace('\n  ')

idea/testData/psi/When.txt

@@ -27,35 +27,36 @@ JetFile: When.jet
           PsiWhiteSpace(' ')
           PsiElement(EQ)('=')
           PsiWhiteSpace(' ')
-          FUNCTION_LITERAL
-            PsiElement(LBRACE)('{')
-            BODY
-              WHEN
-                PsiElement(when)('when')
-                PsiElement(LPAR)('(')
-                REFERENCE_EXPRESSION
-                  PsiElement(IDENTIFIER)('x')
-                PsiElement(RPAR)(')')
-                PsiWhiteSpace(' ')
-                PsiElement(LBRACE)('{')
-                PsiWhiteSpace(' ')
-                WHEN_ENTRY
-                  WHEN_CONDITION_IS_PATTERN
-                    PsiElement(is)('is')
-                    PsiWhiteSpace(' ')
-                    TYPE_PATTERN
-                      TYPE_REFERENCE
-                        USER_TYPE
-                          REFERENCE_EXPRESSION
-                            PsiElement(IDENTIFIER)('a')
-                  PsiWhiteSpace(' ')
-                  PsiElement(DOUBLE_ARROW)('=>')
-                  PsiWhiteSpace(' ')
+          FUNCTION_LITERAL_EXPRESSION
+            FUNCTION_LITERAL
+              PsiElement(LBRACE)('{')
+              BLOCK
+                WHEN
+                  PsiElement(when)('when')
+                  PsiElement(LPAR)('(')
                   REFERENCE_EXPRESSION
-                    PsiElement(IDENTIFIER)('b')
-                PsiWhiteSpace(' ')
-                PsiElement(RBRACE)('}')
-            PsiElement(RBRACE)('}')
+                    PsiElement(IDENTIFIER)('x')
+                  PsiElement(RPAR)(')')
+                  PsiWhiteSpace(' ')
+                  PsiElement(LBRACE)('{')
+                  PsiWhiteSpace(' ')
+                  WHEN_ENTRY
+                    WHEN_CONDITION_IS_PATTERN
+                      PsiElement(is)('is')
+                      PsiWhiteSpace(' ')
+                      TYPE_PATTERN
+                        TYPE_REFERENCE
+                          USER_TYPE
+                            REFERENCE_EXPRESSION
+                              PsiElement(IDENTIFIER)('a')
+                    PsiWhiteSpace(' ')
+                    PsiElement(DOUBLE_ARROW)('=>')
+                    PsiWhiteSpace(' ')
+                    REFERENCE_EXPRESSION
+                      PsiElement(IDENTIFIER)('b')
+                  PsiWhiteSpace(' ')
+                  PsiElement(RBRACE)('}')
+              PsiElement(RBRACE)('}')
         PsiWhiteSpace('\n\n  ')
         PsiComment(EOL_COMMENT)('// foo')
         PsiWhiteSpace('\n  ')

idea/testData/psi/examples/BitArith.txt

@@ -288,45 +288,46 @@ JetFile: BitArith.jet
           PsiElement(RPAR)(')')
           PsiWhiteSpace(' ')
           BODY
-            FUNCTION_LITERAL
-              PsiElement(LBRACE)('{')
-              PsiWhiteSpace('\n    ')
-              BODY
-                BINARY_EXPRESSION
-                  REFERENCE_EXPRESSION
-                    PsiElement(IDENTIFIER)('result')
-                  PsiWhiteSpace(' ')
-                  OPERATION_REFERENCE
-                    PsiElement(PLUSEQ)('+=')
-                  PsiWhiteSpace(' ')
-                  BINARY_EXPRESSION
-                    REFERENCE_EXPRESSION
-                      PsiElement(IDENTIFIER)('x')
-                    PsiWhiteSpace(' ')
-                    OPERATION_REFERENCE
-                      PsiElement(IDENTIFIER)('and')
-                    PsiWhiteSpace(' ')
-                    INTEGER_CONSTANT
-                      PsiElement(INTEGER_LITERAL)('1')
+            FUNCTION_LITERAL_EXPRESSION
+              FUNCTION_LITERAL
+                PsiElement(LBRACE)('{')
                 PsiWhiteSpace('\n    ')
-                BINARY_EXPRESSION
-                  REFERENCE_EXPRESSION
-                    PsiElement(IDENTIFIER)('x')
-                  PsiWhiteSpace(' ')
-                  OPERATION_REFERENCE
-                    PsiElement(EQ)('=')
-                  PsiWhiteSpace(' ')
+                BLOCK
+                  BINARY_EXPRESSION
+                    REFERENCE_EXPRESSION
+                      PsiElement(IDENTIFIER)('result')
+                    PsiWhiteSpace(' ')
+                    OPERATION_REFERENCE
+                      PsiElement(PLUSEQ)('+=')
+                    PsiWhiteSpace(' ')
+                    BINARY_EXPRESSION
+                      REFERENCE_EXPRESSION
+                        PsiElement(IDENTIFIER)('x')
+                      PsiWhiteSpace(' ')
+                      OPERATION_REFERENCE
+                        PsiElement(IDENTIFIER)('and')
+                      PsiWhiteSpace(' ')
+                      INTEGER_CONSTANT
+                        PsiElement(INTEGER_LITERAL)('1')
+                  PsiWhiteSpace('\n    ')
                   BINARY_EXPRESSION
                     REFERENCE_EXPRESSION
                       PsiElement(IDENTIFIER)('x')
                     PsiWhiteSpace(' ')
                     OPERATION_REFERENCE
-                      PsiElement(IDENTIFIER)('ushr')
+                      PsiElement(EQ)('=')
                     PsiWhiteSpace(' ')
-                    INTEGER_CONSTANT
-                      PsiElement(INTEGER_LITERAL)('1')
-              PsiWhiteSpace('\n  ')
-              PsiElement(RBRACE)('}')
+                    BINARY_EXPRESSION
+                      REFERENCE_EXPRESSION
+                        PsiElement(IDENTIFIER)('x')
+                      PsiWhiteSpace(' ')
+                      OPERATION_REFERENCE
+                        PsiElement(IDENTIFIER)('ushr')
+                      PsiWhiteSpace(' ')
+                      INTEGER_CONSTANT
+                        PsiElement(INTEGER_LITERAL)('1')
+                PsiWhiteSpace('\n  ')
+                PsiElement(RBRACE)('}')
         PsiWhiteSpace('\n  ')
         REFERENCE_EXPRESSION
           PsiElement(IDENTIFIER)('result')

idea/testData/psi/examples/Builder.txt

@@ -48,21 +48,22 @@ JetFile: Builder.jet
                   REFERENCE_EXPRESSION
                     PsiElement(IDENTIFIER)('library')
                   PsiWhiteSpace(' ')
-                  FUNCTION_LITERAL
-                    PsiElement(LBRACE)('{')
-                    PsiWhiteSpace('\n    ')
-                    BODY
-                      CALL_EXPRESSION
-                        REFERENCE_EXPRESSION
-                          PsiElement(IDENTIFIER)('classpath')
-                        VALUE_ARGUMENT_LIST
-                          PsiElement(LPAR)('(')
-                          VALUE_ARGUMENT
-                            STRING_CONSTANT
-                              PsiElement(STRING_LITERAL)('"$libs/groovy-..."')
-                          PsiElement(RPAR)(')')
-                    PsiWhiteSpace('\n  ')
-                    PsiElement(RBRACE)('}')
+                  FUNCTION_LITERAL_EXPRESSION
+                    FUNCTION_LITERAL
+                      PsiElement(LBRACE)('{')
+                      PsiWhiteSpace('\n    ')
+                      BLOCK
+                        CALL_EXPRESSION
+                          REFERENCE_EXPRESSION
+                            PsiElement(IDENTIFIER)('classpath')
+                          VALUE_ARGUMENT_LIST
+                            PsiElement(LPAR)('(')
+                            VALUE_ARGUMENT
+                              STRING_CONSTANT
+                                PsiElement(STRING_LITERAL)('"$libs/groovy-..."')
+                            PsiElement(RPAR)(')')
+                      PsiWhiteSpace('\n  ')
+                      PsiElement(RBRACE)('}')
               PsiWhiteSpace('\n\n  ')
               PROPERTY
                 MODIFIER_LIST
@@ -85,46 +86,48 @@ JetFile: Builder.jet
                   REFERENCE_EXPRESSION
                     PsiElement(IDENTIFIER)('library')
                   PsiWhiteSpace(' ')
-                  FUNCTION_LITERAL
-                    PsiElement(LBRACE)('{')
-                    PsiWhiteSpace('\n    ')
-                    BODY
-                      DOT_QUALIFIED_EXPRESSION
+                  FUNCTION_LITERAL_EXPRESSION
+                    FUNCTION_LITERAL
+                      PsiElement(LBRACE)('{')
+                      PsiWhiteSpace('\n    ')
+                      BLOCK
                         DOT_QUALIFIED_EXPRESSION
+                          DOT_QUALIFIED_EXPRESSION
+                            CALL_EXPRESSION
+                              REFERENCE_EXPRESSION
+                                PsiElement(IDENTIFIER)('File')
+                              VALUE_ARGUMENT_LIST
+                                PsiElement(LPAR)('(')
+                                VALUE_ARGUMENT
+                                  STRING_CONSTANT
+                                    PsiElement(STRING_LITERAL)('"$gantHome/lib"')
+                                PsiElement(RPAR)(')')
+                            PsiElement(DOT)('.')
+                            REFERENCE_EXPRESSION
+                              PsiElement(IDENTIFIER)('files')
+                          PsiElement(DOT)('.')
                           CALL_EXPRESSION
                             REFERENCE_EXPRESSION
-                              PsiElement(IDENTIFIER)('File')
-                            VALUE_ARGUMENT_LIST
-                              PsiElement(LPAR)('(')
-                              VALUE_ARGUMENT
-                                STRING_CONSTANT
-                                  PsiElement(STRING_LITERAL)('"$gantHome/lib"')
-                              PsiElement(RPAR)(')')
-                          PsiElement(DOT)('.')
-                          REFERENCE_EXPRESSION
-                            PsiElement(IDENTIFIER)('files')
-                        PsiElement(DOT)('.')
-                        CALL_EXPRESSION
-                          REFERENCE_EXPRESSION
-                            PsiElement(IDENTIFIER)('each')
-                          PsiWhiteSpace(' ')
-                          FUNCTION_LITERAL
-                            PsiElement(LBRACE)('{')
-                            PsiWhiteSpace('\n      ')
-                            BODY
-                              CALL_EXPRESSION
-                                REFERENCE_EXPRESSION
-                                  PsiElement(IDENTIFIER)('classpath')
-                                VALUE_ARGUMENT_LIST
-                                  PsiElement(LPAR)('(')
-                                  VALUE_ARGUMENT
+                              PsiElement(IDENTIFIER)('each')
+                            PsiWhiteSpace(' ')
+                            FUNCTION_LITERAL_EXPRESSION
+                              FUNCTION_LITERAL
+                                PsiElement(LBRACE)('{')
+                                PsiWhiteSpace('\n      ')
+                                BLOCK
+                                  CALL_EXPRESSION
                                     REFERENCE_EXPRESSION
-                                      PsiElement(IDENTIFIER)('it')
-                                  PsiElement(RPAR)(')')
-                            PsiWhiteSpace('\n    ')
-                            PsiElement(RBRACE)('}')
-                    PsiWhiteSpace('\n  ')
-                    PsiElement(RBRACE)('}')
+                                      PsiElement(IDENTIFIER)('classpath')
+                                    VALUE_ARGUMENT_LIST
+                                      PsiElement(LPAR)('(')
+                                      VALUE_ARGUMENT
+                                        REFERENCE_EXPRESSION
+                                          PsiElement(IDENTIFIER)('it')
+                                      PsiElement(RPAR)(')')
+                                PsiWhiteSpace('\n    ')
+                                PsiElement(RBRACE)('}')
+                      PsiWhiteSpace('\n  ')
+                      PsiElement(RBRACE)('}')
               PsiWhiteSpace('\n\n  ')
               PROPERTY
                 MODIFIER_LIST
@@ -147,51 +150,52 @@ JetFile: Builder.jet
                   REFERENCE_EXPRESSION
                     PsiElement(IDENTIFIER)('module')
                   PsiWhiteSpace(' ')
-                  FUNCTION_LITERAL
-                    PsiElement(LBRACE)('{')
-                    PsiWhiteSpace('\n    ')
-                    BODY
-                      BINARY_EXPRESSION
-                        REFERENCE_EXPRESSION
-                          PsiElement(IDENTIFIER)('targetLevel')
-                        PsiWhiteSpace(' ')
-                        OPERATION_REFERENCE
-                          PsiElement(EQ)('=')
-                        PsiWhiteSpace(' ')
-                        STRING_CONSTANT
-                          PsiElement(STRING_LITERAL)('"1.5"')
+                  FUNCTION_LITERAL_EXPRESSION
+                    FUNCTION_LITERAL
+                      PsiElement(LBRACE)('{')
                       PsiWhiteSpace('\n    ')
-                      CALL_EXPRESSION
-                        REFERENCE_EXPRESSION
-                          PsiElement(IDENTIFIER)('classpath')
-                        VALUE_ARGUMENT_LIST
-                          PsiElement(LPAR)('(')
-                          VALUE_ARGUMENT
-                            REFERENCE_EXPRESSION
-                              PsiElement(IDENTIFIER)('antLayout')
-                          PsiElement(COMMA)(',')
+                      BLOCK
+                        BINARY_EXPRESSION
+                          REFERENCE_EXPRESSION
+                            PsiElement(IDENTIFIER)('targetLevel')
                           PsiWhiteSpace(' ')
-                          VALUE_ARGUMENT
-                            REFERENCE_EXPRESSION
-                              PsiElement(IDENTIFIER)('gant')
-                          PsiElement(COMMA)(',')
+                          OPERATION_REFERENCE
+                            PsiElement(EQ)('=')
                           PsiWhiteSpace(' ')
-                          VALUE_ARGUMENT
-                            REFERENCE_EXPRESSION
-                              PsiElement(IDENTIFIER)('groovy')
-                          PsiElement(RPAR)(')')
-                      PsiWhiteSpace('\n    ')
-                      CALL_EXPRESSION
-                        REFERENCE_EXPRESSION
-                          PsiElement(IDENTIFIER)('src')
-                        VALUE_ARGUMENT_LIST
-                          PsiElement(LPAR)('(')
-                          VALUE_ARGUMENT
-                            STRING_CONSTANT
-                              PsiElement(STRING_LITERAL)('"$projectHome/antLayout/src"')
-                          PsiElement(RPAR)(')')
-                    PsiWhiteSpace('\n  ')
-                    PsiElement(RBRACE)('}')
+                          STRING_CONSTANT
+                            PsiElement(STRING_LITERAL)('"1.5"')
+                        PsiWhiteSpace('\n    ')
+                        CALL_EXPRESSION
+                          REFERENCE_EXPRESSION
+                            PsiElement(IDENTIFIER)('classpath')
+                          VALUE_ARGUMENT_LIST
+                            PsiElement(LPAR)('(')
+                            VALUE_ARGUMENT
+                              REFERENCE_EXPRESSION
+                                PsiElement(IDENTIFIER)('antLayout')
+                            PsiElement(COMMA)(',')
+                            PsiWhiteSpace(' ')
+                            VALUE_ARGUMENT
+                              REFERENCE_EXPRESSION
+                                PsiElement(IDENTIFIER)('gant')
+                            PsiElement(COMMA)(',')
+                            PsiWhiteSpace(' ')
+                            VALUE_ARGUMENT
+                              REFERENCE_EXPRESSION
+                                PsiElement(IDENTIFIER)('groovy')
+                            PsiElement(RPAR)(')')
+                        PsiWhiteSpace('\n    ')
+                        CALL_EXPRESSION
+                          REFERENCE_EXPRESSION
+                            PsiElement(IDENTIFIER)('src')
+                          VALUE_ARGUMENT_LIST
+                            PsiElement(LPAR)('(')
+                            VALUE_ARGUMENT
+                              STRING_CONSTANT
+                                PsiElement(STRING_LITERAL)('"$projectHome/antLayout/src"')
+                            PsiElement(RPAR)(')')
+                      PsiWhiteSpace('\n  ')
+                      PsiElement(RBRACE)('}')
               PsiWhiteSpace('\n\n')
               PsiElement(RBRACE)('}')
         PsiElement(DOT)('.')

idea/testData/psi/examples/FunctionsAndTypes.txt

@@ -447,41 +447,42 @@ JetFile: FunctionsAndTypes.jet
       PsiWhiteSpace(' ')
       PsiElement(EQ)('=')
       PsiWhiteSpace(' ')
-      FUNCTION_LITERAL
-        PsiElement(LBRACE)('{')
-        VALUE_PARAMETER_LIST
-          PsiElement(LPAR)('(')
-          VALUE_PARAMETER
-            PsiElement(IDENTIFIER)('t')
-            PsiWhiteSpace(' ')
-            PsiElement(COLON)(':')
-            PsiWhiteSpace(' ')
-            TYPE_REFERENCE
-              USER_TYPE
-                REFERENCE_EXPRESSION
-                  PsiElement(IDENTIFIER)('T')
-          PsiElement(RPAR)(')')
-        PsiWhiteSpace(' ')
-        PsiElement(COLON)(':')
-        PsiWhiteSpace(' ')
-        TYPE_REFERENCE
-          USER_TYPE
-            REFERENCE_EXPRESSION
-              PsiElement(IDENTIFIER)('X')
-        PsiWhiteSpace(' ')
-        PsiElement(DOUBLE_ARROW)('=>')
-        PsiWhiteSpace(' ')
-        BODY
-          CALL_EXPRESSION
-            REFERENCE_EXPRESSION
-              PsiElement(IDENTIFIER)('something')
-            VALUE_ARGUMENT_LIST
-              PsiElement(LPAR)('(')
-              VALUE_ARGUMENT
-                REFERENCE_EXPRESSION
-                  PsiElement(IDENTIFIER)('t')
-              PsiElement(RPAR)(')')
-        PsiElement(RBRACE)('}')
+      FUNCTION_LITERAL_EXPRESSION
+        FUNCTION_LITERAL
+          PsiElement(LBRACE)('{')
+          VALUE_PARAMETER_LIST
+            PsiElement(LPAR)('(')
+            VALUE_PARAMETER
+              PsiElement(IDENTIFIER)('t')
+              PsiWhiteSpace(' ')
+              PsiElement(COLON)(':')
+              PsiWhiteSpace(' ')
+              TYPE_REFERENCE
+                USER_TYPE
+                  REFERENCE_EXPRESSION
+                    PsiElement(IDENTIFIER)('T')
+            PsiElement(RPAR)(')')
+          PsiWhiteSpace(' ')
+          PsiElement(COLON)(':')
+          PsiWhiteSpace(' ')
+          TYPE_REFERENCE
+            USER_TYPE
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('X')
+          PsiWhiteSpace(' ')
+          PsiElement(DOUBLE_ARROW)('=>')
+          PsiWhiteSpace(' ')
+          BLOCK
+            CALL_EXPRESSION
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('something')
+              VALUE_ARGUMENT_LIST
+                PsiElement(LPAR)('(')
+                VALUE_ARGUMENT
+                  REFERENCE_EXPRESSION
+                    PsiElement(IDENTIFIER)('t')
+                PsiElement(RPAR)(')')
+          PsiElement(RBRACE)('}')
     PsiWhiteSpace('\n')
     FUN
       PsiElement(fun)('fun')
@@ -526,34 +527,35 @@ JetFile: FunctionsAndTypes.jet
       PsiWhiteSpace(' ')
       PsiElement(EQ)('=')
       PsiWhiteSpace(' ')
-      FUNCTION_LITERAL
-        PsiElement(LBRACE)('{')
-        VALUE_PARAMETER_LIST
-          PsiElement(LPAR)('(')
-          VALUE_PARAMETER
-            PsiElement(IDENTIFIER)('t')
-            PsiWhiteSpace(' ')
-            PsiElement(COLON)(':')
-            PsiWhiteSpace(' ')
-            TYPE_REFERENCE
-              USER_TYPE
-                REFERENCE_EXPRESSION
-                  PsiElement(IDENTIFIER)('T')
-          PsiElement(RPAR)(')')
-        PsiWhiteSpace(' ')
-        PsiElement(DOUBLE_ARROW)('=>')
-        PsiWhiteSpace(' ')
-        BODY
-          CALL_EXPRESSION
-            REFERENCE_EXPRESSION
-              PsiElement(IDENTIFIER)('something')
-            VALUE_ARGUMENT_LIST
-              PsiElement(LPAR)('(')
-              VALUE_ARGUMENT
-                REFERENCE_EXPRESSION
-                  PsiElement(IDENTIFIER)('t')
-              PsiElement(RPAR)(')')
-        PsiElement(RBRACE)('}')
+      FUNCTION_LITERAL_EXPRESSION
+        FUNCTION_LITERAL
+          PsiElement(LBRACE)('{')
+          VALUE_PARAMETER_LIST
+            PsiElement(LPAR)('(')
+            VALUE_PARAMETER
+              PsiElement(IDENTIFIER)('t')
+              PsiWhiteSpace(' ')
+              PsiElement(COLON)(':')
+              PsiWhiteSpace(' ')
+              TYPE_REFERENCE
+                USER_TYPE
+                  REFERENCE_EXPRESSION
+                    PsiElement(IDENTIFIER)('T')
+            PsiElement(RPAR)(')')
+          PsiWhiteSpace(' ')
+          PsiElement(DOUBLE_ARROW)('=>')
+          PsiWhiteSpace(' ')
+          BLOCK
+            CALL_EXPRESSION
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('something')
+              VALUE_ARGUMENT_LIST
+                PsiElement(LPAR)('(')
+                VALUE_ARGUMENT
+                  REFERENCE_EXPRESSION
+                    PsiElement(IDENTIFIER)('t')
+                PsiElement(RPAR)(')')
+          PsiElement(RBRACE)('}')
     PsiWhiteSpace('\n')
     PROPERTY
       PsiElement(val)('val')
@@ -562,34 +564,35 @@ JetFile: FunctionsAndTypes.jet
       PsiWhiteSpace(' ')
       PsiElement(EQ)('=')
       PsiWhiteSpace(' ')
-      FUNCTION_LITERAL
-        PsiElement(LBRACE)('{')
-        VALUE_PARAMETER_LIST
-          PsiElement(LPAR)('(')
-          VALUE_PARAMETER
-            PsiElement(IDENTIFIER)('T')
-          PsiElement(RPAR)(')')
-        PsiWhiteSpace(' ')
-        PsiElement(COLON)(':')
-        PsiWhiteSpace(' ')
-        TYPE_REFERENCE
-          USER_TYPE
-            REFERENCE_EXPRESSION
-              PsiElement(IDENTIFIER)('X')
-        PsiWhiteSpace(' ')
-        PsiElement(DOUBLE_ARROW)('=>')
-        PsiWhiteSpace(' ')
-        BODY
-          CALL_EXPRESSION
-            REFERENCE_EXPRESSION
-              PsiElement(IDENTIFIER)('something')
-            VALUE_ARGUMENT_LIST
-              PsiElement(LPAR)('(')
-              VALUE_ARGUMENT
-                REFERENCE_EXPRESSION
-                  PsiElement(IDENTIFIER)('it')
-              PsiElement(RPAR)(')')
-        PsiElement(RBRACE)('}')
+      FUNCTION_LITERAL_EXPRESSION
+        FUNCTION_LITERAL
+          PsiElement(LBRACE)('{')
+          VALUE_PARAMETER_LIST
+            PsiElement(LPAR)('(')
+            VALUE_PARAMETER
+              PsiElement(IDENTIFIER)('T')
+            PsiElement(RPAR)(')')
+          PsiWhiteSpace(' ')
+          PsiElement(COLON)(':')
+          PsiWhiteSpace(' ')
+          TYPE_REFERENCE
+            USER_TYPE
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('X')
+          PsiWhiteSpace(' ')
+          PsiElement(DOUBLE_ARROW)('=>')
+          PsiWhiteSpace(' ')
+          BLOCK
+            CALL_EXPRESSION
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('something')
+              VALUE_ARGUMENT_LIST
+                PsiElement(LPAR)('(')
+                VALUE_ARGUMENT
+                  REFERENCE_EXPRESSION
+                    PsiElement(IDENTIFIER)('it')
+                PsiElement(RPAR)(')')
+          PsiElement(RBRACE)('}')
     PsiWhiteSpace('\n')
     PROPERTY
       PsiElement(val)('val')
@@ -598,25 +601,26 @@ JetFile: FunctionsAndTypes.jet
       PsiWhiteSpace(' ')
       PsiElement(EQ)('=')
       PsiWhiteSpace(' ')
-      FUNCTION_LITERAL
-        PsiElement(LBRACE)('{')
-        VALUE_PARAMETER_LIST
-          VALUE_PARAMETER
-            PsiElement(IDENTIFIER)('t')
-        PsiWhiteSpace(' ')
-        PsiElement(DOUBLE_ARROW)('=>')
-        PsiWhiteSpace(' ')
-        BODY
-          CALL_EXPRESSION
-            REFERENCE_EXPRESSION
-              PsiElement(IDENTIFIER)('something')
-            VALUE_ARGUMENT_LIST
-              PsiElement(LPAR)('(')
-              VALUE_ARGUMENT
-                REFERENCE_EXPRESSION
-                  PsiElement(IDENTIFIER)('t')
-              PsiElement(RPAR)(')')
-        PsiElement(RBRACE)('}')
+      FUNCTION_LITERAL_EXPRESSION
+        FUNCTION_LITERAL
+          PsiElement(LBRACE)('{')
+          VALUE_PARAMETER_LIST
+            VALUE_PARAMETER
+              PsiElement(IDENTIFIER)('t')
+          PsiWhiteSpace(' ')
+          PsiElement(DOUBLE_ARROW)('=>')
+          PsiWhiteSpace(' ')
+          BLOCK
+            CALL_EXPRESSION
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('something')
+              VALUE_ARGUMENT_LIST
+                PsiElement(LPAR)('(')
+                VALUE_ARGUMENT
+                  REFERENCE_EXPRESSION
+                    PsiElement(IDENTIFIER)('t')
+                PsiElement(RPAR)(')')
+          PsiElement(RBRACE)('}')
     PsiWhiteSpace('\n')
     PROPERTY
       PsiElement(val)('val')
@@ -625,19 +629,20 @@ JetFile: FunctionsAndTypes.jet
       PsiWhiteSpace(' ')
       PsiElement(EQ)('=')
       PsiWhiteSpace(' ')
-      FUNCTION_LITERAL
-        PsiElement(LBRACE)('{')
-        BODY
-          CALL_EXPRESSION
-            REFERENCE_EXPRESSION
-              PsiElement(IDENTIFIER)('something')
-            VALUE_ARGUMENT_LIST
-              PsiElement(LPAR)('(')
-              VALUE_ARGUMENT
-                REFERENCE_EXPRESSION
-                  PsiElement(IDENTIFIER)('it')
-              PsiElement(RPAR)(')')
-        PsiElement(RBRACE)('}')
+      FUNCTION_LITERAL_EXPRESSION
+        FUNCTION_LITERAL
+          PsiElement(LBRACE)('{')
+          BLOCK
+            CALL_EXPRESSION
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('something')
+              VALUE_ARGUMENT_LIST
+                PsiElement(LPAR)('(')
+                VALUE_ARGUMENT
+                  REFERENCE_EXPRESSION
+                    PsiElement(IDENTIFIER)('it')
+                PsiElement(RPAR)(')')
+          PsiElement(RBRACE)('}')
     PsiWhiteSpace('\n\n')
     PROPERTY
       PsiElement(val)('val')
@@ -668,13 +673,14 @@ JetFile: FunctionsAndTypes.jet
       PsiWhiteSpace(' ')
       PsiElement(EQ)('=')
       PsiWhiteSpace(' ')
-      FUNCTION_LITERAL
-        PsiElement(LBRACE)('{')
-        BODY
-          CALL_EXPRESSION
-            REFERENCE_EXPRESSION
-              PsiElement(IDENTIFIER)('X')
-            VALUE_ARGUMENT_LIST
-              PsiElement(LPAR)('(')
-              PsiElement(RPAR)(')')
-        PsiElement(RBRACE)('}')
+      FUNCTION_LITERAL_EXPRESSION
+        FUNCTION_LITERAL
+          PsiElement(LBRACE)('{')
+          BLOCK
+            CALL_EXPRESSION
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('X')
+              VALUE_ARGUMENT_LIST
+                PsiElement(LPAR)('(')
+                PsiElement(RPAR)(')')
+          PsiElement(RBRACE)('}')

idea/testData/psi/examples/Graph.txt

@@ -421,37 +421,39 @@ JetFile: Graph.jet
               CALL_EXPRESSION
                 REFERENCE_EXPRESSION
                   PsiElement(IDENTIFIER)('filter')
-                FUNCTION_LITERAL
-                  PsiElement(LBRACE)('{')
-                  BODY
-                    BINARY_EXPRESSION
-                      DOT_QUALIFIED_EXPRESSION
+                FUNCTION_LITERAL_EXPRESSION
+                  FUNCTION_LITERAL
+                    PsiElement(LBRACE)('{')
+                    BLOCK
+                      BINARY_EXPRESSION
+                        DOT_QUALIFIED_EXPRESSION
+                          REFERENCE_EXPRESSION
+                            PsiElement(IDENTIFIER)('it')
+                          PsiElement(DOT)('.')
+                          REFERENCE_EXPRESSION
+                            PsiElement(IDENTIFIER)('from')
+                        PsiWhiteSpace(' ')
+                        OPERATION_REFERENCE
+                          PsiElement(EQEQ)('==')
+                        PsiWhiteSpace(' ')
                         REFERENCE_EXPRESSION
-                          PsiElement(IDENTIFIER)('it')
-                        PsiElement(DOT)('.')
-                        REFERENCE_EXPRESSION
-                          PsiElement(IDENTIFIER)('from')
-                      PsiWhiteSpace(' ')
-                      OPERATION_REFERENCE
-                        PsiElement(EQEQ)('==')
-                      PsiWhiteSpace(' ')
-                      REFERENCE_EXPRESSION
-                        PsiElement(IDENTIFIER)('v')
-                  PsiElement(RBRACE)('}')
+                          PsiElement(IDENTIFIER)('v')
+                    PsiElement(RBRACE)('}')
             PsiElement(DOT)('.')
             CALL_EXPRESSION
               REFERENCE_EXPRESSION
                 PsiElement(IDENTIFIER)('map')
-              FUNCTION_LITERAL
-                PsiElement(LBRACE)('{')
-                BODY
-                  DOT_QUALIFIED_EXPRESSION
-                    REFERENCE_EXPRESSION
-                      PsiElement(IDENTIFIER)('it')
-                    PsiElement(DOT)('.')
-                    REFERENCE_EXPRESSION
-                      PsiElement(IDENTIFIER)('to')
-                PsiElement(RBRACE)('}')
+              FUNCTION_LITERAL_EXPRESSION
+                FUNCTION_LITERAL
+                  PsiElement(LBRACE)('{')
+                  BLOCK
+                    DOT_QUALIFIED_EXPRESSION
+                      REFERENCE_EXPRESSION
+                        PsiElement(IDENTIFIER)('it')
+                      PsiElement(DOT)('.')
+                      REFERENCE_EXPRESSION
+                        PsiElement(IDENTIFIER)('to')
+                  PsiElement(RBRACE)('}')
         PsiWhiteSpace(' ')
         PsiComment(EOL_COMMENT)('// type is IIterable<Vertex<V>>')
         PsiWhiteSpace('\n\n  ')
@@ -527,29 +529,30 @@ JetFile: Graph.jet
               CALL_EXPRESSION
                 REFERENCE_EXPRESSION
                   PsiElement(IDENTIFIER)('foreach')
-                FUNCTION_LITERAL
-                  PsiElement(LBRACE)('{')
-                  BODY
-                    CALL_EXPRESSION
-                      REFERENCE_EXPRESSION
-                        PsiElement(IDENTIFIER)('dfs')
-                      VALUE_ARGUMENT_LIST
-                        PsiElement(LPAR)('(')
-                        VALUE_ARGUMENT
-                          REFERENCE_EXPRESSION
-                            PsiElement(IDENTIFIER)('it')
-                        PsiElement(COMMA)(',')
-                        PsiWhiteSpace(' ')
-                        VALUE_ARGUMENT
-                          REFERENCE_EXPRESSION
-                            PsiElement(IDENTIFIER)('visited')
-                        PsiElement(COMMA)(',')
-                        PsiWhiteSpace(' ')
-                        VALUE_ARGUMENT
-                          REFERENCE_EXPRESSION
-                            PsiElement(IDENTIFIER)('handler')
-                        PsiElement(RPAR)(')')
-                  PsiElement(RBRACE)('}')
+                FUNCTION_LITERAL_EXPRESSION
+                  FUNCTION_LITERAL
+                    PsiElement(LBRACE)('{')
+                    BLOCK
+                      CALL_EXPRESSION
+                        REFERENCE_EXPRESSION
+                          PsiElement(IDENTIFIER)('dfs')
+                        VALUE_ARGUMENT_LIST
+                          PsiElement(LPAR)('(')
+                          VALUE_ARGUMENT
+                            REFERENCE_EXPRESSION
+                              PsiElement(IDENTIFIER)('it')
+                          PsiElement(COMMA)(',')
+                          PsiWhiteSpace(' ')
+                          VALUE_ARGUMENT
+                            REFERENCE_EXPRESSION
+                              PsiElement(IDENTIFIER)('visited')
+                          PsiElement(COMMA)(',')
+                          PsiWhiteSpace(' ')
+                          VALUE_ARGUMENT
+                            REFERENCE_EXPRESSION
+                              PsiElement(IDENTIFIER)('handler')
+                          PsiElement(RPAR)(')')
+                    PsiElement(RBRACE)('}')
             PsiWhiteSpace('\n\n    ')
             FUN
               PsiElement(fun)('fun')
@@ -683,29 +686,30 @@ JetFile: Graph.jet
                   CALL_EXPRESSION
                     REFERENCE_EXPRESSION
                       PsiElement(IDENTIFIER)('foreach')
-                    FUNCTION_LITERAL
-                      PsiElement(LBRACE)('{')
-                      BODY
-                        CALL_EXPRESSION
-                          REFERENCE_EXPRESSION
-                            PsiElement(IDENTIFIER)('dfs')
-                          VALUE_ARGUMENT_LIST
-                            PsiElement(LPAR)('(')
-                            VALUE_ARGUMENT
-                              REFERENCE_EXPRESSION
-                                PsiElement(IDENTIFIER)('it')
-                            PsiElement(COMMA)(',')
-                            PsiWhiteSpace(' ')
-                            VALUE_ARGUMENT
-                              REFERENCE_EXPRESSION
-                                PsiElement(IDENTIFIER)('visited')
-                            PsiElement(COMMA)(',')
-                            PsiWhiteSpace(' ')
-                            VALUE_ARGUMENT
-                              REFERENCE_EXPRESSION
-                                PsiElement(IDENTIFIER)('handler')
-                            PsiElement(RPAR)(')')
-                      PsiElement(RBRACE)('}')
+                    FUNCTION_LITERAL_EXPRESSION
+                      FUNCTION_LITERAL
+                        PsiElement(LBRACE)('{')
+                        BLOCK
+                          CALL_EXPRESSION
+                            REFERENCE_EXPRESSION
+                              PsiElement(IDENTIFIER)('dfs')
+                            VALUE_ARGUMENT_LIST
+                              PsiElement(LPAR)('(')
+                              VALUE_ARGUMENT
+                                REFERENCE_EXPRESSION
+                                  PsiElement(IDENTIFIER)('it')
+                              PsiElement(COMMA)(',')
+                              PsiWhiteSpace(' ')
+                              VALUE_ARGUMENT
+                                REFERENCE_EXPRESSION
+                                  PsiElement(IDENTIFIER)('visited')
+                              PsiElement(COMMA)(',')
+                              PsiWhiteSpace(' ')
+                              VALUE_ARGUMENT
+                                REFERENCE_EXPRESSION
+                                  PsiElement(IDENTIFIER)('handler')
+                              PsiElement(RPAR)(')')
+                        PsiElement(RBRACE)('}')
                 PsiWhiteSpace('\n    ')
                 PsiElement(RBRACE)('}')
             PsiWhiteSpace('\n  ')
@@ -811,174 +815,178 @@ JetFile: Graph.jet
                 REFERENCE_EXPRESSION
                   PsiElement(IDENTIFIER)('foreach')
                 PsiWhiteSpace(' ')
-                FUNCTION_LITERAL
-                  PsiElement(LBRACE)('{')
-                  PsiWhiteSpace('\n      ')
-                  BODY
-                    IF
-                      PsiElement(if)('if')
-                      PsiWhiteSpace(' ')
-                      PsiElement(LPAR)('(')
-                      CONDITION
-                        PREFIX_EXPRESSION
-                          OPERATION_REFERENCE
-                            PsiElement(EXCL)('!')
-                          DOT_QUALIFIED_EXPRESSION
-                            REFERENCE_EXPRESSION
-                              PsiElement(IDENTIFIER)('visited')
-                            PsiElement(DOT)('.')
-                            CALL_EXPRESSION
-                              REFERENCE_EXPRESSION
-                                PsiElement(IDENTIFIER)('add')
-                              VALUE_ARGUMENT_LIST
-                                PsiElement(LPAR)('(')
-                                VALUE_ARGUMENT
-                                  REFERENCE_EXPRESSION
-                                    PsiElement(IDENTIFIER)('it')
-                                PsiElement(RPAR)(')')
-                      PsiElement(RPAR)(')')
-                      PsiWhiteSpace('\n        ')
-                      THEN
-                        CONTINUE
-                          PsiElement(continue)('continue')
+                FUNCTION_LITERAL_EXPRESSION
+                  FUNCTION_LITERAL
+                    PsiElement(LBRACE)('{')
                     PsiWhiteSpace('\n      ')
-                    DOT_QUALIFIED_EXPRESSION
-                      REFERENCE_EXPRESSION
-                        PsiElement(IDENTIFIER)('pending')
-                      PsiElement(DOT)('.')
-                      CALL_EXPRESSION
-                        REFERENCE_EXPRESSION
-                          PsiElement(IDENTIFIER)('push')
-                        VALUE_ARGUMENT_LIST
-                          PsiElement(LPAR)('(')
-                          VALUE_ARGUMENT
-                            REFERENCE_EXPRESSION
-                              PsiElement(IDENTIFIER)('it')
-                          PsiElement(RPAR)(')')
-                    PsiWhiteSpace('\n      ')
-                    WHILE
-                      PsiElement(while)('while')
-                      PsiWhiteSpace(' ')
-                      PsiElement(LPAR)('(')
-                      CONDITION
-                        PREFIX_EXPRESSION
-                          OPERATION_REFERENCE
-                            PsiElement(EXCL)('!')
-                          DOT_QUALIFIED_EXPRESSION
-                            REFERENCE_EXPRESSION
-                              PsiElement(IDENTIFIER)('pending')
-                            PsiElement(DOT)('.')
-                            REFERENCE_EXPRESSION
-                              PsiElement(IDENTIFIER)('isEmpty')
-                      PsiElement(RPAR)(')')
-                      PsiWhiteSpace(' ')
-                      BODY
-                        FUNCTION_LITERAL
-                          PsiElement(LBRACE)('{')
-                          PsiWhiteSpace('\n        ')
-                          BODY
-                            PROPERTY
-                              PsiElement(val)('val')
-                              PsiWhiteSpace(' ')
-                              PsiElement(IDENTIFIER)('current')
-                              PsiWhiteSpace(' ')
-                              PsiElement(EQ)('=')
-                              PsiWhiteSpace(' ')
-                              DOT_QUALIFIED_EXPRESSION
-                                REFERENCE_EXPRESSION
-                                  PsiElement(IDENTIFIER)('pending')
-                                PsiElement(DOT)('.')
-                                CALL_EXPRESSION
-                                  REFERENCE_EXPRESSION
-                                    PsiElement(IDENTIFIER)('pop')
-                                  VALUE_ARGUMENT_LIST
-                                    PsiElement(LPAR)('(')
-                                    PsiElement(RPAR)(')')
-                            PsiWhiteSpace('\n        ')
-                            CALL_EXPRESSION
-                              REFERENCE_EXPRESSION
-                                PsiElement(IDENTIFIER)('handler')
-                              VALUE_ARGUMENT_LIST
-                                PsiElement(LPAR)('(')
-                                VALUE_ARGUMENT
-                                  REFERENCE_EXPRESSION
-                                    PsiElement(IDENTIFIER)('current')
-                                PsiElement(RPAR)(')')
-                            PsiElement(SEMICOLON)(';')
-                            PsiWhiteSpace('\n        ')
+                    BLOCK
+                      IF
+                        PsiElement(if)('if')
+                        PsiWhiteSpace(' ')
+                        PsiElement(LPAR)('(')
+                        CONDITION
+                          PREFIX_EXPRESSION
+                            OPERATION_REFERENCE
+                              PsiElement(EXCL)('!')
                             DOT_QUALIFIED_EXPRESSION
+                              REFERENCE_EXPRESSION
+                                PsiElement(IDENTIFIER)('visited')
+                              PsiElement(DOT)('.')
                               CALL_EXPRESSION
                                 REFERENCE_EXPRESSION
-                                  PsiElement(IDENTIFIER)('neighbours')
+                                  PsiElement(IDENTIFIER)('add')
                                 VALUE_ARGUMENT_LIST
                                   PsiElement(LPAR)('(')
                                   VALUE_ARGUMENT
                                     REFERENCE_EXPRESSION
-                                      PsiElement(IDENTIFIER)('current')
+                                      PsiElement(IDENTIFIER)('it')
                                   PsiElement(RPAR)(')')
+                        PsiElement(RPAR)(')')
+                        PsiWhiteSpace('\n        ')
+                        THEN
+                          CONTINUE
+                            PsiElement(continue)('continue')
+                      PsiWhiteSpace('\n      ')
+                      DOT_QUALIFIED_EXPRESSION
+                        REFERENCE_EXPRESSION
+                          PsiElement(IDENTIFIER)('pending')
+                        PsiElement(DOT)('.')
+                        CALL_EXPRESSION
+                          REFERENCE_EXPRESSION
+                            PsiElement(IDENTIFIER)('push')
+                          VALUE_ARGUMENT_LIST
+                            PsiElement(LPAR)('(')
+                            VALUE_ARGUMENT
+                              REFERENCE_EXPRESSION
+                                PsiElement(IDENTIFIER)('it')
+                            PsiElement(RPAR)(')')
+                      PsiWhiteSpace('\n      ')
+                      WHILE
+                        PsiElement(while)('while')
+                        PsiWhiteSpace(' ')
+                        PsiElement(LPAR)('(')
+                        CONDITION
+                          PREFIX_EXPRESSION
+                            OPERATION_REFERENCE
+                              PsiElement(EXCL)('!')
+                            DOT_QUALIFIED_EXPRESSION
+                              REFERENCE_EXPRESSION
+                                PsiElement(IDENTIFIER)('pending')
                               PsiElement(DOT)('.')
-                              CALL_EXPRESSION
-                                REFERENCE_EXPRESSION
-                                  PsiElement(IDENTIFIER)('foreach')
-                                PsiWhiteSpace(' ')
-                                FUNCTION_LITERAL
-                                  PsiElement(LBRACE)('{')
+                              REFERENCE_EXPRESSION
+                                PsiElement(IDENTIFIER)('isEmpty')
+                        PsiElement(RPAR)(')')
+                        PsiWhiteSpace(' ')
+                        BODY
+                          FUNCTION_LITERAL_EXPRESSION
+                            FUNCTION_LITERAL
+                              PsiElement(LBRACE)('{')
+                              PsiWhiteSpace('\n        ')
+                              BLOCK
+                                PROPERTY
+                                  PsiElement(val)('val')
                                   PsiWhiteSpace(' ')
-                                  VALUE_PARAMETER_LIST
-                                    VALUE_PARAMETER
-                                      PsiElement(IDENTIFIER)('n')
+                                  PsiElement(IDENTIFIER)('current')
                                   PsiWhiteSpace(' ')
-                                  PsiElement(DOUBLE_ARROW)('=>')
-                                  PsiWhiteSpace('\n          ')
-                                  BODY
-                                    IF
-                                      PsiElement(if)('if')
-                                      PsiWhiteSpace(' ')
+                                  PsiElement(EQ)('=')
+                                  PsiWhiteSpace(' ')
+                                  DOT_QUALIFIED_EXPRESSION
+                                    REFERENCE_EXPRESSION
+                                      PsiElement(IDENTIFIER)('pending')
+                                    PsiElement(DOT)('.')
+                                    CALL_EXPRESSION
+                                      REFERENCE_EXPRESSION
+                                        PsiElement(IDENTIFIER)('pop')
+                                      VALUE_ARGUMENT_LIST
+                                        PsiElement(LPAR)('(')
+                                        PsiElement(RPAR)(')')
+                                PsiWhiteSpace('\n        ')
+                                CALL_EXPRESSION
+                                  REFERENCE_EXPRESSION
+                                    PsiElement(IDENTIFIER)('handler')
+                                  VALUE_ARGUMENT_LIST
+                                    PsiElement(LPAR)('(')
+                                    VALUE_ARGUMENT
+                                      REFERENCE_EXPRESSION
+                                        PsiElement(IDENTIFIER)('current')
+                                    PsiElement(RPAR)(')')
+                                PsiElement(SEMICOLON)(';')
+                                PsiWhiteSpace('\n        ')
+                                DOT_QUALIFIED_EXPRESSION
+                                  CALL_EXPRESSION
+                                    REFERENCE_EXPRESSION
+                                      PsiElement(IDENTIFIER)('neighbours')
+                                    VALUE_ARGUMENT_LIST
                                       PsiElement(LPAR)('(')
-                                      CONDITION
-                                        DOT_QUALIFIED_EXPRESSION
-                                          REFERENCE_EXPRESSION
-                                            PsiElement(IDENTIFIER)('visited')
-                                          PsiElement(DOT)('.')
-                                          CALL_EXPRESSION
-                                            REFERENCE_EXPRESSION
-                                              PsiElement(IDENTIFIER)('add')
-                                            VALUE_ARGUMENT_LIST
-                                              PsiElement(LPAR)('(')
-                                              VALUE_ARGUMENT
-                                                REFERENCE_EXPRESSION
-                                                  PsiElement(IDENTIFIER)('n')
-                                              PsiElement(RPAR)(')')
+                                      VALUE_ARGUMENT
+                                        REFERENCE_EXPRESSION
+                                          PsiElement(IDENTIFIER)('current')
                                       PsiElement(RPAR)(')')
-                                      PsiWhiteSpace(' ')
-                                      THEN
-                                        FUNCTION_LITERAL
-                                          PsiElement(LBRACE)('{')
-                                          PsiWhiteSpace('\n            ')
-                                          BODY
-                                            DOT_QUALIFIED_EXPRESSION
-                                              REFERENCE_EXPRESSION
-                                                PsiElement(IDENTIFIER)('pending')
-                                              PsiElement(DOT)('.')
-                                              CALL_EXPRESSION
+                                  PsiElement(DOT)('.')
+                                  CALL_EXPRESSION
+                                    REFERENCE_EXPRESSION
+                                      PsiElement(IDENTIFIER)('foreach')
+                                    PsiWhiteSpace(' ')
+                                    FUNCTION_LITERAL_EXPRESSION
+                                      FUNCTION_LITERAL
+                                        PsiElement(LBRACE)('{')
+                                        PsiWhiteSpace(' ')
+                                        VALUE_PARAMETER_LIST
+                                          VALUE_PARAMETER
+                                            PsiElement(IDENTIFIER)('n')
+                                        PsiWhiteSpace(' ')
+                                        PsiElement(DOUBLE_ARROW)('=>')
+                                        PsiWhiteSpace('\n          ')
+                                        BLOCK
+                                          IF
+                                            PsiElement(if)('if')
+                                            PsiWhiteSpace(' ')
+                                            PsiElement(LPAR)('(')
+                                            CONDITION
+                                              DOT_QUALIFIED_EXPRESSION
                                                 REFERENCE_EXPRESSION
-                                                  PsiElement(IDENTIFIER)('push')
-                                                VALUE_ARGUMENT_LIST
-                                                  PsiElement(LPAR)('(')
-                                                  VALUE_ARGUMENT
-                                                    REFERENCE_EXPRESSION
-                                                      PsiElement(IDENTIFIER)('n')
-                                                  PsiElement(RPAR)(')')
-                                          PsiWhiteSpace('\n          ')
-                                          PsiElement(RBRACE)('}')
-                                  PsiWhiteSpace('\n        ')
-                                  PsiElement(RBRACE)('}')
-                          PsiWhiteSpace('\n    ')
-                          PsiComment(BLOCK_COMMENT)('/* alternative\n        pending->push(neighbours(current).filter{n => !visited[n])})\n        // -> means that if push(x : T) and actual parameter y is IIterable<T>, this compiles into\n          y.foreach{ n => push(n) }\n     */')
-                          PsiWhiteSpace('\n      ')
-                          PsiElement(RBRACE)('}')
-                  PsiWhiteSpace('\n    ')
-                  PsiElement(RBRACE)('}')
+                                                  PsiElement(IDENTIFIER)('visited')
+                                                PsiElement(DOT)('.')
+                                                CALL_EXPRESSION
+                                                  REFERENCE_EXPRESSION
+                                                    PsiElement(IDENTIFIER)('add')
+                                                  VALUE_ARGUMENT_LIST
+                                                    PsiElement(LPAR)('(')
+                                                    VALUE_ARGUMENT
+                                                      REFERENCE_EXPRESSION
+                                                        PsiElement(IDENTIFIER)('n')
+                                                    PsiElement(RPAR)(')')
+                                            PsiElement(RPAR)(')')
+                                            PsiWhiteSpace(' ')
+                                            THEN
+                                              FUNCTION_LITERAL_EXPRESSION
+                                                FUNCTION_LITERAL
+                                                  PsiElement(LBRACE)('{')
+                                                  PsiWhiteSpace('\n            ')
+                                                  BLOCK
+                                                    DOT_QUALIFIED_EXPRESSION
+                                                      REFERENCE_EXPRESSION
+                                                        PsiElement(IDENTIFIER)('pending')
+                                                      PsiElement(DOT)('.')
+                                                      CALL_EXPRESSION
+                                                        REFERENCE_EXPRESSION
+                                                          PsiElement(IDENTIFIER)('push')
+                                                        VALUE_ARGUMENT_LIST
+                                                          PsiElement(LPAR)('(')
+                                                          VALUE_ARGUMENT
+                                                            REFERENCE_EXPRESSION
+                                                              PsiElement(IDENTIFIER)('n')
+                                                          PsiElement(RPAR)(')')
+                                                  PsiWhiteSpace('\n          ')
+                                                  PsiElement(RBRACE)('}')
+                                        PsiWhiteSpace('\n        ')
+                                        PsiElement(RBRACE)('}')
+                              PsiWhiteSpace('\n    ')
+                              PsiComment(BLOCK_COMMENT)('/* alternative\n        pending->push(neighbours(current).filter{n => !visited[n])})\n        // -> means that if push(x : T) and actual parameter y is IIterable<T>, this compiles into\n          y.foreach{ n => push(n) }\n     */')
+                              PsiWhiteSpace('\n      ')
+                              PsiElement(RBRACE)('}')
+                    PsiWhiteSpace('\n    ')
+                    PsiElement(RBRACE)('}')
             PsiWhiteSpace('\n  ')
             PsiElement(RBRACE)('}')
         PsiWhiteSpace('\n')

idea/testData/psi/examples/LINQ.txt

@@ -20,58 +20,61 @@ JetFile: LINQ.jet
               OPERATION_REFERENCE
                 PsiElement(IDENTIFIER)('filter')
               PsiWhiteSpace(' ')
+              FUNCTION_LITERAL_EXPRESSION
+                FUNCTION_LITERAL
+                  PsiElement(LBRACE)('{')
+                  BLOCK
+                    DOT_QUALIFIED_EXPRESSION
+                      REFERENCE_EXPRESSION
+                        PsiElement(IDENTIFIER)('it')
+                      PsiElement(DOT)('.')
+                      REFERENCE_EXPRESSION
+                        PsiElement(IDENTIFIER)('x')
+                  PsiElement(RBRACE)('}')
+            PsiWhiteSpace(' ')
+            OPERATION_REFERENCE
+              PsiElement(IDENTIFIER)('map')
+            PsiWhiteSpace(' ')
+            FUNCTION_LITERAL_EXPRESSION
               FUNCTION_LITERAL
                 PsiElement(LBRACE)('{')
-                BODY
+                BLOCK
                   DOT_QUALIFIED_EXPRESSION
                     REFERENCE_EXPRESSION
                       PsiElement(IDENTIFIER)('it')
                     PsiElement(DOT)('.')
                     REFERENCE_EXPRESSION
-                      PsiElement(IDENTIFIER)('x')
+                      PsiElement(IDENTIFIER)('foo')
                 PsiElement(RBRACE)('}')
-            PsiWhiteSpace(' ')
-            OPERATION_REFERENCE
-              PsiElement(IDENTIFIER)('map')
-            PsiWhiteSpace(' ')
-            FUNCTION_LITERAL
-              PsiElement(LBRACE)('{')
-              BODY
-                DOT_QUALIFIED_EXPRESSION
-                  REFERENCE_EXPRESSION
-                    PsiElement(IDENTIFIER)('it')
-                  PsiElement(DOT)('.')
-                  REFERENCE_EXPRESSION
-                    PsiElement(IDENTIFIER)('foo')
-              PsiElement(RBRACE)('}')
           PsiWhiteSpace(' ')
           OPERATION_REFERENCE
             PsiElement(IDENTIFIER)('aggregate')
           PsiWhiteSpace(' ')
-          FUNCTION_LITERAL
-            PsiElement(LBRACE)('{')
-            VALUE_PARAMETER_LIST
-              PsiElement(LPAR)('(')
-              VALUE_PARAMETER
-                PsiElement(IDENTIFIER)('a')
-              PsiElement(COMMA)(',')
-              PsiWhiteSpace(' ')
-              VALUE_PARAMETER
-                PsiElement(IDENTIFIER)('b')
-              PsiElement(RPAR)(')')
-            PsiWhiteSpace(' ')
-            PsiElement(DOUBLE_ARROW)('=>')
-            PsiWhiteSpace(' ')
-            BODY
-              BINARY_EXPRESSION
-                REFERENCE_EXPRESSION
+          FUNCTION_LITERAL_EXPRESSION
+            FUNCTION_LITERAL
+              PsiElement(LBRACE)('{')
+              VALUE_PARAMETER_LIST
+                PsiElement(LPAR)('(')
+                VALUE_PARAMETER
                   PsiElement(IDENTIFIER)('a')
+                PsiElement(COMMA)(',')
                 PsiWhiteSpace(' ')
-                OPERATION_REFERENCE
-                  PsiElement(PLUS)('+')
-                PsiWhiteSpace(' ')
-                REFERENCE_EXPRESSION
+                VALUE_PARAMETER
                   PsiElement(IDENTIFIER)('b')
-            PsiElement(RBRACE)('}')
+                PsiElement(RPAR)(')')
+              PsiWhiteSpace(' ')
+              PsiElement(DOUBLE_ARROW)('=>')
+              PsiWhiteSpace(' ')
+              BLOCK
+                BINARY_EXPRESSION
+                  REFERENCE_EXPRESSION
+                    PsiElement(IDENTIFIER)('a')
+                  PsiWhiteSpace(' ')
+                  OPERATION_REFERENCE
+                    PsiElement(PLUS)('+')
+                  PsiWhiteSpace(' ')
+                  REFERENCE_EXPRESSION
+                    PsiElement(IDENTIFIER)('b')
+              PsiElement(RBRACE)('}')
         PsiWhiteSpace('\n')
         PsiElement(RBRACE)('}')

idea/testData/psi/examples/PolymorphicClassObjects.txt

@@ -326,78 +326,80 @@ JetFile: PolymorphicClassObjects.jet
           PsiWhiteSpace(' ')
           PsiElement(EQ)('=')
           PsiWhiteSpace(' ')
-          FUNCTION_LITERAL
-            PsiElement(LBRACE)('{')
-            PsiWhiteSpace('\n    ')
-            BODY
-              PROPERTY
-                PsiElement(val)('val')
-                PsiWhiteSpace(' ')
-                PsiElement(IDENTIFIER)('builder')
-                PsiWhiteSpace(' ')
-                PsiElement(EQ)('=')
-                PsiWhiteSpace(' ')
+          FUNCTION_LITERAL_EXPRESSION
+            FUNCTION_LITERAL
+              PsiElement(LBRACE)('{')
+              PsiWhiteSpace('\n    ')
+              BLOCK
+                PROPERTY
+                  PsiElement(val)('val')
+                  PsiWhiteSpace(' ')
+                  PsiElement(IDENTIFIER)('builder')
+                  PsiWhiteSpace(' ')
+                  PsiElement(EQ)('=')
+                  PsiWhiteSpace(' ')
+                  DOT_QUALIFIED_EXPRESSION
+                    REFERENCE_EXPRESSION
+                      PsiElement(IDENTIFIER)('T')
+                    PsiElement(DOT)('.')
+                    CALL_EXPRESSION
+                      REFERENCE_EXPRESSION
+                        PsiElement(IDENTIFIER)('newBuilder')
+                      VALUE_ARGUMENT_LIST
+                        PsiElement(LPAR)('(')
+                        PsiElement(RPAR)(')')
+                PsiWhiteSpace('\n    ')
+                FOR
+                  PsiElement(for)('for')
+                  PsiWhiteSpace(' ')
+                  PsiElement(LPAR)('(')
+                  LOOP_PARAMETER
+                    PsiElement(IDENTIFIER)('e')
+                  PsiWhiteSpace(' ')
+                  PsiElement(in)('in')
+                  PsiWhiteSpace(' ')
+                  LOOP_RANGE
+                    THIS_EXPRESSION
+                      REFERENCE_EXPRESSION
+                        PsiElement(this)('this')
+                  PsiElement(RPAR)(')')
+                  PsiWhiteSpace(' ')
+                  BODY
+                    FUNCTION_LITERAL_EXPRESSION
+                      FUNCTION_LITERAL
+                        PsiElement(LBRACE)('{')
+                        PsiWhiteSpace('\n      ')
+                        BLOCK
+                          BINARY_EXPRESSION
+                            REFERENCE_EXPRESSION
+                              PsiElement(IDENTIFIER)('builder')
+                            PsiWhiteSpace(' ')
+                            OPERATION_REFERENCE
+                              PsiElement(PLUSEQ)('+=')
+                            PsiWhiteSpace(' ')
+                            CALL_EXPRESSION
+                              REFERENCE_EXPRESSION
+                                PsiElement(IDENTIFIER)('f')
+                              VALUE_ARGUMENT_LIST
+                                PsiElement(LPAR)('(')
+                                VALUE_ARGUMENT
+                                  REFERENCE_EXPRESSION
+                                    PsiElement(IDENTIFIER)('e')
+                                PsiElement(RPAR)(')')
+                        PsiWhiteSpace('\n    ')
+                        PsiElement(RBRACE)('}')
+                PsiWhiteSpace('\n    ')
                 DOT_QUALIFIED_EXPRESSION
                   REFERENCE_EXPRESSION
-                    PsiElement(IDENTIFIER)('T')
+                    PsiElement(IDENTIFIER)('builder')
                   PsiElement(DOT)('.')
                   CALL_EXPRESSION
                     REFERENCE_EXPRESSION
-                      PsiElement(IDENTIFIER)('newBuilder')
+                      PsiElement(IDENTIFIER)('result')
                     VALUE_ARGUMENT_LIST
                       PsiElement(LPAR)('(')
                       PsiElement(RPAR)(')')
-              PsiWhiteSpace('\n    ')
-              FOR
-                PsiElement(for)('for')
-                PsiWhiteSpace(' ')
-                PsiElement(LPAR)('(')
-                LOOP_PARAMETER
-                  PsiElement(IDENTIFIER)('e')
-                PsiWhiteSpace(' ')
-                PsiElement(in)('in')
-                PsiWhiteSpace(' ')
-                LOOP_RANGE
-                  THIS_EXPRESSION
-                    REFERENCE_EXPRESSION
-                      PsiElement(this)('this')
-                PsiElement(RPAR)(')')
-                PsiWhiteSpace(' ')
-                BODY
-                  FUNCTION_LITERAL
-                    PsiElement(LBRACE)('{')
-                    PsiWhiteSpace('\n      ')
-                    BODY
-                      BINARY_EXPRESSION
-                        REFERENCE_EXPRESSION
-                          PsiElement(IDENTIFIER)('builder')
-                        PsiWhiteSpace(' ')
-                        OPERATION_REFERENCE
-                          PsiElement(PLUSEQ)('+=')
-                        PsiWhiteSpace(' ')
-                        CALL_EXPRESSION
-                          REFERENCE_EXPRESSION
-                            PsiElement(IDENTIFIER)('f')
-                          VALUE_ARGUMENT_LIST
-                            PsiElement(LPAR)('(')
-                            VALUE_ARGUMENT
-                              REFERENCE_EXPRESSION
-                                PsiElement(IDENTIFIER)('e')
-                            PsiElement(RPAR)(')')
-                    PsiWhiteSpace('\n    ')
-                    PsiElement(RBRACE)('}')
-              PsiWhiteSpace('\n    ')
-              DOT_QUALIFIED_EXPRESSION
-                REFERENCE_EXPRESSION
-                  PsiElement(IDENTIFIER)('builder')
-                PsiElement(DOT)('.')
-                CALL_EXPRESSION
-                  REFERENCE_EXPRESSION
-                    PsiElement(IDENTIFIER)('result')
-                  VALUE_ARGUMENT_LIST
-                    PsiElement(LPAR)('(')
-                    PsiElement(RPAR)(')')
-            PsiWhiteSpace('\n  ')
-            PsiElement(RBRACE)('}')
+              PsiWhiteSpace('\n  ')
+              PsiElement(RBRACE)('}')
         PsiWhiteSpace('\n')
         PsiElement(RBRACE)('}')

idea/testData/psi/examples/Queue.txt

@@ -191,64 +191,66 @@ JetFile: Queue.jet
               PsiElement(RPAR)(')')
               PsiWhiteSpace(' ')
               THEN
-                FUNCTION_LITERAL
-                  PsiElement(LBRACE)('{')
-                  PsiWhiteSpace('\n      ')
-                  BODY
-                    BINARY_EXPRESSION
-                      REFERENCE_EXPRESSION
-                        PsiElement(IDENTIFIER)('head')
-                      PsiWhiteSpace(' ')
-                      OPERATION_REFERENCE
-                        PsiElement(EQ)('=')
-                      PsiWhiteSpace(' ')
-                      REFERENCE_EXPRESSION
-                        PsiElement(IDENTIFIER)('i')
+                FUNCTION_LITERAL_EXPRESSION
+                  FUNCTION_LITERAL
+                    PsiElement(LBRACE)('{')
                     PsiWhiteSpace('\n      ')
-                    BINARY_EXPRESSION
-                      REFERENCE_EXPRESSION
-                        PsiElement(IDENTIFIER)('tail')
-                      PsiWhiteSpace(' ')
-                      OPERATION_REFERENCE
-                        PsiElement(EQ)('=')
-                      PsiWhiteSpace(' ')
-                      REFERENCE_EXPRESSION
-                        PsiElement(IDENTIFIER)('head')
-                  PsiWhiteSpace('\n    ')
-                  PsiElement(RBRACE)('}')
+                    BLOCK
+                      BINARY_EXPRESSION
+                        REFERENCE_EXPRESSION
+                          PsiElement(IDENTIFIER)('head')
+                        PsiWhiteSpace(' ')
+                        OPERATION_REFERENCE
+                          PsiElement(EQ)('=')
+                        PsiWhiteSpace(' ')
+                        REFERENCE_EXPRESSION
+                          PsiElement(IDENTIFIER)('i')
+                      PsiWhiteSpace('\n      ')
+                      BINARY_EXPRESSION
+                        REFERENCE_EXPRESSION
+                          PsiElement(IDENTIFIER)('tail')
+                        PsiWhiteSpace(' ')
+                        OPERATION_REFERENCE
+                          PsiElement(EQ)('=')
+                        PsiWhiteSpace(' ')
+                        REFERENCE_EXPRESSION
+                          PsiElement(IDENTIFIER)('head')
+                    PsiWhiteSpace('\n    ')
+                    PsiElement(RBRACE)('}')
               PsiWhiteSpace(' ')
               PsiElement(else)('else')
               PsiWhiteSpace(' ')
               ELSE
-                FUNCTION_LITERAL
-                  PsiElement(LBRACE)('{')
-                  PsiWhiteSpace('\n      ')
-                  BODY
-                    BINARY_EXPRESSION
-                      DOT_QUALIFIED_EXPRESSION
+                FUNCTION_LITERAL_EXPRESSION
+                  FUNCTION_LITERAL
+                    PsiElement(LBRACE)('{')
+                    PsiWhiteSpace('\n      ')
+                    BLOCK
+                      BINARY_EXPRESSION
+                        DOT_QUALIFIED_EXPRESSION
+                          REFERENCE_EXPRESSION
+                            PsiElement(IDENTIFIER)('tail')
+                          PsiElement(DOT)('.')
+                          REFERENCE_EXPRESSION
+                            PsiElement(IDENTIFIER)('next')
+                        PsiWhiteSpace(' ')
+                        OPERATION_REFERENCE
+                          PsiElement(EQ)('=')
+                        PsiWhiteSpace(' ')
+                        REFERENCE_EXPRESSION
+                          PsiElement(IDENTIFIER)('i')
+                      PsiWhiteSpace('\n      ')
+                      BINARY_EXPRESSION
                         REFERENCE_EXPRESSION
                           PsiElement(IDENTIFIER)('tail')
-                        PsiElement(DOT)('.')
+                        PsiWhiteSpace(' ')
+                        OPERATION_REFERENCE
+                          PsiElement(EQ)('=')
+                        PsiWhiteSpace(' ')
                         REFERENCE_EXPRESSION
-                          PsiElement(IDENTIFIER)('next')
-                      PsiWhiteSpace(' ')
-                      OPERATION_REFERENCE
-                        PsiElement(EQ)('=')
-                      PsiWhiteSpace(' ')
-                      REFERENCE_EXPRESSION
-                        PsiElement(IDENTIFIER)('i')
-                    PsiWhiteSpace('\n      ')
-                    BINARY_EXPRESSION
-                      REFERENCE_EXPRESSION
-                        PsiElement(IDENTIFIER)('tail')
-                      PsiWhiteSpace(' ')
-                      OPERATION_REFERENCE
-                        PsiElement(EQ)('=')
-                      PsiWhiteSpace(' ')
-                      REFERENCE_EXPRESSION
-                        PsiElement(IDENTIFIER)('i')
-                  PsiWhiteSpace('\n    ')
-                  PsiElement(RBRACE)('}')
+                          PsiElement(IDENTIFIER)('i')
+                    PsiWhiteSpace('\n    ')
+                    PsiElement(RBRACE)('}')
             PsiWhiteSpace('\n  ')
             PsiElement(RBRACE)('}')
         PsiWhiteSpace('\n\n  ')
@@ -295,69 +297,70 @@ JetFile: Queue.jet
             PsiElement(else)('else')
             PsiWhiteSpace(' ')
             ELSE
-              FUNCTION_LITERAL
-                PsiElement(LBRACE)('{')
-                PsiWhiteSpace('\n      ')
-                BODY
-                  PROPERTY
-                    PsiElement(val)('val')
-                    PsiWhiteSpace(' ')
-                    PsiElement(IDENTIFIER)('result')
-                    PsiWhiteSpace(' ')
-                    PsiElement(EQ)('=')
-                    PsiWhiteSpace(' ')
-                    DOT_QUALIFIED_EXPRESSION
-                      REFERENCE_EXPRESSION
-                        PsiElement(IDENTIFIER)('head')
-                      PsiElement(DOT)('.')
-                      REFERENCE_EXPRESSION
-                        PsiElement(IDENTIFIER)('data')
+              FUNCTION_LITERAL_EXPRESSION
+                FUNCTION_LITERAL
+                  PsiElement(LBRACE)('{')
                   PsiWhiteSpace('\n      ')
-                  BINARY_EXPRESSION
-                    REFERENCE_EXPRESSION
-                      PsiElement(IDENTIFIER)('head')
-                    PsiWhiteSpace(' ')
-                    OPERATION_REFERENCE
+                  BLOCK
+                    PROPERTY
+                      PsiElement(val)('val')
+                      PsiWhiteSpace(' ')
+                      PsiElement(IDENTIFIER)('result')
+                      PsiWhiteSpace(' ')
                       PsiElement(EQ)('=')
-                    PsiWhiteSpace(' ')
-                    DOT_QUALIFIED_EXPRESSION
-                      REFERENCE_EXPRESSION
-                        PsiElement(IDENTIFIER)('head')
-                      PsiElement(DOT)('.')
-                      REFERENCE_EXPRESSION
-                        PsiElement(IDENTIFIER)('next')
-                  PsiWhiteSpace('\n      ')
-                  IF
-                    PsiElement(if)('if')
-                    PsiWhiteSpace(' ')
-                    PsiElement(LPAR)('(')
-                    CONDITION
-                      BINARY_EXPRESSION
+                      PsiWhiteSpace(' ')
+                      DOT_QUALIFIED_EXPRESSION
                         REFERENCE_EXPRESSION
                           PsiElement(IDENTIFIER)('head')
-                        PsiWhiteSpace(' ')
-                        OPERATION_REFERENCE
-                          PsiElement(EQEQ)('==')
-                        PsiWhiteSpace(' ')
-                        NULL
-                          PsiElement(null)('null')
-                    PsiElement(RPAR)(')')
-                    PsiWhiteSpace('\n        ')
-                    THEN
-                      BINARY_EXPRESSION
+                        PsiElement(DOT)('.')
                         REFERENCE_EXPRESSION
-                          PsiElement(IDENTIFIER)('tail')
-                        PsiWhiteSpace(' ')
-                        OPERATION_REFERENCE
-                          PsiElement(EQ)('=')
-                        PsiWhiteSpace(' ')
-                        NULL
-                          PsiElement(null)('null')
-                  PsiWhiteSpace('\n      ')
-                  REFERENCE_EXPRESSION
-                    PsiElement(IDENTIFIER)('result')
-                PsiWhiteSpace('\n    ')
-                PsiElement(RBRACE)('}')
+                          PsiElement(IDENTIFIER)('data')
+                    PsiWhiteSpace('\n      ')
+                    BINARY_EXPRESSION
+                      REFERENCE_EXPRESSION
+                        PsiElement(IDENTIFIER)('head')
+                      PsiWhiteSpace(' ')
+                      OPERATION_REFERENCE
+                        PsiElement(EQ)('=')
+                      PsiWhiteSpace(' ')
+                      DOT_QUALIFIED_EXPRESSION
+                        REFERENCE_EXPRESSION
+                          PsiElement(IDENTIFIER)('head')
+                        PsiElement(DOT)('.')
+                        REFERENCE_EXPRESSION
+                          PsiElement(IDENTIFIER)('next')
+                    PsiWhiteSpace('\n      ')
+                    IF
+                      PsiElement(if)('if')
+                      PsiWhiteSpace(' ')
+                      PsiElement(LPAR)('(')
+                      CONDITION
+                        BINARY_EXPRESSION
+                          REFERENCE_EXPRESSION
+                            PsiElement(IDENTIFIER)('head')
+                          PsiWhiteSpace(' ')
+                          OPERATION_REFERENCE
+                            PsiElement(EQEQ)('==')
+                          PsiWhiteSpace(' ')
+                          NULL
+                            PsiElement(null)('null')
+                      PsiElement(RPAR)(')')
+                      PsiWhiteSpace('\n        ')
+                      THEN
+                        BINARY_EXPRESSION
+                          REFERENCE_EXPRESSION
+                            PsiElement(IDENTIFIER)('tail')
+                          PsiWhiteSpace(' ')
+                          OPERATION_REFERENCE
+                            PsiElement(EQ)('=')
+                          PsiWhiteSpace(' ')
+                          NULL
+                            PsiElement(null)('null')
+                    PsiWhiteSpace('\n      ')
+                    REFERENCE_EXPRESSION
+                      PsiElement(IDENTIFIER)('result')
+                  PsiWhiteSpace('\n    ')
+                  PsiElement(RBRACE)('}')
         PsiWhiteSpace('\n\n  ')
         PROPERTY
           MODIFIER_LIST

idea/testData/psi/examples/UnionFind.txt

@@ -150,18 +150,19 @@ JetFile: UnionFind.jet
               PsiElement(RPAR)(')')
               PsiWhiteSpace(' ')
               THEN
-                FUNCTION_LITERAL
-                  PsiElement(LBRACE)('{')
-                  PsiWhiteSpace('\n      ')
-                  BODY
-                    RETURN
-                      PsiElement(return)('return')
-                      PsiWhiteSpace(' ')
-                      REFERENCE_EXPRESSION
-                        PsiElement(IDENTIFIER)('x')
-                    PsiElement(SEMICOLON)(';')
-                  PsiWhiteSpace('\n    ')
-                  PsiElement(RBRACE)('}')
+                FUNCTION_LITERAL_EXPRESSION
+                  FUNCTION_LITERAL
+                    PsiElement(LBRACE)('{')
+                    PsiWhiteSpace('\n      ')
+                    BLOCK
+                      RETURN
+                        PsiElement(return)('return')
+                        PsiWhiteSpace(' ')
+                        REFERENCE_EXPRESSION
+                          PsiElement(IDENTIFIER)('x')
+                      PsiElement(SEMICOLON)(';')
+                    PsiWhiteSpace('\n    ')
+                    PsiElement(RBRACE)('}')
             PsiWhiteSpace('\n    ')
             PROPERTY
               PsiElement(val)('val')
@@ -282,80 +283,83 @@ JetFile: UnionFind.jet
               PsiElement(RPAR)(')')
               PsiWhiteSpace(' ')
               THEN
-                FUNCTION_LITERAL
-                  PsiElement(LBRACE)('{')
-                  PsiWhiteSpace('\n      ')
-                  BODY
-                    IF
-                      PsiElement(if)('if')
-                      PsiWhiteSpace(' ')
-                      PsiElement(LPAR)('(')
-                      CONDITION
-                        DOT_QUALIFIED_EXPRESSION
+                FUNCTION_LITERAL_EXPRESSION
+                  FUNCTION_LITERAL
+                    PsiElement(LBRACE)('{')
+                    PsiWhiteSpace('\n      ')
+                    BLOCK
+                      IF
+                        PsiElement(if)('if')
+                        PsiWhiteSpace(' ')
+                        PsiElement(LPAR)('(')
+                        CONDITION
                           DOT_QUALIFIED_EXPRESSION
-                            REFERENCE_EXPRESSION
-                              PsiElement(IDENTIFIER)('Random')
+                            DOT_QUALIFIED_EXPRESSION
+                              REFERENCE_EXPRESSION
+                                PsiElement(IDENTIFIER)('Random')
+                              PsiElement(DOT)('.')
+                              CALL_EXPRESSION
+                                REFERENCE_EXPRESSION
+                                  PsiElement(IDENTIFIER)('nextInt')
+                                VALUE_ARGUMENT_LIST
+                                  PsiElement(LPAR)('(')
+                                  PsiElement(RPAR)(')')
                             PsiElement(DOT)('.')
-                            CALL_EXPRESSION
-                              REFERENCE_EXPRESSION
-                                PsiElement(IDENTIFIER)('nextInt')
-                              VALUE_ARGUMENT_LIST
-                                PsiElement(LPAR)('(')
-                                PsiElement(RPAR)(')')
-                          PsiElement(DOT)('.')
-                          REFERENCE_EXPRESSION
-                            PsiElement(IDENTIFIER)('isOdd')
-                      PsiElement(RPAR)(')')
-                      PsiWhiteSpace(' ')
-                      THEN
-                        FUNCTION_LITERAL
-                          PsiElement(LBRACE)('{')
-                          PsiWhiteSpace('\n        ')
-                          BODY
-                            BINARY_EXPRESSION
-                              ARRAY_ACCESS_EXPRESSION
-                                REFERENCE_EXPRESSION
-                                  PsiElement(IDENTIFIER)('data')
-                                INDICES
-                                  PsiElement(LBRACKET)('[')
-                                  REFERENCE_EXPRESSION
-                                    PsiElement(IDENTIFIER)('pb')
-                                  PsiElement(RBRACKET)(']')
-                              PsiWhiteSpace(' ')
-                              OPERATION_REFERENCE
-                                PsiElement(EQ)('=')
-                              PsiWhiteSpace(' ')
-                              REFERENCE_EXPRESSION
-                                PsiElement(IDENTIFIER)('pa')
-                          PsiWhiteSpace('\n      ')
-                          PsiElement(RBRACE)('}')
-                      PsiWhiteSpace(' ')
-                      PsiElement(else)('else')
-                      PsiWhiteSpace(' ')
-                      ELSE
-                        FUNCTION_LITERAL
-                          PsiElement(LBRACE)('{')
-                          PsiWhiteSpace('\n        ')
-                          BODY
-                            BINARY_EXPRESSION
-                              ARRAY_ACCESS_EXPRESSION
-                                REFERENCE_EXPRESSION
-                                  PsiElement(IDENTIFIER)('data')
-                                INDICES
-                                  PsiElement(LBRACKET)('[')
+                            REFERENCE_EXPRESSION
+                              PsiElement(IDENTIFIER)('isOdd')
+                        PsiElement(RPAR)(')')
+                        PsiWhiteSpace(' ')
+                        THEN
+                          FUNCTION_LITERAL_EXPRESSION
+                            FUNCTION_LITERAL
+                              PsiElement(LBRACE)('{')
+                              PsiWhiteSpace('\n        ')
+                              BLOCK
+                                BINARY_EXPRESSION
+                                  ARRAY_ACCESS_EXPRESSION
+                                    REFERENCE_EXPRESSION
+                                      PsiElement(IDENTIFIER)('data')
+                                    INDICES
+                                      PsiElement(LBRACKET)('[')
+                                      REFERENCE_EXPRESSION
+                                        PsiElement(IDENTIFIER)('pb')
+                                      PsiElement(RBRACKET)(']')
+                                  PsiWhiteSpace(' ')
+                                  OPERATION_REFERENCE
+                                    PsiElement(EQ)('=')
+                                  PsiWhiteSpace(' ')
                                   REFERENCE_EXPRESSION
                                     PsiElement(IDENTIFIER)('pa')
-                                  PsiElement(RBRACKET)(']')
-                              PsiWhiteSpace(' ')
-                              OPERATION_REFERENCE
-                                PsiElement(EQ)('=')
-                              PsiWhiteSpace(' ')
-                              REFERENCE_EXPRESSION
-                                PsiElement(IDENTIFIER)('pb')
-                          PsiWhiteSpace('\n      ')
-                          PsiElement(RBRACE)('}')
-                  PsiWhiteSpace('\n    ')
-                  PsiElement(RBRACE)('}')
+                              PsiWhiteSpace('\n      ')
+                              PsiElement(RBRACE)('}')
+                        PsiWhiteSpace(' ')
+                        PsiElement(else)('else')
+                        PsiWhiteSpace(' ')
+                        ELSE
+                          FUNCTION_LITERAL_EXPRESSION
+                            FUNCTION_LITERAL
+                              PsiElement(LBRACE)('{')
+                              PsiWhiteSpace('\n        ')
+                              BLOCK
+                                BINARY_EXPRESSION
+                                  ARRAY_ACCESS_EXPRESSION
+                                    REFERENCE_EXPRESSION
+                                      PsiElement(IDENTIFIER)('data')
+                                    INDICES
+                                      PsiElement(LBRACKET)('[')
+                                      REFERENCE_EXPRESSION
+                                        PsiElement(IDENTIFIER)('pa')
+                                      PsiElement(RBRACKET)(']')
+                                  PsiWhiteSpace(' ')
+                                  OPERATION_REFERENCE
+                                    PsiElement(EQ)('=')
+                                  PsiWhiteSpace(' ')
+                                  REFERENCE_EXPRESSION
+                                    PsiElement(IDENTIFIER)('pb')
+                              PsiWhiteSpace('\n      ')
+                              PsiElement(RBRACE)('}')
+                    PsiWhiteSpace('\n    ')
+                    PsiElement(RBRACE)('}')
             PsiWhiteSpace('\n  ')
             PsiElement(RBRACE)('}')
         PsiWhiteSpace('\n')

idea/testData/psi/examples/With.txt

@@ -104,47 +104,11 @@ JetFile: With.jet
                   PsiElement(IDENTIFIER)('out')
             PsiElement(RPAR)(')')
           PsiWhiteSpace(' ')
-          FUNCTION_LITERAL
-            PsiElement(LBRACE)('{')
-            PsiWhiteSpace('\n    ')
-            BODY
-              CALL_EXPRESSION
-                REFERENCE_EXPRESSION
-                  PsiElement(IDENTIFIER)('println')
-                VALUE_ARGUMENT_LIST
-                  PsiElement(LPAR)('(')
-                  VALUE_ARGUMENT
-                    STRING_CONSTANT
-                      PsiElement(STRING_LITERAL)('"foo"')
-                  PsiElement(RPAR)(')')
-              PsiElement(SEMICOLON)(';')
-              PsiWhiteSpace('\n    ')
-              CALL_EXPRESSION
-                REFERENCE_EXPRESSION
-                  PsiElement(IDENTIFIER)('print')
-                VALUE_ARGUMENT_LIST
-                  PsiElement(LPAR)('(')
-                  VALUE_ARGUMENT
-                    STRING_CONSTANT
-                      PsiElement(STRING_LITERAL)('"bar"')
-                  PsiElement(RPAR)(')')
-              PsiElement(SEMICOLON)(';')
-            PsiWhiteSpace('\n  ')
-            PsiElement(RBRACE)('}')
-        PsiWhiteSpace('\n\n  ')
-        DOT_QUALIFIED_EXPRESSION
-          DOT_QUALIFIED_EXPRESSION
-            REFERENCE_EXPRESSION
-              PsiElement(IDENTIFIER)('System')
-            PsiElement(DOT)('.')
-            REFERENCE_EXPRESSION
-              PsiElement(IDENTIFIER)('out')
-          PsiElement(DOT)('.')
-          CALL_EXPRESSION
+          FUNCTION_LITERAL_EXPRESSION
             FUNCTION_LITERAL
               PsiElement(LBRACE)('{')
               PsiWhiteSpace('\n    ')
-              BODY
+              BLOCK
                 CALL_EXPRESSION
                   REFERENCE_EXPRESSION
                     PsiElement(IDENTIFIER)('println')
@@ -168,6 +132,44 @@ JetFile: With.jet
                 PsiElement(SEMICOLON)(';')
               PsiWhiteSpace('\n  ')
               PsiElement(RBRACE)('}')
+        PsiWhiteSpace('\n\n  ')
+        DOT_QUALIFIED_EXPRESSION
+          DOT_QUALIFIED_EXPRESSION
+            REFERENCE_EXPRESSION
+              PsiElement(IDENTIFIER)('System')
+            PsiElement(DOT)('.')
+            REFERENCE_EXPRESSION
+              PsiElement(IDENTIFIER)('out')
+          PsiElement(DOT)('.')
+          CALL_EXPRESSION
+            FUNCTION_LITERAL_EXPRESSION
+              FUNCTION_LITERAL
+                PsiElement(LBRACE)('{')
+                PsiWhiteSpace('\n    ')
+                BLOCK
+                  CALL_EXPRESSION
+                    REFERENCE_EXPRESSION
+                      PsiElement(IDENTIFIER)('println')
+                    VALUE_ARGUMENT_LIST
+                      PsiElement(LPAR)('(')
+                      VALUE_ARGUMENT
+                        STRING_CONSTANT
+                          PsiElement(STRING_LITERAL)('"foo"')
+                      PsiElement(RPAR)(')')
+                  PsiElement(SEMICOLON)(';')
+                  PsiWhiteSpace('\n    ')
+                  CALL_EXPRESSION
+                    REFERENCE_EXPRESSION
+                      PsiElement(IDENTIFIER)('print')
+                    VALUE_ARGUMENT_LIST
+                      PsiElement(LPAR)('(')
+                      VALUE_ARGUMENT
+                        STRING_CONSTANT
+                          PsiElement(STRING_LITERAL)('"bar"')
+                      PsiElement(RPAR)(')')
+                  PsiElement(SEMICOLON)(';')
+                PsiWhiteSpace('\n  ')
+                PsiElement(RBRACE)('}')
             VALUE_ARGUMENT_LIST
               PsiElement(LPAR)('(')
               PsiElement(RPAR)(')')

idea/testData/psi/examples/collections/ArrayList.txt

@@ -671,30 +671,31 @@ JetFile: ArrayList.jet
               PsiElement(RPAR)(')')
               PsiWhiteSpace(' ')
               THEN
-                FUNCTION_LITERAL
-                  PsiElement(LBRACE)('{')
-                  PsiWhiteSpace('\n      ')
-                  BODY
-                    BINARY_EXPRESSION
-                      ARRAY_ACCESS_EXPRESSION
+                FUNCTION_LITERAL_EXPRESSION
+                  FUNCTION_LITERAL
+                    PsiElement(LBRACE)('{')
+                    PsiWhiteSpace('\n      ')
+                    BLOCK
+                      BINARY_EXPRESSION
+                        ARRAY_ACCESS_EXPRESSION
+                          REFERENCE_EXPRESSION
+                            PsiElement(IDENTIFIER)('data')
+                          INDICES
+                            PsiElement(LBRACKET)('[')
+                            POSTFIX_EXPRESSION
+                              REFERENCE_EXPRESSION
+                                PsiElement(IDENTIFIER)('used')
+                              OPERATION_REFERENCE
+                                PsiElement(PLUSPLUS)('++')
+                            PsiElement(RBRACKET)(']')
+                        PsiWhiteSpace(' ')
+                        OPERATION_REFERENCE
+                          PsiElement(EQ)('=')
+                        PsiWhiteSpace(' ')
                         REFERENCE_EXPRESSION
-                          PsiElement(IDENTIFIER)('data')
-                        INDICES
-                          PsiElement(LBRACKET)('[')
-                          POSTFIX_EXPRESSION
-                            REFERENCE_EXPRESSION
-                              PsiElement(IDENTIFIER)('used')
-                            OPERATION_REFERENCE
-                              PsiElement(PLUSPLUS)('++')
-                          PsiElement(RBRACKET)(']')
-                      PsiWhiteSpace(' ')
-                      OPERATION_REFERENCE
-                        PsiElement(EQ)('=')
-                      PsiWhiteSpace(' ')
-                      REFERENCE_EXPRESSION
-                        PsiElement(IDENTIFIER)('value')
-                  PsiWhiteSpace('\n    ')
-                  PsiElement(RBRACE)('}')
+                          PsiElement(IDENTIFIER)('value')
+                    PsiWhiteSpace('\n    ')
+                    PsiElement(RBRACE)('}')
               PsiWhiteSpace(' ')
               PsiElement(else)('else')
               PsiWhiteSpace(' ')
@@ -716,89 +717,90 @@ JetFile: ArrayList.jet
                   PsiElement(RPAR)(')')
                   PsiWhiteSpace(' ')
                   THEN
-                    FUNCTION_LITERAL
-                      PsiElement(LBRACE)('{')
-                      PsiWhiteSpace('\n      ')
-                      BODY
-                        FOR
-                          PsiElement(for)('for')
-                          PsiWhiteSpace(' ')
-                          PsiElement(LPAR)('(')
-                          LOOP_PARAMETER
-                            PsiElement(IDENTIFIER)('i')
-                          PsiWhiteSpace(' ')
-                          PsiElement(in)('in')
-                          PsiWhiteSpace(' ')
-                          LOOP_RANGE
-                            BINARY_EXPRESSION
+                    FUNCTION_LITERAL_EXPRESSION
+                      FUNCTION_LITERAL
+                        PsiElement(LBRACE)('{')
+                        PsiWhiteSpace('\n      ')
+                        BLOCK
+                          FOR
+                            PsiElement(for)('for')
+                            PsiWhiteSpace(' ')
+                            PsiElement(LPAR)('(')
+                            LOOP_PARAMETER
+                              PsiElement(IDENTIFIER)('i')
+                            PsiWhiteSpace(' ')
+                            PsiElement(in)('in')
+                            PsiWhiteSpace(' ')
+                            LOOP_RANGE
                               BINARY_EXPRESSION
-                                REFERENCE_EXPRESSION
-                                  PsiElement(IDENTIFIER)('used')
+                                BINARY_EXPRESSION
+                                  REFERENCE_EXPRESSION
+                                    PsiElement(IDENTIFIER)('used')
+                                  OPERATION_REFERENCE
+                                    PsiElement(MINUS)('-')
+                                  INTEGER_CONSTANT
+                                    PsiElement(INTEGER_LITERAL)('1')
                                 OPERATION_REFERENCE
-                                  PsiElement(MINUS)('-')
-                                INTEGER_CONSTANT
-                                  PsiElement(INTEGER_LITERAL)('1')
-                              OPERATION_REFERENCE
-                                PsiElement(RANGE)('..')
-                              REFERENCE_EXPRESSION
-                                PsiElement(IDENTIFIER)('index')
-                          PsiElement(RPAR)(')')
-                          PsiWhiteSpace(' ')
-                          PsiComment(EOL_COMMENT)('// backwards, special operator...  Need to optimize this to be a real indexed loop')
-                          PsiWhiteSpace('\n        ')
-                          BODY
-                            BINARY_EXPRESSION
-                              ARRAY_ACCESS_EXPRESSION
+                                  PsiElement(RANGE)('..')
                                 REFERENCE_EXPRESSION
-                                  PsiElement(IDENTIFIER)('data')
-                                INDICES
-                                  PsiElement(LBRACKET)('[')
-                                  BINARY_EXPRESSION
+                                  PsiElement(IDENTIFIER)('index')
+                            PsiElement(RPAR)(')')
+                            PsiWhiteSpace(' ')
+                            PsiComment(EOL_COMMENT)('// backwards, special operator...  Need to optimize this to be a real indexed loop')
+                            PsiWhiteSpace('\n        ')
+                            BODY
+                              BINARY_EXPRESSION
+                                ARRAY_ACCESS_EXPRESSION
+                                  REFERENCE_EXPRESSION
+                                    PsiElement(IDENTIFIER)('data')
+                                  INDICES
+                                    PsiElement(LBRACKET)('[')
+                                    BINARY_EXPRESSION
+                                      REFERENCE_EXPRESSION
+                                        PsiElement(IDENTIFIER)('i')
+                                      PsiWhiteSpace(' ')
+                                      OPERATION_REFERENCE
+                                        PsiElement(PLUS)('+')
+                                      PsiWhiteSpace(' ')
+                                      INTEGER_CONSTANT
+                                        PsiElement(INTEGER_LITERAL)('1')
+                                    PsiElement(RBRACKET)(']')
+                                PsiWhiteSpace(' ')
+                                OPERATION_REFERENCE
+                                  PsiElement(EQ)('=')
+                                PsiWhiteSpace(' ')
+                                ARRAY_ACCESS_EXPRESSION
+                                  REFERENCE_EXPRESSION
+                                    PsiElement(IDENTIFIER)('data')
+                                  INDICES
+                                    PsiElement(LBRACKET)('[')
                                     REFERENCE_EXPRESSION
                                       PsiElement(IDENTIFIER)('i')
-                                    PsiWhiteSpace(' ')
-                                    OPERATION_REFERENCE
-                                      PsiElement(PLUS)('+')
-                                    PsiWhiteSpace(' ')
-                                    INTEGER_CONSTANT
-                                      PsiElement(INTEGER_LITERAL)('1')
-                                  PsiElement(RBRACKET)(']')
-                              PsiWhiteSpace(' ')
-                              OPERATION_REFERENCE
-                                PsiElement(EQ)('=')
-                              PsiWhiteSpace(' ')
-                              ARRAY_ACCESS_EXPRESSION
-                                REFERENCE_EXPRESSION
-                                  PsiElement(IDENTIFIER)('data')
-                                INDICES
-                                  PsiElement(LBRACKET)('[')
-                                  REFERENCE_EXPRESSION
-                                    PsiElement(IDENTIFIER)('i')
-                                  PsiElement(RBRACKET)(']')
-                        PsiWhiteSpace('\n      ')
-                        BINARY_EXPRESSION
-                          ARRAY_ACCESS_EXPRESSION
-                            REFERENCE_EXPRESSION
-                              PsiElement(IDENTIFIER)('data')
-                            INDICES
-                              PsiElement(LBRACKET)('[')
+                                    PsiElement(RBRACKET)(']')
+                          PsiWhiteSpace('\n      ')
+                          BINARY_EXPRESSION
+                            ARRAY_ACCESS_EXPRESSION
                               REFERENCE_EXPRESSION
-                                PsiElement(IDENTIFIER)('index')
-                              PsiElement(RBRACKET)(']')
-                          PsiWhiteSpace(' ')
-                          OPERATION_REFERENCE
-                            PsiElement(EQ)('=')
-                          PsiWhiteSpace(' ')
-                          REFERENCE_EXPRESSION
-                            PsiElement(IDENTIFIER)('value')
-                        PsiWhiteSpace('\n      ')
-                        POSTFIX_EXPRESSION
-                          REFERENCE_EXPRESSION
-                            PsiElement(IDENTIFIER)('used')
-                          OPERATION_REFERENCE
-                            PsiElement(PLUSPLUS)('++')
-                      PsiWhiteSpace('\n    ')
-                      PsiElement(RBRACE)('}')
+                                PsiElement(IDENTIFIER)('data')
+                              INDICES
+                                PsiElement(LBRACKET)('[')
+                                REFERENCE_EXPRESSION
+                                  PsiElement(IDENTIFIER)('index')
+                                PsiElement(RBRACKET)(']')
+                            PsiWhiteSpace(' ')
+                            OPERATION_REFERENCE
+                              PsiElement(EQ)('=')
+                            PsiWhiteSpace(' ')
+                            REFERENCE_EXPRESSION
+                              PsiElement(IDENTIFIER)('value')
+                          PsiWhiteSpace('\n      ')
+                          POSTFIX_EXPRESSION
+                            REFERENCE_EXPRESSION
+                              PsiElement(IDENTIFIER)('used')
+                            OPERATION_REFERENCE
+                              PsiElement(PLUSPLUS)('++')
+                        PsiWhiteSpace('\n    ')
+                        PsiElement(RBRACE)('}')
                   PsiWhiteSpace(' ')
                   PsiElement(else)('else')
                   PsiWhiteSpace(' ')

idea/testData/psi/examples/collections/IIterator.txt

@@ -251,22 +251,23 @@ JetFile: IIterator.jet
               PsiElement(RPAR)(')')
               PsiWhiteSpace(' ')
               THEN
-                FUNCTION_LITERAL
-                  PsiElement(LBRACE)('{')
-                  PsiWhiteSpace('\n      ')
-                  BODY
-                    THROW
-                      PsiElement(throw)('throw')
-                      PsiWhiteSpace(' ')
-                      CALL_EXPRESSION
-                        REFERENCE_EXPRESSION
-                          PsiElement(IDENTIFIER)('IndexOutOfBoundsException')
-                        VALUE_ARGUMENT_LIST
-                          PsiElement(LPAR)('(')
-                          PsiElement(RPAR)(')')
-                    PsiElement(SEMICOLON)(';')
-                  PsiWhiteSpace('\n    ')
-                  PsiElement(RBRACE)('}')
+                FUNCTION_LITERAL_EXPRESSION
+                  FUNCTION_LITERAL
+                    PsiElement(LBRACE)('{')
+                    PsiWhiteSpace('\n      ')
+                    BLOCK
+                      THROW
+                        PsiElement(throw)('throw')
+                        PsiWhiteSpace(' ')
+                        CALL_EXPRESSION
+                          REFERENCE_EXPRESSION
+                            PsiElement(IDENTIFIER)('IndexOutOfBoundsException')
+                          VALUE_ARGUMENT_LIST
+                            PsiElement(LPAR)('(')
+                            PsiElement(RPAR)(')')
+                      PsiElement(SEMICOLON)(';')
+                    PsiWhiteSpace('\n    ')
+                    PsiElement(RBRACE)('}')
             PsiWhiteSpace('\n\n    ')
             IF
               PsiElement(if)('if')
@@ -338,56 +339,57 @@ JetFile: IIterator.jet
               PsiElement(RPAR)(')')
               PsiWhiteSpace(' ')
               BODY
-                FUNCTION_LITERAL
-                  PsiElement(LBRACE)('{')
-                  PsiWhiteSpace('\n      ')
-                  BODY
-                    IF
-                      PsiElement(if)('if')
-                      PsiWhiteSpace(' ')
-                      PsiElement(LPAR)('(')
-                      CONDITION
-                        PREFIX_EXPRESSION
-                          OPERATION_REFERENCE
-                            PsiElement(EXCL)('!')
-                          REFERENCE_EXPRESSION
-                            PsiElement(IDENTIFIER)('hasNext')
-                      PsiElement(RPAR)(')')
-                      PsiWhiteSpace('\n        ')
-                      THEN
-                        RETURN
-                          PsiElement(return)('return')
-                          PsiWhiteSpace(' ')
-                          REFERENCE_EXPRESSION
-                            PsiElement(IDENTIFIER)('count')
+                FUNCTION_LITERAL_EXPRESSION
+                  FUNCTION_LITERAL
+                    PsiElement(LBRACE)('{')
                     PsiWhiteSpace('\n      ')
-                    BINARY_EXPRESSION
-                      ARRAY_ACCESS_EXPRESSION
-                        REFERENCE_EXPRESSION
-                          PsiElement(IDENTIFIER)('buffer')
-                        INDICES
-                          PsiElement(LBRACKET)('[')
+                    BLOCK
+                      IF
+                        PsiElement(if)('if')
+                        PsiWhiteSpace(' ')
+                        PsiElement(LPAR)('(')
+                        CONDITION
+                          PREFIX_EXPRESSION
+                            OPERATION_REFERENCE
+                              PsiElement(EXCL)('!')
+                            REFERENCE_EXPRESSION
+                              PsiElement(IDENTIFIER)('hasNext')
+                        PsiElement(RPAR)(')')
+                        PsiWhiteSpace('\n        ')
+                        THEN
+                          RETURN
+                            PsiElement(return)('return')
+                            PsiWhiteSpace(' ')
+                            REFERENCE_EXPRESSION
+                              PsiElement(IDENTIFIER)('count')
+                      PsiWhiteSpace('\n      ')
+                      BINARY_EXPRESSION
+                        ARRAY_ACCESS_EXPRESSION
                           REFERENCE_EXPRESSION
-                            PsiElement(IDENTIFIER)('i')
-                          PsiElement(RBRACKET)(']')
-                      PsiWhiteSpace(' ')
-                      OPERATION_REFERENCE
-                        PsiElement(EQ)('=')
-                      PsiWhiteSpace(' ')
-                      CALL_EXPRESSION
+                            PsiElement(IDENTIFIER)('buffer')
+                          INDICES
+                            PsiElement(LBRACKET)('[')
+                            REFERENCE_EXPRESSION
+                              PsiElement(IDENTIFIER)('i')
+                            PsiElement(RBRACKET)(']')
+                        PsiWhiteSpace(' ')
+                        OPERATION_REFERENCE
+                          PsiElement(EQ)('=')
+                        PsiWhiteSpace(' ')
+                        CALL_EXPRESSION
+                          REFERENCE_EXPRESSION
+                            PsiElement(IDENTIFIER)('next')
+                          VALUE_ARGUMENT_LIST
+                            PsiElement(LPAR)('(')
+                            PsiElement(RPAR)(')')
+                      PsiWhiteSpace('\n      ')
+                      POSTFIX_EXPRESSION
                         REFERENCE_EXPRESSION
-                          PsiElement(IDENTIFIER)('next')
-                        VALUE_ARGUMENT_LIST
-                          PsiElement(LPAR)('(')
-                          PsiElement(RPAR)(')')
-                    PsiWhiteSpace('\n      ')
-                    POSTFIX_EXPRESSION
-                      REFERENCE_EXPRESSION
-                        PsiElement(IDENTIFIER)('count')
-                      OPERATION_REFERENCE
-                        PsiElement(PLUSPLUS)('++')
-                  PsiWhiteSpace('\n    ')
-                  PsiElement(RBRACE)('}')
+                          PsiElement(IDENTIFIER)('count')
+                        OPERATION_REFERENCE
+                          PsiElement(PLUSPLUS)('++')
+                    PsiWhiteSpace('\n    ')
+                    PsiElement(RBRACE)('}')
             PsiWhiteSpace('\n    ')
             RETURN
               PsiElement(return)('return')

idea/testData/psi/examples/collections/LinkedList.txt

@@ -224,159 +224,163 @@ JetFile: LinkedList.jet
               PsiElement(RPAR)(')')
               PsiWhiteSpace(' ')
               THEN
-                FUNCTION_LITERAL
-                  PsiElement(LBRACE)('{')
-                  PsiWhiteSpace('\n      ')
-                  BODY
-                    BINARY_EXPRESSION
-                      DOT_QUALIFIED_EXPRESSION
+                FUNCTION_LITERAL_EXPRESSION
+                  FUNCTION_LITERAL
+                    PsiElement(LBRACE)('{')
+                    PsiWhiteSpace('\n      ')
+                    BLOCK
+                      BINARY_EXPRESSION
+                        DOT_QUALIFIED_EXPRESSION
+                          REFERENCE_EXPRESSION
+                            PsiElement(IDENTIFIER)('newItem')
+                          PsiElement(DOT)('.')
+                          REFERENCE_EXPRESSION
+                            PsiElement(IDENTIFIER)('next')
+                        PsiWhiteSpace(' ')
+                        OPERATION_REFERENCE
+                          PsiElement(EQ)('=')
+                        PsiWhiteSpace(' ')
+                        REFERENCE_EXPRESSION
+                          PsiElement(IDENTIFIER)('head')
+                      PsiWhiteSpace('\n      ')
+                      BINARY_EXPRESSION
+                        REFERENCE_EXPRESSION
+                          PsiElement(IDENTIFIER)('head')
+                        PsiWhiteSpace(' ')
+                        OPERATION_REFERENCE
+                          PsiElement(EQ)('=')
+                        PsiWhiteSpace(' ')
                         REFERENCE_EXPRESSION
                           PsiElement(IDENTIFIER)('newItem')
-                        PsiElement(DOT)('.')
-                        REFERENCE_EXPRESSION
-                          PsiElement(IDENTIFIER)('next')
-                      PsiWhiteSpace(' ')
-                      OPERATION_REFERENCE
-                        PsiElement(EQ)('=')
-                      PsiWhiteSpace(' ')
-                      REFERENCE_EXPRESSION
-                        PsiElement(IDENTIFIER)('head')
-                    PsiWhiteSpace('\n      ')
-                    BINARY_EXPRESSION
-                      REFERENCE_EXPRESSION
-                        PsiElement(IDENTIFIER)('head')
-                      PsiWhiteSpace(' ')
-                      OPERATION_REFERENCE
-                        PsiElement(EQ)('=')
-                      PsiWhiteSpace(' ')
-                      REFERENCE_EXPRESSION
-                        PsiElement(IDENTIFIER)('newItem')
-                    PsiWhiteSpace('\n      ')
-                    IF
-                      PsiElement(if)('if')
-                      PsiWhiteSpace(' ')
-                      PsiElement(LPAR)('(')
-                      CONDITION
-                        BINARY_EXPRESSION
-                          REFERENCE_EXPRESSION
-                            PsiElement(IDENTIFIER)('tail')
-                          PsiWhiteSpace(' ')
-                          OPERATION_REFERENCE
-                            PsiElement(EQEQEQ)('===')
-                          PsiWhiteSpace(' ')
-                          NULL
-                            PsiElement(null)('null')
-                      PsiElement(RPAR)(')')
-                      PsiWhiteSpace(' ')
-                      THEN
-                        FUNCTION_LITERAL
-                          PsiElement(LBRACE)('{')
-                          PsiWhiteSpace('\n        ')
-                          BODY
-                            BINARY_EXPRESSION
-                              REFERENCE_EXPRESSION
-                                PsiElement(IDENTIFIER)('tail')
-                              PsiWhiteSpace(' ')
-                              OPERATION_REFERENCE
-                                PsiElement(EQ)('=')
-                              PsiWhiteSpace(' ')
-                              REFERENCE_EXPRESSION
-                                PsiElement(IDENTIFIER)('head')
-                          PsiWhiteSpace('\n      ')
-                          PsiElement(RBRACE)('}')
-                  PsiWhiteSpace('\n    ')
-                  PsiElement(RBRACE)('}')
+                      PsiWhiteSpace('\n      ')
+                      IF
+                        PsiElement(if)('if')
+                        PsiWhiteSpace(' ')
+                        PsiElement(LPAR)('(')
+                        CONDITION
+                          BINARY_EXPRESSION
+                            REFERENCE_EXPRESSION
+                              PsiElement(IDENTIFIER)('tail')
+                            PsiWhiteSpace(' ')
+                            OPERATION_REFERENCE
+                              PsiElement(EQEQEQ)('===')
+                            PsiWhiteSpace(' ')
+                            NULL
+                              PsiElement(null)('null')
+                        PsiElement(RPAR)(')')
+                        PsiWhiteSpace(' ')
+                        THEN
+                          FUNCTION_LITERAL_EXPRESSION
+                            FUNCTION_LITERAL
+                              PsiElement(LBRACE)('{')
+                              PsiWhiteSpace('\n        ')
+                              BLOCK
+                                BINARY_EXPRESSION
+                                  REFERENCE_EXPRESSION
+                                    PsiElement(IDENTIFIER)('tail')
+                                  PsiWhiteSpace(' ')
+                                  OPERATION_REFERENCE
+                                    PsiElement(EQ)('=')
+                                  PsiWhiteSpace(' ')
+                                  REFERENCE_EXPRESSION
+                                    PsiElement(IDENTIFIER)('head')
+                              PsiWhiteSpace('\n      ')
+                              PsiElement(RBRACE)('}')
+                    PsiWhiteSpace('\n    ')
+                    PsiElement(RBRACE)('}')
               PsiWhiteSpace(' ')
               PsiElement(else)('else')
               PsiWhiteSpace(' ')
               ELSE
-                FUNCTION_LITERAL
-                  PsiElement(LBRACE)('{')
-                  PsiWhiteSpace('\n      ')
-                  BODY
-                    PROPERTY
-                      PsiElement(var)('var')
-                      PsiWhiteSpace(' ')
-                      PsiElement(IDENTIFIER)('insertAfter')
-                      PsiWhiteSpace(' ')
-                      PsiElement(EQ)('=')
-                      PsiWhiteSpace(' ')
-                      CALL_EXPRESSION
-                        REFERENCE_EXPRESSION
-                          PsiElement(IDENTIFIER)('itemAt')
-                        VALUE_ARGUMENT_LIST
-                          PsiElement(LPAR)('(')
-                          VALUE_ARGUMENT
-                            REFERENCE_EXPRESSION
-                              PsiElement(IDENTIFIER)('index')
-                          PsiElement(RPAR)(')')
+                FUNCTION_LITERAL_EXPRESSION
+                  FUNCTION_LITERAL
+                    PsiElement(LBRACE)('{')
                     PsiWhiteSpace('\n      ')
-                    BINARY_EXPRESSION
-                      DOT_QUALIFIED_EXPRESSION
-                        REFERENCE_EXPRESSION
-                          PsiElement(IDENTIFIER)('newItem')
-                        PsiElement(DOT)('.')
-                        REFERENCE_EXPRESSION
-                          PsiElement(IDENTIFIER)('next')
-                      PsiWhiteSpace(' ')
-                      OPERATION_REFERENCE
+                    BLOCK
+                      PROPERTY
+                        PsiElement(var)('var')
+                        PsiWhiteSpace(' ')
+                        PsiElement(IDENTIFIER)('insertAfter')
+                        PsiWhiteSpace(' ')
                         PsiElement(EQ)('=')
-                      PsiWhiteSpace(' ')
-                      DOT_QUALIFIED_EXPRESSION
-                        REFERENCE_EXPRESSION
-                          PsiElement(IDENTIFIER)('insertAfter')
-                        PsiElement(DOT)('.')
-                        REFERENCE_EXPRESSION
-                          PsiElement(IDENTIFIER)('next')
-                    PsiWhiteSpace('\n      ')
-                    BINARY_EXPRESSION
-                      DOT_QUALIFIED_EXPRESSION
-                        REFERENCE_EXPRESSION
-                          PsiElement(IDENTIFIER)('insertAfter')
-                        PsiElement(DOT)('.')
-                        REFERENCE_EXPRESSION
-                          PsiElement(IDENTIFIER)('next')
-                      PsiWhiteSpace(' ')
-                      OPERATION_REFERENCE
-                        PsiElement(EQ)('=')
-                      PsiWhiteSpace(' ')
-                      REFERENCE_EXPRESSION
-                        PsiElement(IDENTIFIER)('newItem')
-                    PsiWhiteSpace('\n      ')
-                    IF
-                      PsiElement(if)('if')
-                      PsiWhiteSpace(' ')
-                      PsiElement(LPAR)('(')
-                      CONDITION
-                        BINARY_EXPRESSION
+                        PsiWhiteSpace(' ')
+                        CALL_EXPRESSION
                           REFERENCE_EXPRESSION
-                            PsiElement(IDENTIFIER)('tail')
-                          PsiWhiteSpace(' ')
-                          OPERATION_REFERENCE
-                            PsiElement(EQEQEQ)('===')
-                          PsiWhiteSpace(' ')
+                            PsiElement(IDENTIFIER)('itemAt')
+                          VALUE_ARGUMENT_LIST
+                            PsiElement(LPAR)('(')
+                            VALUE_ARGUMENT
+                              REFERENCE_EXPRESSION
+                                PsiElement(IDENTIFIER)('index')
+                            PsiElement(RPAR)(')')
+                      PsiWhiteSpace('\n      ')
+                      BINARY_EXPRESSION
+                        DOT_QUALIFIED_EXPRESSION
+                          REFERENCE_EXPRESSION
+                            PsiElement(IDENTIFIER)('newItem')
+                          PsiElement(DOT)('.')
+                          REFERENCE_EXPRESSION
+                            PsiElement(IDENTIFIER)('next')
+                        PsiWhiteSpace(' ')
+                        OPERATION_REFERENCE
+                          PsiElement(EQ)('=')
+                        PsiWhiteSpace(' ')
+                        DOT_QUALIFIED_EXPRESSION
                           REFERENCE_EXPRESSION
                             PsiElement(IDENTIFIER)('insertAfter')
-                      PsiElement(RPAR)(')')
-                      PsiWhiteSpace(' ')
-                      THEN
-                        FUNCTION_LITERAL
-                          PsiElement(LBRACE)('{')
-                          PsiWhiteSpace('\n        ')
-                          BODY
-                            BINARY_EXPRESSION
-                              REFERENCE_EXPRESSION
-                                PsiElement(IDENTIFIER)('tail')
-                              PsiWhiteSpace(' ')
-                              OPERATION_REFERENCE
-                                PsiElement(EQ)('=')
-                              PsiWhiteSpace(' ')
-                              REFERENCE_EXPRESSION
-                                PsiElement(IDENTIFIER)('newItem')
-                          PsiWhiteSpace('\n      ')
-                          PsiElement(RBRACE)('}')
-                  PsiWhiteSpace('\n    ')
-                  PsiElement(RBRACE)('}')
+                          PsiElement(DOT)('.')
+                          REFERENCE_EXPRESSION
+                            PsiElement(IDENTIFIER)('next')
+                      PsiWhiteSpace('\n      ')
+                      BINARY_EXPRESSION
+                        DOT_QUALIFIED_EXPRESSION
+                          REFERENCE_EXPRESSION
+                            PsiElement(IDENTIFIER)('insertAfter')
+                          PsiElement(DOT)('.')
+                          REFERENCE_EXPRESSION
+                            PsiElement(IDENTIFIER)('next')
+                        PsiWhiteSpace(' ')
+                        OPERATION_REFERENCE
+                          PsiElement(EQ)('=')
+                        PsiWhiteSpace(' ')
+                        REFERENCE_EXPRESSION
+                          PsiElement(IDENTIFIER)('newItem')
+                      PsiWhiteSpace('\n      ')
+                      IF
+                        PsiElement(if)('if')
+                        PsiWhiteSpace(' ')
+                        PsiElement(LPAR)('(')
+                        CONDITION
+                          BINARY_EXPRESSION
+                            REFERENCE_EXPRESSION
+                              PsiElement(IDENTIFIER)('tail')
+                            PsiWhiteSpace(' ')
+                            OPERATION_REFERENCE
+                              PsiElement(EQEQEQ)('===')
+                            PsiWhiteSpace(' ')
+                            REFERENCE_EXPRESSION
+                              PsiElement(IDENTIFIER)('insertAfter')
+                        PsiElement(RPAR)(')')
+                        PsiWhiteSpace(' ')
+                        THEN
+                          FUNCTION_LITERAL_EXPRESSION
+                            FUNCTION_LITERAL
+                              PsiElement(LBRACE)('{')
+                              PsiWhiteSpace('\n        ')
+                              BLOCK
+                                BINARY_EXPRESSION
+                                  REFERENCE_EXPRESSION
+                                    PsiElement(IDENTIFIER)('tail')
+                                  PsiWhiteSpace(' ')
+                                  OPERATION_REFERENCE
+                                    PsiElement(EQ)('=')
+                                  PsiWhiteSpace(' ')
+                                  REFERENCE_EXPRESSION
+                                    PsiElement(IDENTIFIER)('newItem')
+                              PsiWhiteSpace('\n      ')
+                              PsiElement(RBRACE)('}')
+                    PsiWhiteSpace('\n    ')
+                    PsiElement(RBRACE)('}')
             PsiWhiteSpace('\n  ')
             PsiElement(RBRACE)('}')
         PsiWhiteSpace('\n\n  ')
@@ -430,24 +434,25 @@ JetFile: LinkedList.jet
               PsiElement(RPAR)(')')
               PsiWhiteSpace(' ')
               THEN
-                FUNCTION_LITERAL
-                  PsiElement(LBRACE)('{')
-                  PsiWhiteSpace('\n      ')
-                  BODY
-                    THROW
-                      PsiElement(throw)('throw')
-                      PsiWhiteSpace(' ')
-                      CALL_EXPRESSION
-                        REFERENCE_EXPRESSION
-                          PsiElement(IDENTIFIER)('IndexOutOfBoundsException')
-                        VALUE_ARGUMENT_LIST
-                          PsiElement(LPAR)('(')
-                          VALUE_ARGUMENT
-                            REFERENCE_EXPRESSION
-                              PsiElement(IDENTIFIER)('index')
-                          PsiElement(RPAR)(')')
-                  PsiWhiteSpace('\n    ')
-                  PsiElement(RBRACE)('}')
+                FUNCTION_LITERAL_EXPRESSION
+                  FUNCTION_LITERAL
+                    PsiElement(LBRACE)('{')
+                    PsiWhiteSpace('\n      ')
+                    BLOCK
+                      THROW
+                        PsiElement(throw)('throw')
+                        PsiWhiteSpace(' ')
+                        CALL_EXPRESSION
+                          REFERENCE_EXPRESSION
+                            PsiElement(IDENTIFIER)('IndexOutOfBoundsException')
+                          VALUE_ARGUMENT_LIST
+                            PsiElement(LPAR)('(')
+                            VALUE_ARGUMENT
+                              REFERENCE_EXPRESSION
+                                PsiElement(IDENTIFIER)('index')
+                            PsiElement(RPAR)(')')
+                    PsiWhiteSpace('\n    ')
+                    PsiElement(RBRACE)('}')
             PsiWhiteSpace('\n  ')
             PsiElement(RBRACE)('}')
         PsiWhiteSpace('\n\n  ')
@@ -525,154 +530,158 @@ JetFile: LinkedList.jet
               PsiElement(RPAR)(')')
               PsiWhiteSpace(' ')
               THEN
-                FUNCTION_LITERAL
-                  PsiElement(LBRACE)('{')
-                  PsiWhiteSpace('\n      ')
-                  BODY
-                    BINARY_EXPRESSION
-                      REFERENCE_EXPRESSION
-                        PsiElement(IDENTIFIER)('head')
-                      PsiWhiteSpace(' ')
-                      OPERATION_REFERENCE
-                        PsiElement(EQ)('=')
-                      PsiWhiteSpace(' ')
-                      DOT_QUALIFIED_EXPRESSION
-                        REFERENCE_EXPRESSION
-                          PsiElement(IDENTIFIER)('item')
-                        PsiElement(DOT)('.')
-                        REFERENCE_EXPRESSION
-                          PsiElement(IDENTIFIER)('next')
+                FUNCTION_LITERAL_EXPRESSION
+                  FUNCTION_LITERAL
+                    PsiElement(LBRACE)('{')
                     PsiWhiteSpace('\n      ')
-                    IF
-                      PsiElement(if)('if')
-                      PsiWhiteSpace(' ')
-                      PsiElement(LPAR)('(')
-                      CONDITION
-                        BINARY_EXPRESSION
-                          REFERENCE_EXPRESSION
-                            PsiElement(IDENTIFIER)('head')
-                          PsiWhiteSpace(' ')
-                          OPERATION_REFERENCE
-                            PsiElement(EQEQEQ)('===')
-                          PsiWhiteSpace(' ')
-                          NULL
-                            PsiElement(null)('null')
-                      PsiElement(RPAR)(')')
-                      PsiWhiteSpace('\n        ')
-                      THEN
-                        BINARY_EXPRESSION
-                          REFERENCE_EXPRESSION
-                            PsiElement(IDENTIFIER)('tail')
-                          OPERATION_REFERENCE
-                            PsiElement(EQ)('=')
-                          PsiWhiteSpace(' ')
-                          NULL
-                            PsiElement(null)('null')
-                  PsiWhiteSpace('\n    ')
-                  PsiElement(RBRACE)('}')
-              PsiWhiteSpace(' ')
-              PsiElement(else)('else')
-              PsiWhiteSpace(' ')
-              ELSE
-                FUNCTION_LITERAL
-                  PsiElement(LBRACE)('{')
-                  PsiWhiteSpace('\n      ')
-                  BODY
-                    BINARY_EXPRESSION
-                      DOT_QUALIFIED_EXPRESSION
+                    BLOCK
+                      BINARY_EXPRESSION
+                        REFERENCE_EXPRESSION
+                          PsiElement(IDENTIFIER)('head')
+                        PsiWhiteSpace(' ')
+                        OPERATION_REFERENCE
+                          PsiElement(EQ)('=')
+                        PsiWhiteSpace(' ')
                         DOT_QUALIFIED_EXPRESSION
                           REFERENCE_EXPRESSION
                             PsiElement(IDENTIFIER)('item')
                           PsiElement(DOT)('.')
                           REFERENCE_EXPRESSION
-                            PsiElement(IDENTIFIER)('previous')
-                        PsiElement(DOT)('.')
-                        REFERENCE_EXPRESSION
-                          PsiElement(IDENTIFIER)('next')
-                      PsiWhiteSpace(' ')
-                      OPERATION_REFERENCE
-                        PsiElement(EQ)('=')
-                      PsiWhiteSpace(' ')
-                      DOT_QUALIFIED_EXPRESSION
-                        REFERENCE_EXPRESSION
-                          PsiElement(IDENTIFIER)('item')
-                        PsiElement(DOT)('.')
-                        REFERENCE_EXPRESSION
-                          PsiElement(IDENTIFIER)('next')
+                            PsiElement(IDENTIFIER)('next')
+                      PsiWhiteSpace('\n      ')
+                      IF
+                        PsiElement(if)('if')
+                        PsiWhiteSpace(' ')
+                        PsiElement(LPAR)('(')
+                        CONDITION
+                          BINARY_EXPRESSION
+                            REFERENCE_EXPRESSION
+                              PsiElement(IDENTIFIER)('head')
+                            PsiWhiteSpace(' ')
+                            OPERATION_REFERENCE
+                              PsiElement(EQEQEQ)('===')
+                            PsiWhiteSpace(' ')
+                            NULL
+                              PsiElement(null)('null')
+                        PsiElement(RPAR)(')')
+                        PsiWhiteSpace('\n        ')
+                        THEN
+                          BINARY_EXPRESSION
+                            REFERENCE_EXPRESSION
+                              PsiElement(IDENTIFIER)('tail')
+                            OPERATION_REFERENCE
+                              PsiElement(EQ)('=')
+                            PsiWhiteSpace(' ')
+                            NULL
+                              PsiElement(null)('null')
+                    PsiWhiteSpace('\n    ')
+                    PsiElement(RBRACE)('}')
+              PsiWhiteSpace(' ')
+              PsiElement(else)('else')
+              PsiWhiteSpace(' ')
+              ELSE
+                FUNCTION_LITERAL_EXPRESSION
+                  FUNCTION_LITERAL
+                    PsiElement(LBRACE)('{')
                     PsiWhiteSpace('\n      ')
-                    IF
-                      PsiElement(if)('if')
-                      PsiWhiteSpace(' ')
-                      PsiElement(LPAR)('(')
-                      CONDITION
-                        BINARY_EXPRESSION
+                    BLOCK
+                      BINARY_EXPRESSION
+                        DOT_QUALIFIED_EXPRESSION
                           DOT_QUALIFIED_EXPRESSION
                             REFERENCE_EXPRESSION
                               PsiElement(IDENTIFIER)('item')
                             PsiElement(DOT)('.')
                             REFERENCE_EXPRESSION
-                              PsiElement(IDENTIFIER)('next')
-                          PsiWhiteSpace(' ')
-                          OPERATION_REFERENCE
-                            PsiElement(EQEQEQ)('===')
-                          PsiWhiteSpace(' ')
-                          NULL
-                            PsiElement(null)('null')
-                      PsiElement(RPAR)(')')
-                      PsiWhiteSpace(' ')
-                      THEN
-                        FUNCTION_LITERAL
-                          PsiElement(LBRACE)('{')
-                          PsiWhiteSpace('\n        ')
-                          BODY
-                            BINARY_EXPRESSION
-                              DOT_QUALIFIED_EXPRESSION
-                                DOT_QUALIFIED_EXPRESSION
-                                  REFERENCE_EXPRESSION
-                                    PsiElement(IDENTIFIER)('item')
-                                  PsiElement(DOT)('.')
-                                  REFERENCE_EXPRESSION
-                                    PsiElement(IDENTIFIER)('next')
-                                PsiElement(DOT)('.')
-                                REFERENCE_EXPRESSION
-                                  PsiElement(IDENTIFIER)('previous')
-                              PsiWhiteSpace(' ')
-                              OPERATION_REFERENCE
-                                PsiElement(EQ)('=')
-                              PsiWhiteSpace(' ')
-                              DOT_QUALIFIED_EXPRESSION
-                                REFERENCE_EXPRESSION
-                                  PsiElement(IDENTIFIER)('item')
-                                PsiElement(DOT)('.')
-                                REFERENCE_EXPRESSION
-                                  PsiElement(IDENTIFIER)('previous')
-                          PsiWhiteSpace('\n      ')
-                          PsiElement(RBRACE)('}')
-                      PsiWhiteSpace(' ')
-                      PsiElement(else)('else')
-                      PsiWhiteSpace(' ')
-                      ELSE
-                        FUNCTION_LITERAL
-                          PsiElement(LBRACE)('{')
-                          PsiWhiteSpace('\n        ')
-                          BODY
-                            BINARY_EXPRESSION
+                              PsiElement(IDENTIFIER)('previous')
+                          PsiElement(DOT)('.')
+                          REFERENCE_EXPRESSION
+                            PsiElement(IDENTIFIER)('next')
+                        PsiWhiteSpace(' ')
+                        OPERATION_REFERENCE
+                          PsiElement(EQ)('=')
+                        PsiWhiteSpace(' ')
+                        DOT_QUALIFIED_EXPRESSION
+                          REFERENCE_EXPRESSION
+                            PsiElement(IDENTIFIER)('item')
+                          PsiElement(DOT)('.')
+                          REFERENCE_EXPRESSION
+                            PsiElement(IDENTIFIER)('next')
+                      PsiWhiteSpace('\n      ')
+                      IF
+                        PsiElement(if)('if')
+                        PsiWhiteSpace(' ')
+                        PsiElement(LPAR)('(')
+                        CONDITION
+                          BINARY_EXPRESSION
+                            DOT_QUALIFIED_EXPRESSION
                               REFERENCE_EXPRESSION
-                                PsiElement(IDENTIFIER)('tail')
-                              PsiWhiteSpace(' ')
-                              OPERATION_REFERENCE
-                                PsiElement(EQ)('=')
-                              PsiWhiteSpace(' ')
-                              DOT_QUALIFIED_EXPRESSION
-                                REFERENCE_EXPRESSION
-                                  PsiElement(IDENTIFIER)('tail')
-                                PsiElement(DOT)('.')
-                                REFERENCE_EXPRESSION
-                                  PsiElement(IDENTIFIER)('previous')
-                          PsiWhiteSpace('\n      ')
-                          PsiElement(RBRACE)('}')
-                  PsiWhiteSpace('\n    ')
-                  PsiElement(RBRACE)('}')
+                                PsiElement(IDENTIFIER)('item')
+                              PsiElement(DOT)('.')
+                              REFERENCE_EXPRESSION
+                                PsiElement(IDENTIFIER)('next')
+                            PsiWhiteSpace(' ')
+                            OPERATION_REFERENCE
+                              PsiElement(EQEQEQ)('===')
+                            PsiWhiteSpace(' ')
+                            NULL
+                              PsiElement(null)('null')
+                        PsiElement(RPAR)(')')
+                        PsiWhiteSpace(' ')
+                        THEN
+                          FUNCTION_LITERAL_EXPRESSION
+                            FUNCTION_LITERAL
+                              PsiElement(LBRACE)('{')
+                              PsiWhiteSpace('\n        ')
+                              BLOCK
+                                BINARY_EXPRESSION
+                                  DOT_QUALIFIED_EXPRESSION
+                                    DOT_QUALIFIED_EXPRESSION
+                                      REFERENCE_EXPRESSION
+                                        PsiElement(IDENTIFIER)('item')
+                                      PsiElement(DOT)('.')
+                                      REFERENCE_EXPRESSION
+                                        PsiElement(IDENTIFIER)('next')
+                                    PsiElement(DOT)('.')
+                                    REFERENCE_EXPRESSION
+                                      PsiElement(IDENTIFIER)('previous')
+                                  PsiWhiteSpace(' ')
+                                  OPERATION_REFERENCE
+                                    PsiElement(EQ)('=')
+                                  PsiWhiteSpace(' ')
+                                  DOT_QUALIFIED_EXPRESSION
+                                    REFERENCE_EXPRESSION
+                                      PsiElement(IDENTIFIER)('item')
+                                    PsiElement(DOT)('.')
+                                    REFERENCE_EXPRESSION
+                                      PsiElement(IDENTIFIER)('previous')
+                              PsiWhiteSpace('\n      ')
+                              PsiElement(RBRACE)('}')
+                        PsiWhiteSpace(' ')
+                        PsiElement(else)('else')
+                        PsiWhiteSpace(' ')
+                        ELSE
+                          FUNCTION_LITERAL_EXPRESSION
+                            FUNCTION_LITERAL
+                              PsiElement(LBRACE)('{')
+                              PsiWhiteSpace('\n        ')
+                              BLOCK
+                                BINARY_EXPRESSION
+                                  REFERENCE_EXPRESSION
+                                    PsiElement(IDENTIFIER)('tail')
+                                  PsiWhiteSpace(' ')
+                                  OPERATION_REFERENCE
+                                    PsiElement(EQ)('=')
+                                  PsiWhiteSpace(' ')
+                                  DOT_QUALIFIED_EXPRESSION
+                                    REFERENCE_EXPRESSION
+                                      PsiElement(IDENTIFIER)('tail')
+                                    PsiElement(DOT)('.')
+                                    REFERENCE_EXPRESSION
+                                      PsiElement(IDENTIFIER)('previous')
+                              PsiWhiteSpace('\n      ')
+                              PsiElement(RBRACE)('}')
+                    PsiWhiteSpace('\n    ')
+                    PsiElement(RBRACE)('}')
             PsiWhiteSpace('\n    ')
             POSTFIX_EXPRESSION
               REFERENCE_EXPRESSION
@@ -849,25 +858,26 @@ JetFile: LinkedList.jet
               PsiElement(RPAR)(')')
               PsiWhiteSpace(' ')
               BODY
-                FUNCTION_LITERAL
-                  PsiElement(LBRACE)('{')
-                  PsiWhiteSpace('\n      ')
-                  BODY
-                    BINARY_EXPRESSION
-                      REFERENCE_EXPRESSION
-                        PsiElement(IDENTIFIER)('result')
-                      PsiWhiteSpace(' ')
-                      OPERATION_REFERENCE
-                        PsiElement(EQ)('=')
-                      PsiWhiteSpace(' ')
-                      DOT_QUALIFIED_EXPRESSION
+                FUNCTION_LITERAL_EXPRESSION
+                  FUNCTION_LITERAL
+                    PsiElement(LBRACE)('{')
+                    PsiWhiteSpace('\n      ')
+                    BLOCK
+                      BINARY_EXPRESSION
                         REFERENCE_EXPRESSION
                           PsiElement(IDENTIFIER)('result')
-                        PsiElement(DOT)('.')
-                        REFERENCE_EXPRESSION
-                          PsiElement(IDENTIFIER)('next')
-                  PsiWhiteSpace('\n    ')
-                  PsiElement(RBRACE)('}')
+                        PsiWhiteSpace(' ')
+                        OPERATION_REFERENCE
+                          PsiElement(EQ)('=')
+                        PsiWhiteSpace(' ')
+                        DOT_QUALIFIED_EXPRESSION
+                          REFERENCE_EXPRESSION
+                            PsiElement(IDENTIFIER)('result')
+                          PsiElement(DOT)('.')
+                          REFERENCE_EXPRESSION
+                            PsiElement(IDENTIFIER)('next')
+                    PsiWhiteSpace('\n    ')
+                    PsiElement(RBRACE)('}')
             PsiWhiteSpace('\n    ')
             RETURN
               PsiElement(return)('return')

idea/testData/psi/examples/io/IOSamples.txt

@@ -356,36 +356,37 @@ JetFile: IOSamples.jet
               PsiElement(RPAR)(')')
               PsiWhiteSpace(' ')
               THEN
-                FUNCTION_LITERAL
-                  PsiElement(LBRACE)('{')
-                  PsiWhiteSpace('\n      ')
-                  BODY
-                    BINARY_EXPRESSION
-                      REFERENCE_EXPRESSION
-                        PsiElement(IDENTIFIER)('nextUsed')
-                      PsiWhiteSpace(' ')
-                      OPERATION_REFERENCE
-                        PsiElement(EQ)('=')
-                      PsiWhiteSpace(' ')
-                      BOOLEAN_CONSTANT
-                        PsiElement(true)('true')
+                FUNCTION_LITERAL_EXPRESSION
+                  FUNCTION_LITERAL
+                    PsiElement(LBRACE)('{')
                     PsiWhiteSpace('\n      ')
-                    RETURN
-                      PsiElement(return)('return')
-                      PsiWhiteSpace(' ')
-                      BINARY_WITH_TYPE
+                    BLOCK
+                      BINARY_EXPRESSION
                         REFERENCE_EXPRESSION
-                          PsiElement(IDENTIFIER)('next')
+                          PsiElement(IDENTIFIER)('nextUsed')
                         PsiWhiteSpace(' ')
                         OPERATION_REFERENCE
-                          PsiElement(as)('as')
+                          PsiElement(EQ)('=')
                         PsiWhiteSpace(' ')
-                        TYPE_REFERENCE
-                          USER_TYPE
-                            REFERENCE_EXPRESSION
-                              PsiElement(IDENTIFIER)('Byte')
-                  PsiWhiteSpace('\n    ')
-                  PsiElement(RBRACE)('}')
+                        BOOLEAN_CONSTANT
+                          PsiElement(true)('true')
+                      PsiWhiteSpace('\n      ')
+                      RETURN
+                        PsiElement(return)('return')
+                        PsiWhiteSpace(' ')
+                        BINARY_WITH_TYPE
+                          REFERENCE_EXPRESSION
+                            PsiElement(IDENTIFIER)('next')
+                          PsiWhiteSpace(' ')
+                          OPERATION_REFERENCE
+                            PsiElement(as)('as')
+                          PsiWhiteSpace(' ')
+                          TYPE_REFERENCE
+                            USER_TYPE
+                              REFERENCE_EXPRESSION
+                                PsiElement(IDENTIFIER)('Byte')
+                    PsiWhiteSpace('\n    ')
+                    PsiElement(RBRACE)('}')
             PsiWhiteSpace('\n    ')
             RETURN
               PsiElement(return)('return')
@@ -437,41 +438,42 @@ JetFile: IOSamples.jet
                 PsiElement(RPAR)(')')
                 PsiWhiteSpace(' ')
                 THEN
-                  FUNCTION_LITERAL
-                    PsiElement(LBRACE)('{')
-                    PsiWhiteSpace('\n        ')
-                    BODY
-                      BINARY_EXPRESSION
-                        REFERENCE_EXPRESSION
-                          PsiElement(IDENTIFIER)('nextUsed')
-                        PsiWhiteSpace(' ')
-                        OPERATION_REFERENCE
-                          PsiElement(EQ)('=')
-                        PsiWhiteSpace(' ')
-                        BOOLEAN_CONSTANT
-                          PsiElement(false)('false')
+                  FUNCTION_LITERAL_EXPRESSION
+                    FUNCTION_LITERAL
+                      PsiElement(LBRACE)('{')
                       PsiWhiteSpace('\n        ')
-                      BINARY_EXPRESSION
-                        REFERENCE_EXPRESSION
-                          PsiElement(IDENTIFIER)('next')
-                        PsiWhiteSpace(' ')
-                        OPERATION_REFERENCE
-                          PsiElement(EQ)('=')
-                        PsiWhiteSpace(' ')
-                        DOT_QUALIFIED_EXPRESSION
+                      BLOCK
+                        BINARY_EXPRESSION
                           REFERENCE_EXPRESSION
-                            PsiElement(IDENTIFIER)('stream')
-                          PsiElement(DOT)('.')
-                          CALL_EXPRESSION
+                            PsiElement(IDENTIFIER)('nextUsed')
+                          PsiWhiteSpace(' ')
+                          OPERATION_REFERENCE
+                            PsiElement(EQ)('=')
+                          PsiWhiteSpace(' ')
+                          BOOLEAN_CONSTANT
+                            PsiElement(false)('false')
+                        PsiWhiteSpace('\n        ')
+                        BINARY_EXPRESSION
+                          REFERENCE_EXPRESSION
+                            PsiElement(IDENTIFIER)('next')
+                          PsiWhiteSpace(' ')
+                          OPERATION_REFERENCE
+                            PsiElement(EQ)('=')
+                          PsiWhiteSpace(' ')
+                          DOT_QUALIFIED_EXPRESSION
                             REFERENCE_EXPRESSION
-                              PsiElement(IDENTIFIER)('read')
-                            VALUE_ARGUMENT_LIST
-                              PsiElement(LPAR)('(')
-                              PsiElement(RPAR)(')')
-                    PsiWhiteSpace(' ')
-                    PsiComment(EOL_COMMENT)('// throws IOException')
-                    PsiWhiteSpace('\n      ')
-                    PsiElement(RBRACE)('}')
+                              PsiElement(IDENTIFIER)('stream')
+                            PsiElement(DOT)('.')
+                            CALL_EXPRESSION
+                              REFERENCE_EXPRESSION
+                                PsiElement(IDENTIFIER)('read')
+                              VALUE_ARGUMENT_LIST
+                                PsiElement(LPAR)('(')
+                                PsiElement(RPAR)(')')
+                      PsiWhiteSpace(' ')
+                      PsiComment(EOL_COMMENT)('// throws IOException')
+                      PsiWhiteSpace('\n      ')
+                      PsiElement(RBRACE)('}')
               PsiWhiteSpace('\n      ')
               RETURN
                 PsiElement(return)('return')

idea/testData/psi/examples/priorityqueues/BinaryHeap.txt

@@ -209,21 +209,22 @@ JetFile: BinaryHeap.jet
               PsiElement(RPAR)(')')
               PsiWhiteSpace(' ')
               BODY
-                FUNCTION_LITERAL
-                  PsiElement(LBRACE)('{')
-                  PsiWhiteSpace('\n      ')
-                  BODY
-                    CALL_EXPRESSION
-                      REFERENCE_EXPRESSION
-                        PsiElement(IDENTIFIER)('siftDown')
-                      VALUE_ARGUMENT_LIST
-                        PsiElement(LPAR)('(')
-                        VALUE_ARGUMENT
-                          REFERENCE_EXPRESSION
-                            PsiElement(IDENTIFIER)('i')
-                        PsiElement(RPAR)(')')
-                  PsiWhiteSpace('\n    ')
-                  PsiElement(RBRACE)('}')
+                FUNCTION_LITERAL_EXPRESSION
+                  FUNCTION_LITERAL
+                    PsiElement(LBRACE)('{')
+                    PsiWhiteSpace('\n      ')
+                    BLOCK
+                      CALL_EXPRESSION
+                        REFERENCE_EXPRESSION
+                          PsiElement(IDENTIFIER)('siftDown')
+                        VALUE_ARGUMENT_LIST
+                          PsiElement(LPAR)('(')
+                          VALUE_ARGUMENT
+                            REFERENCE_EXPRESSION
+                              PsiElement(IDENTIFIER)('i')
+                          PsiElement(RPAR)(')')
+                    PsiWhiteSpace('\n    ')
+                    PsiElement(RBRACE)('}')
             PsiWhiteSpace('\n\n  ')
             PsiElement(RBRACE)('}')
         PsiWhiteSpace('\n\n  ')
@@ -574,89 +575,26 @@ JetFile: BinaryHeap.jet
               PsiElement(RPAR)(')')
               PsiWhiteSpace(' ')
               BODY
-                FUNCTION_LITERAL
-                  PsiElement(LBRACE)('{')
-                  PsiWhiteSpace('\n      ')
-                  BODY
-                    PROPERTY
-                      PsiElement(var)('var')
-                      PsiWhiteSpace(' ')
-                      PsiElement(IDENTIFIER)('min')
-                      PsiWhiteSpace(' ')
-                      PsiElement(EQ)('=')
-                      PsiWhiteSpace(' ')
-                      REFERENCE_EXPRESSION
-                        PsiElement(IDENTIFIER)('current')
+                FUNCTION_LITERAL_EXPRESSION
+                  FUNCTION_LITERAL
+                    PsiElement(LBRACE)('{')
                     PsiWhiteSpace('\n      ')
-                    IF
-                      PsiElement(if)('if')
-                      PsiWhiteSpace(' ')
-                      PsiElement(LPAR)('(')
-                      CONDITION
-                        BINARY_EXPRESSION
-                          DOT_QUALIFIED_EXPRESSION
-                            DOT_QUALIFIED_EXPRESSION
-                              REFERENCE_EXPRESSION
-                                PsiElement(IDENTIFIER)('current')
-                              PsiElement(DOT)('.')
-                              REFERENCE_EXPRESSION
-                                PsiElement(IDENTIFIER)('left')
-                            PsiElement(DOT)('.')
-                            REFERENCE_EXPRESSION
-                              PsiElement(IDENTIFIER)('value')
-                          PsiWhiteSpace(' ')
-                          OPERATION_REFERENCE
-                            PsiElement(LT)('<')
-                          PsiWhiteSpace(' ')
-                          DOT_QUALIFIED_EXPRESSION
-                            REFERENCE_EXPRESSION
-                              PsiElement(IDENTIFIER)('min')
-                            PsiElement(DOT)('.')
-                            REFERENCE_EXPRESSION
-                              PsiElement(IDENTIFIER)('value')
-                      PsiElement(RPAR)(')')
-                      PsiWhiteSpace(' ')
-                      THEN
-                        FUNCTION_LITERAL
-                          PsiElement(LBRACE)('{')
-                          PsiWhiteSpace('\n        ')
-                          BODY
-                            BINARY_EXPRESSION
-                              REFERENCE_EXPRESSION
-                                PsiElement(IDENTIFIER)('min')
-                              PsiWhiteSpace(' ')
-                              OPERATION_REFERENCE
-                                PsiElement(EQ)('=')
-                              PsiWhiteSpace(' ')
-                              DOT_QUALIFIED_EXPRESSION
-                                REFERENCE_EXPRESSION
-                                  PsiElement(IDENTIFIER)('current')
-                                PsiElement(DOT)('.')
-                                REFERENCE_EXPRESSION
-                                  PsiElement(IDENTIFIER)('left')
-                          PsiWhiteSpace('\n      ')
-                          PsiElement(RBRACE)('}')
-                    PsiWhiteSpace('\n      ')
-                    IF
-                      PsiElement(if)('if')
-                      PsiWhiteSpace(' ')
-                      PsiElement(LPAR)('(')
-                      CONDITION
-                        BINARY_EXPRESSION
-                          DOT_QUALIFIED_EXPRESSION
-                            DOT_QUALIFIED_EXPRESSION
-                              REFERENCE_EXPRESSION
-                                PsiElement(IDENTIFIER)('current')
-                              PsiElement(DOT)('.')
-                              REFERENCE_EXPRESSION
-                                PsiElement(IDENTIFIER)('right')
-                            PsiElement(DOT)('.')
-                            REFERENCE_EXPRESSION
-                              PsiElement(IDENTIFIER)('exists')
-                          PsiWhiteSpace(' ')
-                          OPERATION_REFERENCE
-                            PsiElement(ANDAND)('&&')
-                          PsiWhiteSpace(' ')
+                    BLOCK
+                      PROPERTY
+                        PsiElement(var)('var')
+                        PsiWhiteSpace(' ')
+                        PsiElement(IDENTIFIER)('min')
+                        PsiWhiteSpace(' ')
+                        PsiElement(EQ)('=')
+                        PsiWhiteSpace(' ')
+                        REFERENCE_EXPRESSION
+                          PsiElement(IDENTIFIER)('current')
+                      PsiWhiteSpace('\n      ')
+                      IF
+                        PsiElement(if)('if')
+                        PsiWhiteSpace(' ')
+                        PsiElement(LPAR)('(')
+                        CONDITION
                           BINARY_EXPRESSION
                             DOT_QUALIFIED_EXPRESSION
                               DOT_QUALIFIED_EXPRESSION
@@ -664,7 +602,7 @@ JetFile: BinaryHeap.jet
                                   PsiElement(IDENTIFIER)('current')
                                 PsiElement(DOT)('.')
                                 REFERENCE_EXPRESSION
-                                  PsiElement(IDENTIFIER)('right')
+                                  PsiElement(IDENTIFIER)('left')
                               PsiElement(DOT)('.')
                               REFERENCE_EXPRESSION
                                 PsiElement(IDENTIFIER)('value')
@@ -678,79 +616,145 @@ JetFile: BinaryHeap.jet
                               PsiElement(DOT)('.')
                               REFERENCE_EXPRESSION
                                 PsiElement(IDENTIFIER)('value')
-                      PsiElement(RPAR)(')')
-                      PsiWhiteSpace(' ')
-                      THEN
-                        FUNCTION_LITERAL
-                          PsiElement(LBRACE)('{')
-                          PsiWhiteSpace('\n        ')
-                          BODY
-                            BINARY_EXPRESSION
-                              REFERENCE_EXPRESSION
-                                PsiElement(IDENTIFIER)('min')
-                              PsiWhiteSpace(' ')
-                              OPERATION_REFERENCE
-                                PsiElement(EQ)('=')
-                              PsiWhiteSpace(' ')
+                        PsiElement(RPAR)(')')
+                        PsiWhiteSpace(' ')
+                        THEN
+                          FUNCTION_LITERAL_EXPRESSION
+                            FUNCTION_LITERAL
+                              PsiElement(LBRACE)('{')
+                              PsiWhiteSpace('\n        ')
+                              BLOCK
+                                BINARY_EXPRESSION
+                                  REFERENCE_EXPRESSION
+                                    PsiElement(IDENTIFIER)('min')
+                                  PsiWhiteSpace(' ')
+                                  OPERATION_REFERENCE
+                                    PsiElement(EQ)('=')
+                                  PsiWhiteSpace(' ')
+                                  DOT_QUALIFIED_EXPRESSION
+                                    REFERENCE_EXPRESSION
+                                      PsiElement(IDENTIFIER)('current')
+                                    PsiElement(DOT)('.')
+                                    REFERENCE_EXPRESSION
+                                      PsiElement(IDENTIFIER)('left')
+                              PsiWhiteSpace('\n      ')
+                              PsiElement(RBRACE)('}')
+                      PsiWhiteSpace('\n      ')
+                      IF
+                        PsiElement(if)('if')
+                        PsiWhiteSpace(' ')
+                        PsiElement(LPAR)('(')
+                        CONDITION
+                          BINARY_EXPRESSION
+                            DOT_QUALIFIED_EXPRESSION
                               DOT_QUALIFIED_EXPRESSION
                                 REFERENCE_EXPRESSION
                                   PsiElement(IDENTIFIER)('current')
                                 PsiElement(DOT)('.')
                                 REFERENCE_EXPRESSION
                                   PsiElement(IDENTIFIER)('right')
-                          PsiWhiteSpace('\n      ')
-                          PsiElement(RBRACE)('}')
-                    PsiWhiteSpace('\n      ')
-                    IF
-                      PsiElement(if)('if')
-                      PsiWhiteSpace(' ')
-                      PsiElement(LPAR)('(')
-                      CONDITION
-                        BINARY_EXPRESSION
-                          REFERENCE_EXPRESSION
-                            PsiElement(IDENTIFIER)('min')
-                          PsiWhiteSpace(' ')
-                          OPERATION_REFERENCE
-                            PsiElement(EQEQ)('==')
-                          PsiWhiteSpace(' ')
-                          REFERENCE_EXPRESSION
-                            PsiElement(IDENTIFIER)('current')
-                      PsiElement(RPAR)(')')
-                      PsiWhiteSpace(' ')
-                      THEN
-                        BREAK
-                          PsiElement(break)('break')
-                    PsiWhiteSpace('\n      ')
-                    DOT_QUALIFIED_EXPRESSION
-                      REFERENCE_EXPRESSION
-                        PsiElement(IDENTIFIER)('data')
-                      PsiElement(DOT)('.')
-                      CALL_EXPRESSION
-                        REFERENCE_EXPRESSION
-                          PsiElement(IDENTIFIER)('swap')
-                        VALUE_ARGUMENT_LIST
-                          PsiElement(LPAR)('(')
-                          VALUE_ARGUMENT
+                              PsiElement(DOT)('.')
+                              REFERENCE_EXPRESSION
+                                PsiElement(IDENTIFIER)('exists')
+                            PsiWhiteSpace(' ')
+                            OPERATION_REFERENCE
+                              PsiElement(ANDAND)('&&')
+                            PsiWhiteSpace(' ')
+                            BINARY_EXPRESSION
+                              DOT_QUALIFIED_EXPRESSION
+                                DOT_QUALIFIED_EXPRESSION
+                                  REFERENCE_EXPRESSION
+                                    PsiElement(IDENTIFIER)('current')
+                                  PsiElement(DOT)('.')
+                                  REFERENCE_EXPRESSION
+                                    PsiElement(IDENTIFIER)('right')
+                                PsiElement(DOT)('.')
+                                REFERENCE_EXPRESSION
+                                  PsiElement(IDENTIFIER)('value')
+                              PsiWhiteSpace(' ')
+                              OPERATION_REFERENCE
+                                PsiElement(LT)('<')
+                              PsiWhiteSpace(' ')
+                              DOT_QUALIFIED_EXPRESSION
+                                REFERENCE_EXPRESSION
+                                  PsiElement(IDENTIFIER)('min')
+                                PsiElement(DOT)('.')
+                                REFERENCE_EXPRESSION
+                                  PsiElement(IDENTIFIER)('value')
+                        PsiElement(RPAR)(')')
+                        PsiWhiteSpace(' ')
+                        THEN
+                          FUNCTION_LITERAL_EXPRESSION
+                            FUNCTION_LITERAL
+                              PsiElement(LBRACE)('{')
+                              PsiWhiteSpace('\n        ')
+                              BLOCK
+                                BINARY_EXPRESSION
+                                  REFERENCE_EXPRESSION
+                                    PsiElement(IDENTIFIER)('min')
+                                  PsiWhiteSpace(' ')
+                                  OPERATION_REFERENCE
+                                    PsiElement(EQ)('=')
+                                  PsiWhiteSpace(' ')
+                                  DOT_QUALIFIED_EXPRESSION
+                                    REFERENCE_EXPRESSION
+                                      PsiElement(IDENTIFIER)('current')
+                                    PsiElement(DOT)('.')
+                                    REFERENCE_EXPRESSION
+                                      PsiElement(IDENTIFIER)('right')
+                              PsiWhiteSpace('\n      ')
+                              PsiElement(RBRACE)('}')
+                      PsiWhiteSpace('\n      ')
+                      IF
+                        PsiElement(if)('if')
+                        PsiWhiteSpace(' ')
+                        PsiElement(LPAR)('(')
+                        CONDITION
+                          BINARY_EXPRESSION
                             REFERENCE_EXPRESSION
                               PsiElement(IDENTIFIER)('min')
-                          PsiElement(COMMA)(',')
-                          PsiWhiteSpace(' ')
-                          VALUE_ARGUMENT
+                            PsiWhiteSpace(' ')
+                            OPERATION_REFERENCE
+                              PsiElement(EQEQ)('==')
+                            PsiWhiteSpace(' ')
                             REFERENCE_EXPRESSION
                               PsiElement(IDENTIFIER)('current')
-                          PsiElement(RPAR)(')')
-                    PsiWhiteSpace('\n      ')
-                    BINARY_EXPRESSION
-                      REFERENCE_EXPRESSION
-                        PsiElement(IDENTIFIER)('current')
-                      PsiWhiteSpace(' ')
-                      OPERATION_REFERENCE
-                        PsiElement(EQ)('=')
-                      PsiWhiteSpace(' ')
-                      REFERENCE_EXPRESSION
-                        PsiElement(IDENTIFIER)('min')
-                  PsiWhiteSpace('\n    ')
-                  PsiElement(RBRACE)('}')
+                        PsiElement(RPAR)(')')
+                        PsiWhiteSpace(' ')
+                        THEN
+                          BREAK
+                            PsiElement(break)('break')
+                      PsiWhiteSpace('\n      ')
+                      DOT_QUALIFIED_EXPRESSION
+                        REFERENCE_EXPRESSION
+                          PsiElement(IDENTIFIER)('data')
+                        PsiElement(DOT)('.')
+                        CALL_EXPRESSION
+                          REFERENCE_EXPRESSION
+                            PsiElement(IDENTIFIER)('swap')
+                          VALUE_ARGUMENT_LIST
+                            PsiElement(LPAR)('(')
+                            VALUE_ARGUMENT
+                              REFERENCE_EXPRESSION
+                                PsiElement(IDENTIFIER)('min')
+                            PsiElement(COMMA)(',')
+                            PsiWhiteSpace(' ')
+                            VALUE_ARGUMENT
+                              REFERENCE_EXPRESSION
+                                PsiElement(IDENTIFIER)('current')
+                            PsiElement(RPAR)(')')
+                      PsiWhiteSpace('\n      ')
+                      BINARY_EXPRESSION
+                        REFERENCE_EXPRESSION
+                          PsiElement(IDENTIFIER)('current')
+                        PsiWhiteSpace(' ')
+                        OPERATION_REFERENCE
+                          PsiElement(EQ)('=')
+                        PsiWhiteSpace(' ')
+                        REFERENCE_EXPRESSION
+                          PsiElement(IDENTIFIER)('min')
+                    PsiWhiteSpace('\n    ')
+                    PsiElement(RBRACE)('}')
             PsiWhiteSpace('\n  ')
             PsiElement(RBRACE)('}')
         PsiWhiteSpace('\n\n  ')
@@ -825,83 +829,85 @@ JetFile: BinaryHeap.jet
               PsiElement(RPAR)(')')
               PsiWhiteSpace(' ')
               BODY
-                FUNCTION_LITERAL
-                  PsiElement(LBRACE)('{')
-                  PsiWhiteSpace('\n      ')
-                  BODY
-                    IF
-                      PsiElement(if)('if')
-                      PsiWhiteSpace(' ')
-                      PsiElement(LPAR)('(')
-                      CONDITION
-                        BINARY_EXPRESSION
-                          DOT_QUALIFIED_EXPRESSION
-                            REFERENCE_EXPRESSION
-                              PsiElement(IDENTIFIER)('current')
-                            PsiElement(DOT)('.')
-                            REFERENCE_EXPRESSION
-                              PsiElement(IDENTIFIER)('value')
-                          PsiWhiteSpace(' ')
-                          OPERATION_REFERENCE
-                            PsiElement(LT)('<')
-                          PsiWhiteSpace(' ')
-                          DOT_QUALIFIED_EXPRESSION
+                FUNCTION_LITERAL_EXPRESSION
+                  FUNCTION_LITERAL
+                    PsiElement(LBRACE)('{')
+                    PsiWhiteSpace('\n      ')
+                    BLOCK
+                      IF
+                        PsiElement(if)('if')
+                        PsiWhiteSpace(' ')
+                        PsiElement(LPAR)('(')
+                        CONDITION
+                          BINARY_EXPRESSION
                             DOT_QUALIFIED_EXPRESSION
                               REFERENCE_EXPRESSION
                                 PsiElement(IDENTIFIER)('current')
                               PsiElement(DOT)('.')
                               REFERENCE_EXPRESSION
-                                PsiElement(IDENTIFIER)('parent')
-                            PsiElement(DOT)('.')
-                            REFERENCE_EXPRESSION
-                              PsiElement(IDENTIFIER)('value')
-                      PsiElement(RPAR)(')')
-                      PsiWhiteSpace(' ')
-                      THEN
-                        FUNCTION_LITERAL
-                          PsiElement(LBRACE)('{')
-                          PsiWhiteSpace('\n        ')
-                          BODY
+                                PsiElement(IDENTIFIER)('value')
+                            PsiWhiteSpace(' ')
+                            OPERATION_REFERENCE
+                              PsiElement(LT)('<')
+                            PsiWhiteSpace(' ')
                             DOT_QUALIFIED_EXPRESSION
-                              REFERENCE_EXPRESSION
-                                PsiElement(IDENTIFIER)('data')
-                              PsiElement(DOT)('.')
-                              CALL_EXPRESSION
-                                REFERENCE_EXPRESSION
-                                  PsiElement(IDENTIFIER)('swap')
-                                VALUE_ARGUMENT_LIST
-                                  PsiElement(LPAR)('(')
-                                  VALUE_ARGUMENT
-                                    REFERENCE_EXPRESSION
-                                      PsiElement(IDENTIFIER)('current')
-                                  PsiElement(COMMA)(',')
-                                  PsiWhiteSpace(' ')
-                                  VALUE_ARGUMENT
-                                    DOT_QUALIFIED_EXPRESSION
-                                      REFERENCE_EXPRESSION
-                                        PsiElement(IDENTIFIER)('current')
-                                      PsiElement(DOT)('.')
-                                      REFERENCE_EXPRESSION
-                                        PsiElement(IDENTIFIER)('parent')
-                                  PsiElement(RPAR)(')')
-                            PsiWhiteSpace('\n        ')
-                            BINARY_EXPRESSION
-                              REFERENCE_EXPRESSION
-                                PsiElement(IDENTIFIER)('current')
-                              PsiWhiteSpace(' ')
-                              OPERATION_REFERENCE
-                                PsiElement(EQ)('=')
-                              PsiWhiteSpace(' ')
                               DOT_QUALIFIED_EXPRESSION
                                 REFERENCE_EXPRESSION
                                   PsiElement(IDENTIFIER)('current')
                                 PsiElement(DOT)('.')
                                 REFERENCE_EXPRESSION
                                   PsiElement(IDENTIFIER)('parent')
-                          PsiWhiteSpace('\n      ')
-                          PsiElement(RBRACE)('}')
-                  PsiWhiteSpace('\n    ')
-                  PsiElement(RBRACE)('}')
+                              PsiElement(DOT)('.')
+                              REFERENCE_EXPRESSION
+                                PsiElement(IDENTIFIER)('value')
+                        PsiElement(RPAR)(')')
+                        PsiWhiteSpace(' ')
+                        THEN
+                          FUNCTION_LITERAL_EXPRESSION
+                            FUNCTION_LITERAL
+                              PsiElement(LBRACE)('{')
+                              PsiWhiteSpace('\n        ')
+                              BLOCK
+                                DOT_QUALIFIED_EXPRESSION
+                                  REFERENCE_EXPRESSION
+                                    PsiElement(IDENTIFIER)('data')
+                                  PsiElement(DOT)('.')
+                                  CALL_EXPRESSION
+                                    REFERENCE_EXPRESSION
+                                      PsiElement(IDENTIFIER)('swap')
+                                    VALUE_ARGUMENT_LIST
+                                      PsiElement(LPAR)('(')
+                                      VALUE_ARGUMENT
+                                        REFERENCE_EXPRESSION
+                                          PsiElement(IDENTIFIER)('current')
+                                      PsiElement(COMMA)(',')
+                                      PsiWhiteSpace(' ')
+                                      VALUE_ARGUMENT
+                                        DOT_QUALIFIED_EXPRESSION
+                                          REFERENCE_EXPRESSION
+                                            PsiElement(IDENTIFIER)('current')
+                                          PsiElement(DOT)('.')
+                                          REFERENCE_EXPRESSION
+                                            PsiElement(IDENTIFIER)('parent')
+                                      PsiElement(RPAR)(')')
+                                PsiWhiteSpace('\n        ')
+                                BINARY_EXPRESSION
+                                  REFERENCE_EXPRESSION
+                                    PsiElement(IDENTIFIER)('current')
+                                  PsiWhiteSpace(' ')
+                                  OPERATION_REFERENCE
+                                    PsiElement(EQ)('=')
+                                  PsiWhiteSpace(' ')
+                                  DOT_QUALIFIED_EXPRESSION
+                                    REFERENCE_EXPRESSION
+                                      PsiElement(IDENTIFIER)('current')
+                                    PsiElement(DOT)('.')
+                                    REFERENCE_EXPRESSION
+                                      PsiElement(IDENTIFIER)('parent')
+                              PsiWhiteSpace('\n      ')
+                              PsiElement(RBRACE)('}')
+                    PsiWhiteSpace('\n    ')
+                    PsiElement(RBRACE)('}')
             PsiWhiteSpace('\n  ')
             PsiElement(RBRACE)('}')
         PsiWhiteSpace('\n\n  ')

idea/testData/psi/examples/util/Comparison.txt

@@ -328,105 +328,106 @@ JetFile: Comparison.jet
       PsiWhiteSpace(' ')
       PsiElement(EQ)('=')
       PsiWhiteSpace(' ')
-      FUNCTION_LITERAL
-        PsiElement(LBRACE)('{')
-        VALUE_PARAMETER_LIST
-          PsiElement(LPAR)('(')
-          VALUE_PARAMETER
-            PsiElement(IDENTIFIER)('a')
-          PsiElement(COMMA)(',')
+      FUNCTION_LITERAL_EXPRESSION
+        FUNCTION_LITERAL
+          PsiElement(LBRACE)('{')
+          VALUE_PARAMETER_LIST
+            PsiElement(LPAR)('(')
+            VALUE_PARAMETER
+              PsiElement(IDENTIFIER)('a')
+            PsiElement(COMMA)(',')
+            PsiWhiteSpace(' ')
+            VALUE_PARAMETER
+              PsiElement(IDENTIFIER)('b')
+            PsiElement(RPAR)(')')
           PsiWhiteSpace(' ')
-          VALUE_PARAMETER
-            PsiElement(IDENTIFIER)('b')
-          PsiElement(RPAR)(')')
-        PsiWhiteSpace(' ')
-        PsiElement(DOUBLE_ARROW)('=>')
-        PsiWhiteSpace('\n  ')
-        BODY
-          PROPERTY
-            PsiElement(val)('val')
-            PsiWhiteSpace(' ')
-            PsiElement(IDENTIFIER)('res')
-            PsiWhiteSpace(' ')
-            PsiElement(EQ)('=')
-            PsiWhiteSpace(' ')
-            CALL_EXPRESSION
-              REFERENCE_EXPRESSION
-                PsiElement(IDENTIFIER)('cmp')
-              VALUE_ARGUMENT_LIST
-                PsiElement(LPAR)('(')
-                VALUE_ARGUMENT
-                  REFERENCE_EXPRESSION
-                    PsiElement(IDENTIFIER)('a')
-                PsiElement(COMMA)(',')
-                PsiWhiteSpace(' ')
-                VALUE_ARGUMENT
-                  REFERENCE_EXPRESSION
-                    PsiElement(IDENTIFIER)('b')
-                PsiElement(RPAR)(')')
+          PsiElement(DOUBLE_ARROW)('=>')
           PsiWhiteSpace('\n  ')
-          IF
-            PsiElement(if)('if')
-            PsiWhiteSpace(' ')
-            PsiElement(LPAR)('(')
-            CONDITION
-              BINARY_EXPRESSION
+          BLOCK
+            PROPERTY
+              PsiElement(val)('val')
+              PsiWhiteSpace(' ')
+              PsiElement(IDENTIFIER)('res')
+              PsiWhiteSpace(' ')
+              PsiElement(EQ)('=')
+              PsiWhiteSpace(' ')
+              CALL_EXPRESSION
                 REFERENCE_EXPRESSION
-                  PsiElement(IDENTIFIER)('res')
-                PsiWhiteSpace(' ')
-                OPERATION_REFERENCE
-                  PsiElement(EQEQ)('==')
-                PsiWhiteSpace(' ')
-                INTEGER_CONSTANT
-                  PsiElement(INTEGER_LITERAL)('0')
-            PsiElement(RPAR)(')')
-            PsiWhiteSpace(' ')
-            THEN
-              RETURN
-                PsiElement(return)('return')
-                PsiWhiteSpace(' ')
-                DOT_QUALIFIED_EXPRESSION
+                  PsiElement(IDENTIFIER)('cmp')
+                VALUE_ARGUMENT_LIST
+                  PsiElement(LPAR)('(')
+                  VALUE_ARGUMENT
+                    REFERENCE_EXPRESSION
+                      PsiElement(IDENTIFIER)('a')
+                  PsiElement(COMMA)(',')
+                  PsiWhiteSpace(' ')
+                  VALUE_ARGUMENT
+                    REFERENCE_EXPRESSION
+                      PsiElement(IDENTIFIER)('b')
+                  PsiElement(RPAR)(')')
+            PsiWhiteSpace('\n  ')
+            IF
+              PsiElement(if)('if')
+              PsiWhiteSpace(' ')
+              PsiElement(LPAR)('(')
+              CONDITION
+                BINARY_EXPRESSION
                   REFERENCE_EXPRESSION
-                    PsiElement(IDENTIFIER)('ComparisonResult')
-                  PsiElement(DOT)('.')
+                    PsiElement(IDENTIFIER)('res')
+                  PsiWhiteSpace(' ')
+                  OPERATION_REFERENCE
+                    PsiElement(EQEQ)('==')
+                  PsiWhiteSpace(' ')
+                  INTEGER_CONSTANT
+                    PsiElement(INTEGER_LITERAL)('0')
+              PsiElement(RPAR)(')')
+              PsiWhiteSpace(' ')
+              THEN
+                RETURN
+                  PsiElement(return)('return')
+                  PsiWhiteSpace(' ')
+                  DOT_QUALIFIED_EXPRESSION
+                    REFERENCE_EXPRESSION
+                      PsiElement(IDENTIFIER)('ComparisonResult')
+                    PsiElement(DOT)('.')
+                    REFERENCE_EXPRESSION
+                      PsiElement(IDENTIFIER)('EQ')
+            PsiWhiteSpace('\n  ')
+            IF
+              PsiElement(if)('if')
+              PsiWhiteSpace(' ')
+              PsiElement(LPAR)('(')
+              CONDITION
+                BINARY_EXPRESSION
                   REFERENCE_EXPRESSION
-                    PsiElement(IDENTIFIER)('EQ')
-          PsiWhiteSpace('\n  ')
-          IF
-            PsiElement(if)('if')
-            PsiWhiteSpace(' ')
-            PsiElement(LPAR)('(')
-            CONDITION
-              BINARY_EXPRESSION
+                    PsiElement(IDENTIFIER)('res')
+                  PsiWhiteSpace(' ')
+                  OPERATION_REFERENCE
+                    PsiElement(LT)('<')
+                  PsiWhiteSpace(' ')
+                  INTEGER_CONSTANT
+                    PsiElement(INTEGER_LITERAL)('0')
+              PsiElement(RPAR)(')')
+              PsiWhiteSpace(' ')
+              THEN
+                RETURN
+                  PsiElement(return)('return')
+                  PsiWhiteSpace(' ')
+                  DOT_QUALIFIED_EXPRESSION
+                    REFERENCE_EXPRESSION
+                      PsiElement(IDENTIFIER)('ComparisonResult')
+                    PsiElement(DOT)('.')
+                    REFERENCE_EXPRESSION
+                      PsiElement(IDENTIFIER)('LS')
+            PsiWhiteSpace('\n  ')
+            RETURN
+              PsiElement(return)('return')
+              PsiWhiteSpace(' ')
+              DOT_QUALIFIED_EXPRESSION
                 REFERENCE_EXPRESSION
-                  PsiElement(IDENTIFIER)('res')
-                PsiWhiteSpace(' ')
-                OPERATION_REFERENCE
-                  PsiElement(LT)('<')
-                PsiWhiteSpace(' ')
-                INTEGER_CONSTANT
-                  PsiElement(INTEGER_LITERAL)('0')
-            PsiElement(RPAR)(')')
-            PsiWhiteSpace(' ')
-            THEN
-              RETURN
-                PsiElement(return)('return')
-                PsiWhiteSpace(' ')
-                DOT_QUALIFIED_EXPRESSION
-                  REFERENCE_EXPRESSION
-                    PsiElement(IDENTIFIER)('ComparisonResult')
-                  PsiElement(DOT)('.')
-                  REFERENCE_EXPRESSION
-                    PsiElement(IDENTIFIER)('LS')
-          PsiWhiteSpace('\n  ')
-          RETURN
-            PsiElement(return)('return')
-            PsiWhiteSpace(' ')
-            DOT_QUALIFIED_EXPRESSION
-              REFERENCE_EXPRESSION
-                PsiElement(IDENTIFIER)('ComparisonResult')
-              PsiElement(DOT)('.')
-              REFERENCE_EXPRESSION
-                PsiElement(IDENTIFIER)('GR')
-        PsiWhiteSpace('\n')
-        PsiElement(RBRACE)('}')
+                  PsiElement(IDENTIFIER)('ComparisonResult')
+                PsiElement(DOT)('.')
+                REFERENCE_EXPRESSION
+                  PsiElement(IDENTIFIER)('GR')
+          PsiWhiteSpace('\n')
+          PsiElement(RBRACE)('}')

idea/tests/org/jetbrains/jet/JetTestUtils.java

@@ -111,7 +111,7 @@ public class JetTestUtils {
                 }
 
                 @Override
-                public FunctionDescriptor getFunctionDescriptor(JetFunction declaration) {
+                public FunctionDescriptor getFunctionDescriptor(JetNamedFunction declaration) {
                     throw new UnsupportedOperationException(); // TODO
                 }
 

idea/tests/org/jetbrains/jet/types/JetOverridingTest.java

@@ -8,7 +8,7 @@ import org.jetbrains.jet.lang.descriptors.FunctionDescriptor;
 import org.jetbrains.jet.lang.descriptors.FunctionDescriptorUtil;
 import org.jetbrains.jet.lang.descriptors.ModuleDescriptor;
 import org.jetbrains.jet.lang.psi.JetChangeUtil;
-import org.jetbrains.jet.lang.psi.JetFunction;
+import org.jetbrains.jet.lang.psi.JetNamedFunction;
 import org.jetbrains.jet.lang.resolve.ClassDescriptorResolver;
 import org.jetbrains.jet.lang.types.*;
 import org.jetbrains.jet.parsing.JetParsingTest;
@@ -144,7 +144,7 @@ public class JetOverridingTest extends LightDaemonAnalyzerTestCase {
     }
 
     private FunctionDescriptor makeFunction(String funDecl) {
-        JetFunction function = JetChangeUtil.createFunction(getProject(), funDecl);
+        JetNamedFunction function = JetChangeUtil.createFunction(getProject(), funDecl);
         return classDescriptorResolver.resolveFunctionDescriptor(root, library.getLibraryScope(), function);
     }
 }