Merge remote branch 'origin/master'

.idea/compiler.xml

@@ -15,7 +15,6 @@
       <entry name="?*.tld" />
       <entry name="?*.ftl" />
       <entry name="?*.jet" />
-      <entry name="/**/?*.kt" />
     </wildcardResourcePatterns>
     <annotationProcessing enabled="false" useClasspath="true" />
   </component>

.idea/modules.xml

@@ -11,7 +11,6 @@
       <module fileurl="file://$PROJECT_DIR$/compiler/frontend.java/frontend.java.iml" filepath="$PROJECT_DIR$/compiler/frontend.java/frontend.java.iml" />
       <module fileurl="file://$PROJECT_DIR$/grammar/grammar.iml" filepath="$PROJECT_DIR$/grammar/grammar.iml" />
       <module fileurl="file://$PROJECT_DIR$/idea/idea.iml" filepath="$PROJECT_DIR$/idea/idea.iml" />
-      <module fileurl="file://$PROJECT_DIR$/shift/shift.iml" filepath="$PROJECT_DIR$/shift/shift.iml" />
       <module fileurl="file://$PROJECT_DIR$/stdlib/stdlib.iml" filepath="$PROJECT_DIR$/stdlib/stdlib.iml" />
     </modules>
   </component>

build.xml

@@ -3,13 +3,9 @@
     <property name="build.number" value="snapshot"/>
     <property name="output.name" value="kotlin-${build.number}"/>
 
-    <path id="libs">
+    <path id="classpath">
         <fileset dir="${basedir}/ideaSDK" includes="*.jar"/>
         <fileset dir="${basedir}/lib" includes="*.jar"/>
-    </path>
-
-    <path id="classpath">
-        <path refid="libs"/>
         <pathelement path="${output}/classes/runtime"/>
     </path>
 
@@ -43,23 +39,14 @@
             <arg value="${basedir}/stdlib/ktSrc"/>
             <arg value="-output"/>
             <arg value="${basedir}/classes/stdlib"/>
-            <arg value="-stdlib"/>
         </java>
     </target>
 
-    <target name="compileTests" depends="compile">
+    <target name="jarRT" depends="compile">
-        <mkdir dir="${output}/classes/tests"/>
-        <javac destdir="${output}/classes/tests" debug="true" debuglevel="lines,vars,source">
-            <src path="${basedir}/compiler/tests"/>
-            <classpath refid="classpath.kotlin"/>
-        </javac>
-    </target>
-
-    <target name="jarRT" depends="compileStdlib">
         <jar destfile="${output}/kotlin-runtime.jar">
             <fileset dir="${output}/classes/runtime"/>
-            <fileset dir="${output}/classes/stdlib"/>
+            <!--<fileset dir="${output}/classes/stdlib"/>-->
-            <fileset dir="${basedir}/stdlib/ktSrc/" includes="**/*"/>
+            <fileset dir="${basedir}" includes="stdlib/ktSrc/**/*"/>
         </jar>
     </target>
 
@@ -70,7 +57,6 @@
             <src refid="sourcepath"/>
             <classpath refid="classpath"/>
         </javac>
-        <copy file="${basedir}/compiler/frontend/src/jet/Library.jet" tofile="${output}/classes/compiler/jet/Library.jet"/>
     </target>
 
     <target name="jar" depends="compile">
@@ -84,32 +70,6 @@
         <delete dir="${output}"/>
     </target>
 
-    <target name="test" depends="compileTests,jar,jarRT">
-        <mkdir dir="${output}/reports"/>
-        <junit printsummary="yes" haltonerror="false" haltonfailure="false">
-          <classpath>
-              <pathelement location="${output}/kotlin-compiler.jar"/>
-              <pathelement location="${output}/kotlin-runtime.jar"/>
-              <pathelement location="${output}/classes/tests"/>
-              <path refid="classpath"/>
-          </classpath>
-            
-          <formatter type="brief"/>
-          <formatter type="xml"/>
-
-          <batchtest todir="${output}/reports">
-            <fileset dir="${basedir}/compiler/tests">
-              <include name="**/*Test.java"/>
-            </fileset>
-          </batchtest>
-        </junit>
-
-        <junitreport>
-            <fileset dir="${output}/reports" includes="TEST-*.xml"/>
-            <report format="frames" todir="${output}/reports/html"/>
-        </junitreport>
-    </target>
-
     <target name="dist" depends="clean,jarRT,jar">
         <zip destfile="${output}/${output.name}.zip">
             <zipfileset prefix="${output.name}/bin" filemode="755" dir="${basedir}/compiler/cli/bin"/>

compiler/backend/src/org/jetbrains/jet/codegen/ClassFileFactory.java

@@ -1,6 +1,6 @@
 package org.jetbrains.jet.codegen;
 
-import org.jetbrains.jet.lang.psi.JetNamespace;
+import org.jetbrains.jet.lang.psi.JetFile;
 import org.jetbrains.jet.lang.psi.JetPsiUtil;
 
 import java.util.*;
@@ -30,13 +30,13 @@ public class ClassFileFactory {
         return newVisitor(className + ".class");
     }
 
-    NamespaceCodegen forNamespace(JetNamespace namespace) {
+    NamespaceCodegen forNamespace(JetFile file) {
         assert !isDone : "Already done!";
-        String fqName = JetPsiUtil.getFQName(namespace);
+        String fqName = JetPsiUtil.getFQName(file);
         NamespaceCodegen codegen = ns2codegen.get(fqName);
         if (codegen == null) {
             final ClassBuilder builder = newVisitor(NamespaceCodegen.getJVMClassName(fqName) + ".class");
-            codegen = new NamespaceCodegen(builder, fqName, state, namespace.getContainingFile());
+            codegen = new NamespaceCodegen(builder, fqName, state, file.getContainingFile());
             ns2codegen.put(fqName, codegen);
         }
 

compiler/backend/src/org/jetbrains/jet/codegen/GenerationState.java

@@ -6,6 +6,7 @@ package org.jetbrains.jet.codegen;
 import com.intellij.openapi.application.ApplicationManager;
 import com.intellij.openapi.project.Project;
 import com.intellij.openapi.util.Pair;
+import com.intellij.psi.PsiElement;
 import com.intellij.util.containers.Stack;
 import org.jetbrains.jet.codegen.intrinsics.IntrinsicMethods;
 import org.jetbrains.jet.lang.cfg.pseudocode.JetControlFlowDataTraceFactory;
@@ -78,15 +79,14 @@ public class GenerationState {
         return Pair.create(className, factory.forAnonymousSubclass(className));
     }
 
-    public NamespaceCodegen forNamespace(JetNamespace namespace) {
+    public NamespaceCodegen forNamespace(JetFile namespace) {
         return factory.forNamespace(namespace);
     }
 
-    public BindingContext compile(JetFile psiFile) {
+    public BindingContext compile(JetFile file) {
-        final JetNamespace namespace = psiFile.getRootNamespace();
+        final BindingContext bindingContext = AnalyzerFacade.analyzeOneFileWithJavaIntegration(file, JetControlFlowDataTraceFactory.EMPTY);
-        final BindingContext bindingContext = AnalyzerFacade.analyzeOneNamespaceWithJavaIntegration(namespace, JetControlFlowDataTraceFactory.EMPTY);
         AnalyzingUtils.throwExceptionOnErrors(bindingContext);
-        compileCorrectNamespaces(bindingContext, Collections.singletonList(namespace));
+        compileCorrectFiles(bindingContext, Collections.singletonList(file));
         return bindingContext;
 //        NamespaceCodegen codegen = forNamespace(namespace);
 //        bindingContexts.push(bindingContext);
@@ -102,15 +102,15 @@ public class GenerationState {
 //        }
     }
 
-    public void compileCorrectNamespaces(BindingContext bindingContext, List<JetNamespace> namespaces) {
+    public void compileCorrectFiles(BindingContext bindingContext, List<JetFile> files) {
-        compileCorrectNamespaces(bindingContext, namespaces, CompilationErrorHandler.THROW_EXCEPTION);
+        compileCorrectFiles(bindingContext, files, CompilationErrorHandler.THROW_EXCEPTION);
     }
 
-    public void compileCorrectNamespaces(BindingContext bindingContext, List<JetNamespace> namespaces, CompilationErrorHandler errorHandler) {
+    public void compileCorrectFiles(BindingContext bindingContext, List<JetFile> files, CompilationErrorHandler errorHandler) {
         typeMapper = new JetTypeMapper(standardLibrary, bindingContext);
         bindingContexts.push(bindingContext);
         try {
-            for (JetNamespace namespace : namespaces) {
+            for (JetFile namespace : files) {
                 try {
                     generateNamespace(namespace);
                 }
@@ -129,7 +129,7 @@ public class GenerationState {
         }
     }
 
-    protected void generateNamespace(JetNamespace namespace) {
+    protected void generateNamespace(JetFile namespace) {
         NamespaceCodegen codegen = forNamespace(namespace);
         codegen.generate(namespace);
     }
@@ -149,8 +149,8 @@ public class GenerationState {
         return new GeneratedAnonymousClassDescriptor(nameAndVisitor.first, callableMethod.getSignature().getAsmMethod(), objectContext.outerWasUsed, null);
     }
 
-    public static void prepareAnonymousClasses(JetElement aClass, final JetTypeMapper typeMapper) {
+    public static void prepareAnonymousClasses(PsiElement element, final JetTypeMapper typeMapper) {
-        aClass.acceptChildren(new JetVisitorVoid() {
+        element.acceptChildren(new JetVisitorVoid() {
             @Override
             public void visitJetElement(JetElement element) {
                 super.visitJetElement(element);

compiler/backend/src/org/jetbrains/jet/codegen/JetTypeMapper.java

@@ -619,6 +619,11 @@ public class JetTypeMapper {
                     signatureVisitor.writeInterfaceBoundEnd();
                 }
             }
+            if (jetType.getConstructor().getDeclarationDescriptor() instanceof TypeParameterDescriptor) {
+                signatureVisitor.writeInterfaceBound();
+                mapType(jetType, signatureVisitor);
+                signatureVisitor.writeInterfaceBoundEnd();
+            }
         }
         
         signatureVisitor.writeFormalTypeParameterEnd();
@@ -753,11 +758,12 @@ public class JetTypeMapper {
             return name;
         }
 
-        @SuppressWarnings("unchecked") JetNamedDeclaration container = PsiTreeUtil.getParentOfType(expression, JetNamespace.class, JetClass.class, JetObjectDeclaration.class);
+        @SuppressWarnings("unchecked")
+        PsiElement container = PsiTreeUtil.getParentOfType(expression, JetFile.class, JetClass.class, JetObjectDeclaration.class);
 
         String baseName;
-        if (container instanceof JetNamespace) {
+        if (container instanceof JetFile) {
-            baseName = NamespaceCodegen.getJVMClassName(JetPsiUtil.getFQName(((JetNamespace) container)));
+            baseName = NamespaceCodegen.getJVMClassName(JetPsiUtil.getFQName(((JetFile) container)));
         }
         else {
             ClassDescriptor aClass = bindingContext.get(BindingContext.CLASS, container);

compiler/backend/src/org/jetbrains/jet/codegen/NamespaceCodegen.java

@@ -43,8 +43,8 @@ public class NamespaceCodegen {
         v.visitSource(sourceFile.getName(), null);
     }
 
-    public void generate(JetNamespace namespace) {
+    public void generate(JetFile file) {
-        NamespaceDescriptor descriptor = state.getBindingContext().get(BindingContext.NAMESPACE, namespace);
+        NamespaceDescriptor descriptor = state.getBindingContext().get(BindingContext.NAMESPACE, file);
         final CodegenContext context = CodegenContext.STATIC.intoNamespace(descriptor);
 
         final FunctionCodegen functionCodegen = new FunctionCodegen(context, v, state);
@@ -52,10 +52,10 @@ public class NamespaceCodegen {
         final ClassCodegen classCodegen = state.forClass();
 
         if (v.generateCode()) {
-            GenerationState.prepareAnonymousClasses(namespace, state.getTypeMapper());
+            GenerationState.prepareAnonymousClasses(file, state.getTypeMapper());
         }
 
-        for (JetDeclaration declaration : namespace.getDeclarations()) {
+        for (JetDeclaration declaration : file.getDeclarations()) {
             if (declaration instanceof JetProperty) {
                 propertyCodegen.gen((JetProperty) declaration);
             }
@@ -72,20 +72,20 @@ public class NamespaceCodegen {
             else if (declaration instanceof JetClassOrObject) {
                 classCodegen.generate(context, (JetClassOrObject) declaration);
             }
-            else if (declaration instanceof JetNamespace) {
+//            else if (declaration instanceof JetFile) {
-                JetNamespace childNamespace = (JetNamespace) declaration;
+//                JetFile childNamespace = (JetFile) declaration;
-                state.forNamespace(childNamespace).generate(childNamespace);
+//                state.forNamespace(childNamespace).generate(childNamespace);
-            }
+//            }
         }
 
-        if (hasNonConstantPropertyInitializers(namespace)) {
+        if (hasNonConstantPropertyInitializers(file)) {
-            generateStaticInitializers(namespace);
+            generateStaticInitializers(file);
         }
 
-        generateTypeInfoFields(namespace, context);
+        generateTypeInfoFields(file, context);
     }
 
-    private void generateStaticInitializers(JetNamespace namespace) {
+    private void generateStaticInitializers(JetFile namespace) {
         MethodVisitor mv = v.newMethod(namespace, ACC_PUBLIC | ACC_STATIC,
                                        "<clinit>", "()V", null, null);
         if (v.generateCode()) {
@@ -115,9 +115,9 @@ public class NamespaceCodegen {
         }
     }
 
-    private void generateTypeInfoFields(JetNamespace namespace, CodegenContext context) {
+    private void generateTypeInfoFields(JetFile file, CodegenContext context) {
         if(context.typeInfoConstants != null) {
-            String jvmClassName = getJVMClassName(namespace.getName());
+            String jvmClassName = getJVMClassName(file.getNamespaceHeader().getName());
             for(int index = 0; index != context.typeInfoConstantsCount; index++) {
                 JetType type = context.reverseTypeInfoConstants.get(index);
                 String fieldName = "$typeInfoCache$" + index;
@@ -137,7 +137,7 @@ public class NamespaceCodegen {
                 v.visitFieldInsn(PUTSTATIC, jvmClassName, fieldName, "Ljet/TypeInfo;");
                 v.visitLabel(end);
                 v.visitInsn(ARETURN);
-                FunctionCodegen.endVisit(v, "type info method", namespace);
+                FunctionCodegen.endVisit(v, "type info method", file);
             }
         }
     }
@@ -187,7 +187,7 @@ public class NamespaceCodegen {
         }
     }
 
-    private static boolean hasNonConstantPropertyInitializers(JetNamespace namespace) {
+    private static boolean hasNonConstantPropertyInitializers(JetFile namespace) {
         for (JetDeclaration declaration : namespace.getDeclarations()) {
             if (declaration instanceof JetProperty) {
                 final JetExpression initializer = ((JetProperty) declaration).getInitializer();

compiler/backend/src/org/jetbrains/jet/compiler/CompileEnvironment.java

@@ -1,19 +1,20 @@
 package org.jetbrains.jet.compiler;
 
+import com.intellij.openapi.Disposable;
 import com.intellij.openapi.application.PathManager;
-import com.intellij.openapi.project.Project;
+import com.intellij.openapi.util.Disposer;
 import com.intellij.openapi.util.io.FileUtil;
 import com.intellij.openapi.util.text.StringUtil;
-import com.intellij.openapi.vfs.VirtualFileSystem;
 import com.intellij.util.Function;
 import com.intellij.util.Processor;
 import jet.ExtensionFunction0;
 import jet.modules.IModuleBuilder;
 import jet.modules.IModuleSetBuilder;
 import org.jetbrains.annotations.Nullable;
+import org.jetbrains.jet.JetCoreEnvironment;
 import org.jetbrains.jet.codegen.ClassFileFactory;
 import org.jetbrains.jet.codegen.GeneratedClassLoader;
-import org.jetbrains.jet.lang.psi.JetNamespace;
+import org.jetbrains.jet.lang.psi.JetFile;
 import org.jetbrains.jet.lang.psi.JetPsiUtil;
 import org.jetbrains.jet.plugin.JetMainDetector;
 
@@ -26,13 +27,74 @@ import java.util.List;
 import java.util.jar.*;
 
 /**
- * @author alex.tkachman
+ * The environment for compiling a bunch of source files or
+ *
+ * @author yole
  */
-public abstract class AbstractCompileEnvironment {
+public class CompileEnvironment {
-    protected Project project;
+    private JetCoreEnvironment myEnvironment;
+    private final Disposable myRootDisposable;
+    private PrintStream myErrorStream = System.out;
 
-    protected abstract void addToClasspath(File file);
+    public CompileEnvironment() {
+        myRootDisposable = new Disposable() {
+            @Override
+            public void dispose() {
+            }
+        };
+        myEnvironment = new JetCoreEnvironment(myRootDisposable);
+    }
 
+    public void setErrorStream(PrintStream errorStream) {
+        myErrorStream = errorStream;
+    }
+
+    public void dispose() {
+        Disposer.dispose(myRootDisposable);
+    }
+
+    public boolean initializeKotlinRuntime() {
+        return initializeKotlinRuntime(myEnvironment);
+    }
+
+    public static boolean initializeKotlinRuntime(JetCoreEnvironment environment) {
+        final File unpackedRuntimePath = getUnpackedRuntimePath();
+        if (unpackedRuntimePath != null) {
+            environment.addToClasspath(unpackedRuntimePath);
+        }
+        else {
+            final File runtimeJarPath = getRuntimeJarPath();
+            if (runtimeJarPath != null && runtimeJarPath.exists()) {
+                environment.addToClasspath(runtimeJarPath);
+            }
+            else {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    public static File getUnpackedRuntimePath() {
+        URL url = CompileEnvironment.class.getClassLoader().getResource("jet/JetObject.class");
+        if (url != null && url.getProtocol().equals("file")) {
+            return new File(url.getPath()).getParentFile().getParentFile();
+        }
+        return null;
+    }
+
+    public static File getRuntimeJarPath() {
+        URL url = CompileEnvironment.class.getClassLoader().getResource("jet/JetObject.class");
+        if (url != null && url.getProtocol().equals("jar")) {
+            String path = url.getPath();
+            return new File(path.substring(path.indexOf(":") + 1, path.indexOf("!/")));
+        }
+        return null;
+    }
+
+    public void setJavaRuntime(File rtJarPath) {
+        myEnvironment.addToClasspath(rtJarPath);
+    }
+    
     public static File findRtJar(boolean failOnError) {
         String javaHome = System.getenv("JAVA_HOME");
         File rtJar;
@@ -99,52 +161,6 @@ public abstract class AbstractCompileEnvironment {
         return null;
     }
 
-    public abstract VirtualFileSystem getLocalFileSystem();
-
-    public abstract VirtualFileSystem getJarFileSystem();
-
-    public Project getProject() {
-        return project;
-    }
-
-    public static File getUnpackedRuntimePath() {
-        URL url = CoreCompileEnvironment.class.getClassLoader().getResource("jet/JetObject.class");
-        if (url != null && url.getProtocol().equals("file")) {
-            return new File(url.getPath()).getParentFile().getParentFile();
-        }
-        return null;
-    }
-
-    public static File getRuntimeJarPath() {
-        URL url = CoreCompileEnvironment.class.getClassLoader().getResource("jet/JetObject.class");
-        if (url != null && url.getProtocol().equals("jar")) {
-            String path = url.getPath();
-            return new File(path.substring(path.indexOf(":") + 1, path.indexOf("!/")));
-        }
-        return null;
-    }
-
-    public static boolean initializeKotlinRuntime(AbstractCompileEnvironment environment) {
-        final File unpackedRuntimePath = getUnpackedRuntimePath();
-        if (unpackedRuntimePath != null) {
-            environment.addToClasspath(unpackedRuntimePath);
-        }
-        else {
-            final File runtimeJarPath = getRuntimeJarPath();
-            if (runtimeJarPath != null && runtimeJarPath.exists()) {
-                environment.addToClasspath(runtimeJarPath);
-            }
-            else {
-                return false;
-            }
-        }
-        return true;
-    }
-
-    public void setJavaRuntime(File rtJarPath) {
-        addToClasspath(rtJarPath);
-    }
-
     public void compileModuleScript(String moduleFile, String jarPath, boolean jarRuntime) {
         final IModuleSetBuilder moduleSetBuilder = loadModuleScript(moduleFile);
         if (moduleSetBuilder == null) {
@@ -164,11 +180,11 @@ public abstract class AbstractCompileEnvironment {
     }
 
     public IModuleSetBuilder loadModuleScript(String moduleFile) {
-        CompileSession scriptCompileSession = new CompileSession(this);
+        CompileSession scriptCompileSession = new CompileSession(myEnvironment);
         scriptCompileSession.addSources(moduleFile);
         scriptCompileSession.addStdLibSources();
 
-        if (!scriptCompileSession.analyze(System.out)) {
+        if (!scriptCompileSession.analyze(myErrorStream)) {
             return null;
         }
         final ClassFileFactory factory = scriptCompileSession.generate();
@@ -204,22 +220,22 @@ public abstract class AbstractCompileEnvironment {
     }
 
     public ClassFileFactory compileModule(IModuleBuilder moduleBuilder, String directory) {
-        CompileSession moduleCompileSession = new CompileSession(this);
+        CompileSession moduleCompileSession = new CompileSession(myEnvironment);
         moduleCompileSession.addStdLibSources();
         for (String sourceFile : moduleBuilder.getSourceFiles()) {
             moduleCompileSession.addSources(new File(directory, sourceFile).getPath());
         }
         for (String classpathRoot : moduleBuilder.getClasspathRoots()) {
-            addToClasspath(new File(classpathRoot));
+            myEnvironment.addToClasspath(new File(classpathRoot));
         }
-        if (!moduleCompileSession.analyze(System.out)) {
+        if (!moduleCompileSession.analyze(myErrorStream)) {
             return null;
         }
         return moduleCompileSession.generate();
     }
 
     private static String getHomeDirectory() {
-       return new File(PathManager.getResourceRoot(CoreCompileEnvironment.class, "/org/jetbrains/jet/compiler/CoreCompileEnvironment.class")).getParentFile().getParentFile().getParent();
+       return new File(PathManager.getResourceRoot(CompileEnvironment.class, "/org/jetbrains/jet/compiler/CompileEnvironment.class")).getParentFile().getParentFile().getParent();
     }
 
     private static final List<String> sanitized = Arrays.asList("kotlin/", "std/");
@@ -312,20 +328,19 @@ public abstract class AbstractCompileEnvironment {
         }
     }
 
-    public void compileBunchOfSources(String sourceFileOrDir, String jar, String outputDir, boolean includeRuntime, boolean stdlib) {
+    public void compileBunchOfSources(String sourceFileOrDir, String jar, String outputDir, boolean includeRuntime) {
-        CompileSession session = new CompileSession(this);
+        CompileSession session = new CompileSession(myEnvironment);
         session.addSources(sourceFileOrDir);
-        if(!stdlib)
+        session.addStdLibSources();
-            session.addStdLibSources();
 
         String mainClass = null;
-        for (JetNamespace namespace : session.getSourceFileNamespaces()) {
+        for (JetFile file : session.getSourceFileNamespaces()) {
-            if (JetMainDetector.hasMain(namespace.getDeclarations())) {
+            if (JetMainDetector.hasMain(file.getDeclarations())) {
-                mainClass = JetPsiUtil.getFQName(namespace) + ".namespace";
+                mainClass = JetPsiUtil.getFQName(file) + ".namespace";
                 break;
             }
         }
-        if (!session.analyze(System.out)) {
+        if (!session.analyze(myErrorStream)) {
             return;
         }
 
@@ -358,8 +373,4 @@ public abstract class AbstractCompileEnvironment {
 //            }
         }
     }
-
-    public boolean initializeKotlinRuntime() {
-        return initializeKotlinRuntime(this);
-    }
 }

compiler/backend/src/org/jetbrains/jet/compiler/CompileSession.java

@@ -4,14 +4,12 @@ import com.google.common.base.Predicates;
 import com.intellij.openapi.vfs.VirtualFile;
 import com.intellij.psi.PsiFile;
 import com.intellij.psi.PsiManager;
+import org.jetbrains.jet.JetCoreEnvironment;
 import org.jetbrains.jet.codegen.ClassBuilderFactory;
 import org.jetbrains.jet.codegen.ClassFileFactory;
-import org.jetbrains.jet.codegen.CompilationErrorHandler;
 import org.jetbrains.jet.codegen.GenerationState;
 import org.jetbrains.jet.lang.cfg.pseudocode.JetControlFlowDataTraceFactory;
-import org.jetbrains.jet.lang.psi.JetDeclaration;
 import org.jetbrains.jet.lang.psi.JetFile;
-import org.jetbrains.jet.lang.psi.JetNamespace;
 import org.jetbrains.jet.lang.resolve.BindingContext;
 import org.jetbrains.jet.lang.resolve.java.AnalyzerFacade;
 import org.jetbrains.jet.plugin.JetFileType;
@@ -19,7 +17,6 @@ import org.jetbrains.jet.plugin.JetFileType;
 import java.io.File;
 import java.io.PrintStream;
 import java.util.ArrayList;
-import java.util.Collection;
 import java.util.List;
 
 /**
@@ -28,13 +25,13 @@ import java.util.List;
  * @author yole
  */
 public class CompileSession {
-    private final List<JetNamespace> mySourceFileNamespaces = new ArrayList<JetNamespace>();
+    private final JetCoreEnvironment myEnvironment;
-    private final List<JetNamespace> myLibrarySourceFileNamespaces = new ArrayList<JetNamespace>();
+    private final List<JetFile> mySourceFiles = new ArrayList<JetFile>();
+    private final List<JetFile> myLibrarySourceFiles = new ArrayList<JetFile>();
     private List<String> myErrors = new ArrayList<String>();
     private BindingContext myBindingContext;
-    private AbstractCompileEnvironment myEnvironment;
 
-    public CompileSession(AbstractCompileEnvironment environment) {
+    public CompileSession(JetCoreEnvironment environment) {
         myEnvironment = environment;
     }
     
@@ -52,64 +49,42 @@ public class CompileSession {
             return;
         }
 
-        addSources(new File(path), mySourceFileNamespaces);
+        addSources(new File(path));
     }
 
-    private void addSources(File file, List<JetNamespace> namespaces) {
+    private void addSources(File file) {
         if(file.isDirectory()) {
             for (File child : file.listFiles()) {
-                addSources(child, namespaces);
+                addSources(child);
             }
         }
         else {
             VirtualFile fileByPath = myEnvironment.getLocalFileSystem().findFileByPath(file.getAbsolutePath());
             PsiFile psiFile = PsiManager.getInstance(myEnvironment.getProject()).findFile(fileByPath);
             if(psiFile instanceof JetFile) {
-                namespaces.add(((JetFile) psiFile).getRootNamespace());
+                mySourceFiles.add((JetFile) psiFile);
             }
         }
     }
 
     public void addSources(VirtualFile vFile) {
-        addSources(vFile, mySourceFileNamespaces);
-    }
-    
-    public void addSources(VirtualFile vFile, List<JetNamespace> namespaces) {
         if  (vFile.isDirectory())  {
             for (VirtualFile virtualFile : vFile.getChildren()) {
-                addSources(virtualFile, namespaces);
+                addSources(virtualFile);
             }
         }
         else {
             if (vFile.getFileType() == JetFileType.INSTANCE) {
                 PsiFile psiFile = PsiManager.getInstance(myEnvironment.getProject()).findFile(vFile);
                 if (psiFile instanceof JetFile) {
-                    mySourceFileNamespaces.add(((JetFile) psiFile).getRootNamespace());
+                    mySourceFiles.add((JetFile) psiFile);
                 }
             }
         }
     }
 
-    public void addSources(VirtualFile[] allFiles) {
+    public List<JetFile> getSourceFileNamespaces() {
-        for(VirtualFile vFile: allFiles) {
+        return mySourceFiles;
-            if (vFile.getFileType() == JetFileType.INSTANCE) {
-                PsiFile psiFile = PsiManager.getInstance(myEnvironment.getProject()).findFile(vFile);
-                if (psiFile instanceof JetFile) {
-                    mySourceFileNamespaces.add(((JetFile) psiFile).getRootNamespace());
-                }
-            }
-        }
-    }
-
-    public List<JetNamespace> getSourceFileNamespaces() {
-        return mySourceFileNamespaces;
-    }
-
-    public BindingContext analyze() {
-        List<JetNamespace> allNamespaces = new ArrayList<JetNamespace>(mySourceFileNamespaces);
-        allNamespaces.addAll(myLibrarySourceFileNamespaces);
-        return AnalyzerFacade.analyzeNamespacesWithJavaIntegration(
-                myEnvironment.getProject(), allNamespaces, Predicates.<PsiFile>alwaysTrue(), JetControlFlowDataTraceFactory.EMPTY);
     }
 
     public boolean analyze(final PrintStream out) {
@@ -119,48 +94,38 @@ public class CompileSession {
             }
             return false;
         }
-        myBindingContext = analyze();
+        List<JetFile> allNamespaces = new ArrayList<JetFile>(mySourceFiles);
+        allNamespaces.addAll(myLibrarySourceFiles);
+        myBindingContext = AnalyzerFacade.analyzeFilesWithJavaIntegration(
+                myEnvironment.getProject(), allNamespaces, Predicates.<PsiFile>alwaysTrue(), JetControlFlowDataTraceFactory.EMPTY);
         ErrorCollector errorCollector = new ErrorCollector(myBindingContext);
         errorCollector.report(out);
         return !errorCollector.hasErrors;
     }
 
     public ClassFileFactory generate() {
-        return generate(CompilationErrorHandler.THROW_EXCEPTION);
-    }
-
-    public ClassFileFactory generate(CompilationErrorHandler handler) {
         GenerationState generationState = new GenerationState(myEnvironment.getProject(), ClassBuilderFactory.BINARIES);
-        generationState.compileCorrectNamespaces(myBindingContext, mySourceFileNamespaces, handler);
+        generationState.compileCorrectFiles(myBindingContext, mySourceFiles);
         return generationState.getFactory();
     }
 
     public String generateText() {
         GenerationState generationState = new GenerationState(myEnvironment.getProject(), ClassBuilderFactory.TEXT);
-        generationState.compileCorrectNamespaces(myBindingContext, mySourceFileNamespaces);
+        generationState.compileCorrectFiles(myBindingContext, mySourceFiles);
         return generationState.createText();
     }
 
     public boolean addStdLibSources() {
-        return addStdLibSources(false);
+        final File unpackedRuntimePath = CompileEnvironment.getUnpackedRuntimePath();
-    }
-
-    public boolean addStdLibSources(boolean forAnalize) {
-        /*
-        @todo
-        We add sources as library sources in case of jar
-        but as regular one if there is no jar
-         */
-        final File unpackedRuntimePath = CoreCompileEnvironment.getUnpackedRuntimePath();
         if (unpackedRuntimePath != null) {
-            addSources(new File(unpackedRuntimePath, "stdlib/ktSrc").getAbsoluteFile(), forAnalize ? myLibrarySourceFileNamespaces : mySourceFileNamespaces);
+            addSources(new File(unpackedRuntimePath, "../../../stdlib/ktSrc").getAbsoluteFile());
         }
         else {
-            final File runtimeJarPath = CoreCompileEnvironment.getRuntimeJarPath();
+            final File runtimeJarPath = CompileEnvironment.getRuntimeJarPath();
             if (runtimeJarPath != null && runtimeJarPath.exists()) {
                 VirtualFile runtimeJar = myEnvironment.getLocalFileSystem().findFileByPath(runtimeJarPath.getAbsolutePath());
                 VirtualFile jarRoot = myEnvironment.getJarFileSystem().findFileByPath(runtimeJar.getPath() + "!/stdlib/ktSrc");
-                addSources(jarRoot, myLibrarySourceFileNamespaces);
+                addSources(jarRoot);
             }
             else {
                 return false;
@@ -168,8 +133,4 @@ public class CompileSession {
         }
         return true;
     }
-
-    public List<JetNamespace> getLibrarySourceFileNamespaces() {
-        return myLibrarySourceFileNamespaces;
-    }
 }

compiler/backend/src/org/jetbrains/jet/compiler/CoreCompileEnvironment.java

@@ -1,84 +0,0 @@
-package org.jetbrains.jet.compiler;
-
-import com.intellij.openapi.Disposable;
-import com.intellij.openapi.application.PathManager;
-import com.intellij.openapi.project.Project;
-import com.intellij.openapi.util.Disposer;
-import com.intellij.openapi.util.io.FileUtil;
-import com.intellij.openapi.vfs.VirtualFileSystem;
-import com.intellij.util.Processor;
-import jet.ExtensionFunction0;
-import jet.modules.IModuleBuilder;
-import jet.modules.IModuleSetBuilder;
-import org.jetbrains.annotations.Nullable;
-import org.jetbrains.jet.JetCoreEnvironment;
-import org.jetbrains.jet.codegen.ClassFileFactory;
-import org.jetbrains.jet.codegen.GeneratedClassLoader;
-import org.jetbrains.jet.lang.psi.JetNamespace;
-import org.jetbrains.jet.lang.psi.JetPsiUtil;
-import org.jetbrains.jet.plugin.JetMainDetector;
-
-import java.io.*;
-import java.lang.reflect.Field;
-import java.net.URL;
-import java.util.Arrays;
-import java.util.List;
-import java.util.jar.*;
-
-/**
- * The environment for compiling a bunch of source files or
- *
- * @author yole
- * @author alex.tkachman
- */
-public class CoreCompileEnvironment extends AbstractCompileEnvironment {
-    private final Disposable myRootDisposable;
-    private final VirtualFileSystem localFileSystem;
-    private VirtualFileSystem jarFileSystem;
-    private JetCoreEnvironment myEnvironment;
-
-    public CoreCompileEnvironment() {
-        myRootDisposable = new Disposable() {
-            @Override
-            public void dispose() {
-            }
-        };
-        myEnvironment = new JetCoreEnvironment(myRootDisposable);
-        localFileSystem = myEnvironment.getLocalFileSystem();
-        jarFileSystem = myEnvironment.getJarFileSystem();
-        project = myEnvironment.getProject();
-    }
-
-    public CoreCompileEnvironment(JetCoreEnvironment myEnvironment) {
-        this.myRootDisposable = null;
-        this.myEnvironment = myEnvironment;
-        localFileSystem = myEnvironment.getLocalFileSystem();
-        jarFileSystem = myEnvironment.getJarFileSystem();
-        project = myEnvironment.getProject();
-    }
-
-    public void dispose() {
-        if(myRootDisposable != null)
-            Disposer.dispose(myRootDisposable);
-    }
-
-    @Override
-    public void addToClasspath(File file) {
-        myEnvironment.addToClasspath(file);
-    }
-
-    @Override
-    public VirtualFileSystem getLocalFileSystem() {
-        return localFileSystem;
-    }
-
-    @Override
-    public Project getProject() {
-        return project;
-    }
-
-    @Override
-    public VirtualFileSystem getJarFileSystem() {
-        return jarFileSystem;
-    }
-}

compiler/cli/src/org/jetbrains/jet/cli/KotlinCompiler.java

@@ -2,8 +2,7 @@ package org.jetbrains.jet.cli;
 
 import com.sampullara.cli.Args;
 import com.sampullara.cli.Argument;
-import org.jetbrains.jet.compiler.AbstractCompileEnvironment;
+import org.jetbrains.jet.compiler.CompileEnvironment;
-import org.jetbrains.jet.compiler.CoreCompileEnvironment;
 import org.jetbrains.jet.compiler.CompileEnvironmentException;
 
 /**
@@ -26,8 +25,6 @@ public class KotlinCompiler {
         public String module;
         @Argument(value = "includeRuntime", description = "include Kotlin runtime in to resulting jar")
         public boolean includeRuntime;
-        @Argument(value = "stdlib", description = "means that we compile stdlib itself")
-        public boolean stdlib;
     }
 
     public static void main(String[] args) {
@@ -42,10 +39,10 @@ public class KotlinCompiler {
             return;
         }
 
-        CoreCompileEnvironment environment = new CoreCompileEnvironment();
+        CompileEnvironment environment = new CompileEnvironment();
 
         try {
-            environment.setJavaRuntime(AbstractCompileEnvironment.findRtJar(true));
+            environment.setJavaRuntime(CompileEnvironment.findRtJar(true));
             if (!environment.initializeKotlinRuntime()) {
                 System.out.println("No runtime library found");
                 return;
@@ -56,7 +53,7 @@ public class KotlinCompiler {
                 return;
             }
             else {
-                environment.compileBunchOfSources(arguments.src, arguments.jar, arguments.outputDir, arguments.includeRuntime, arguments.stdlib);
+                environment.compileBunchOfSources(arguments.src, arguments.jar, arguments.outputDir, arguments.includeRuntime);
             }
         } catch (CompileEnvironmentException e) {
             System.out.println(e.getMessage());

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/AnalyzerFacade.java

@@ -17,45 +17,39 @@ import org.jetbrains.jet.lang.StandardConfiguration;
 import org.jetbrains.jet.lang.cfg.pseudocode.JetControlFlowDataTraceFactory;
 import org.jetbrains.jet.lang.diagnostics.DiagnosticUtils;
 import org.jetbrains.jet.lang.diagnostics.Errors;
-import org.jetbrains.jet.lang.psi.JetDeclaration;
 import org.jetbrains.jet.lang.psi.JetFile;
-import org.jetbrains.jet.lang.psi.JetNamespace;
 import org.jetbrains.jet.lang.resolve.AnalyzingUtils;
 import org.jetbrains.jet.lang.resolve.BindingContext;
 import org.jetbrains.jet.lang.resolve.BindingTraceContext;
 
-import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Collections;
-import java.util.List;
 
 /**
  * @author abreslav
  */
 public class AnalyzerFacade {
 
-    public static final Function<JetFile, Collection<JetDeclaration>> SINGLE_DECLARATION_PROVIDER = new Function<JetFile, Collection<JetDeclaration>>() {
+    public static final Function<JetFile, Collection<JetFile>> SINGLE_DECLARATION_PROVIDER = new Function<JetFile, Collection<JetFile>>() {
         @Override
-        public Collection<JetDeclaration> fun(JetFile file) {
+        public Collection<JetFile> fun(JetFile file) {
-            return Collections.<JetDeclaration>singleton(file.getRootNamespace());
+            return Collections.singleton(file);
         }
     };
 
     private final static Key<CachedValue<BindingContext>> BINDING_CONTEXT = Key.create("BINDING_CONTEXT");
     private static final Object lock = new Object();
 
-    public static BindingContext analyzeFileWithCache(@NotNull final JetFile file, @NotNull final Function<JetFile, Collection<JetDeclaration>> declarationProvider) {
+    public static BindingContext analyzeFileWithCache(@NotNull final JetFile file, @NotNull final Function<JetFile, Collection<JetFile>> declarationProvider) {
-
         // Need lock for getValue(), because parallel threads can start evaluation of compute() simultaneously
         synchronized (lock) {
-
             CachedValue<BindingContext> bindingContextCachedValue = file.getUserData(BINDING_CONTEXT);
             if (bindingContextCachedValue == null) {
                 bindingContextCachedValue = CachedValuesManager.getManager(file.getProject()).createCachedValue(new CachedValueProvider<BindingContext>() {
                     @Override
                     public Result<BindingContext> compute() {
                         try {
-                            BindingContext bindingContext = analyzeNamespacesWithJavaIntegration(file.getProject(), declarationProvider.fun(file), Predicates.<PsiFile>equalTo(file), JetControlFlowDataTraceFactory.EMPTY);
+                            BindingContext bindingContext = analyzeFilesWithJavaIntegration(file.getProject(), declarationProvider.fun(file), Predicates.<PsiFile>equalTo(file), JetControlFlowDataTraceFactory.EMPTY);
                             return new Result<BindingContext>(bindingContext, PsiModificationTracker.MODIFICATION_COUNT);
                         }
                         catch (ProcessCanceledException e) {
@@ -73,46 +67,32 @@ public class AnalyzerFacade {
                 }, false);
                 file.putUserData(BINDING_CONTEXT, bindingContextCachedValue);
             }
-
             return bindingContextCachedValue.getValue();
         }
     }
 
-    public static BindingContext analyzeOneNamespaceWithJavaIntegration(JetNamespace namespace, JetControlFlowDataTraceFactory flowDataTraceFactory) {
+    public static BindingContext analyzeOneFileWithJavaIntegration(JetFile file, JetControlFlowDataTraceFactory flowDataTraceFactory) {
-        return analyzeNamespacesWithJavaIntegration(namespace.getProject(), Collections.singleton(namespace), Predicates.<PsiFile>alwaysTrue(), flowDataTraceFactory);
+        return analyzeFilesWithJavaIntegration(file.getProject(), Collections.singleton(file), Predicates.<PsiFile>alwaysTrue(), flowDataTraceFactory);
     }
 
-    public static BindingContext analyzeNamespacesWithJavaIntegration(Project project, Collection<? extends JetDeclaration> declarations, Predicate<PsiFile> filesToAnalyzeCompletely, JetControlFlowDataTraceFactory flowDataTraceFactory) {
+    public static BindingContext analyzeFilesWithJavaIntegration(Project project, Collection<JetFile> files, Predicate<PsiFile> filesToAnalyzeCompletely, JetControlFlowDataTraceFactory flowDataTraceFactory) {
         BindingTraceContext bindingTraceContext = new BindingTraceContext();
         JetSemanticServices semanticServices = JetSemanticServices.createSemanticServices(project);
-        return AnalyzingUtils.analyzeNamespacesWithGivenTrace(
+        return AnalyzingUtils.analyzeFilesWithGivenTrace(
                 project,
                 JavaBridgeConfiguration.createJavaBridgeConfiguration(project, bindingTraceContext, StandardConfiguration.createStandardConfiguration(project)),
-                declarations,
+                files,
                 filesToAnalyzeCompletely,
                 flowDataTraceFactory,
                 bindingTraceContext,
                 semanticServices);
     }
 
-    public static BindingContext shallowAnalyzeFiles(Collection<PsiFile> files) {
+    public static BindingContext shallowAnalyzeFiles(Collection<JetFile> files) {
         assert files.size() > 0;
 
         Project project = files.iterator().next().getProject();
 
-        Collection<JetNamespace> namespaces = collectRootNamespaces(files);
+        return analyzeFilesWithJavaIntegration(project, files, Predicates.<PsiFile>alwaysFalse(), JetControlFlowDataTraceFactory.EMPTY);
-
-        return analyzeNamespacesWithJavaIntegration(project, namespaces, Predicates.<PsiFile>alwaysFalse(), JetControlFlowDataTraceFactory.EMPTY);
     }
-
+}
-    public static List<JetNamespace> collectRootNamespaces(Collection<PsiFile> files) {
-        List<JetNamespace> namespaces = new ArrayList<JetNamespace>();
-
-        for (PsiFile file : files) {
-            if (file instanceof JetFile) {
-                namespaces.add(((JetFile) file).getRootNamespace());
-            }
-        }
-        return namespaces;
-    }
-}

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaDescriptorResolver.java

@@ -166,8 +166,17 @@ public class JavaDescriptorResolver {
         );
         classDescriptor.setName(name);
         
+        class OuterClassTypeVariableResolver implements TypeVariableResolver {
+
+            @NotNull
+            @Override
+            public TypeParameterDescriptor getTypeVariable(@NotNull String name) {
+                throw new IllegalStateException("not implemented"); // TODO
+            }
+        }
+
         List<JetType> supertypes = new ArrayList<JetType>();
-        List<TypeParameterDescriptor> typeParameters = resolveClassTypeParameters(psiClass, classDescriptor);
+        List<TypeParameterDescriptor> typeParameters = resolveClassTypeParameters(psiClass, classDescriptor, new OuterClassTypeVariableResolver());
         classDescriptor.setTypeConstructor(new TypeConstructorImpl(
                 classDescriptor,
                 Collections.<AnnotationDescriptor>emptyList(), // TODO
@@ -225,7 +234,10 @@ public class JavaDescriptorResolver {
                         classDescriptor,
                         Collections.<AnnotationDescriptor>emptyList(), // TODO
                         false);
-                ValueParameterDescriptors valueParameterDescriptors = resolveParameterDescriptors(constructorDescriptor, constructor.getParameterList().getParameters());
+                ValueParameterDescriptors valueParameterDescriptors = resolveParameterDescriptors(constructorDescriptor,
+                        constructor.getParameterList().getParameters(),
+                        new TypeParameterListTypeVariableResolver(typeParameters) // TODO: outer too
+                    );
                 if (valueParameterDescriptors.receiverType != null) {
                     throw new IllegalStateException();
                 }
@@ -242,14 +254,14 @@ public class JavaDescriptorResolver {
         return classDescriptor;
     }
 
-    private List<TypeParameterDescriptor> resolveClassTypeParameters(PsiClass psiClass, JavaClassDescriptor classDescriptor) {
+    private List<TypeParameterDescriptor> resolveClassTypeParameters(PsiClass psiClass, JavaClassDescriptor classDescriptor, TypeVariableResolver typeVariableResolver) {
         for (PsiAnnotation annotation : psiClass.getModifierList().getAnnotations()) {
             if (annotation.getQualifiedName().equals(JvmStdlibNames.JET_CLASS.getFqName())) {
                 PsiLiteralExpression attributeValue = (PsiLiteralExpression) annotation.findAttributeValue(JvmStdlibNames.JET_CLASS_SIGNATURE);
                 if (attributeValue != null) {
                     String typeParametersString = (String) attributeValue.getValue();
                     if (typeParametersString != null) {
-                        return resolveClassTypeParametersFromJetSignature(typeParametersString, psiClass, classDescriptor);
+                        return resolveClassTypeParametersFromJetSignature(typeParametersString, psiClass, classDescriptor, typeVariableResolver);
                     }
                 }
             }
@@ -290,14 +302,20 @@ public class JavaDescriptorResolver {
         private final PsiTypeParameterListOwner psiOwner;
         private final String name;
         private final TypeInfoVariance variance;
+        private final TypeVariableResolver typeVariableResolver;
 
         protected JetSignatureTypeParameterVisitor(DeclarationDescriptor containingDeclaration, PsiTypeParameterListOwner psiOwner,
-                String name, TypeInfoVariance variance)
+                String name, TypeInfoVariance variance, TypeVariableResolver typeVariableResolver)
         {
+            if (name.isEmpty()) {
+                throw new IllegalStateException();
+            }
+            
             this.containingDeclaration = containingDeclaration;
             this.psiOwner = psiOwner;
             this.name = name;
             this.variance = variance;
+            this.typeVariableResolver = typeVariableResolver;
         }
 
         int index = 0;
@@ -307,7 +325,7 @@ public class JavaDescriptorResolver {
         
         @Override
         public JetSignatureVisitor visitClassBound() {
-            return new JetTypeJetSignatureReader(JavaDescriptorResolver.this, semanticServices.getJetSemanticServices().getStandardLibrary()) {
+            return new JetTypeJetSignatureReader(JavaDescriptorResolver.this, semanticServices.getJetSemanticServices().getStandardLibrary(), typeVariableResolver) {
                 @Override
                 protected void done(@NotNull JetType jetType) {
                     if (isJavaLangObject(jetType)) {
@@ -320,7 +338,7 @@ public class JavaDescriptorResolver {
 
         @Override
         public JetSignatureVisitor visitInterfaceBound() {
-            return new JetTypeJetSignatureReader(JavaDescriptorResolver.this, semanticServices.getJetSemanticServices().getStandardLibrary()) {
+            return new JetTypeJetSignatureReader(JavaDescriptorResolver.this, semanticServices.getJetSemanticServices().getStandardLibrary(), typeVariableResolver) {
                 @Override
                 protected void done(@NotNull JetType jetType) {
                     upperBounds.add(jetType);
@@ -348,12 +366,28 @@ public class JavaDescriptorResolver {
     /**
      * @see #resolveMethodTypeParametersFromJetSignature(String, FunctionDescriptor)
      */
-    private List<TypeParameterDescriptor> resolveClassTypeParametersFromJetSignature(String jetSignature, final PsiClass clazz, final JavaClassDescriptor classDescriptor) {
+    private List<TypeParameterDescriptor> resolveClassTypeParametersFromJetSignature(String jetSignature, final PsiClass clazz,
+            final JavaClassDescriptor classDescriptor, final TypeVariableResolver outerClassTypeVariableResolver) {
         final List<TypeParameterDescriptor> r = new ArrayList<TypeParameterDescriptor>();
+        
+        class MyTypeVariableResolver implements TypeVariableResolver {
+
+            @NotNull
+            @Override
+            public TypeParameterDescriptor getTypeVariable(@NotNull String name) {
+                for (TypeParameterDescriptor typeParameter : r) {
+                    if (typeParameter.getName().equals(name)) {
+                        return typeParameter;
+                    }
+                }
+                return outerClassTypeVariableResolver.getTypeVariable(name);
+            }
+        }
+        
         new JetSignatureReader(jetSignature).accept(new JetSignatureExceptionsAdapter() {
             @Override
             public JetSignatureVisitor visitFormalTypeParameter(final String name, final TypeInfoVariance variance) {
-                return new JetSignatureTypeParameterVisitor(classDescriptor, clazz, name, variance) {
+                return new JetSignatureTypeParameterVisitor(classDescriptor, clazz, name, variance, new MyTypeVariableResolver()) {
                     @Override
                     protected void done(TypeParameterDescriptor typeParameterDescriptor) {
                         r.add(typeParameterDescriptor);
@@ -548,12 +582,13 @@ public class JavaDescriptorResolver {
         }
     }
 
-    public ValueParameterDescriptors resolveParameterDescriptors(DeclarationDescriptor containingDeclaration, PsiParameter[] parameters) {
+    public ValueParameterDescriptors resolveParameterDescriptors(DeclarationDescriptor containingDeclaration,
+            PsiParameter[] parameters, TypeVariableResolver typeVariableResolver) {
         List<ValueParameterDescriptor> result = new ArrayList<ValueParameterDescriptor>();
         JetType receiverType = null;
         for (int i = 0, parametersLength = parameters.length; i < parametersLength; i++) {
             PsiParameter parameter = parameters[i];
-            JvmMethodParameterMeaning meaning = resolveParameterDescriptor(containingDeclaration, i, parameter);
+            JvmMethodParameterMeaning meaning = resolveParameterDescriptor(containingDeclaration, i, parameter, typeVariableResolver);
             if (meaning.kind == JvmMethodParameterKind.TYPE_INFO) {
                 // TODO
             } else if (meaning.kind == JvmMethodParameterKind.REGULAR) {
@@ -601,7 +636,8 @@ public class JavaDescriptorResolver {
     }
 
     @NotNull
-    private JvmMethodParameterMeaning resolveParameterDescriptor(DeclarationDescriptor containingDeclaration, int i, PsiParameter parameter) {
+    private JvmMethodParameterMeaning resolveParameterDescriptor(DeclarationDescriptor containingDeclaration, int i,
+            PsiParameter parameter, TypeVariableResolver typeVariableResolver) {
         PsiType psiType = parameter.getType();
 
         JetType varargElementType;
@@ -663,7 +699,7 @@ public class JavaDescriptorResolver {
         
         JetType outType;
         if (typeFromAnnotation != null && typeFromAnnotation.length() > 0) {
-            outType = semanticServices.getTypeTransformer().transformToType(typeFromAnnotation);
+            outType = semanticServices.getTypeTransformer().transformToType(typeFromAnnotation, typeVariableResolver);
         } else {
             outType = semanticServices.getTypeTransformer().transformToType(psiType);
         }
@@ -750,6 +786,26 @@ public class JavaDescriptorResolver {
         return typeSubstitutor;
     }
 
+    private static class TypeParameterListTypeVariableResolver implements TypeVariableResolver {
+
+        private final List<TypeParameterDescriptor> typeParameters;
+
+        private TypeParameterListTypeVariableResolver(List<TypeParameterDescriptor> typeParameters) {
+            this.typeParameters = typeParameters;
+        }
+
+        @NotNull
+        @Override
+        public TypeParameterDescriptor getTypeVariable(@NotNull String name) {
+            for (TypeParameterDescriptor typeParameter : typeParameters) {
+                if (typeParameter.getName().equals(name)) {
+                    return typeParameter;
+                }
+            }
+            throw new IllegalStateException("unresolver variable: " + name); // TODO: report properly
+        }
+    }
+
     @Nullable
     public FunctionDescriptor resolveMethodToFunctionDescriptor(DeclarationDescriptor owner, PsiClass psiClass, TypeSubstitutor typeSubstitutorForGenericSuperclasses, PsiMethod method) {
         PsiType returnType = method.getReturnType();
@@ -763,7 +819,17 @@ public class JavaDescriptorResolver {
             }
             return functionDescriptor;
         }
-        DeclarationDescriptor classDescriptor = method.hasModifierProperty(PsiModifier.STATIC) ? resolveNamespace(method.getContainingClass()) : resolveClass(method.getContainingClass());
+        DeclarationDescriptor classDescriptor;
+        final List<TypeParameterDescriptor> classTypeParameters;
+        if (method.hasModifierProperty(PsiModifier.STATIC)) {
+            classDescriptor = resolveNamespace(method.getContainingClass());
+            classTypeParameters = Collections.emptyList();
+        }
+        else {
+            ClassDescriptor classClassDescriptor = resolveClass(method.getContainingClass());
+            classDescriptor = classClassDescriptor;
+            classTypeParameters = classClassDescriptor.getTypeConstructor().getParameters();
+        }
         if (classDescriptor == null) {
             return null;
         }
@@ -774,14 +840,39 @@ public class JavaDescriptorResolver {
                 method.getName()
         );
         methodDescriptorCache.put(method, functionDescriptorImpl);
-        List<TypeParameterDescriptor> typeParameters = resolveMethodTypeParameters(method, functionDescriptorImpl);
+
-        ValueParameterDescriptors valueParameterDescriptors = resolveParameterDescriptors(functionDescriptorImpl, parameters);
+        // TODO: add outer classes
+        TypeParameterListTypeVariableResolver typeVariableResolverForParameters = new TypeParameterListTypeVariableResolver(classTypeParameters);
+
+        final List<TypeParameterDescriptor> methodTypeParameters = resolveMethodTypeParameters(method, functionDescriptorImpl, typeVariableResolverForParameters);
+
+        class MethodTypeVariableResolver implements TypeVariableResolver {
+
+            @NotNull
+            @Override
+            public TypeParameterDescriptor getTypeVariable(@NotNull String name) {
+                for (TypeParameterDescriptor typeParameter : methodTypeParameters) {
+                    if (typeParameter.getName().equals(name)) {
+                        return typeParameter;
+                    }
+                }
+                for (TypeParameterDescriptor typeParameter : classTypeParameters) {
+                    if (typeParameter.getName().equals(name)) {
+                        return typeParameter;
+                    }
+                }
+                throw new IllegalStateException("unresolver variable: " + name); // TODO: report properly
+            }
+        }
+
+
+        ValueParameterDescriptors valueParameterDescriptors = resolveParameterDescriptors(functionDescriptorImpl, parameters, new MethodTypeVariableResolver());
         functionDescriptorImpl.initialize(
                 valueParameterDescriptors.receiverType,
                 DescriptorUtils.getExpectedThisObjectIfNeeded(classDescriptor),
-                typeParameters,
+                methodTypeParameters,
                 valueParameterDescriptors.descriptors,
-                makeReturnType(returnType, method),
+                makeReturnType(returnType, method, new MethodTypeVariableResolver()),
                 Modality.convertFromFlags(method.hasModifierProperty(PsiModifier.ABSTRACT), !method.hasModifierProperty(PsiModifier.FINAL)),
                 resolveVisibilityFromPsiModifiers(method)
         );
@@ -793,14 +884,14 @@ public class JavaDescriptorResolver {
         return substitutedFunctionDescriptor;
     }
 
-    private List<TypeParameterDescriptor> resolveMethodTypeParameters(PsiMethod method, FunctionDescriptorImpl functionDescriptorImpl) {
+    private List<TypeParameterDescriptor> resolveMethodTypeParameters(PsiMethod method, FunctionDescriptorImpl functionDescriptorImpl, TypeVariableResolver classTypeVariableResolver) {
         for (PsiAnnotation annotation : method.getModifierList().getAnnotations()) {
             if (annotation.getQualifiedName().equals(JvmStdlibNames.JET_METHOD.getFqName())) {
                 PsiLiteralExpression attributeValue = (PsiLiteralExpression) annotation.findAttributeValue(JvmStdlibNames.JET_METHOD_TYPE_PARAMETERS_FIELD);
                 if (attributeValue != null) {
                     String typeParametersString = (String) attributeValue.getValue();
                     if (typeParametersString != null) {
-                        List<TypeParameterDescriptor> r = resolveMethodTypeParametersFromJetSignature(typeParametersString, method, functionDescriptorImpl);
+                        List<TypeParameterDescriptor> r = resolveMethodTypeParametersFromJetSignature(typeParametersString, method, functionDescriptorImpl, classTypeVariableResolver);
                         initializeTypeParameters(method);
                         return r;
                     }
@@ -816,13 +907,30 @@ public class JavaDescriptorResolver {
     /**
      * @see #resolveClassTypeParametersFromJetSignature(String, com.intellij.psi.PsiClass, JavaClassDescriptor) 
      */
-    private List<TypeParameterDescriptor> resolveMethodTypeParametersFromJetSignature(String jetSignature, final PsiMethod method, final FunctionDescriptor functionDescriptor) {
+    private List<TypeParameterDescriptor> resolveMethodTypeParametersFromJetSignature(String jetSignature, final PsiMethod method,
+            final FunctionDescriptor functionDescriptor, final TypeVariableResolver classTypeVariableResolver)
+    {
         final List<TypeParameterDescriptor> r = new ArrayList<TypeParameterDescriptor>();
+        
+        class MyTypeVariableResolver implements TypeVariableResolver {
+
+            @NotNull
+            @Override
+            public TypeParameterDescriptor getTypeVariable(@NotNull String name) {
+                for (TypeParameterDescriptor typeParameter : r) {
+                    if (typeParameter.getName().equals(name)) {
+                        return typeParameter;
+                    }
+                }
+                return classTypeVariableResolver.getTypeVariable(name);
+            }
+        }
+        
         new JetSignatureReader(jetSignature).acceptFormalTypeParametersOnly(new JetSignatureExceptionsAdapter() {
             @Override
             public JetSignatureVisitor visitFormalTypeParameter(final String name, final TypeInfoVariance variance) {
                 
-                return new JetSignatureTypeParameterVisitor(functionDescriptor, method, name, variance) {
+                return new JetSignatureTypeParameterVisitor(functionDescriptor, method, name, variance, new MyTypeVariableResolver()) {
                     @Override
                     protected void done(TypeParameterDescriptor typeParameterDescriptor) {
                         r.add(typeParameterDescriptor);
@@ -834,7 +942,7 @@ public class JavaDescriptorResolver {
         return r;
     }
 
-    private JetType makeReturnType(PsiType returnType, PsiMethod method) {
+    private JetType makeReturnType(PsiType returnType, PsiMethod method, TypeVariableResolver typeVariableResolver) {
         boolean changeNullable = false;
         boolean nullable = true;
         
@@ -859,7 +967,7 @@ public class JavaDescriptorResolver {
         }
         JetType transformedType;
         if (returnTypeFromAnnotation != null && returnTypeFromAnnotation.length() > 0) {
-            transformedType = semanticServices.getTypeTransformer().transformToType(returnTypeFromAnnotation);
+            transformedType = semanticServices.getTypeTransformer().transformToType(returnTypeFromAnnotation, typeVariableResolver);
         } else {
             transformedType = semanticServices.getTypeTransformer().transformToType(returnType);
         }

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaTypeTransformer.java

@@ -59,9 +59,9 @@ public class JavaTypeTransformer {
     }
 
     @NotNull
-    public JetType transformToType(@NotNull String kotlinSignature) {
+    public JetType transformToType(@NotNull String kotlinSignature, TypeVariableResolver typeVariableResolver) {
         final JetType[] r = new JetType[1];
-        JetTypeJetSignatureReader reader = new JetTypeJetSignatureReader(resolver, standardLibrary) {
+        JetTypeJetSignatureReader reader = new JetTypeJetSignatureReader(resolver, standardLibrary, typeVariableResolver) {
             @Override
             protected void done(@NotNull JetType jetType) {
                 r[0] = jetType;

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JetTypeJetSignatureReader.java

@@ -2,6 +2,7 @@ package org.jetbrains.jet.lang.resolve.java;
 
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
+import org.jetbrains.jet.lang.descriptors.TypeParameterDescriptor;
 import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
 import org.jetbrains.jet.lang.types.ErrorUtils;
 import org.jetbrains.jet.lang.types.JetStandardClasses;
@@ -25,10 +26,12 @@ public abstract class JetTypeJetSignatureReader extends JetSignatureExceptionsAd
     
     private final JavaDescriptorResolver javaDescriptorResolver;
     private final JetStandardLibrary jetStandardLibrary;
+    private final TypeVariableResolver typeVariableResolver;
 
-    public JetTypeJetSignatureReader(JavaDescriptorResolver javaDescriptorResolver, JetStandardLibrary jetStandardLibrary) {
+    public JetTypeJetSignatureReader(JavaDescriptorResolver javaDescriptorResolver, JetStandardLibrary jetStandardLibrary, TypeVariableResolver typeVariableResolver) {
         this.javaDescriptorResolver = javaDescriptorResolver;
         this.jetStandardLibrary = jetStandardLibrary;
+        this.typeVariableResolver = typeVariableResolver;
     }
     
     
@@ -111,7 +114,7 @@ public abstract class JetTypeJetSignatureReader extends JetSignatureExceptionsAd
 
     @Override
     public JetSignatureVisitor visitTypeArgument(final char wildcard) {
-        return new JetTypeJetSignatureReader(javaDescriptorResolver, jetStandardLibrary) {
+        return new JetTypeJetSignatureReader(javaDescriptorResolver, jetStandardLibrary, typeVariableResolver) {
 
             @Override
             protected void done(@NotNull JetType jetType) {
@@ -122,7 +125,7 @@ public abstract class JetTypeJetSignatureReader extends JetSignatureExceptionsAd
 
     @Override
     public JetSignatureVisitor visitArrayType(final boolean nullable) {
-        return new JetTypeJetSignatureReader(javaDescriptorResolver, jetStandardLibrary) {
+        return new JetTypeJetSignatureReader(javaDescriptorResolver, jetStandardLibrary, typeVariableResolver) {
             @Override
             protected void done(@NotNull JetType jetType) {
                 JetType arrayType = TypeUtils.makeNullableAsSpecified(jetStandardLibrary.getArrayType(jetType), nullable);
@@ -133,8 +136,8 @@ public abstract class JetTypeJetSignatureReader extends JetSignatureExceptionsAd
 
     @Override
     public void visitTypeVariable(String name, boolean nullable) {
-        // TODO: need a way to get type TypeParameterDescriptor by name
+        JetType r = TypeUtils.makeNullableAsSpecified(typeVariableResolver.getTypeVariable(name).getDefaultType(), nullable);
-        throw new IllegalStateException();
+        done(r);
     }
 
     @Override

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/TypeVariableResolver.java

@@ -0,0 +1,12 @@
+package org.jetbrains.jet.lang.resolve.java;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.lang.descriptors.TypeParameterDescriptor;
+
+/**
+ * @author Stepan Koltsov
+ */
+public interface TypeVariableResolver {
+    @NotNull
+    TypeParameterDescriptor getTypeVariable(@NotNull String name);
+}

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

@@ -10,7 +10,6 @@ import org.jetbrains.jet.lang.psi.*;
 public interface JetNodeTypes {
     IFileElementType JET_FILE = new IFileElementType(JetLanguage.INSTANCE);
 
-    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", JetNamedFunction.class);
@@ -35,7 +34,6 @@ public interface JetNodeTypes {
 
     JetNodeType CLASS_BODY                          = new JetNodeType("CLASS_BODY", JetClassBody.class);
     JetNodeType IMPORT_DIRECTIVE                    = new JetNodeType("IMPORT_DIRECTIVE", JetImportDirective.class);
-    JetNodeType NAMESPACE_BODY                      = new JetNodeType("NAMESPACE_BODY", JetNamespaceBody.class);
     JetNodeType MODIFIER_LIST                       = new JetNodeType("MODIFIER_LIST", JetModifierList.class);
     JetNodeType PRIMARY_CONSTRUCTOR_MODIFIER_LIST   = new JetNodeType("PRIMARY_CONSTRUCTOR_MODIFIER_LIST", JetModifierList.class);
     JetNodeType ANNOTATION = new JetNodeType("ANNOTATION", JetAnnotation.class);

compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/RedeclarationDiagnostic.java

@@ -7,8 +7,6 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
 import org.jetbrains.jet.lang.resolve.BindingContext;
 
-import static org.jetbrains.jet.lang.diagnostics.Severity.ERROR;
-
 /**
  * @author abreslav
  */
@@ -37,7 +35,7 @@ public interface RedeclarationDiagnostic extends DiagnosticWithPsiElement<PsiEle
             if (element == null) {
                 element = contextToResolveToDeclaration.get(BindingContext.DESCRIPTOR_TO_DECLARATION, duplicatingDescriptor);
                 assert element != null : "No element for descriptor: " + duplicatingDescriptor;
-                }
+            }
             return element;
         }
         

compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/RedeclarationDiagnosticFactory.java

@@ -4,6 +4,7 @@ import com.intellij.openapi.util.TextRange;
 import com.intellij.psi.PsiElement;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
+import org.jetbrains.jet.lang.psi.JetFile;
 import org.jetbrains.jet.lang.psi.JetNamedDeclaration;
 import org.jetbrains.jet.lang.resolve.BindingContext;
 
@@ -45,6 +46,13 @@ public class RedeclarationDiagnosticFactory extends AbstractDiagnosticFactory {
                 return nameIdentifier.getTextRange();
             }
         }
+        else if (redeclaration instanceof JetFile) {
+            JetFile file = (JetFile) redeclaration;
+            PsiElement nameIdentifier = file.getNamespaceHeader().getNameIdentifier();
+            if (nameIdentifier != null) {
+                return nameIdentifier.getTextRange();
+            }
+        }
         return redeclaration.getTextRange();
     }
 

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

@@ -497,7 +497,7 @@ public class JetExpressionParsing extends AbstractJetParsing {
      *   : functionLiteral
      *   : declaration
      *   : SimpleName
-     *   : "namespace" // foo the root namespace
+     *   : "package" // foo the root namespace
      *   ;
      */
     private void parseAtomicExpression() {

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

@@ -80,13 +80,11 @@ public class JetParsing extends AbstractJetParsing {
      */
     public void parseFile() {
         PsiBuilder.Marker fileMarker = mark();
-        PsiBuilder.Marker namespaceMarker = mark();
 
         parsePreamble();
 
         parseToplevelDeclarations(false);
 
-        namespaceMarker.done(NAMESPACE);
         fileMarker.done(JET_FILE);
     }
 
@@ -377,45 +375,6 @@ public class JetParsing extends AbstractJetParsing {
         attribute.done(ANNOTATION_ENTRY);
     }
 
-    /*
-     * namespace
-     *   : "namespace" SimpleName{"."} "{"
-     *        import*
-     *        toplevelObject[| import]*
-     *     "}"
-     *   ;
-     */
-    private JetNodeType parseNamespaceBlock() {
-        assert _at(NAMESPACE_KEYWORD);
-        PsiBuilder.Marker namespaceHeader = mark();
-        advance(); // NAMESPACE_KEYWORD
-
-        if (at(LBRACE)) {
-            error("Expecting namespace name");
-        }
-        else {
-            parseNamespaceName();
-        }
-        namespaceHeader.done(NAMESPACE_HEADER);
-
-        if (!at(LBRACE)) {
-            error("A namespace block in '{...}' expected");
-            return NAMESPACE;
-        }
-
-        myBuilder.enableNewlines();
-        advance(); // LBRACE
-        PsiBuilder.Marker namespaceBody = mark();
-
-        parseToplevelDeclarations(true);
-
-        namespaceBody.done(NAMESPACE_BODY);
-        expect(RBRACE, "Expecting '}'");
-        myBuilder.restoreNewlinesState();
-
-        return NAMESPACE;
-    }
-
     /*
      * class
      *   : modifiers ("class" | "trait") SimpleName

compiler/frontend/src/org/jetbrains/jet/lang/psi/JetFile.java

@@ -7,11 +7,14 @@ import com.intellij.extapi.psi.PsiFileBase;
 import com.intellij.openapi.fileTypes.FileType;
 import com.intellij.psi.FileViewProvider;
 import com.intellij.psi.PsiElementVisitor;
+import com.intellij.psi.util.PsiTreeUtil;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.JetNodeTypes;
 import org.jetbrains.jet.plugin.JetFileType;
 import org.jetbrains.jet.plugin.JetLanguage;
 
+import java.util.List;
+
 public class JetFile extends PsiFileBase {
     public JetFile(FileViewProvider viewProvider) {
         super(viewProvider, JetLanguage.INSTANCE);
@@ -27,9 +30,23 @@ public class JetFile extends PsiFileBase {
         return "JetFile: " + getName();
     }
 
+    public List<JetDeclaration> getDeclarations() {
+        return PsiTreeUtil.getChildrenOfTypeAsList(this, JetDeclaration.class);
+    }
+
+    public List<JetImportDirective> getImportDirectives() {
+        return PsiTreeUtil.getChildrenOfTypeAsList(this, JetImportDirective.class);
+    }
+
     @NotNull
-    public JetNamespace getRootNamespace() {
+    public JetNamespaceHeader getNamespaceHeader() {
-        return (JetNamespace) getNode().findChildByType(JetNodeTypes.NAMESPACE).getPsi();
+        return (JetNamespaceHeader) getNode().findChildByType(JetNodeTypes.NAMESPACE_HEADER).getPsi();
+    }
+
+    @NotNull
+    @Override
+    public String getName() {
+        return super.getName(); // TODO
     }
 
     @Override

compiler/frontend/src/org/jetbrains/jet/lang/psi/JetNamespace.java

@@ -1,61 +0,0 @@
-package org.jetbrains.jet.lang.psi;
-
-import com.intellij.lang.ASTNode;
-import com.intellij.psi.PsiElement;
-import com.intellij.psi.util.PsiTreeUtil;
-import com.intellij.util.IncorrectOperationException;
-import org.jetbrains.annotations.NonNls;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.jet.JetNodeTypes;
-
-import java.util.List;
-
-/**
- * @author max
- */
-public class JetNamespace extends JetNamedDeclaration {
-    public JetNamespace(@NotNull ASTNode node) {
-        super(node);
-    }
-
-    @Override
-    public void accept(@NotNull JetVisitorVoid visitor) {
-        visitor.visitNamespace(this);
-    }
-
-    @Override
-    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
-        return visitor.visitNamespace(this, data);
-    }
-
-    public List<JetDeclaration> getDeclarations() {
-        PsiElement body = findChildByType(JetNodeTypes.NAMESPACE_BODY);
-        return PsiTreeUtil.getChildrenOfTypeAsList(body != null ? body : this, JetDeclaration.class);
-    }
-
-    public List<JetImportDirective> getImportDirectives() {
-        PsiElement body = findChildByType(JetNodeTypes.NAMESPACE_BODY);
-        return PsiTreeUtil.getChildrenOfTypeAsList(body != null ? body : this, JetImportDirective.class);
-    }
-
-    public String getName() {
-        String name = super.getName();
-        return name == null ? "" : name;
-    }
-
-    @NotNull
-    public JetNamespaceHeader getHeader() {
-        return (JetNamespaceHeader) findChildByType(JetNodeTypes.NAMESPACE_HEADER);
-    }
-
-    @Override
-    public PsiElement getNameIdentifier() {
-        return getHeader().getNameIdentifier();
-    }
-
-    @Override
-    public PsiElement setName(@NonNls @NotNull String name) throws IncorrectOperationException {
-        throw new UnsupportedOperationException();
-    }
-
-}

compiler/frontend/src/org/jetbrains/jet/lang/psi/JetNewExpression.java

@@ -1,52 +0,0 @@
-package org.jetbrains.jet.lang.psi;
-
-/**
- * @author max
- */
-//public class JetNewExpression extends JetExpression implements JetCallElement {
-//    public JetNewExpression(@NotNull ASTNode node) {
-//        super(node);
-//    }
-//
-//    @Override
-//    public void accept(JetVisitorVoid visitor) {
-//        visitor.visitNewExpression(this);
-//    }
-//
-//    @Nullable @IfNotParsed
-//    public JetTypeReference getTypeReference() {
-//        return (JetTypeReference) findChildByType(JetNodeTypes.TYPE_REFERENCE);
-//    }
-//
-//    @Override
-//    @Nullable
-//    public JetValueArgumentList getValueArgumentList() {
-//        return (JetValueArgumentList) findChildByType(JetNodeTypes.VALUE_ARGUMENT_LIST);
-//    }
-//
-//    @Override
-//    @NotNull
-//    public List<JetValueArgument> getValueArguments() {
-//        JetValueArgumentList list = getValueArgumentList();
-//        return list != null ? list.getArguments() : Collections.<JetValueArgument>emptyList();
-//    }
-//
-//    @Override
-//    @NotNull
-//    public List<JetExpression> getFunctionLiteralArguments() {
-//        return findChildrenByType(JetNodeTypes.FUNCTION_LITERAL_EXPRESSION);
-//    }
-//
-//    @NotNull
-//    @Override
-//    public List<JetTypeProjection> getTypeArguments() {
-//        return Collections.emptyList();
-//    }
-//
-//    @NotNull
-//    @Override
-//    public JetElement asElement() {
-//        return this;
-//    }
-//
-//}

compiler/frontend/src/org/jetbrains/jet/lang/psi/JetPsiFactory.java

@@ -60,8 +60,7 @@ public class JetPsiFactory {
 
     private static <T> T createDeclaration(Project project, String text, Class<T> clazz) {
         JetFile file = createFile(project, text);
-        JetNamespace rootNamespace = file.getRootNamespace();
+        List<JetDeclaration> dcls = file.getDeclarations();
-        List<JetDeclaration> dcls = rootNamespace.getDeclarations();
         assert dcls.size() == 1 : dcls.size();
         @SuppressWarnings("unchecked")
         T result = (T) dcls.get(0);
@@ -92,13 +91,13 @@ public class JetPsiFactory {
         return function.getValueParameters().get(0);
     }
 
-    public static JetNamespace createNamespace(Project project, String text) {
+//    public static JetNamespace createNamespace(Project project, String text) {
-        JetFile file = createFile(project, text);
+//        JetFile file = createFile(project, text);
-        return file.getRootNamespace();
+//        return file.getRootNamespace();
-    }
+//    }
 
     public static JetImportDirective createImportDirective(Project project, String classPath) {
-        JetNamespace namespace = createNamespace(project, "import " + classPath);
+        JetFile namespace = createFile(project, "import " + classPath);
         return namespace.getImportDirectives().iterator().next();
     }
 

compiler/frontend/src/org/jetbrains/jet/lang/psi/JetPsiUtil.java

@@ -1,7 +1,6 @@
 package org.jetbrains.jet.lang.psi;
 
 import com.intellij.psi.PsiElement;
-import com.intellij.psi.util.PsiTreeUtil;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lexer.JetTokens;
@@ -72,7 +71,7 @@ public class JetPsiUtil {
     public static JetNamedFunction getSurroundingFunction(@Nullable PsiElement element) {
         while (element != null) {
             if (element instanceof JetNamedFunction) return (JetNamedFunction) element;
-            if (element instanceof JetClassOrObject || element instanceof JetNamespace) return null;
+            if (element instanceof JetClassOrObject || element instanceof JetFile) return null;
             element = element.getParent();
         }
         return null;
@@ -104,16 +103,16 @@ public class JetPsiUtil {
         }
     }
 
-    public static String getFQName(JetNamespace jetNamespace) {
+//    public static String getFQName(JetNamespace jetNamespace) {
-        JetNamespace parent = PsiTreeUtil.getParentOfType(jetNamespace, JetNamespace.class);
+//        JetNamespace parent = PsiTreeUtil.getParentOfType(jetNamespace, JetNamespace.class);
-        if (parent != null) {
+//        if (parent != null) {
-            String parentFQName = getFQName(parent);
+//            String parentFQName = getFQName(parent);
-            if (parentFQName.length() > 0) {
+//            if (parentFQName.length() > 0) {
-                return parentFQName + "." + getFQName(jetNamespace.getHeader());
+//                return parentFQName + "." + getFQName(jetNamespace.getNamespaceHeader());
-            }
+//            }
-        }
+//        }
-        return getFQName(jetNamespace.getHeader()); // TODO: Must include module root namespace
+//        return getFQName(jetNamespace.getNamespaceHeader()); // TODO: Must include module root namespace
-    }
+//    }
 
     private static String getFQName(JetNamespaceHeader header) {
         StringBuilder builder = new StringBuilder();
@@ -121,15 +120,18 @@ public class JetPsiUtil {
             builder.append(nameExpression.getReferencedName());
             builder.append(".");
         }
-//        PsiElement nameIdentifier = header.getNameIdentifier();
         builder.append(header.getName());
         return builder.toString();
     }
 
+    public static String getFQName(JetFile file) {
+        return getFQName(file.getNamespaceHeader());
+    }
+
     public static String getFQName(JetClass jetClass) {
-        JetNamedDeclaration parent = PsiTreeUtil.getParentOfType(jetClass, JetNamespace.class, JetClass.class);
+        PsiElement parent = jetClass.getParent();
-        if (parent instanceof JetNamespace) {
+        if (parent instanceof JetFile) {
-            return makeFQName(getFQName(((JetNamespace) parent)), jetClass);
+            return makeFQName(getFQName((JetFile) parent), jetClass);
         }
         if (parent instanceof JetClass) {
             return makeFQName(getFQName(((JetClass) parent)), jetClass);

compiler/frontend/src/org/jetbrains/jet/lang/psi/JetVisitor.java

@@ -15,10 +15,6 @@ public class JetVisitor<R, D> extends PsiElementVisitor {
         return visitExpression(dcl, data);
     }
 
-    public R visitNamespace(JetNamespace namespace, D data) {
-        return visitDeclaration(namespace, data);
-    }
-
     public R visitClass(JetClass klass, D data) {
         return visitNamedDeclaration(klass, data);
     }

compiler/frontend/src/org/jetbrains/jet/lang/psi/JetVisitorVoid.java

@@ -14,10 +14,6 @@ public class JetVisitorVoid extends PsiElementVisitor {
         visitExpression(dcl);
     }
 
-    public void visitNamespace(JetNamespace namespace) {
-        visitDeclaration(namespace);
-    }
-
     public void visitClass(JetClass klass) {
         visitNamedDeclaration(klass);
     }

compiler/frontend/src/org/jetbrains/jet/lang/resolve/AnalyzingUtils.java

@@ -16,7 +16,7 @@ import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.diagnostics.Diagnostic;
 import org.jetbrains.jet.lang.diagnostics.DiagnosticHolder;
 import org.jetbrains.jet.lang.diagnostics.DiagnosticUtils;
-import org.jetbrains.jet.lang.psi.JetDeclaration;
+import org.jetbrains.jet.lang.psi.JetFile;
 import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 import org.jetbrains.jet.lang.resolve.scopes.WritableScope;
 import org.jetbrains.jet.lang.resolve.scopes.WritableScopeImpl;
@@ -69,21 +69,21 @@ public class AnalyzingUtils {
 
     // --------------------------------------------------------------------------------------------------------------------------
 
-    public static BindingContext analyzeNamespaces(
+    public static BindingContext analyzeFiles(
             @NotNull Project project,
             @NotNull Configuration configuration,
-            @NotNull Collection<? extends JetDeclaration> declarations,
+            @NotNull Collection<JetFile> files,
             @NotNull Predicate<PsiFile> filesToAnalyzeCompletely,
             @NotNull JetControlFlowDataTraceFactory flowDataTraceFactory) {
         BindingTraceContext bindingTraceContext = new BindingTraceContext();
         JetSemanticServices semanticServices = JetSemanticServices.createSemanticServices(project);
-        return analyzeNamespacesWithGivenTrace(project, configuration, declarations, filesToAnalyzeCompletely, flowDataTraceFactory, bindingTraceContext, semanticServices);
+        return analyzeFilesWithGivenTrace(project, configuration, files, filesToAnalyzeCompletely, flowDataTraceFactory, bindingTraceContext, semanticServices);
     }
 
-    public static BindingContext analyzeNamespacesWithGivenTrace(
+    public static BindingContext analyzeFilesWithGivenTrace(
             @NotNull Project project,
             @NotNull Configuration configuration,
-            @NotNull Collection<? extends JetDeclaration> declarations,
+            @NotNull Collection<JetFile> files,
             @NotNull Predicate<PsiFile> filesToAnalyzeCompletely,
             @NotNull JetControlFlowDataTraceFactory flowDataTraceFactory,
             @NotNull BindingTraceContext bindingTraceContext,
@@ -130,7 +130,7 @@ public class AnalyzingUtils {
             public ClassObjectStatus setClassObjectDescriptor(@NotNull MutableClassDescriptor classObjectDescriptor) {
                 throw new IllegalStateException("Must be guaranteed not to happen by the parser");
             }
-        }, declarations, filesToAnalyzeCompletely, flowDataTraceFactory, configuration);
+        }, files, filesToAnalyzeCompletely, flowDataTraceFactory, configuration);
         return bindingTraceContext.getBindingContext();
     }
 

compiler/frontend/src/org/jetbrains/jet/lang/resolve/BindingContext.java

@@ -8,7 +8,6 @@ import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
 import org.jetbrains.jet.lang.diagnostics.Diagnostic;
 import org.jetbrains.jet.lang.psi.*;
 import org.jetbrains.jet.lang.resolve.calls.ResolvedCall;
-import org.jetbrains.jet.lang.resolve.calls.ResolvedCallImpl;
 import org.jetbrains.jet.lang.resolve.constants.CompileTimeConstant;
 import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 import org.jetbrains.jet.lang.types.DeferredType;

compiler/frontend/src/org/jetbrains/jet/lang/resolve/DeclarationResolver.java

@@ -63,8 +63,8 @@ public class DeclarationResolver {
     }
 
     private void resolveFunctionAndPropertyHeaders() {
-        for (Map.Entry<JetNamespace, WritableScope> entry : context.getNamespaceScopes().entrySet()) {
+        for (Map.Entry<JetFile, WritableScope> entry : context.getNamespaceScopes().entrySet()) {
-            JetNamespace namespace = entry.getKey();
+            JetFile namespace = entry.getKey();
             WritableScope namespaceScope = entry.getValue();
             NamespaceLike namespaceDescriptor = context.getNamespaceDescriptors().get(namespace);
 

compiler/frontend/src/org/jetbrains/jet/lang/resolve/ImportsResolver.java

@@ -39,15 +39,15 @@ public class ImportsResolver {
 
     private void processImports(boolean firstPhase) {
         ImportResolver importResolver = new ImportResolver(context.getTrace(), firstPhase);
-        for (JetNamespace jetNamespace : context.getNamespaceDescriptors().keySet()) {
+        for (JetFile file : context.getNamespaceDescriptors().keySet()) {
-            WritableScope namespaceScope = context.getNamespaceScopes().get(jetNamespace);
+            WritableScope namespaceScope = context.getNamespaceScopes().get(file);
             if (firstPhase) {
                 context.getConfiguration().addDefaultImports(context.getTrace(), namespaceScope);
             }
 
-            List<JetImportDirective> importDirectives = jetNamespace.getImportDirectives();
+            List<JetImportDirective> importDirectives = file.getImportDirectives();
             for (JetImportDirective importDirective : importDirectives) {
-                importResolver.processImportReference(importDirective, namespaceScope, context.getDeclaringScopes().get(jetNamespace));
+                importResolver.processImportReference(importDirective, namespaceScope, JetScope.EMPTY);
             }
         }
     }

compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalysisContext.java

@@ -30,8 +30,8 @@ import java.util.Set;
     private final ImportsResolver importsResolver;
     private final Map<JetClass, MutableClassDescriptor> classes = Maps.newLinkedHashMap();
     private final Map<JetObjectDeclaration, MutableClassDescriptor> objects = Maps.newLinkedHashMap();
-    protected final Map<JetNamespace, WritableScope> namespaceScopes = Maps.newHashMap();
+    protected final Map<JetFile, WritableScope> namespaceScopes = Maps.newHashMap();
-    protected final Map<JetNamespace, NamespaceDescriptorImpl> namespaceDescriptors = Maps.newHashMap();
+    protected final Map<JetFile, NamespaceDescriptorImpl> namespaceDescriptors = Maps.newHashMap();
 
     private final Map<JetDeclaration, JetScope> declaringScopes = Maps.newHashMap();
     private final Map<JetNamedFunction, FunctionDescriptorImpl> functions = Maps.newLinkedHashMap();
@@ -114,11 +114,11 @@ import java.util.Set;
         return objects;
     }
 
-    public Map<JetNamespace, WritableScope> getNamespaceScopes() {
+    public Map<JetFile, WritableScope> getNamespaceScopes() {
         return namespaceScopes;
     }
 
-    public Map<JetNamespace, NamespaceDescriptorImpl> getNamespaceDescriptors() {
+    public Map<JetFile, NamespaceDescriptorImpl> getNamespaceDescriptors() {
         return namespaceDescriptors;
     }
 

compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalyzer.java

@@ -2,14 +2,14 @@ package org.jetbrains.jet.lang.resolve;
 
 import com.google.common.base.Predicate;
 import com.google.common.base.Predicates;
+import com.intellij.psi.PsiElement;
 import com.intellij.psi.PsiFile;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.Configuration;
 import org.jetbrains.jet.lang.JetSemanticServices;
 import org.jetbrains.jet.lang.cfg.pseudocode.JetControlFlowDataTraceFactory;
 import org.jetbrains.jet.lang.descriptors.*;
-import org.jetbrains.jet.lang.psi.JetDeclaration;
+import org.jetbrains.jet.lang.psi.JetFile;
-import org.jetbrains.jet.lang.psi.JetNamespace;
 import org.jetbrains.jet.lang.psi.JetObjectDeclaration;
 import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 import org.jetbrains.jet.lang.resolve.scopes.WritableScope;
@@ -29,12 +29,12 @@ public class TopDownAnalyzer {
             @NotNull BindingTrace trace,
             @NotNull JetScope outerScope,
             @NotNull NamespaceLike owner,
-            @NotNull Collection<? extends JetDeclaration> declarations,
+            @NotNull Collection<JetFile> files,
             @NotNull Predicate<PsiFile> analyzeCompletely,
             @NotNull JetControlFlowDataTraceFactory flowDataTraceFactory,
             @NotNull Configuration configuration
             ) {
-        process(semanticServices, trace, outerScope, owner, declarations, analyzeCompletely, flowDataTraceFactory, configuration, false);
+        process(semanticServices, trace, outerScope, owner, files, analyzeCompletely, flowDataTraceFactory, configuration, false);
     }
 
     private static void process(
@@ -42,7 +42,7 @@ public class TopDownAnalyzer {
             @NotNull BindingTrace trace,
             @NotNull JetScope outerScope,
             @NotNull NamespaceLike owner,
-            @NotNull Collection<? extends JetDeclaration> declarations,
+            @NotNull Collection<? extends PsiElement> declarations,
             @NotNull Predicate<PsiFile> analyzeCompletely,
             @NotNull JetControlFlowDataTraceFactory flowDataTraceFactory,
             @NotNull Configuration configuration,
@@ -55,7 +55,7 @@ public class TopDownAnalyzer {
     private static void doProcess(
             TopDownAnalysisContext context, JetScope outerScope,
             NamespaceLike owner,
-            Collection<? extends JetDeclaration> declarations,
+            Collection<? extends PsiElement> declarations,
             JetControlFlowDataTraceFactory flowDataTraceFactory) {
 //        context.enableDebugOutput();
         context.debug("Enter");
@@ -93,14 +93,14 @@ public class TopDownAnalyzer {
             @NotNull BindingTrace trace,
             @NotNull WritableScope outerScope,
             @NotNull NamespaceDescriptorImpl standardLibraryNamespace,
-            @NotNull JetNamespace namespace) {
+            @NotNull JetFile file) {
         TopDownAnalysisContext context = new TopDownAnalysisContext(semanticServices, trace, Predicates.<PsiFile>alwaysTrue(), Configuration.EMPTY, false);
-        context.getNamespaceScopes().put(namespace, standardLibraryNamespace.getMemberScope());
+        context.getNamespaceDescriptors().put(file, standardLibraryNamespace);
-        context.getNamespaceDescriptors().put(namespace, standardLibraryNamespace);
+        context.getNamespaceScopes().put(file, standardLibraryNamespace.getMemberScope());
-        context.getDeclaringScopes().put(namespace, outerScope);
+//        context.getDeclaringScopes().put(file, outerScope);
         context.setAnalyzingBootstrapLibrary(true);
 
-        doProcess(context, outerScope, standardLibraryNamespace, namespace.getDeclarations(), JetControlFlowDataTraceFactory.EMPTY);
+        doProcess(context, outerScope, standardLibraryNamespace, file.getDeclarations(), JetControlFlowDataTraceFactory.EMPTY);
     }
 
     public static void processObject(
@@ -140,7 +140,7 @@ public class TopDownAnalyzer {
             public ClassObjectStatus setClassObjectDescriptor(@NotNull MutableClassDescriptor classObjectDescriptor) {
                 return ClassObjectStatus.NOT_ALLOWED;
             }
-        }, Collections.<JetDeclaration>singletonList(object), Predicates.equalTo(object.getContainingFile()), JetControlFlowDataTraceFactory.EMPTY, Configuration.EMPTY, true);
+        }, Collections.<PsiElement>singletonList(object), Predicates.equalTo(object.getContainingFile()), JetControlFlowDataTraceFactory.EMPTY, Configuration.EMPTY, true);
     }
 
 }

compiler/frontend/src/org/jetbrains/jet/lang/resolve/TypeHierarchyResolver.java

@@ -39,7 +39,7 @@ public class TypeHierarchyResolver {
         this.context = context;
     }
 
-    public void process(@NotNull JetScope outerScope, @NotNull NamespaceLike owner, @NotNull Collection<? extends JetDeclaration> declarations) {
+    public void process(@NotNull JetScope outerScope, @NotNull NamespaceLike owner, @NotNull Collection<? extends PsiElement> declarations) {
         collectNamespacesAndClassifiers(outerScope, outerScope, owner, declarations); // namespaceScopes, classes
 
         context.getImportsResolver().processTypeImports();
@@ -67,22 +67,21 @@ public class TypeHierarchyResolver {
             @NotNull final JetScope outerScope,
             @NotNull final JetScope outerScopeForStatic,
             @NotNull final NamespaceLike owner,
-            @NotNull Collection<? extends JetDeclaration> declarations) {
+            @NotNull Collection<? extends PsiElement> declarations) {
-        for (JetDeclaration declaration : declarations) {
+        for (PsiElement declaration : declarations) {
             declaration.accept(new JetVisitorVoid() {
                 @Override
-                public void visitNamespace(JetNamespace namespace) {
+                public void visitJetFile(JetFile file) {
-                    NamespaceDescriptorImpl namespaceDescriptor = createNamespaceDescriptorPathIfNeeded(namespace, owner);
+                    NamespaceDescriptorImpl namespaceDescriptor = createNamespaceDescriptorPathIfNeeded(file, owner);
-                    context.getNamespaceDescriptors().put(namespace, namespaceDescriptor);
+                    context.getNamespaceDescriptors().put(file, namespaceDescriptor);
 
                     WriteThroughScope namespaceScope = new WriteThroughScope(outerScope, namespaceDescriptor.getMemberScope(), new TraceBasedRedeclarationHandler(context.getTrace()));
                     namespaceScope.changeLockLevel(WritableScope.LockLevel.BOTH);
-                    context.getNamespaceScopes().put(namespace, namespaceScope);
+                    context.getNamespaceScopes().put(file, namespaceScope);
-                    context.getDeclaringScopes().put(namespace, outerScope);
 
 //                    processImports(namespace, namespaceScope, outerScope);
 
-                    collectNamespacesAndClassifiers(namespaceScope, namespaceScope, namespaceDescriptor, namespace.getDeclarations());
+                    collectNamespacesAndClassifiers(namespaceScope, namespaceScope, namespaceDescriptor, file.getDeclarations());
                 }
 
                 @Override
@@ -195,19 +194,19 @@ public class TypeHierarchyResolver {
         }
     }
 
-    private NamespaceDescriptorImpl createNamespaceDescriptorPathIfNeeded(JetNamespace namespace, NamespaceLike owner) {
+    private NamespaceDescriptorImpl createNamespaceDescriptorPathIfNeeded(JetFile file, NamespaceLike owner) {
         NamespaceLike currentOwner = owner;
-        for (JetSimpleNameExpression nameExpression : namespace.getHeader().getParentNamespaceNames()) {
+        for (JetSimpleNameExpression nameExpression : file.getNamespaceHeader().getParentNamespaceNames()) {
             currentOwner = createNamespaceDescriptorIfNeeded(null, currentOwner, JetPsiUtil.safeName(nameExpression.getReferencedName()));
             context.getTrace().record(REFERENCE_TARGET, nameExpression, currentOwner);
         }
 
-        String name = JetPsiUtil.safeName(namespace.getName());
+        String name = JetPsiUtil.safeName(file.getNamespaceHeader().getName());
-        return createNamespaceDescriptorIfNeeded(namespace, currentOwner, name);
+        return createNamespaceDescriptorIfNeeded(file, currentOwner, name);
     }
 
     @NotNull
-    private NamespaceDescriptorImpl createNamespaceDescriptorIfNeeded(@Nullable JetNamespace namespace, @NotNull NamespaceLike owner, @NotNull String name) {
+    private NamespaceDescriptorImpl createNamespaceDescriptorIfNeeded(@Nullable JetFile file, @NotNull NamespaceLike owner, @NotNull String name) {
         NamespaceDescriptorImpl namespaceDescriptor = owner.getNamespace(name);
         if (namespaceDescriptor == null) {
             namespaceDescriptor = new NamespaceDescriptorImpl(
@@ -221,8 +220,8 @@ public class TypeHierarchyResolver {
             namespaceDescriptor.initialize(scope);
             context.getConfiguration().extendNamespaceScope(context.getTrace(), namespaceDescriptor, scope);
             owner.addNamespace(namespaceDescriptor);
-            if (namespace != null) {
+            if (file != null) {
-                context.getTrace().record(BindingContext.NAMESPACE, namespace, namespaceDescriptor);
+                context.getTrace().record(BindingContext.NAMESPACE, file, namespaceDescriptor);
             }
         }
         return namespaceDescriptor;

compiler/frontend/src/org/jetbrains/jet/lang/types/JetStandardLibrary.java

@@ -137,7 +137,7 @@ public class JetStandardLibrary {
             writableScope.changeLockLevel(WritableScope.LockLevel.BOTH);
 //            this.libraryScope = bootstrappingTDA.process(JetStandardClasses.STANDARD_CLASSES, file.getRootNamespace().getDeclarations());
 //            bootstrappingTDA.process(writableScope, JetStandardClasses.STANDARD_CLASSES_NAMESPACE, file.getRootNamespace().getDeclarations());
-            TopDownAnalyzer.processStandardLibraryNamespace(bootstrappingSemanticServices, bindingTraceContext, writableScope, JetStandardClasses.STANDARD_CLASSES_NAMESPACE, file.getRootNamespace());
+            TopDownAnalyzer.processStandardLibraryNamespace(bootstrappingSemanticServices, bindingTraceContext, writableScope, JetStandardClasses.STANDARD_CLASSES_NAMESPACE, file);
 //            this.libraryScope = JetStandardClasses.STANDARD_CLASSES_NAMESPACE.getMemberScope();
 
             AnalyzingUtils.throwExceptionOnErrors(bindingTraceContext.getBindingContext());

compiler/testData/compiler/smoke/Smoke.kts

@@ -1,7 +1,6 @@
 import kotlin.modules.*
 
 val modules = module("smoke") {
-    source files "src/Smoke.kt"
+    source files "Smoke.kt"
-    testSource files "test/SmokeTest.kt"
     jar name System.getProperty("java.io.tmpdir") + "/smoke.jar"
 }

compiler/testData/compiler/smoke/test/SmokeTest.kt

@@ -1,9 +0,0 @@
-import std.io
-
-import junit.framework.*
-
-class SmokeTest() : TestCase() {
-    fun testMe() {
-        println("test")
-    }
-}

compiler/testData/psi/AnnotatedExpressions.txt

@@ -1,48 +1,47 @@
 JetFile: AnnotatedExpressions.jet
-  NAMESPACE
+  NAMESPACE_HEADER
-    NAMESPACE_HEADER
+    <empty list>
-      <empty list>
+  FUN
-    FUN
+    PsiElement(fun)('fun')
-      PsiElement(fun)('fun')
+    PsiWhiteSpace(' ')
-      PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('foo')
-      PsiElement(IDENTIFIER)('foo')
+    VALUE_PARAMETER_LIST
-      VALUE_PARAMETER_LIST
+      PsiElement(LPAR)('(')
-        PsiElement(LPAR)('(')
+      PsiElement(RPAR)(')')
-        PsiElement(RPAR)(')')
+    PsiWhiteSpace(' ')
-      PsiWhiteSpace(' ')
+    BLOCK
-      BLOCK
+      PsiElement(LBRACE)('{')
-        PsiElement(LBRACE)('{')
+      PsiWhiteSpace('\n    ')
-        PsiWhiteSpace('\n    ')
+      ANNOTATED_EXPRESSION
-        ANNOTATED_EXPRESSION
+        ANNOTATION
-          ANNOTATION
+          PsiElement(LBRACKET)('[')
-            PsiElement(LBRACKET)('[')
+          ANNOTATION_ENTRY
-            ANNOTATION_ENTRY
+            CONSTRUCTOR_CALLEE
-              CONSTRUCTOR_CALLEE
+              TYPE_REFERENCE
-                TYPE_REFERENCE
+                USER_TYPE
-                  USER_TYPE
+                  REFERENCE_EXPRESSION
-                    REFERENCE_EXPRESSION
+                    PsiElement(IDENTIFIER)('a')
-                      PsiElement(IDENTIFIER)('a')
+          PsiElement(RBRACKET)(']')
-            PsiElement(RBRACKET)(']')
+        PsiWhiteSpace(' ')
-          PsiWhiteSpace(' ')
+        REFERENCE_EXPRESSION
+          PsiElement(IDENTIFIER)('foo')
+      PsiWhiteSpace('\n    ')
+      INTEGER_CONSTANT
+        PsiElement(INTEGER_LITERAL)('1')
+      PsiWhiteSpace('\n    ')
+      ANNOTATED_EXPRESSION
+        ANNOTATION
+          PsiElement(LBRACKET)('[')
+          ANNOTATION_ENTRY
+            CONSTRUCTOR_CALLEE
+              TYPE_REFERENCE
+                USER_TYPE
+                  REFERENCE_EXPRESSION
+                    PsiElement(IDENTIFIER)('a')
+          PsiElement(RBRACKET)(']')
+        PsiWhiteSpace(' ')
+        THIS_EXPRESSION
           REFERENCE_EXPRESSION
-            PsiElement(IDENTIFIER)('foo')
+            PsiElement(this)('this')
-        PsiWhiteSpace('\n    ')
+      PsiWhiteSpace('\n')
-        INTEGER_CONSTANT
+      PsiElement(RBRACE)('}')
-          PsiElement(INTEGER_LITERAL)('1')
-        PsiWhiteSpace('\n    ')
-        ANNOTATED_EXPRESSION
-          ANNOTATION
-            PsiElement(LBRACKET)('[')
-            ANNOTATION_ENTRY
-              CONSTRUCTOR_CALLEE
-                TYPE_REFERENCE
-                  USER_TYPE
-                    REFERENCE_EXPRESSION
-                      PsiElement(IDENTIFIER)('a')
-            PsiElement(RBRACKET)(']')
-          PsiWhiteSpace(' ')
-          THIS_EXPRESSION
-            REFERENCE_EXPRESSION
-              PsiElement(this)('this')
-        PsiWhiteSpace('\n')
-        PsiElement(RBRACE)('}')

compiler/testData/psi/AnonymousInitializer.txt

@@ -1,49 +1,48 @@
 JetFile: AnonymousInitializer.jet
-  NAMESPACE
+  NAMESPACE_HEADER
-    NAMESPACE_HEADER
+    <empty list>
+  CLASS
+    PsiElement(class)('class')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('Foo')
+    PsiWhiteSpace(' ')
+    TYPE_PARAMETER_LIST
       <empty list>
-    CLASS
+    CLASS_BODY
-      PsiElement(class)('class')
+      PsiElement(LBRACE)('{')
-      PsiWhiteSpace(' ')
+      PsiWhiteSpace('\n\n  ')
-      PsiElement(IDENTIFIER)('Foo')
+      ANONYMOUS_INITIALIZER
-      PsiWhiteSpace(' ')
+        BLOCK
-      TYPE_PARAMETER_LIST
+          PsiElement(LBRACE)('{')
-        <empty list>
+          PsiWhiteSpace('\n    ')
-      CLASS_BODY
+          CALL_EXPRESSION
-        PsiElement(LBRACE)('{')
+            REFERENCE_EXPRESSION
-        PsiWhiteSpace('\n\n  ')
+              PsiElement(IDENTIFIER)('foo')
-        ANONYMOUS_INITIALIZER
+            VALUE_ARGUMENT_LIST
-          BLOCK
+              PsiElement(LPAR)('(')
-            PsiElement(LBRACE)('{')
+              PsiElement(RPAR)(')')
-            PsiWhiteSpace('\n    ')
+          PsiWhiteSpace('\n    ')
-            CALL_EXPRESSION
+          PROPERTY
-              REFERENCE_EXPRESSION
+            PsiElement(val)('val')
-                PsiElement(IDENTIFIER)('foo')
+            PsiWhiteSpace(' ')
-              VALUE_ARGUMENT_LIST
+            PsiElement(IDENTIFIER)('c')
-                PsiElement(LPAR)('(')
+            PsiWhiteSpace(' ')
-                PsiElement(RPAR)(')')
+            PsiElement(EQ)('=')
-            PsiWhiteSpace('\n    ')
+            PsiWhiteSpace(' ')
-            PROPERTY
+            REFERENCE_EXPRESSION
-              PsiElement(val)('val')
+              PsiElement(IDENTIFIER)('f')
-              PsiWhiteSpace(' ')
+          PsiWhiteSpace('\n  ')
-              PsiElement(IDENTIFIER)('c')
+          PsiElement(RBRACE)('}')
-              PsiWhiteSpace(' ')
+      PsiWhiteSpace('\n\n  ')
-              PsiElement(EQ)('=')
+      CONSTRUCTOR
-              PsiWhiteSpace(' ')
+        PsiElement(this)('this')
-              REFERENCE_EXPRESSION
+        VALUE_PARAMETER_LIST
-                PsiElement(IDENTIFIER)('f')
+          PsiElement(LPAR)('(')
-            PsiWhiteSpace('\n  ')
+          PsiElement(RPAR)(')')
-            PsiElement(RBRACE)('}')
+        PsiWhiteSpace(' ')
-        PsiWhiteSpace('\n\n  ')
+        BLOCK
-        CONSTRUCTOR
+          PsiElement(LBRACE)('{')
-          PsiElement(this)('this')
+          PsiWhiteSpace('\n\n  ')
-          VALUE_PARAMETER_LIST
+          PsiElement(RBRACE)('}')
-            PsiElement(LPAR)('(')
+      PsiWhiteSpace('\n')
-            PsiElement(RPAR)(')')
+      PsiElement(RBRACE)('}')
-          PsiWhiteSpace(' ')
-          BLOCK
-            PsiElement(LBRACE)('{')
-            PsiWhiteSpace('\n\n  ')
-            PsiElement(RBRACE)('}')
-        PsiWhiteSpace('\n')
-        PsiElement(RBRACE)('}')

compiler/testData/psi/Attributes.txt

@@ -1,48 +1,112 @@
 JetFile: Attributes.jet
-  NAMESPACE
+  NAMESPACE_HEADER
-    NAMESPACE_HEADER
+    PsiElement(namespace)('package')
-      PsiElement(namespace)('package')
+    PsiWhiteSpace(' ')
-      PsiWhiteSpace(' ')
+    REFERENCE_EXPRESSION
-      REFERENCE_EXPRESSION
+      PsiElement(IDENTIFIER)('foo')
-        PsiElement(IDENTIFIER)('foo')
+    PsiElement(DOT)('.')
-      PsiElement(DOT)('.')
+    REFERENCE_EXPRESSION
-      REFERENCE_EXPRESSION
+      PsiElement(IDENTIFIER)('bar')
-        PsiElement(IDENTIFIER)('bar')
+    PsiElement(DOT)('.')
-      PsiElement(DOT)('.')
+    PsiElement(IDENTIFIER)('goo')
-      PsiElement(IDENTIFIER)('goo')
+  PsiWhiteSpace('\n\n')
-    PsiWhiteSpace('\n\n')
+  CLASS
-    CLASS
+    MODIFIER_LIST
-      MODIFIER_LIST
+      PsiElement(abstract)('abstract')
-        PsiElement(abstract)('abstract')
+      PsiWhiteSpace('\n')
-        PsiWhiteSpace('\n')
+      PsiElement(open)('open')
-        PsiElement(open)('open')
+      PsiWhiteSpace('\n')
-        PsiWhiteSpace('\n')
+      PsiElement(enum)('enum')
-        PsiElement(enum)('enum')
+      PsiWhiteSpace('\n')
-        PsiWhiteSpace('\n')
+      PsiElement(open)('open')
-        PsiElement(open)('open')
+      PsiWhiteSpace('\n')
-        PsiWhiteSpace('\n')
+      PsiElement(annotation)('annotation')
-        PsiElement(annotation)('annotation')
+      PsiWhiteSpace('\n')
-        PsiWhiteSpace('\n')
+      PsiElement(override)('override')
-        PsiElement(override)('override')
+      PsiWhiteSpace('\n')
-        PsiWhiteSpace('\n')
+      PsiElement(open)('open')
-        PsiElement(open)('open')
+      PsiWhiteSpace('\n')
-        PsiWhiteSpace('\n')
+      PsiElement(abstract)('abstract')
-        PsiElement(abstract)('abstract')
+      PsiWhiteSpace('\n')
-        PsiWhiteSpace('\n')
+      PsiElement(private)('private')
-        PsiElement(private)('private')
+      PsiWhiteSpace('\n')
-        PsiWhiteSpace('\n')
+      PsiElement(protected)('protected')
-        PsiElement(protected)('protected')
+      PsiWhiteSpace('\n')
-        PsiWhiteSpace('\n')
+      PsiElement(public)('public')
-        PsiElement(public)('public')
+      PsiWhiteSpace('\n')
-        PsiWhiteSpace('\n')
+      PsiElement(internal)('internal')
-        PsiElement(internal)('internal')
+      PsiWhiteSpace('\n')
-        PsiWhiteSpace('\n')
+      ANNOTATION
-        ANNOTATION
+        PsiElement(LBRACKET)('[')
-          PsiElement(LBRACKET)('[')
+        ANNOTATION_ENTRY
-          ANNOTATION_ENTRY
+          CONSTRUCTOR_CALLEE
-            CONSTRUCTOR_CALLEE
+            TYPE_REFERENCE
-              TYPE_REFERENCE
+              USER_TYPE
+                REFERENCE_EXPRESSION
+                  PsiElement(IDENTIFIER)('foo')
+                TYPE_ARGUMENT_LIST
+                  PsiElement(LT)('<')
+                  TYPE_PROJECTION
+                    TYPE_REFERENCE
+                      USER_TYPE
+                        REFERENCE_EXPRESSION
+                          PsiElement(IDENTIFIER)('A')
+                  PsiElement(COMMA)(',')
+                  PsiWhiteSpace(' ')
+                  TYPE_PROJECTION
+                    TYPE_REFERENCE
+                      USER_TYPE
+                        REFERENCE_EXPRESSION
+                          PsiElement(IDENTIFIER)('B')
+                  PsiElement(GT)('>')
+          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(' ')
+        ANNOTATION_ENTRY
+          CONSTRUCTOR_CALLEE
+            TYPE_REFERENCE
+              USER_TYPE
+                REFERENCE_EXPRESSION
+                  PsiElement(IDENTIFIER)('ina')
+        PsiWhiteSpace(' ')
+        ANNOTATION_ENTRY
+          CONSTRUCTOR_CALLEE
+            TYPE_REFERENCE
+              USER_TYPE
                 USER_TYPE
+                  USER_TYPE
+                    USER_TYPE
+                      USER_TYPE
+                        USER_TYPE
+                          REFERENCE_EXPRESSION
+                            PsiElement(IDENTIFIER)('foo')
+                        PsiElement(DOT)('.')
+                        REFERENCE_EXPRESSION
+                          PsiElement(IDENTIFIER)('bar')
+                      PsiElement(DOT)('.')
+                      REFERENCE_EXPRESSION
+                        PsiElement(IDENTIFIER)('goo')
+                    PsiElement(DOT)('.')
+                    REFERENCE_EXPRESSION
+                      PsiElement(IDENTIFIER)('doo')
+                    TYPE_ARGUMENT_LIST
+                      PsiElement(LT)('<')
+                      TYPE_PROJECTION
+                        TYPE_REFERENCE
+                          USER_TYPE
+                            REFERENCE_EXPRESSION
+                              PsiElement(IDENTIFIER)('f')
+                      PsiElement(GT)('>')
+                  PsiElement(DOT)('.')
                   REFERENCE_EXPRESSION
                     PsiElement(IDENTIFIER)('foo')
                   TYPE_ARGUMENT_LIST
@@ -51,268 +115,203 @@ JetFile: Attributes.jet
                       TYPE_REFERENCE
                         USER_TYPE
                           REFERENCE_EXPRESSION
-                            PsiElement(IDENTIFIER)('A')
+                            PsiElement(IDENTIFIER)('bar')
                     PsiElement(COMMA)(',')
                     PsiWhiteSpace(' ')
                     TYPE_PROJECTION
                       TYPE_REFERENCE
                         USER_TYPE
                           REFERENCE_EXPRESSION
-                            PsiElement(IDENTIFIER)('B')
+                            PsiElement(IDENTIFIER)('goo')
                     PsiElement(GT)('>')
-            VALUE_ARGUMENT_LIST
+                PsiElement(DOT)('.')
-              PsiElement(LPAR)('(')
-              VALUE_ARGUMENT
                 REFERENCE_EXPRESSION
-                  PsiElement(IDENTIFIER)('a')
+                  PsiElement(IDENTIFIER)('foo')
-              PsiElement(COMMA)(',')
+        PsiElement(RBRACKET)(']')
-              PsiWhiteSpace(' ')
+      PsiWhiteSpace('\n')
-              VALUE_ARGUMENT
+      ANNOTATION
+        PsiElement(LBRACKET)('[')
+        ANNOTATION_ENTRY
+          CONSTRUCTOR_CALLEE
+            TYPE_REFERENCE
+              USER_TYPE
                 REFERENCE_EXPRESSION
-                  PsiElement(IDENTIFIER)('b')
+                  PsiElement(IDENTIFIER)('df')
-              PsiElement(RPAR)(')')
+        PsiElement(RBRACKET)(']')
-          PsiWhiteSpace(' ')
+      PsiWhiteSpace('\n')
-          ANNOTATION_ENTRY
+      PsiElement(in)('in')
-            CONSTRUCTOR_CALLEE
+      PsiWhiteSpace('\n')
-              TYPE_REFERENCE
+      ANNOTATION
-                USER_TYPE
+        PsiElement(LBRACKET)('[')
-                  REFERENCE_EXPRESSION
+        ANNOTATION_ENTRY
-                    PsiElement(IDENTIFIER)('ina')
+          CONSTRUCTOR_CALLEE
-          PsiWhiteSpace(' ')
+            TYPE_REFERENCE
-          ANNOTATION_ENTRY
+              USER_TYPE
-            CONSTRUCTOR_CALLEE
+                REFERENCE_EXPRESSION
-              TYPE_REFERENCE
+                  PsiElement(IDENTIFIER)('sdfsdf')
-                USER_TYPE
+        PsiElement(RBRACKET)(']')
+      PsiWhiteSpace('\n')
+      PsiElement(out)('out')
+      PsiWhiteSpace('\n')
+      PsiElement(ref)('ref')
+    PsiWhiteSpace('\n ')
+    PsiElement(class)('class')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('Bar')
+    TYPE_PARAMETER_LIST
+      PsiElement(LT)('<')
+      TYPE_PARAMETER
+        MODIFIER_LIST
+          PsiElement(abstract)('abstract')
+          PsiWhiteSpace('\n')
+          PsiElement(open)('open')
+          PsiWhiteSpace('\n')
+          ANNOTATION
+            PsiElement(LBRACKET)('[')
+            ANNOTATION_ENTRY
+              CONSTRUCTOR_CALLEE
+                TYPE_REFERENCE
+                  USER_TYPE
+                    REFERENCE_EXPRESSION
+                      PsiElement(IDENTIFIER)('sdfsdf')
+              VALUE_ARGUMENT_LIST
+                PsiElement(LPAR)('(')
+                VALUE_ARGUMENT
+                  BINARY_EXPRESSION
+                    INTEGER_CONSTANT
+                      PsiElement(INTEGER_LITERAL)('1')
+                    OPERATION_REFERENCE
+                      PsiElement(PLUS)('+')
+                    INTEGER_CONSTANT
+                      PsiElement(INTEGER_LITERAL)('1')
+                PsiElement(RPAR)(')')
+            PsiWhiteSpace(' ')
+            ANNOTATION_ENTRY
+              CONSTRUCTOR_CALLEE
+                TYPE_REFERENCE
+                  USER_TYPE
+                    REFERENCE_EXPRESSION
+                      PsiElement(IDENTIFIER)('a')
+            PsiElement(RBRACKET)(']')
+          PsiWhiteSpace('\n')
+          ANNOTATION
+            PsiElement(LBRACKET)('[')
+            ANNOTATION_ENTRY
+              CONSTRUCTOR_CALLEE
+                TYPE_REFERENCE
+                  USER_TYPE
+                    REFERENCE_EXPRESSION
+                      PsiElement(IDENTIFIER)('sdfsdf')
+              VALUE_ARGUMENT_LIST
+                PsiElement(LPAR)('(')
+                VALUE_ARGUMENT
+                  BINARY_EXPRESSION
+                    INTEGER_CONSTANT
+                      PsiElement(INTEGER_LITERAL)('1')
+                    OPERATION_REFERENCE
+                      PsiElement(PLUS)('+')
+                    INTEGER_CONSTANT
+                      PsiElement(INTEGER_LITERAL)('1')
+                PsiElement(RPAR)(')')
+            PsiElement(RBRACKET)(']')
+          PsiWhiteSpace('\n')
+          ANNOTATION
+            PsiElement(LBRACKET)('[')
+            ANNOTATION_ENTRY
+              CONSTRUCTOR_CALLEE
+                TYPE_REFERENCE
+                  USER_TYPE
+                    REFERENCE_EXPRESSION
+                      PsiElement(IDENTIFIER)('a')
+              VALUE_ARGUMENT_LIST
+                PsiElement(LPAR)('(')
+                PsiElement(RPAR)(')')
+            PsiWhiteSpace(' ')
+            ANNOTATION_ENTRY
+              CONSTRUCTOR_CALLEE
+                TYPE_REFERENCE
+                  USER_TYPE
+                    REFERENCE_EXPRESSION
+                      PsiElement(IDENTIFIER)('sdfsdf')
+              VALUE_ARGUMENT_LIST
+                PsiElement(LPAR)('(')
+                VALUE_ARGUMENT
+                  BINARY_EXPRESSION
+                    INTEGER_CONSTANT
+                      PsiElement(INTEGER_LITERAL)('1')
+                    OPERATION_REFERENCE
+                      PsiElement(PLUS)('+')
+                    INTEGER_CONSTANT
+                      PsiElement(INTEGER_LITERAL)('1')
+                PsiElement(RPAR)(')')
+            PsiElement(RBRACKET)(']')
+          PsiWhiteSpace('\n')
+          PsiElement(enum)('enum')
+          PsiWhiteSpace('\n')
+          PsiElement(open)('open')
+          PsiWhiteSpace('\n')
+          PsiElement(annotation)('annotation')
+          PsiWhiteSpace('\n')
+          PsiElement(override)('override')
+          PsiWhiteSpace('\n')
+          PsiElement(open)('open')
+          PsiWhiteSpace('\n')
+          PsiElement(abstract)('abstract')
+          PsiWhiteSpace('\n')
+          ANNOTATION
+            PsiElement(LBRACKET)('[')
+            ANNOTATION_ENTRY
+              CONSTRUCTOR_CALLEE
+                TYPE_REFERENCE
+                  USER_TYPE
+                    REFERENCE_EXPRESSION
+                      PsiElement(IDENTIFIER)('sdfsd')
+            PsiWhiteSpace(' ')
+            ANNOTATION_ENTRY
+              CONSTRUCTOR_CALLEE
+                TYPE_REFERENCE
+                  USER_TYPE
+                    REFERENCE_EXPRESSION
+                      PsiElement(IDENTIFIER)('sdfsd')
+            PsiWhiteSpace(' ')
+            ANNOTATION_ENTRY
+              CONSTRUCTOR_CALLEE
+                TYPE_REFERENCE
                   USER_TYPE
                     USER_TYPE
                       USER_TYPE
                         USER_TYPE
-                          USER_TYPE
-                            REFERENCE_EXPRESSION
-                              PsiElement(IDENTIFIER)('foo')
-                          PsiElement(DOT)('.')
                           REFERENCE_EXPRESSION
-                            PsiElement(IDENTIFIER)('bar')
+                            PsiElement(IDENTIFIER)('a')
                         PsiElement(DOT)('.')
                         REFERENCE_EXPRESSION
-                          PsiElement(IDENTIFIER)('goo')
+                          PsiElement(IDENTIFIER)('b')
                       PsiElement(DOT)('.')
                       REFERENCE_EXPRESSION
-                        PsiElement(IDENTIFIER)('doo')
+                        PsiElement(IDENTIFIER)('f')
-                      TYPE_ARGUMENT_LIST
-                        PsiElement(LT)('<')
-                        TYPE_PROJECTION
-                          TYPE_REFERENCE
-                            USER_TYPE
-                              REFERENCE_EXPRESSION
-                                PsiElement(IDENTIFIER)('f')
-                        PsiElement(GT)('>')
                     PsiElement(DOT)('.')
                     REFERENCE_EXPRESSION
-                      PsiElement(IDENTIFIER)('foo')
+                      PsiElement(IDENTIFIER)('c')
-                    TYPE_ARGUMENT_LIST
+            PsiElement(RBRACKET)(']')
-                      PsiElement(LT)('<')
+          PsiWhiteSpace('\n')
-                      TYPE_PROJECTION
+          PsiElement(private)('private')
-                        TYPE_REFERENCE
+          PsiWhiteSpace('\n')
-                          USER_TYPE
+          PsiElement(protected)('protected')
-                            REFERENCE_EXPRESSION
+          PsiWhiteSpace('\n')
-                              PsiElement(IDENTIFIER)('bar')
+          PsiElement(public)('public')
-                      PsiElement(COMMA)(',')
+          PsiWhiteSpace('\n')
-                      PsiWhiteSpace(' ')
+          PsiElement(internal)('internal')
-                      TYPE_PROJECTION
+          PsiWhiteSpace('\n')
-                        TYPE_REFERENCE
+          PsiElement(in)('in')
-                          USER_TYPE
+          PsiWhiteSpace('\n')
-                            REFERENCE_EXPRESSION
+          PsiElement(out)('out')
-                              PsiElement(IDENTIFIER)('goo')
+          PsiWhiteSpace('\n')
-                      PsiElement(GT)('>')
+          PsiElement(ref)('ref')
-                  PsiElement(DOT)('.')
+        PsiWhiteSpace(' ')
-                  REFERENCE_EXPRESSION
+        PsiElement(IDENTIFIER)('T')
-                    PsiElement(IDENTIFIER)('foo')
+      PsiElement(GT)('>')
-          PsiElement(RBRACKET)(']')
+    PsiWhiteSpace(' ')
-        PsiWhiteSpace('\n')
+    CLASS_BODY
-        ANNOTATION
+      PsiElement(LBRACE)('{')
-          PsiElement(LBRACKET)('[')
+      PsiWhiteSpace('\n')
-          ANNOTATION_ENTRY
+      PsiElement(RBRACE)('}')
-            CONSTRUCTOR_CALLEE
-              TYPE_REFERENCE
-                USER_TYPE
-                  REFERENCE_EXPRESSION
-                    PsiElement(IDENTIFIER)('df')
-          PsiElement(RBRACKET)(']')
-        PsiWhiteSpace('\n')
-        PsiElement(in)('in')
-        PsiWhiteSpace('\n')
-        ANNOTATION
-          PsiElement(LBRACKET)('[')
-          ANNOTATION_ENTRY
-            CONSTRUCTOR_CALLEE
-              TYPE_REFERENCE
-                USER_TYPE
-                  REFERENCE_EXPRESSION
-                    PsiElement(IDENTIFIER)('sdfsdf')
-          PsiElement(RBRACKET)(']')
-        PsiWhiteSpace('\n')
-        PsiElement(out)('out')
-        PsiWhiteSpace('\n')
-        PsiElement(ref)('ref')
-      PsiWhiteSpace('\n ')
-      PsiElement(class)('class')
-      PsiWhiteSpace(' ')
-      PsiElement(IDENTIFIER)('Bar')
-      TYPE_PARAMETER_LIST
-        PsiElement(LT)('<')
-        TYPE_PARAMETER
-          MODIFIER_LIST
-            PsiElement(abstract)('abstract')
-            PsiWhiteSpace('\n')
-            PsiElement(open)('open')
-            PsiWhiteSpace('\n')
-            ANNOTATION
-              PsiElement(LBRACKET)('[')
-              ANNOTATION_ENTRY
-                CONSTRUCTOR_CALLEE
-                  TYPE_REFERENCE
-                    USER_TYPE
-                      REFERENCE_EXPRESSION
-                        PsiElement(IDENTIFIER)('sdfsdf')
-                VALUE_ARGUMENT_LIST
-                  PsiElement(LPAR)('(')
-                  VALUE_ARGUMENT
-                    BINARY_EXPRESSION
-                      INTEGER_CONSTANT
-                        PsiElement(INTEGER_LITERAL)('1')
-                      OPERATION_REFERENCE
-                        PsiElement(PLUS)('+')
-                      INTEGER_CONSTANT
-                        PsiElement(INTEGER_LITERAL)('1')
-                  PsiElement(RPAR)(')')
-              PsiWhiteSpace(' ')
-              ANNOTATION_ENTRY
-                CONSTRUCTOR_CALLEE
-                  TYPE_REFERENCE
-                    USER_TYPE
-                      REFERENCE_EXPRESSION
-                        PsiElement(IDENTIFIER)('a')
-              PsiElement(RBRACKET)(']')
-            PsiWhiteSpace('\n')
-            ANNOTATION
-              PsiElement(LBRACKET)('[')
-              ANNOTATION_ENTRY
-                CONSTRUCTOR_CALLEE
-                  TYPE_REFERENCE
-                    USER_TYPE
-                      REFERENCE_EXPRESSION
-                        PsiElement(IDENTIFIER)('sdfsdf')
-                VALUE_ARGUMENT_LIST
-                  PsiElement(LPAR)('(')
-                  VALUE_ARGUMENT
-                    BINARY_EXPRESSION
-                      INTEGER_CONSTANT
-                        PsiElement(INTEGER_LITERAL)('1')
-                      OPERATION_REFERENCE
-                        PsiElement(PLUS)('+')
-                      INTEGER_CONSTANT
-                        PsiElement(INTEGER_LITERAL)('1')
-                  PsiElement(RPAR)(')')
-              PsiElement(RBRACKET)(']')
-            PsiWhiteSpace('\n')
-            ANNOTATION
-              PsiElement(LBRACKET)('[')
-              ANNOTATION_ENTRY
-                CONSTRUCTOR_CALLEE
-                  TYPE_REFERENCE
-                    USER_TYPE
-                      REFERENCE_EXPRESSION
-                        PsiElement(IDENTIFIER)('a')
-                VALUE_ARGUMENT_LIST
-                  PsiElement(LPAR)('(')
-                  PsiElement(RPAR)(')')
-              PsiWhiteSpace(' ')
-              ANNOTATION_ENTRY
-                CONSTRUCTOR_CALLEE
-                  TYPE_REFERENCE
-                    USER_TYPE
-                      REFERENCE_EXPRESSION
-                        PsiElement(IDENTIFIER)('sdfsdf')
-                VALUE_ARGUMENT_LIST
-                  PsiElement(LPAR)('(')
-                  VALUE_ARGUMENT
-                    BINARY_EXPRESSION
-                      INTEGER_CONSTANT
-                        PsiElement(INTEGER_LITERAL)('1')
-                      OPERATION_REFERENCE
-                        PsiElement(PLUS)('+')
-                      INTEGER_CONSTANT
-                        PsiElement(INTEGER_LITERAL)('1')
-                  PsiElement(RPAR)(')')
-              PsiElement(RBRACKET)(']')
-            PsiWhiteSpace('\n')
-            PsiElement(enum)('enum')
-            PsiWhiteSpace('\n')
-            PsiElement(open)('open')
-            PsiWhiteSpace('\n')
-            PsiElement(annotation)('annotation')
-            PsiWhiteSpace('\n')
-            PsiElement(override)('override')
-            PsiWhiteSpace('\n')
-            PsiElement(open)('open')
-            PsiWhiteSpace('\n')
-            PsiElement(abstract)('abstract')
-            PsiWhiteSpace('\n')
-            ANNOTATION
-              PsiElement(LBRACKET)('[')
-              ANNOTATION_ENTRY
-                CONSTRUCTOR_CALLEE
-                  TYPE_REFERENCE
-                    USER_TYPE
-                      REFERENCE_EXPRESSION
-                        PsiElement(IDENTIFIER)('sdfsd')
-              PsiWhiteSpace(' ')
-              ANNOTATION_ENTRY
-                CONSTRUCTOR_CALLEE
-                  TYPE_REFERENCE
-                    USER_TYPE
-                      REFERENCE_EXPRESSION
-                        PsiElement(IDENTIFIER)('sdfsd')
-              PsiWhiteSpace(' ')
-              ANNOTATION_ENTRY
-                CONSTRUCTOR_CALLEE
-                  TYPE_REFERENCE
-                    USER_TYPE
-                      USER_TYPE
-                        USER_TYPE
-                          USER_TYPE
-                            REFERENCE_EXPRESSION
-                              PsiElement(IDENTIFIER)('a')
-                          PsiElement(DOT)('.')
-                          REFERENCE_EXPRESSION
-                            PsiElement(IDENTIFIER)('b')
-                        PsiElement(DOT)('.')
-                        REFERENCE_EXPRESSION
-                          PsiElement(IDENTIFIER)('f')
-                      PsiElement(DOT)('.')
-                      REFERENCE_EXPRESSION
-                        PsiElement(IDENTIFIER)('c')
-              PsiElement(RBRACKET)(']')
-            PsiWhiteSpace('\n')
-            PsiElement(private)('private')
-            PsiWhiteSpace('\n')
-            PsiElement(protected)('protected')
-            PsiWhiteSpace('\n')
-            PsiElement(public)('public')
-            PsiWhiteSpace('\n')
-            PsiElement(internal)('internal')
-            PsiWhiteSpace('\n')
-            PsiElement(in)('in')
-            PsiWhiteSpace('\n')
-            PsiElement(out)('out')
-            PsiWhiteSpace('\n')
-            PsiElement(ref)('ref')
-          PsiWhiteSpace(' ')
-          PsiElement(IDENTIFIER)('T')
-        PsiElement(GT)('>')
-      PsiWhiteSpace(' ')
-      CLASS_BODY
-        PsiElement(LBRACE)('{')
-        PsiWhiteSpace('\n')
-        PsiElement(RBRACE)('}')

compiler/testData/psi/AttributesOnPatterns.txt

@@ -1,185 +1,184 @@
 JetFile: AttributesOnPatterns.jet
-  NAMESPACE
+  NAMESPACE_HEADER
-    NAMESPACE_HEADER
+    <empty list>
-      <empty list>
+  FUN
-    FUN
+    PsiElement(fun)('fun')
-      PsiElement(fun)('fun')
+    PsiWhiteSpace(' ')
-      PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('foo')
-      PsiElement(IDENTIFIER)('foo')
+    VALUE_PARAMETER_LIST
-      VALUE_PARAMETER_LIST
+      PsiElement(LPAR)('(')
+      PsiElement(RPAR)(')')
+    PsiWhiteSpace(' ')
+    BLOCK
+      PsiElement(LBRACE)('{')
+      PsiWhiteSpace('\n\n    ')
+      WHEN
+        PsiElement(when)('when')
+        PsiWhiteSpace(' ')
         PsiElement(LPAR)('(')
+        REFERENCE_EXPRESSION
+          PsiElement(IDENTIFIER)('e')
         PsiElement(RPAR)(')')
-      PsiWhiteSpace(' ')
+        PsiWhiteSpace(' ')
-      BLOCK
         PsiElement(LBRACE)('{')
-        PsiWhiteSpace('\n\n    ')
+        PsiWhiteSpace('\n      ')
-        WHEN
+        WHEN_ENTRY
-          PsiElement(when)('when')
+          WHEN_CONDITION_IS_PATTERN
-          PsiWhiteSpace(' ')
+            PsiElement(is)('is')
-          PsiElement(LPAR)('(')
-          REFERENCE_EXPRESSION
-            PsiElement(IDENTIFIER)('e')
-          PsiElement(RPAR)(')')
-          PsiWhiteSpace(' ')
-          PsiElement(LBRACE)('{')
-          PsiWhiteSpace('\n      ')
-          WHEN_ENTRY
-            WHEN_CONDITION_IS_PATTERN
-              PsiElement(is)('is')
-              PsiWhiteSpace(' ')
-              BINDING_PATTERN
-                ANNOTATION
-                  PsiElement(LBRACKET)('[')
-                  ANNOTATION_ENTRY
-                    CONSTRUCTOR_CALLEE
-                      TYPE_REFERENCE
-                        USER_TYPE
-                          REFERENCE_EXPRESSION
-                            PsiElement(IDENTIFIER)('a')
-                  PsiElement(RBRACKET)(']')
-                PsiWhiteSpace(' ')
-                PROPERTY
-                  PsiElement(val)('val')
-                  PsiWhiteSpace(' ')
-                  PsiElement(IDENTIFIER)('a')
             PsiWhiteSpace(' ')
-            PsiElement(ARROW)('->')
+            BINDING_PATTERN
-            PsiWhiteSpace(' ')
+              ANNOTATION
-            REFERENCE_EXPRESSION
+                PsiElement(LBRACKET)('[')
-              PsiElement(IDENTIFIER)('d')
+                ANNOTATION_ENTRY
-          PsiWhiteSpace('\n      ')
+                  CONSTRUCTOR_CALLEE
-          WHEN_ENTRY
-            WHEN_CONDITION_IS_PATTERN
-              PsiElement(is)('is')
-              PsiWhiteSpace(' ')
-              BINDING_PATTERN
-                ANNOTATION
-                  PsiElement(LBRACKET)('[')
-                  ANNOTATION_ENTRY
-                    CONSTRUCTOR_CALLEE
-                      TYPE_REFERENCE
-                        USER_TYPE
-                          REFERENCE_EXPRESSION
-                            PsiElement(IDENTIFIER)('a')
-                  PsiElement(RBRACKET)(']')
-                PsiWhiteSpace(' ')
-                PROPERTY
-                  PsiElement(val)('val')
-                  PsiWhiteSpace(' ')
-                  PsiElement(IDENTIFIER)('a')
-                PsiWhiteSpace(' ')
-                WHEN_CONDITION_IS_PATTERN
-                  PsiElement(is)('is')
-                  PsiWhiteSpace(' ')
-                  TYPE_PATTERN
                     TYPE_REFERENCE
                       USER_TYPE
                         REFERENCE_EXPRESSION
-                          PsiElement(IDENTIFIER)('foo')
+                          PsiElement(IDENTIFIER)('a')
-            PsiWhiteSpace(' ')
+                PsiElement(RBRACKET)(']')
-            PsiElement(ARROW)('->')
-            PsiWhiteSpace(' ')
-            REFERENCE_EXPRESSION
-              PsiElement(IDENTIFIER)('d')
-          PsiWhiteSpace('\n      ')
-          WHEN_ENTRY
-            WHEN_CONDITION_IS_PATTERN
-              PsiElement(is)('is')
               PsiWhiteSpace(' ')
-              WILDCARD_PATTERN
+              PROPERTY
-                ANNOTATION
+                PsiElement(val)('val')
-                  PsiElement(LBRACKET)('[')
-                  ANNOTATION_ENTRY
-                    CONSTRUCTOR_CALLEE
-                      TYPE_REFERENCE
-                        USER_TYPE
-                          REFERENCE_EXPRESSION
-                            PsiElement(IDENTIFIER)('a')
-                  PsiElement(RBRACKET)(']')
                 PsiWhiteSpace(' ')
-                PsiElement(MUL)('*')
+                PsiElement(IDENTIFIER)('a')
+          PsiWhiteSpace(' ')
+          PsiElement(ARROW)('->')
+          PsiWhiteSpace(' ')
+          REFERENCE_EXPRESSION
+            PsiElement(IDENTIFIER)('d')
+        PsiWhiteSpace('\n      ')
+        WHEN_ENTRY
+          WHEN_CONDITION_IS_PATTERN
+            PsiElement(is)('is')
             PsiWhiteSpace(' ')
-            PsiElement(ARROW)('->')
+            BINDING_PATTERN
-            PsiWhiteSpace(' ')
+              ANNOTATION
-            REFERENCE_EXPRESSION
+                PsiElement(LBRACKET)('[')
-              PsiElement(IDENTIFIER)('d')
+                ANNOTATION_ENTRY
-          PsiWhiteSpace('\n      ')
+                  CONSTRUCTOR_CALLEE
-          WHEN_ENTRY
+                    TYPE_REFERENCE
-            WHEN_CONDITION_IS_PATTERN
+                      USER_TYPE
-              PsiElement(is)('is')
+                        REFERENCE_EXPRESSION
+                          PsiElement(IDENTIFIER)('a')
+                PsiElement(RBRACKET)(']')
               PsiWhiteSpace(' ')
-              EXPRESSION_PATTERN
+              PROPERTY
-                ANNOTATION
+                PsiElement(val)('val')
-                  PsiElement(LBRACKET)('[')
-                  ANNOTATION_ENTRY
-                    CONSTRUCTOR_CALLEE
-                      TYPE_REFERENCE
-                        USER_TYPE
-                          REFERENCE_EXPRESSION
-                            PsiElement(IDENTIFIER)('a')
-                  PsiElement(RBRACKET)(']')
                 PsiWhiteSpace(' ')
-                INTEGER_CONSTANT
+                PsiElement(IDENTIFIER)('a')
-                  PsiElement(INTEGER_LITERAL)('2')
-            PsiWhiteSpace(' ')
-            PsiElement(ARROW)('->')
-            PsiWhiteSpace(' ')
-            REFERENCE_EXPRESSION
-              PsiElement(IDENTIFIER)('d')
-          PsiWhiteSpace('\n      ')
-          WHEN_ENTRY
-            WHEN_CONDITION_IS_PATTERN
-              PsiElement(is)('is')
               PsiWhiteSpace(' ')
-              TYPE_PATTERN
+              WHEN_CONDITION_IS_PATTERN
-                ANNOTATION
+                PsiElement(is)('is')
-                  PsiElement(LBRACKET)('[')
-                  ANNOTATION_ENTRY
-                    CONSTRUCTOR_CALLEE
-                      TYPE_REFERENCE
-                        USER_TYPE
-                          REFERENCE_EXPRESSION
-                            PsiElement(IDENTIFIER)('a')
-                  PsiElement(RBRACKET)(']')
                 PsiWhiteSpace(' ')
-                TYPE_REFERENCE
+                TYPE_PATTERN
-                  USER_TYPE
+                  TYPE_REFERENCE
-                    REFERENCE_EXPRESSION
+                    USER_TYPE
-                      PsiElement(IDENTIFIER)('T')
+                      REFERENCE_EXPRESSION
+                        PsiElement(IDENTIFIER)('foo')
+          PsiWhiteSpace(' ')
+          PsiElement(ARROW)('->')
+          PsiWhiteSpace(' ')
+          REFERENCE_EXPRESSION
+            PsiElement(IDENTIFIER)('d')
+        PsiWhiteSpace('\n      ')
+        WHEN_ENTRY
+          WHEN_CONDITION_IS_PATTERN
+            PsiElement(is)('is')
             PsiWhiteSpace(' ')
-            PsiElement(ARROW)('->')
+            WILDCARD_PATTERN
-            PsiWhiteSpace(' ')
+              ANNOTATION
-            REFERENCE_EXPRESSION
+                PsiElement(LBRACKET)('[')
-              PsiElement(IDENTIFIER)('d')
+                ANNOTATION_ENTRY
-          PsiWhiteSpace('\n      ')
+                  CONSTRUCTOR_CALLEE
-          WHEN_ENTRY
+                    TYPE_REFERENCE
-            WHEN_CONDITION_IS_PATTERN
+                      USER_TYPE
-              PsiElement(is)('is')
+                        REFERENCE_EXPRESSION
+                          PsiElement(IDENTIFIER)('a')
+                PsiElement(RBRACKET)(']')
               PsiWhiteSpace(' ')
-              DECOMPOSER_PATTERN
+              PsiElement(MUL)('*')
-                ANNOTATION
+          PsiWhiteSpace(' ')
-                  PsiElement(LBRACKET)('[')
+          PsiElement(ARROW)('->')
-                  ANNOTATION_ENTRY
+          PsiWhiteSpace(' ')
-                    CONSTRUCTOR_CALLEE
+          REFERENCE_EXPRESSION
-                      TYPE_REFERENCE
+            PsiElement(IDENTIFIER)('d')
-                        USER_TYPE
+        PsiWhiteSpace('\n      ')
-                          REFERENCE_EXPRESSION
+        WHEN_ENTRY
-                            PsiElement(IDENTIFIER)('a')
+          WHEN_CONDITION_IS_PATTERN
-                  PsiElement(RBRACKET)(']')
+            PsiElement(is)('is')
-                PsiWhiteSpace(' ')
-                REFERENCE_EXPRESSION
-                  PsiElement(IDENTIFIER)('T')
-                PsiWhiteSpace('  ')
-                DECOMPOSER_ARGUMENT_LIST
-                  PsiElement(HASH)('#')
-                  PsiElement(LPAR)('(')
-                  PsiElement(RPAR)(')')
             PsiWhiteSpace(' ')
-            PsiElement(ARROW)('->')
+            EXPRESSION_PATTERN
+              ANNOTATION
+                PsiElement(LBRACKET)('[')
+                ANNOTATION_ENTRY
+                  CONSTRUCTOR_CALLEE
+                    TYPE_REFERENCE
+                      USER_TYPE
+                        REFERENCE_EXPRESSION
+                          PsiElement(IDENTIFIER)('a')
+                PsiElement(RBRACKET)(']')
+              PsiWhiteSpace(' ')
+              INTEGER_CONSTANT
+                PsiElement(INTEGER_LITERAL)('2')
+          PsiWhiteSpace(' ')
+          PsiElement(ARROW)('->')
+          PsiWhiteSpace(' ')
+          REFERENCE_EXPRESSION
+            PsiElement(IDENTIFIER)('d')
+        PsiWhiteSpace('\n      ')
+        WHEN_ENTRY
+          WHEN_CONDITION_IS_PATTERN
+            PsiElement(is)('is')
             PsiWhiteSpace(' ')
-            REFERENCE_EXPRESSION
+            TYPE_PATTERN
-              PsiElement(IDENTIFIER)('d')
+              ANNOTATION
-          PsiWhiteSpace('\n    ')
+                PsiElement(LBRACKET)('[')
-          PsiElement(RBRACE)('}')
+                ANNOTATION_ENTRY
-        PsiWhiteSpace('\n')
+                  CONSTRUCTOR_CALLEE
-        PsiElement(RBRACE)('}')
+                    TYPE_REFERENCE
+                      USER_TYPE
+                        REFERENCE_EXPRESSION
+                          PsiElement(IDENTIFIER)('a')
+                PsiElement(RBRACKET)(']')
+              PsiWhiteSpace(' ')
+              TYPE_REFERENCE
+                USER_TYPE
+                  REFERENCE_EXPRESSION
+                    PsiElement(IDENTIFIER)('T')
+          PsiWhiteSpace(' ')
+          PsiElement(ARROW)('->')
+          PsiWhiteSpace(' ')
+          REFERENCE_EXPRESSION
+            PsiElement(IDENTIFIER)('d')
+        PsiWhiteSpace('\n      ')
+        WHEN_ENTRY
+          WHEN_CONDITION_IS_PATTERN
+            PsiElement(is)('is')
+            PsiWhiteSpace(' ')
+            DECOMPOSER_PATTERN
+              ANNOTATION
+                PsiElement(LBRACKET)('[')
+                ANNOTATION_ENTRY
+                  CONSTRUCTOR_CALLEE
+                    TYPE_REFERENCE
+                      USER_TYPE
+                        REFERENCE_EXPRESSION
+                          PsiElement(IDENTIFIER)('a')
+                PsiElement(RBRACKET)(']')
+              PsiWhiteSpace(' ')
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('T')
+              PsiWhiteSpace('  ')
+              DECOMPOSER_ARGUMENT_LIST
+                PsiElement(HASH)('#')
+                PsiElement(LPAR)('(')
+                PsiElement(RPAR)(')')
+          PsiWhiteSpace(' ')
+          PsiElement(ARROW)('->')
+          PsiWhiteSpace(' ')
+          REFERENCE_EXPRESSION
+            PsiElement(IDENTIFIER)('d')
+        PsiWhiteSpace('\n    ')
+        PsiElement(RBRACE)('}')
+      PsiWhiteSpace('\n')
+      PsiElement(RBRACE)('}')

compiler/testData/psi/Attributes_ERR.txt

@@ -1,54 +1,120 @@
 JetFile: Attributes_ERR.jet
-  NAMESPACE
+  NAMESPACE_HEADER
-    NAMESPACE_HEADER
+    PsiElement(namespace)('package')
-      PsiElement(namespace)('package')
+    PsiWhiteSpace(' ')
-      PsiWhiteSpace(' ')
+    REFERENCE_EXPRESSION
-      REFERENCE_EXPRESSION
+      PsiElement(IDENTIFIER)('foo')
-        PsiElement(IDENTIFIER)('foo')
+    PsiElement(DOT)('.')
-      PsiElement(DOT)('.')
+    REFERENCE_EXPRESSION
-      REFERENCE_EXPRESSION
+      PsiElement(IDENTIFIER)('bar')
-        PsiElement(IDENTIFIER)('bar')
+    PsiElement(DOT)('.')
-      PsiElement(DOT)('.')
+    PsiElement(IDENTIFIER)('goo')
-      PsiElement(IDENTIFIER)('goo')
+  PsiWhiteSpace('\n\n')
-    PsiWhiteSpace('\n\n')
+  CLASS
-    CLASS
+    MODIFIER_LIST
-      MODIFIER_LIST
+      PsiElement(abstract)('abstract')
-        PsiElement(abstract)('abstract')
+      PsiWhiteSpace('\n')
-        PsiWhiteSpace('\n')
+      PsiElement(open)('open')
-        PsiElement(open)('open')
+      PsiWhiteSpace('\n')
-        PsiWhiteSpace('\n')
+      PsiElement(enum)('enum')
-        PsiElement(enum)('enum')
+      PsiWhiteSpace('\n')
-        PsiWhiteSpace('\n')
+      PsiElement(open)('open')
-        PsiElement(open)('open')
+      PsiWhiteSpace('\n')
-        PsiWhiteSpace('\n')
+      PsiElement(annotation)('annotation')
-        PsiElement(annotation)('annotation')
+      PsiWhiteSpace('\n')
-        PsiWhiteSpace('\n')
+      PsiElement(override)('override')
-        PsiElement(override)('override')
+      PsiWhiteSpace('\n')
-        PsiWhiteSpace('\n')
+      PsiElement(open)('open')
-        PsiElement(open)('open')
+      PsiWhiteSpace('\n')
-        PsiWhiteSpace('\n')
+      PsiElement(abstract)('abstract')
-        PsiElement(abstract)('abstract')
+      PsiWhiteSpace('\n')
-        PsiWhiteSpace('\n')
+      ANNOTATION
-        ANNOTATION
+        PsiElement(LBRACKET)('[')
-          PsiElement(LBRACKET)('[')
+        PsiErrorElement:Expecting a list of attributes
-          PsiErrorElement:Expecting a list of attributes
+          <empty list>
-            <empty list>
+        PsiElement(RBRACKET)(']')
-          PsiElement(RBRACKET)(']')
+      PsiWhiteSpace('\n')
-        PsiWhiteSpace('\n')
+      PsiElement(private)('private')
-        PsiElement(private)('private')
+      PsiWhiteSpace('\n')
-        PsiWhiteSpace('\n')
+      PsiElement(protected)('protected')
-        PsiElement(protected)('protected')
+      PsiWhiteSpace('\n')
-        PsiWhiteSpace('\n')
+      PsiElement(public)('public')
-        PsiElement(public)('public')
+      PsiWhiteSpace('\n')
-        PsiWhiteSpace('\n')
+      PsiElement(internal)('internal')
-        PsiElement(internal)('internal')
+      PsiWhiteSpace('\n')
-        PsiWhiteSpace('\n')
+      ANNOTATION
-        ANNOTATION
+        PsiElement(LBRACKET)('[')
-          PsiElement(LBRACKET)('[')
+        ANNOTATION_ENTRY
-          ANNOTATION_ENTRY
+          CONSTRUCTOR_CALLEE
-            CONSTRUCTOR_CALLEE
+            TYPE_REFERENCE
-              TYPE_REFERENCE
+              USER_TYPE
+                REFERENCE_EXPRESSION
+                  PsiElement(IDENTIFIER)('foo')
+                TYPE_ARGUMENT_LIST
+                  PsiElement(LT)('<')
+                  TYPE_PROJECTION
+                    TYPE_REFERENCE
+                      USER_TYPE
+                        REFERENCE_EXPRESSION
+                          PsiElement(IDENTIFIER)('A')
+                  PsiElement(COMMA)(',')
+                  PsiWhiteSpace(' ')
+                  TYPE_PROJECTION
+                    TYPE_REFERENCE
+                      USER_TYPE
+                        REFERENCE_EXPRESSION
+                          PsiElement(IDENTIFIER)('B')
+                  PsiElement(GT)('>')
+          VALUE_ARGUMENT_LIST
+            PsiElement(LPAR)('(')
+            VALUE_ARGUMENT
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('a')
+            PsiElement(COMMA)(',')
+            PsiWhiteSpace(' ')
+            VALUE_ARGUMENT
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('b')
+            PsiElement(RPAR)(')')
+        PsiErrorElement:No commas needed to separate attributes
+          PsiElement(COMMA)(',')
+        PsiWhiteSpace(' ')
+        ANNOTATION_ENTRY
+          CONSTRUCTOR_CALLEE
+            TYPE_REFERENCE
+              USER_TYPE
+                REFERENCE_EXPRESSION
+                  PsiElement(IDENTIFIER)('ina')
+        PsiWhiteSpace(' ')
+        ANNOTATION_ENTRY
+          CONSTRUCTOR_CALLEE
+            TYPE_REFERENCE
+              USER_TYPE
                 USER_TYPE
+                  USER_TYPE
+                    USER_TYPE
+                      USER_TYPE
+                        USER_TYPE
+                          REFERENCE_EXPRESSION
+                            PsiElement(IDENTIFIER)('foo')
+                        PsiElement(DOT)('.')
+                        REFERENCE_EXPRESSION
+                          PsiElement(IDENTIFIER)('bar')
+                      PsiElement(DOT)('.')
+                      REFERENCE_EXPRESSION
+                        PsiElement(IDENTIFIER)('goo')
+                    PsiElement(DOT)('.')
+                    REFERENCE_EXPRESSION
+                      PsiElement(IDENTIFIER)('doo')
+                    TYPE_ARGUMENT_LIST
+                      PsiElement(LT)('<')
+                      TYPE_PROJECTION
+                        TYPE_REFERENCE
+                          USER_TYPE
+                            REFERENCE_EXPRESSION
+                              PsiElement(IDENTIFIER)('f')
+                      PsiElement(GT)('>')
+                  PsiElement(DOT)('.')
                   REFERENCE_EXPRESSION
                     PsiElement(IDENTIFIER)('foo')
                   TYPE_ARGUMENT_LIST
@@ -57,218 +123,151 @@ JetFile: Attributes_ERR.jet
                       TYPE_REFERENCE
                         USER_TYPE
                           REFERENCE_EXPRESSION
-                            PsiElement(IDENTIFIER)('A')
+                            PsiElement(IDENTIFIER)('bar')
                     PsiElement(COMMA)(',')
                     PsiWhiteSpace(' ')
                     TYPE_PROJECTION
                       TYPE_REFERENCE
                         USER_TYPE
                           REFERENCE_EXPRESSION
-                            PsiElement(IDENTIFIER)('B')
+                            PsiElement(IDENTIFIER)('goo')
                     PsiElement(GT)('>')
-            VALUE_ARGUMENT_LIST
+                PsiElement(DOT)('.')
-              PsiElement(LPAR)('(')
-              VALUE_ARGUMENT
                 REFERENCE_EXPRESSION
-                  PsiElement(IDENTIFIER)('a')
+                  PsiElement(IDENTIFIER)('foo')
-              PsiElement(COMMA)(',')
+        PsiElement(RBRACKET)(']')
-              PsiWhiteSpace(' ')
+      PsiWhiteSpace('\n')
-              VALUE_ARGUMENT
+      ANNOTATION
+        PsiElement(LBRACKET)('[')
+        ANNOTATION_ENTRY
+          CONSTRUCTOR_CALLEE
+            TYPE_REFERENCE
+              USER_TYPE
                 REFERENCE_EXPRESSION
-                  PsiElement(IDENTIFIER)('b')
+                  PsiElement(IDENTIFIER)('df')
-              PsiElement(RPAR)(')')
+        PsiElement(RBRACKET)(']')
-          PsiErrorElement:No commas needed to separate attributes
+      PsiWhiteSpace('\n')
-            PsiElement(COMMA)(',')
+      PsiElement(in)('in')
-          PsiWhiteSpace(' ')
+      PsiWhiteSpace('\n')
-          ANNOTATION_ENTRY
+      ANNOTATION
-            CONSTRUCTOR_CALLEE
+        PsiElement(LBRACKET)('[')
-              TYPE_REFERENCE
+        ANNOTATION_ENTRY
-                USER_TYPE
+          CONSTRUCTOR_CALLEE
-                  REFERENCE_EXPRESSION
+            TYPE_REFERENCE
-                    PsiElement(IDENTIFIER)('ina')
+              USER_TYPE
-          PsiWhiteSpace(' ')
+                REFERENCE_EXPRESSION
-          ANNOTATION_ENTRY
+                  PsiElement(IDENTIFIER)('sdfsdf')
-            CONSTRUCTOR_CALLEE
+        PsiWhiteSpace(' ')
-              TYPE_REFERENCE
+        PsiElement(RBRACKET)(']')
-                USER_TYPE
+      PsiWhiteSpace('\n')
+      ANNOTATION
+        PsiElement(LBRACKET)('[')
+        ANNOTATION_ENTRY
+          CONSTRUCTOR_CALLEE
+            TYPE_REFERENCE
+              USER_TYPE
+                REFERENCE_EXPRESSION
+                  PsiElement(IDENTIFIER)('s')
+        PsiWhiteSpace(' ')
+        ANNOTATION_ENTRY
+          CONSTRUCTOR_CALLEE
+            TYPE_REFERENCE
+              USER_TYPE
+                REFERENCE_EXPRESSION
+                  PsiElement(IDENTIFIER)('fd')
+        PsiWhiteSpace(' ')
+        ANNOTATION_ENTRY
+          CONSTRUCTOR_CALLEE
+            TYPE_REFERENCE
+              USER_TYPE
+                REFERENCE_EXPRESSION
+                  PsiElement(IDENTIFIER)('d')
+        PsiErrorElement:No commas needed to separate attributes
+          PsiElement(COMMA)(',')
+        PsiWhiteSpace(' ')
+        PsiElement(RBRACKET)(']')
+      PsiWhiteSpace('\n')
+      PsiElement(out)('out')
+      PsiWhiteSpace('\n')
+      PsiElement(ref)('ref')
+    PsiWhiteSpace('\n ')
+    PsiElement(class)('class')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('Bar')
+    TYPE_PARAMETER_LIST
+      PsiElement(LT)('<')
+      TYPE_PARAMETER
+        MODIFIER_LIST
+          PsiElement(abstract)('abstract')
+          PsiWhiteSpace('\n')
+          PsiElement(open)('open')
+          PsiWhiteSpace('\n')
+          PsiElement(enum)('enum')
+          PsiWhiteSpace('\n')
+          PsiElement(open)('open')
+          PsiWhiteSpace('\n')
+          PsiElement(annotation)('annotation')
+          PsiWhiteSpace('\n')
+          PsiElement(override)('override')
+          PsiWhiteSpace('\n')
+          PsiElement(open)('open')
+          PsiWhiteSpace('\n')
+          PsiElement(abstract)('abstract')
+          PsiWhiteSpace('\n')
+          ANNOTATION
+            PsiElement(LBRACKET)('[')
+            ANNOTATION_ENTRY
+              CONSTRUCTOR_CALLEE
+                TYPE_REFERENCE
+                  USER_TYPE
+                    REFERENCE_EXPRESSION
+                      PsiElement(IDENTIFIER)('sdfsd')
+            PsiWhiteSpace(' ')
+            ANNOTATION_ENTRY
+              CONSTRUCTOR_CALLEE
+                TYPE_REFERENCE
+                  USER_TYPE
+                    REFERENCE_EXPRESSION
+                      PsiElement(IDENTIFIER)('sdfsd')
+            PsiWhiteSpace(' ')
+            ANNOTATION_ENTRY
+              CONSTRUCTOR_CALLEE
+                TYPE_REFERENCE
                   USER_TYPE
                     USER_TYPE
                       USER_TYPE
                         USER_TYPE
-                          USER_TYPE
-                            REFERENCE_EXPRESSION
-                              PsiElement(IDENTIFIER)('foo')
-                          PsiElement(DOT)('.')
                           REFERENCE_EXPRESSION
-                            PsiElement(IDENTIFIER)('bar')
+                            PsiElement(IDENTIFIER)('a')
                         PsiElement(DOT)('.')
                         REFERENCE_EXPRESSION
-                          PsiElement(IDENTIFIER)('goo')
+                          PsiElement(IDENTIFIER)('b')
                       PsiElement(DOT)('.')
                       REFERENCE_EXPRESSION
-                        PsiElement(IDENTIFIER)('doo')
+                        PsiElement(IDENTIFIER)('f')
-                      TYPE_ARGUMENT_LIST
-                        PsiElement(LT)('<')
-                        TYPE_PROJECTION
-                          TYPE_REFERENCE
-                            USER_TYPE
-                              REFERENCE_EXPRESSION
-                                PsiElement(IDENTIFIER)('f')
-                        PsiElement(GT)('>')
                     PsiElement(DOT)('.')
                     REFERENCE_EXPRESSION
-                      PsiElement(IDENTIFIER)('foo')
+                      PsiElement(IDENTIFIER)('c')
-                    TYPE_ARGUMENT_LIST
+            PsiElement(RBRACKET)(']')
-                      PsiElement(LT)('<')
+          PsiWhiteSpace('\n')
-                      TYPE_PROJECTION
+          PsiElement(private)('private')
-                        TYPE_REFERENCE
+          PsiWhiteSpace('\n')
-                          USER_TYPE
+          PsiElement(protected)('protected')
-                            REFERENCE_EXPRESSION
+          PsiWhiteSpace('\n')
-                              PsiElement(IDENTIFIER)('bar')
+          PsiElement(public)('public')
-                      PsiElement(COMMA)(',')
+          PsiWhiteSpace('\n')
-                      PsiWhiteSpace(' ')
+          PsiElement(internal)('internal')
-                      TYPE_PROJECTION
+          PsiWhiteSpace('\n')
-                        TYPE_REFERENCE
+          PsiElement(in)('in')
-                          USER_TYPE
+          PsiWhiteSpace('\n')
-                            REFERENCE_EXPRESSION
+          PsiElement(out)('out')
-                              PsiElement(IDENTIFIER)('goo')
+          PsiWhiteSpace('\n')
-                      PsiElement(GT)('>')
+          PsiElement(ref)('ref')
-                  PsiElement(DOT)('.')
+        PsiWhiteSpace(' ')
-                  REFERENCE_EXPRESSION
+        PsiElement(IDENTIFIER)('T')
-                    PsiElement(IDENTIFIER)('foo')
+      PsiElement(GT)('>')
-          PsiElement(RBRACKET)(']')
+    PsiWhiteSpace(' ')
-        PsiWhiteSpace('\n')
+    CLASS_BODY
-        ANNOTATION
+      PsiElement(LBRACE)('{')
-          PsiElement(LBRACKET)('[')
+      PsiWhiteSpace('\n')
-          ANNOTATION_ENTRY
+      PsiElement(RBRACE)('}')
-            CONSTRUCTOR_CALLEE
-              TYPE_REFERENCE
-                USER_TYPE
-                  REFERENCE_EXPRESSION
-                    PsiElement(IDENTIFIER)('df')
-          PsiElement(RBRACKET)(']')
-        PsiWhiteSpace('\n')
-        PsiElement(in)('in')
-        PsiWhiteSpace('\n')
-        ANNOTATION
-          PsiElement(LBRACKET)('[')
-          ANNOTATION_ENTRY
-            CONSTRUCTOR_CALLEE
-              TYPE_REFERENCE
-                USER_TYPE
-                  REFERENCE_EXPRESSION
-                    PsiElement(IDENTIFIER)('sdfsdf')
-          PsiWhiteSpace(' ')
-          PsiElement(RBRACKET)(']')
-        PsiWhiteSpace('\n')
-        ANNOTATION
-          PsiElement(LBRACKET)('[')
-          ANNOTATION_ENTRY
-            CONSTRUCTOR_CALLEE
-              TYPE_REFERENCE
-                USER_TYPE
-                  REFERENCE_EXPRESSION
-                    PsiElement(IDENTIFIER)('s')
-          PsiWhiteSpace(' ')
-          ANNOTATION_ENTRY
-            CONSTRUCTOR_CALLEE
-              TYPE_REFERENCE
-                USER_TYPE
-                  REFERENCE_EXPRESSION
-                    PsiElement(IDENTIFIER)('fd')
-          PsiWhiteSpace(' ')
-          ANNOTATION_ENTRY
-            CONSTRUCTOR_CALLEE
-              TYPE_REFERENCE
-                USER_TYPE
-                  REFERENCE_EXPRESSION
-                    PsiElement(IDENTIFIER)('d')
-          PsiErrorElement:No commas needed to separate attributes
-            PsiElement(COMMA)(',')
-          PsiWhiteSpace(' ')
-          PsiElement(RBRACKET)(']')
-        PsiWhiteSpace('\n')
-        PsiElement(out)('out')
-        PsiWhiteSpace('\n')
-        PsiElement(ref)('ref')
-      PsiWhiteSpace('\n ')
-      PsiElement(class)('class')
-      PsiWhiteSpace(' ')
-      PsiElement(IDENTIFIER)('Bar')
-      TYPE_PARAMETER_LIST
-        PsiElement(LT)('<')
-        TYPE_PARAMETER
-          MODIFIER_LIST
-            PsiElement(abstract)('abstract')
-            PsiWhiteSpace('\n')
-            PsiElement(open)('open')
-            PsiWhiteSpace('\n')
-            PsiElement(enum)('enum')
-            PsiWhiteSpace('\n')
-            PsiElement(open)('open')
-            PsiWhiteSpace('\n')
-            PsiElement(annotation)('annotation')
-            PsiWhiteSpace('\n')
-            PsiElement(override)('override')
-            PsiWhiteSpace('\n')
-            PsiElement(open)('open')
-            PsiWhiteSpace('\n')
-            PsiElement(abstract)('abstract')
-            PsiWhiteSpace('\n')
-            ANNOTATION
-              PsiElement(LBRACKET)('[')
-              ANNOTATION_ENTRY
-                CONSTRUCTOR_CALLEE
-                  TYPE_REFERENCE
-                    USER_TYPE
-                      REFERENCE_EXPRESSION
-                        PsiElement(IDENTIFIER)('sdfsd')
-              PsiWhiteSpace(' ')
-              ANNOTATION_ENTRY
-                CONSTRUCTOR_CALLEE
-                  TYPE_REFERENCE
-                    USER_TYPE
-                      REFERENCE_EXPRESSION
-                        PsiElement(IDENTIFIER)('sdfsd')
-              PsiWhiteSpace(' ')
-              ANNOTATION_ENTRY
-                CONSTRUCTOR_CALLEE
-                  TYPE_REFERENCE
-                    USER_TYPE
-                      USER_TYPE
-                        USER_TYPE
-                          USER_TYPE
-                            REFERENCE_EXPRESSION
-                              PsiElement(IDENTIFIER)('a')
-                          PsiElement(DOT)('.')
-                          REFERENCE_EXPRESSION
-                            PsiElement(IDENTIFIER)('b')
-                        PsiElement(DOT)('.')
-                        REFERENCE_EXPRESSION
-                          PsiElement(IDENTIFIER)('f')
-                      PsiElement(DOT)('.')
-                      REFERENCE_EXPRESSION
-                        PsiElement(IDENTIFIER)('c')
-              PsiElement(RBRACKET)(']')
-            PsiWhiteSpace('\n')
-            PsiElement(private)('private')
-            PsiWhiteSpace('\n')
-            PsiElement(protected)('protected')
-            PsiWhiteSpace('\n')
-            PsiElement(public)('public')
-            PsiWhiteSpace('\n')
-            PsiElement(internal)('internal')
-            PsiWhiteSpace('\n')
-            PsiElement(in)('in')
-            PsiWhiteSpace('\n')
-            PsiElement(out)('out')
-            PsiWhiteSpace('\n')
-            PsiElement(ref)('ref')
-          PsiWhiteSpace(' ')
-          PsiElement(IDENTIFIER)('T')
-        PsiElement(GT)('>')
-      PsiWhiteSpace(' ')
-      CLASS_BODY
-        PsiElement(LBRACE)('{')
-        PsiWhiteSpace('\n')
-        PsiElement(RBRACE)('}')

compiler/testData/psi/BabySteps.txt

@@ -1,80 +1,79 @@
 JetFile: BabySteps.jet
-  NAMESPACE
+  NAMESPACE_HEADER
-    NAMESPACE_HEADER
+    PsiElement(namespace)('package')
-      PsiElement(namespace)('package')
+    PsiWhiteSpace(' ')
-      PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('foo')
-      PsiElement(IDENTIFIER)('foo')
+  PsiWhiteSpace('\n\n')
-    PsiWhiteSpace('\n\n')
+  CLASS
-    CLASS
+    PsiElement(class)('class')
-      PsiElement(class)('class')
+    PsiWhiteSpace(' ')
-      PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('Runnable')
-      PsiElement(IDENTIFIER)('Runnable')
+    TYPE_PARAMETER_LIST
-      TYPE_PARAMETER_LIST
+      PsiElement(LT)('<')
-        PsiElement(LT)('<')
+      TYPE_PARAMETER
-        TYPE_PARAMETER
+        PsiElement(IDENTIFIER)('a')
-          PsiElement(IDENTIFIER)('a')
+      PsiElement(COMMA)(',')
-        PsiElement(COMMA)(',')
+      TYPE_PARAMETER
-        TYPE_PARAMETER
+        PsiElement(IDENTIFIER)('a')
-          PsiElement(IDENTIFIER)('a')
+      PsiElement(GT)('>')
-        PsiElement(GT)('>')
+    VALUE_PARAMETER_LIST
-      VALUE_PARAMETER_LIST
+      PsiElement(LPAR)('(')
-        PsiElement(LPAR)('(')
+      VALUE_PARAMETER
-        VALUE_PARAMETER
+        PsiElement(IDENTIFIER)('a')
-          PsiElement(IDENTIFIER)('a')
-          PsiWhiteSpace(' ')
-          PsiElement(COLON)(':')
-          PsiWhiteSpace(' ')
-          TYPE_REFERENCE
-            USER_TYPE
-              REFERENCE_EXPRESSION
-                PsiElement(IDENTIFIER)('doo')
-          PsiWhiteSpace(' ')
-          PsiElement(EQ)('=')
-          PsiWhiteSpace(' ')
-          INTEGER_CONSTANT
-            PsiElement(INTEGER_LITERAL)('0')
-        PsiElement(RPAR)(')')
-      PsiWhiteSpace(' ')
-      PsiElement(COLON)(':')
-      PsiWhiteSpace(' ')
-      DELEGATION_SPECIFIER_LIST
-        DELEGATOR_SUPER_CALL
-          CONSTRUCTOR_CALLEE
-            TYPE_REFERENCE
-              USER_TYPE
-                REFERENCE_EXPRESSION
-                  PsiElement(IDENTIFIER)('foo')
-          VALUE_ARGUMENT_LIST
-            PsiElement(LPAR)('(')
-            VALUE_ARGUMENT
-              VALUE_ARGUMENT_NAME
-                REFERENCE_EXPRESSION
-                  PsiElement(IDENTIFIER)('d')
-              PsiElement(EQ)('=')
-              INTEGER_CONSTANT
-                PsiElement(INTEGER_LITERAL)('0')
-            PsiElement(RPAR)(')')
-        PsiElement(COMMA)(',')
         PsiWhiteSpace(' ')
-        DELEGATOR_BY
+        PsiElement(COLON)(':')
-          TYPE_REFERENCE
-            USER_TYPE
-              REFERENCE_EXPRESSION
-                PsiElement(IDENTIFIER)('bar')
-          PsiWhiteSpace(' ')
-          PsiElement(by)('by')
-          PsiWhiteSpace(' ')
-          REFERENCE_EXPRESSION
-            PsiElement(IDENTIFIER)('x')
-        PsiElement(COMMA)(',')
         PsiWhiteSpace(' ')
-        DELEGATOR_SUPER_CLASS
+        TYPE_REFERENCE
+          USER_TYPE
+            REFERENCE_EXPRESSION
+              PsiElement(IDENTIFIER)('doo')
+        PsiWhiteSpace(' ')
+        PsiElement(EQ)('=')
+        PsiWhiteSpace(' ')
+        INTEGER_CONSTANT
+          PsiElement(INTEGER_LITERAL)('0')
+      PsiElement(RPAR)(')')
+    PsiWhiteSpace(' ')
+    PsiElement(COLON)(':')
+    PsiWhiteSpace(' ')
+    DELEGATION_SPECIFIER_LIST
+      DELEGATOR_SUPER_CALL
+        CONSTRUCTOR_CALLEE
           TYPE_REFERENCE
             USER_TYPE
               REFERENCE_EXPRESSION
-                PsiElement(IDENTIFIER)('bar')
+                PsiElement(IDENTIFIER)('foo')
+        VALUE_ARGUMENT_LIST
+          PsiElement(LPAR)('(')
+          VALUE_ARGUMENT
+            VALUE_ARGUMENT_NAME
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('d')
+            PsiElement(EQ)('=')
+            INTEGER_CONSTANT
+              PsiElement(INTEGER_LITERAL)('0')
+          PsiElement(RPAR)(')')
+      PsiElement(COMMA)(',')
       PsiWhiteSpace(' ')
-      CLASS_BODY
+      DELEGATOR_BY
-        PsiElement(LBRACE)('{')
+        TYPE_REFERENCE
-        PsiWhiteSpace('\n\n')
+          USER_TYPE
-        PsiElement(RBRACE)('}')
+            REFERENCE_EXPRESSION
+              PsiElement(IDENTIFIER)('bar')
+        PsiWhiteSpace(' ')
+        PsiElement(by)('by')
+        PsiWhiteSpace(' ')
+        REFERENCE_EXPRESSION
+          PsiElement(IDENTIFIER)('x')
+      PsiElement(COMMA)(',')
+      PsiWhiteSpace(' ')
+      DELEGATOR_SUPER_CLASS
+        TYPE_REFERENCE
+          USER_TYPE
+            REFERENCE_EXPRESSION
+              PsiElement(IDENTIFIER)('bar')
+    PsiWhiteSpace(' ')
+    CLASS_BODY
+      PsiElement(LBRACE)('{')
+      PsiWhiteSpace('\n\n')
+      PsiElement(RBRACE)('}')

compiler/testData/psi/BabySteps_ERR.txt

@@ -1,82 +1,81 @@
 JetFile: BabySteps_ERR.jet
-  NAMESPACE
+  NAMESPACE_HEADER
-    NAMESPACE_HEADER
+    PsiElement(namespace)('package')
-      PsiElement(namespace)('package')
+    PsiWhiteSpace(' ')
-      PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('foo')
-      PsiElement(IDENTIFIER)('foo')
+  PsiWhiteSpace('\n\n')
-    PsiWhiteSpace('\n\n')
+  CLASS
-    CLASS
+    PsiElement(class)('class')
-      PsiElement(class)('class')
+    PsiWhiteSpace(' ')
-      PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('Runnable')
-      PsiElement(IDENTIFIER)('Runnable')
+    TYPE_PARAMETER_LIST
-      TYPE_PARAMETER_LIST
+      PsiElement(LT)('<')
-        PsiElement(LT)('<')
+      TYPE_PARAMETER
-        TYPE_PARAMETER
+        PsiElement(IDENTIFIER)('a')
-          PsiElement(IDENTIFIER)('a')
+      PsiElement(COMMA)(',')
-        PsiElement(COMMA)(',')
+      TYPE_PARAMETER
-        TYPE_PARAMETER
+        PsiElement(IDENTIFIER)('a')
-          PsiElement(IDENTIFIER)('a')
+      PsiElement(GT)('>')
-        PsiElement(GT)('>')
+    VALUE_PARAMETER_LIST
-      VALUE_PARAMETER_LIST
+      PsiElement(LPAR)('(')
-        PsiElement(LPAR)('(')
+      VALUE_PARAMETER
-        VALUE_PARAMETER
+        PsiElement(IDENTIFIER)('a')
-          PsiElement(IDENTIFIER)('a')
-          PsiWhiteSpace(' ')
-          PsiElement(COLON)(':')
-          PsiWhiteSpace(' ')
-          TYPE_REFERENCE
-            USER_TYPE
-              REFERENCE_EXPRESSION
-                PsiElement(IDENTIFIER)('doo')
-          PsiWhiteSpace(' ')
-          PsiElement(EQ)('=')
-          PsiWhiteSpace(' ')
-          INTEGER_CONSTANT
-            PsiElement(INTEGER_LITERAL)('0')
-        PsiElement(RPAR)(')')
-      PsiWhiteSpace(' ')
-      PsiElement(COLON)(':')
-      PsiWhiteSpace(' ')
-      DELEGATION_SPECIFIER_LIST
-        DELEGATOR_SUPER_CALL
-          CONSTRUCTOR_CALLEE
-            TYPE_REFERENCE
-              USER_TYPE
-                REFERENCE_EXPRESSION
-                  PsiElement(IDENTIFIER)('foo')
-          VALUE_ARGUMENT_LIST
-            PsiElement(LPAR)('(')
-            VALUE_ARGUMENT
-              VALUE_ARGUMENT_NAME
-                REFERENCE_EXPRESSION
-                  PsiElement(IDENTIFIER)('d')
-              PsiElement(EQ)('=')
-              INTEGER_CONSTANT
-                PsiElement(INTEGER_LITERAL)('0')
-            PsiElement(RPAR)(')')
-        PsiElement(COMMA)(',')
         PsiWhiteSpace(' ')
-        PsiErrorElement:Expecting a delegation specifier
+        PsiElement(COLON)(':')
-          PsiElement(COMMA)(',')
-        DELEGATOR_BY
-          TYPE_REFERENCE
-            USER_TYPE
-              REFERENCE_EXPRESSION
-                PsiElement(IDENTIFIER)('bar')
-          PsiWhiteSpace(' ')
-          PsiElement(by)('by')
-          PsiWhiteSpace(' ')
-          REFERENCE_EXPRESSION
-            PsiElement(IDENTIFIER)('x')
-        PsiElement(COMMA)(',')
         PsiWhiteSpace(' ')
-        DELEGATOR_SUPER_CLASS
+        TYPE_REFERENCE
+          USER_TYPE
+            REFERENCE_EXPRESSION
+              PsiElement(IDENTIFIER)('doo')
+        PsiWhiteSpace(' ')
+        PsiElement(EQ)('=')
+        PsiWhiteSpace(' ')
+        INTEGER_CONSTANT
+          PsiElement(INTEGER_LITERAL)('0')
+      PsiElement(RPAR)(')')
+    PsiWhiteSpace(' ')
+    PsiElement(COLON)(':')
+    PsiWhiteSpace(' ')
+    DELEGATION_SPECIFIER_LIST
+      DELEGATOR_SUPER_CALL
+        CONSTRUCTOR_CALLEE
           TYPE_REFERENCE
             USER_TYPE
               REFERENCE_EXPRESSION
-                PsiElement(IDENTIFIER)('bar')
+                PsiElement(IDENTIFIER)('foo')
+        VALUE_ARGUMENT_LIST
+          PsiElement(LPAR)('(')
+          VALUE_ARGUMENT
+            VALUE_ARGUMENT_NAME
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('d')
+            PsiElement(EQ)('=')
+            INTEGER_CONSTANT
+              PsiElement(INTEGER_LITERAL)('0')
+          PsiElement(RPAR)(')')
+      PsiElement(COMMA)(',')
       PsiWhiteSpace(' ')
-      CLASS_BODY
+      PsiErrorElement:Expecting a delegation specifier
-        PsiElement(LBRACE)('{')
+        PsiElement(COMMA)(',')
-        PsiWhiteSpace('\n\n')
+      DELEGATOR_BY
-        PsiElement(RBRACE)('}')
+        TYPE_REFERENCE
+          USER_TYPE
+            REFERENCE_EXPRESSION
+              PsiElement(IDENTIFIER)('bar')
+        PsiWhiteSpace(' ')
+        PsiElement(by)('by')
+        PsiWhiteSpace(' ')
+        REFERENCE_EXPRESSION
+          PsiElement(IDENTIFIER)('x')
+      PsiElement(COMMA)(',')
+      PsiWhiteSpace(' ')
+      DELEGATOR_SUPER_CLASS
+        TYPE_REFERENCE
+          USER_TYPE
+            REFERENCE_EXPRESSION
+              PsiElement(IDENTIFIER)('bar')
+    PsiWhiteSpace(' ')
+    CLASS_BODY
+      PsiElement(LBRACE)('{')
+      PsiWhiteSpace('\n\n')
+      PsiElement(RBRACE)('}')

compiler/testData/psi/ByCaluses.txt

@@ -1,156 +1,205 @@
 JetFile: ByCaluses.jet
-  NAMESPACE
+  NAMESPACE_HEADER
-    NAMESPACE_HEADER
+    <empty list>
+  CLASS
+    PsiElement(class)('class')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('A')
+    PsiWhiteSpace(' ')
+    TYPE_PARAMETER_LIST
       <empty list>
-    CLASS
+    PsiElement(COLON)(':')
-      PsiElement(class)('class')
+    PsiWhiteSpace(' ')
-      PsiWhiteSpace(' ')
+    DELEGATION_SPECIFIER_LIST
-      PsiElement(IDENTIFIER)('A')
+      DELEGATOR_BY
-      PsiWhiteSpace(' ')
+        TYPE_REFERENCE
-      TYPE_PARAMETER_LIST
+          USER_TYPE
-        <empty list>
+            REFERENCE_EXPRESSION
-      PsiElement(COLON)(':')
+              PsiElement(IDENTIFIER)('b')
-      PsiWhiteSpace(' ')
+        PsiWhiteSpace(' ')
-      DELEGATION_SPECIFIER_LIST
+        PsiElement(by)('by')
-        DELEGATOR_BY
+        PsiWhiteSpace(' ')
-          TYPE_REFERENCE
+        REFERENCE_EXPRESSION
-            USER_TYPE
+          PsiElement(IDENTIFIER)('a')
-              REFERENCE_EXPRESSION
+    PsiWhiteSpace(' ')
-                PsiElement(IDENTIFIER)('b')
+    CLASS_BODY
-          PsiWhiteSpace(' ')
+      PsiElement(LBRACE)('{')
-          PsiElement(by)('by')
+      PsiWhiteSpace('\n  ')
-          PsiWhiteSpace(' ')
+      CONSTRUCTOR
+        PsiElement(this)('this')
+        VALUE_PARAMETER_LIST
+          PsiElement(LPAR)('(')
+          PsiElement(RPAR)(')')
+        PsiWhiteSpace(' ')
+        BLOCK
+          PsiElement(LBRACE)('{')
+          PsiElement(RBRACE)('}')
+      PsiWhiteSpace('\n')
+      PsiElement(RBRACE)('}')
+  PsiWhiteSpace('\n')
+  CLASS
+    PsiElement(class)('class')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('A')
+    PsiWhiteSpace(' ')
+    TYPE_PARAMETER_LIST
+      <empty list>
+    PsiElement(COLON)(':')
+    PsiWhiteSpace(' ')
+    DELEGATION_SPECIFIER_LIST
+      DELEGATOR_BY
+        TYPE_REFERENCE
+          USER_TYPE
+            REFERENCE_EXPRESSION
+              PsiElement(IDENTIFIER)('b')
+        PsiWhiteSpace(' ')
+        PsiElement(by)('by')
+        PsiWhiteSpace(' ')
+        BINARY_EXPRESSION
           REFERENCE_EXPRESSION
             PsiElement(IDENTIFIER)('a')
-      PsiWhiteSpace(' ')
-      CLASS_BODY
-        PsiElement(LBRACE)('{')
-        PsiWhiteSpace('\n  ')
-        CONSTRUCTOR
-          PsiElement(this)('this')
-          VALUE_PARAMETER_LIST
-            PsiElement(LPAR)('(')
-            PsiElement(RPAR)(')')
           PsiWhiteSpace(' ')
-          BLOCK
+          OPERATION_REFERENCE
-            PsiElement(LBRACE)('{')
+            PsiElement(PLUS)('+')
-            PsiElement(RBRACE)('}')
-        PsiWhiteSpace('\n')
-        PsiElement(RBRACE)('}')
-    PsiWhiteSpace('\n')
-    CLASS
-      PsiElement(class)('class')
-      PsiWhiteSpace(' ')
-      PsiElement(IDENTIFIER)('A')
-      PsiWhiteSpace(' ')
-      TYPE_PARAMETER_LIST
-        <empty list>
-      PsiElement(COLON)(':')
-      PsiWhiteSpace(' ')
-      DELEGATION_SPECIFIER_LIST
-        DELEGATOR_BY
-          TYPE_REFERENCE
-            USER_TYPE
-              REFERENCE_EXPRESSION
-                PsiElement(IDENTIFIER)('b')
-          PsiWhiteSpace(' ')
-          PsiElement(by)('by')
           PsiWhiteSpace(' ')
           BINARY_EXPRESSION
-            REFERENCE_EXPRESSION
+            CALL_EXPRESSION
-              PsiElement(IDENTIFIER)('a')
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('b')
+              VALUE_ARGUMENT_LIST
+                PsiElement(LPAR)('(')
+                PsiElement(RPAR)(')')
             PsiWhiteSpace(' ')
             OPERATION_REFERENCE
-              PsiElement(PLUS)('+')
+              PsiElement(MUL)('*')
             PsiWhiteSpace(' ')
-            BINARY_EXPRESSION
+            INTEGER_CONSTANT
-              CALL_EXPRESSION
+              PsiElement(INTEGER_LITERAL)('5')
-                REFERENCE_EXPRESSION
+    PsiWhiteSpace(' ')
-                  PsiElement(IDENTIFIER)('b')
+    CLASS_BODY
-                VALUE_ARGUMENT_LIST
+      PsiElement(LBRACE)('{')
-                  PsiElement(LPAR)('(')
+      PsiWhiteSpace('\n  ')
-                  PsiElement(RPAR)(')')
+      CONSTRUCTOR
-              PsiWhiteSpace(' ')
+        PsiElement(this)('this')
-              OPERATION_REFERENCE
+        VALUE_PARAMETER_LIST
-                PsiElement(MUL)('*')
+          PsiElement(LPAR)('(')
-              PsiWhiteSpace(' ')
+          PsiElement(RPAR)(')')
-              INTEGER_CONSTANT
+        PsiWhiteSpace(' ')
-                PsiElement(INTEGER_LITERAL)('5')
+        BLOCK
-      PsiWhiteSpace(' ')
+          PsiElement(LBRACE)('{')
-      CLASS_BODY
+          PsiElement(RBRACE)('}')
-        PsiElement(LBRACE)('{')
+      PsiWhiteSpace('\n')
-        PsiWhiteSpace('\n  ')
+      PsiElement(RBRACE)('}')
-        CONSTRUCTOR
+  PsiWhiteSpace('\n')
-          PsiElement(this)('this')
+  CLASS
-          VALUE_PARAMETER_LIST
+    PsiElement(class)('class')
-            PsiElement(LPAR)('(')
+    PsiWhiteSpace(' ')
-            PsiElement(RPAR)(')')
+    PsiElement(IDENTIFIER)('A')
-          PsiWhiteSpace(' ')
+    PsiWhiteSpace(' ')
-          BLOCK
+    TYPE_PARAMETER_LIST
-            PsiElement(LBRACE)('{')
+      <empty list>
-            PsiElement(RBRACE)('}')
+    PsiElement(COLON)(':')
-        PsiWhiteSpace('\n')
+    PsiWhiteSpace(' ')
-        PsiElement(RBRACE)('}')
+    DELEGATION_SPECIFIER_LIST
-    PsiWhiteSpace('\n')
+      DELEGATOR_BY
-    CLASS
+        TYPE_REFERENCE
-      PsiElement(class)('class')
+          USER_TYPE
-      PsiWhiteSpace(' ')
+            REFERENCE_EXPRESSION
-      PsiElement(IDENTIFIER)('A')
+              PsiElement(IDENTIFIER)('b')
-      PsiWhiteSpace(' ')
+        PsiWhiteSpace(' ')
-      TYPE_PARAMETER_LIST
+        PsiElement(by)('by')
-        <empty list>
+        PsiWhiteSpace(' ')
-      PsiElement(COLON)(':')
+        PARENTHESIZED
-      PsiWhiteSpace(' ')
+          PsiElement(LPAR)('(')
-      DELEGATION_SPECIFIER_LIST
+          REFERENCE_EXPRESSION
-        DELEGATOR_BY
+            PsiElement(IDENTIFIER)('a')
-          TYPE_REFERENCE
+          PsiElement(RPAR)(')')
-            USER_TYPE
+    PsiWhiteSpace(' ')
-              REFERENCE_EXPRESSION
+    CLASS_BODY
-                PsiElement(IDENTIFIER)('b')
+      PsiElement(LBRACE)('{')
-          PsiWhiteSpace(' ')
+      PsiWhiteSpace('\n  ')
-          PsiElement(by)('by')
+      CONSTRUCTOR
-          PsiWhiteSpace(' ')
+        PsiElement(this)('this')
-          PARENTHESIZED
+        VALUE_PARAMETER_LIST
-            PsiElement(LPAR)('(')
+          PsiElement(LPAR)('(')
+          PsiElement(RPAR)(')')
+        PsiWhiteSpace(' ')
+        BLOCK
+          PsiElement(LBRACE)('{')
+          PsiElement(RBRACE)('}')
+      PsiWhiteSpace('\n')
+      PsiElement(RBRACE)('}')
+  PsiWhiteSpace('\n')
+  CLASS
+    PsiElement(class)('class')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('A')
+    PsiWhiteSpace(' ')
+    TYPE_PARAMETER_LIST
+      <empty list>
+    PsiElement(COLON)(':')
+    PsiWhiteSpace(' ')
+    DELEGATION_SPECIFIER_LIST
+      DELEGATOR_BY
+        TYPE_REFERENCE
+          USER_TYPE
+            REFERENCE_EXPRESSION
+              PsiElement(IDENTIFIER)('b')
+        PsiWhiteSpace(' ')
+        PsiElement(by)('by')
+        PsiWhiteSpace(' ')
+        PARENTHESIZED
+          PsiElement(LPAR)('(')
+          CALL_EXPRESSION
             REFERENCE_EXPRESSION
               PsiElement(IDENTIFIER)('a')
-            PsiElement(RPAR)(')')
+            PsiWhiteSpace(' ')
-      PsiWhiteSpace(' ')
+            FUNCTION_LITERAL_EXPRESSION
-      CLASS_BODY
+              FUNCTION_LITERAL
-        PsiElement(LBRACE)('{')
+                PsiElement(LBRACE)('{')
-        PsiWhiteSpace('\n  ')
+                BLOCK
-        CONSTRUCTOR
+                  <empty list>
-          PsiElement(this)('this')
+                PsiElement(RBRACE)('}')
-          VALUE_PARAMETER_LIST
+          PsiElement(RPAR)(')')
-            PsiElement(LPAR)('(')
+    PsiWhiteSpace(' ')
-            PsiElement(RPAR)(')')
+    CLASS_BODY
-          PsiWhiteSpace(' ')
+      PsiElement(LBRACE)('{')
-          BLOCK
+      PsiWhiteSpace('\n  ')
-            PsiElement(LBRACE)('{')
+      CONSTRUCTOR
-            PsiElement(RBRACE)('}')
+        PsiElement(this)('this')
-        PsiWhiteSpace('\n')
+        VALUE_PARAMETER_LIST
-        PsiElement(RBRACE)('}')
+          PsiElement(LPAR)('(')
-    PsiWhiteSpace('\n')
+          PsiElement(RPAR)(')')
-    CLASS
+        PsiWhiteSpace(' ')
-      PsiElement(class)('class')
+        BLOCK
-      PsiWhiteSpace(' ')
+          PsiElement(LBRACE)('{')
-      PsiElement(IDENTIFIER)('A')
+          PsiElement(RBRACE)('}')
-      PsiWhiteSpace(' ')
+      PsiWhiteSpace('\n')
-      TYPE_PARAMETER_LIST
+      PsiElement(RBRACE)('}')
-        <empty list>
+  PsiWhiteSpace('\n')
-      PsiElement(COLON)(':')
+  CLASS
-      PsiWhiteSpace(' ')
+    PsiElement(class)('class')
-      DELEGATION_SPECIFIER_LIST
+    PsiWhiteSpace(' ')
-        DELEGATOR_BY
+    PsiElement(IDENTIFIER)('A')
-          TYPE_REFERENCE
+    PsiWhiteSpace(' ')
-            USER_TYPE
+    TYPE_PARAMETER_LIST
-              REFERENCE_EXPRESSION
+      <empty list>
-                PsiElement(IDENTIFIER)('b')
+    PsiElement(COLON)(':')
-          PsiWhiteSpace(' ')
+    PsiWhiteSpace(' ')
-          PsiElement(by)('by')
+    DELEGATION_SPECIFIER_LIST
-          PsiWhiteSpace(' ')
+      DELEGATOR_BY
-          PARENTHESIZED
+        TYPE_REFERENCE
-            PsiElement(LPAR)('(')
+          USER_TYPE
+            REFERENCE_EXPRESSION
+              PsiElement(IDENTIFIER)('b')
+        PsiWhiteSpace(' ')
+        PsiElement(by)('by')
+        PsiWhiteSpace(' ')
+        ARRAY_ACCESS_EXPRESSION
+          REFERENCE_EXPRESSION
+            PsiElement(IDENTIFIER)('a')
+          INDICES
+            PsiElement(LBRACKET)('[')
             CALL_EXPRESSION
               REFERENCE_EXPRESSION
                 PsiElement(IDENTIFIER)('a')
@@ -161,46 +210,47 @@ JetFile: ByCaluses.jet
                   BLOCK
                     <empty list>
                   PsiElement(RBRACE)('}')
-            PsiElement(RPAR)(')')
+            PsiElement(RBRACKET)(']')
-      PsiWhiteSpace(' ')
+    PsiWhiteSpace(' ')
-      CLASS_BODY
+    CLASS_BODY
-        PsiElement(LBRACE)('{')
+      PsiElement(LBRACE)('{')
-        PsiWhiteSpace('\n  ')
+      PsiWhiteSpace('\n  ')
-        CONSTRUCTOR
+      CONSTRUCTOR
-          PsiElement(this)('this')
+        PsiElement(this)('this')
-          VALUE_PARAMETER_LIST
+        VALUE_PARAMETER_LIST
-            PsiElement(LPAR)('(')
+          PsiElement(LPAR)('(')
-            PsiElement(RPAR)(')')
+          PsiElement(RPAR)(')')
-          PsiWhiteSpace(' ')
+        PsiWhiteSpace(' ')
-          BLOCK
+        BLOCK
-            PsiElement(LBRACE)('{')
+          PsiElement(LBRACE)('{')
-            PsiElement(RBRACE)('}')
+          PsiElement(RBRACE)('}')
-        PsiWhiteSpace('\n')
+      PsiWhiteSpace('\n')
-        PsiElement(RBRACE)('}')
+      PsiElement(RBRACE)('}')
-    PsiWhiteSpace('\n')
+  PsiWhiteSpace('\n')
-    CLASS
+  CLASS
-      PsiElement(class)('class')
+    PsiElement(class)('class')
-      PsiWhiteSpace(' ')
+    PsiWhiteSpace(' ')
-      PsiElement(IDENTIFIER)('A')
+    PsiElement(IDENTIFIER)('A')
-      PsiWhiteSpace(' ')
+    PsiWhiteSpace(' ')
-      TYPE_PARAMETER_LIST
+    TYPE_PARAMETER_LIST
-        <empty list>
+      <empty list>
-      PsiElement(COLON)(':')
+    PsiElement(COLON)(':')
-      PsiWhiteSpace(' ')
+    PsiWhiteSpace(' ')
-      DELEGATION_SPECIFIER_LIST
+    DELEGATION_SPECIFIER_LIST
-        DELEGATOR_BY
+      DELEGATOR_BY
-          TYPE_REFERENCE
+        TYPE_REFERENCE
-            USER_TYPE
+          USER_TYPE
-              REFERENCE_EXPRESSION
-                PsiElement(IDENTIFIER)('b')
-          PsiWhiteSpace(' ')
-          PsiElement(by)('by')
-          PsiWhiteSpace(' ')
-          ARRAY_ACCESS_EXPRESSION
             REFERENCE_EXPRESSION
-              PsiElement(IDENTIFIER)('a')
+              PsiElement(IDENTIFIER)('b')
-            INDICES
+        PsiWhiteSpace(' ')
-              PsiElement(LBRACKET)('[')
+        PsiElement(by)('by')
+        PsiWhiteSpace(' ')
+        CALL_EXPRESSION
+          REFERENCE_EXPRESSION
+            PsiElement(IDENTIFIER)('a')
+          VALUE_ARGUMENT_LIST
+            PsiElement(LPAR)('(')
+            VALUE_ARGUMENT
               CALL_EXPRESSION
                 REFERENCE_EXPRESSION
                   PsiElement(IDENTIFIER)('a')
@@ -211,47 +261,58 @@ JetFile: ByCaluses.jet
                     BLOCK
                       <empty list>
                     PsiElement(RBRACE)('}')
-              PsiElement(RBRACKET)(']')
-      PsiWhiteSpace(' ')
-      CLASS_BODY
-        PsiElement(LBRACE)('{')
-        PsiWhiteSpace('\n  ')
-        CONSTRUCTOR
-          PsiElement(this)('this')
-          VALUE_PARAMETER_LIST
-            PsiElement(LPAR)('(')
             PsiElement(RPAR)(')')
-          PsiWhiteSpace(' ')
+    PsiWhiteSpace(' ')
-          BLOCK
+    CLASS_BODY
-            PsiElement(LBRACE)('{')
+      PsiElement(LBRACE)('{')
-            PsiElement(RBRACE)('}')
+      PsiWhiteSpace('\n  ')
-        PsiWhiteSpace('\n')
+      CONSTRUCTOR
-        PsiElement(RBRACE)('}')
+        PsiElement(this)('this')
-    PsiWhiteSpace('\n')
+        VALUE_PARAMETER_LIST
-    CLASS
+          PsiElement(LPAR)('(')
-      PsiElement(class)('class')
+          PsiElement(RPAR)(')')
-      PsiWhiteSpace(' ')
+        PsiWhiteSpace(' ')
-      PsiElement(IDENTIFIER)('A')
+        BLOCK
-      PsiWhiteSpace(' ')
+          PsiElement(LBRACE)('{')
-      TYPE_PARAMETER_LIST
+          PsiElement(RBRACE)('}')
-        <empty list>
+      PsiWhiteSpace('\n')
-      PsiElement(COLON)(':')
+      PsiElement(RBRACE)('}')
-      PsiWhiteSpace(' ')
+  PsiWhiteSpace('\n')
-      DELEGATION_SPECIFIER_LIST
+  CLASS
-        DELEGATOR_BY
+    PsiElement(class)('class')
-          TYPE_REFERENCE
+    PsiWhiteSpace(' ')
-            USER_TYPE
+    PsiElement(IDENTIFIER)('A')
-              REFERENCE_EXPRESSION
+    PsiWhiteSpace(' ')
-                PsiElement(IDENTIFIER)('b')
+    TYPE_PARAMETER_LIST
-          PsiWhiteSpace(' ')
+      <empty list>
-          PsiElement(by)('by')
+    PsiElement(COLON)(':')
-          PsiWhiteSpace(' ')
+    PsiWhiteSpace(' ')
-          CALL_EXPRESSION
+    DELEGATION_SPECIFIER_LIST
+      DELEGATOR_BY
+        TYPE_REFERENCE
+          USER_TYPE
             REFERENCE_EXPRESSION
-              PsiElement(IDENTIFIER)('a')
+              PsiElement(IDENTIFIER)('b')
-            VALUE_ARGUMENT_LIST
+        PsiWhiteSpace(' ')
-              PsiElement(LPAR)('(')
+        PsiElement(by)('by')
-              VALUE_ARGUMENT
+        PsiWhiteSpace(' ')
+        OBJECT_LITERAL
+          OBJECT_DECLARATION
+            PsiElement(object)('object')
+            PsiWhiteSpace(' ')
+            CLASS_BODY
+              PsiElement(LBRACE)('{')
+              PsiWhiteSpace('\n  ')
+              FUN
+                PsiElement(fun)('fun')
+                PsiWhiteSpace(' ')
+                PsiElement(IDENTIFIER)('f')
+                VALUE_PARAMETER_LIST
+                  PsiElement(LPAR)('(')
+                  PsiElement(RPAR)(')')
+                PsiWhiteSpace(' ')
+                PsiElement(EQ)('=')
+                PsiWhiteSpace(' ')
                 CALL_EXPRESSION
                   REFERENCE_EXPRESSION
                     PsiElement(IDENTIFIER)('a')
@@ -262,82 +323,20 @@ JetFile: ByCaluses.jet
                       BLOCK
                         <empty list>
                       PsiElement(RBRACE)('}')
-              PsiElement(RPAR)(')')
+              PsiWhiteSpace('\n')
-      PsiWhiteSpace(' ')
+              PsiElement(RBRACE)('}')
-      CLASS_BODY
+    PsiWhiteSpace(' ')
-        PsiElement(LBRACE)('{')
+    CLASS_BODY
-        PsiWhiteSpace('\n  ')
+      PsiElement(LBRACE)('{')
-        CONSTRUCTOR
+      PsiWhiteSpace('\n  ')
-          PsiElement(this)('this')
+      CONSTRUCTOR
-          VALUE_PARAMETER_LIST
+        PsiElement(this)('this')
-            PsiElement(LPAR)('(')
+        VALUE_PARAMETER_LIST
-            PsiElement(RPAR)(')')
+          PsiElement(LPAR)('(')
-          PsiWhiteSpace(' ')
+          PsiElement(RPAR)(')')
-          BLOCK
+        PsiWhiteSpace(' ')
-            PsiElement(LBRACE)('{')
+        BLOCK
-            PsiElement(RBRACE)('}')
+          PsiElement(LBRACE)('{')
-        PsiWhiteSpace('\n')
+          PsiElement(RBRACE)('}')
-        PsiElement(RBRACE)('}')
+      PsiWhiteSpace('\n')
-    PsiWhiteSpace('\n')
+      PsiElement(RBRACE)('}')
-    CLASS
-      PsiElement(class)('class')
-      PsiWhiteSpace(' ')
-      PsiElement(IDENTIFIER)('A')
-      PsiWhiteSpace(' ')
-      TYPE_PARAMETER_LIST
-        <empty list>
-      PsiElement(COLON)(':')
-      PsiWhiteSpace(' ')
-      DELEGATION_SPECIFIER_LIST
-        DELEGATOR_BY
-          TYPE_REFERENCE
-            USER_TYPE
-              REFERENCE_EXPRESSION
-                PsiElement(IDENTIFIER)('b')
-          PsiWhiteSpace(' ')
-          PsiElement(by)('by')
-          PsiWhiteSpace(' ')
-          OBJECT_LITERAL
-            OBJECT_DECLARATION
-              PsiElement(object)('object')
-              PsiWhiteSpace(' ')
-              CLASS_BODY
-                PsiElement(LBRACE)('{')
-                PsiWhiteSpace('\n  ')
-                FUN
-                  PsiElement(fun)('fun')
-                  PsiWhiteSpace(' ')
-                  PsiElement(IDENTIFIER)('f')
-                  VALUE_PARAMETER_LIST
-                    PsiElement(LPAR)('(')
-                    PsiElement(RPAR)(')')
-                  PsiWhiteSpace(' ')
-                  PsiElement(EQ)('=')
-                  PsiWhiteSpace(' ')
-                  CALL_EXPRESSION
-                    REFERENCE_EXPRESSION
-                      PsiElement(IDENTIFIER)('a')
-                    PsiWhiteSpace(' ')
-                    FUNCTION_LITERAL_EXPRESSION
-                      FUNCTION_LITERAL
-                        PsiElement(LBRACE)('{')
-                        BLOCK
-                          <empty list>
-                        PsiElement(RBRACE)('}')
-                PsiWhiteSpace('\n')
-                PsiElement(RBRACE)('}')
-      PsiWhiteSpace(' ')
-      CLASS_BODY
-        PsiElement(LBRACE)('{')
-        PsiWhiteSpace('\n  ')
-        CONSTRUCTOR
-          PsiElement(this)('this')
-          VALUE_PARAMETER_LIST
-            PsiElement(LPAR)('(')
-            PsiElement(RPAR)(')')
-          PsiWhiteSpace(' ')
-          BLOCK
-            PsiElement(LBRACE)('{')
-            PsiElement(RBRACE)('}')
-        PsiWhiteSpace('\n')
-        PsiElement(RBRACE)('}')

compiler/testData/psi/CallWithManyClosures.txt

@@ -1,228 +1,227 @@
 JetFile: CallWithManyClosures.jet
-  NAMESPACE
+  NAMESPACE_HEADER
-    NAMESPACE_HEADER
+    <empty list>
-      <empty list>
+  PROPERTY
-    PROPERTY
+    PsiElement(val)('val')
-      PsiElement(val)('val')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('a')
+    PsiWhiteSpace(' ')
+    PsiElement(EQ)('=')
+    PsiWhiteSpace(' ')
+    CALL_EXPRESSION
+      REFERENCE_EXPRESSION
+        PsiElement(IDENTIFIER)('f')
+      VALUE_ARGUMENT_LIST
+        PsiElement(LPAR)('(')
+        PsiElement(RPAR)(')')
       PsiWhiteSpace(' ')
-      PsiElement(IDENTIFIER)('a')
+      FUNCTION_LITERAL_EXPRESSION
+        FUNCTION_LITERAL
+          PsiElement(LBRACE)('{')
+          BLOCK
+            <empty list>
+          PsiElement(RBRACE)('}')
       PsiWhiteSpace(' ')
-      PsiElement(EQ)('=')
+      FUNCTION_LITERAL_EXPRESSION
+        FUNCTION_LITERAL
+          PsiElement(LBRACE)('{')
+          BLOCK
+            <empty list>
+          PsiElement(RBRACE)('}')
       PsiWhiteSpace(' ')
-      CALL_EXPRESSION
+      FUNCTION_LITERAL_EXPRESSION
+        FUNCTION_LITERAL
+          PsiElement(LBRACE)('{')
+          BLOCK
+            <empty list>
+          PsiElement(RBRACE)('}')
+  PsiWhiteSpace('\n')
+  PROPERTY
+    PsiElement(val)('val')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('a')
+    PsiWhiteSpace(' ')
+    PsiElement(EQ)('=')
+    PsiWhiteSpace(' ')
+    CALL_EXPRESSION
+      REFERENCE_EXPRESSION
+        PsiElement(IDENTIFIER)('f')
+      PsiWhiteSpace(' ')
+      FUNCTION_LITERAL_EXPRESSION
+        FUNCTION_LITERAL
+          PsiElement(LBRACE)('{')
+          BLOCK
+            <empty list>
+          PsiElement(RBRACE)('}')
+      PsiWhiteSpace(' ')
+      FUNCTION_LITERAL_EXPRESSION
+        FUNCTION_LITERAL
+          PsiElement(LBRACE)('{')
+          BLOCK
+            <empty list>
+          PsiElement(RBRACE)('}')
+      PsiWhiteSpace(' ')
+      FUNCTION_LITERAL_EXPRESSION
+        FUNCTION_LITERAL
+          PsiElement(LBRACE)('{')
+          BLOCK
+            <empty list>
+          PsiElement(RBRACE)('}')
+  PsiWhiteSpace('\n')
+  PROPERTY
+    PsiElement(val)('val')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('a')
+    PsiWhiteSpace(' ')
+    PsiElement(EQ)('=')
+    PsiWhiteSpace(' ')
+    CALL_EXPRESSION
+      REFERENCE_EXPRESSION
+        PsiElement(IDENTIFIER)('f')
+      PsiWhiteSpace(' ')
+      FUNCTION_LITERAL_EXPRESSION
+        FUNCTION_LITERAL
+          PsiElement(LBRACE)('{')
+          BLOCK
+            <empty list>
+          PsiElement(RBRACE)('}')
+  PsiWhiteSpace('\n')
+  PROPERTY
+    PsiElement(val)('val')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('a')
+    PsiWhiteSpace(' ')
+    PsiElement(EQ)('=')
+    PsiWhiteSpace(' ')
+    CALL_EXPRESSION
+      REFERENCE_EXPRESSION
+        PsiElement(IDENTIFIER)('f')
+      VALUE_ARGUMENT_LIST
+        PsiElement(LPAR)('(')
+        PsiElement(RPAR)(')')
+      PsiWhiteSpace(' ')
+      FUNCTION_LITERAL_EXPRESSION
+        FUNCTION_LITERAL
+          PsiElement(LBRACE)('{')
+          BLOCK
+            <empty list>
+          PsiElement(RBRACE)('}')
+  PsiWhiteSpace('\n')
+  PROPERTY
+    PsiElement(val)('val')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('a')
+    PsiWhiteSpace(' ')
+    PsiElement(EQ)('=')
+    PsiWhiteSpace(' ')
+    CALL_EXPRESSION
+      PARENTHESIZED
+        PsiElement(LPAR)('(')
         REFERENCE_EXPRESSION
           PsiElement(IDENTIFIER)('f')
-        VALUE_ARGUMENT_LIST
+        PsiElement(RPAR)(')')
-          PsiElement(LPAR)('(')
-          PsiElement(RPAR)(')')
-        PsiWhiteSpace(' ')
-        FUNCTION_LITERAL_EXPRESSION
-          FUNCTION_LITERAL
-            PsiElement(LBRACE)('{')
-            BLOCK
-              <empty list>
-            PsiElement(RBRACE)('}')
-        PsiWhiteSpace(' ')
-        FUNCTION_LITERAL_EXPRESSION
-          FUNCTION_LITERAL
-            PsiElement(LBRACE)('{')
-            BLOCK
-              <empty list>
-            PsiElement(RBRACE)('}')
-        PsiWhiteSpace(' ')
-        FUNCTION_LITERAL_EXPRESSION
-          FUNCTION_LITERAL
-            PsiElement(LBRACE)('{')
-            BLOCK
-              <empty list>
-            PsiElement(RBRACE)('}')
-    PsiWhiteSpace('\n')
-    PROPERTY
-      PsiElement(val)('val')
       PsiWhiteSpace(' ')
-      PsiElement(IDENTIFIER)('a')
+      FUNCTION_LITERAL_EXPRESSION
+        FUNCTION_LITERAL
+          PsiElement(LBRACE)('{')
+          BLOCK
+            <empty list>
+          PsiElement(RBRACE)('}')
       PsiWhiteSpace(' ')
-      PsiElement(EQ)('=')
+      FUNCTION_LITERAL_EXPRESSION
+        FUNCTION_LITERAL
+          PsiElement(LBRACE)('{')
+          BLOCK
+            <empty list>
+          PsiElement(RBRACE)('}')
       PsiWhiteSpace(' ')
-      CALL_EXPRESSION
+      FUNCTION_LITERAL_EXPRESSION
+        FUNCTION_LITERAL
+          PsiElement(LBRACE)('{')
+          BLOCK
+            <empty list>
+          PsiElement(RBRACE)('}')
+  PsiWhiteSpace('\n')
+  PROPERTY
+    PsiElement(val)('val')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('a')
+    PsiWhiteSpace(' ')
+    PsiElement(EQ)('=')
+    PsiWhiteSpace(' ')
+    CALL_EXPRESSION
+      PARENTHESIZED
+        PsiElement(LPAR)('(')
         REFERENCE_EXPRESSION
           PsiElement(IDENTIFIER)('f')
-        PsiWhiteSpace(' ')
+        PsiElement(RPAR)(')')
-        FUNCTION_LITERAL_EXPRESSION
+      VALUE_ARGUMENT_LIST
-          FUNCTION_LITERAL
+        PsiElement(LPAR)('(')
-            PsiElement(LBRACE)('{')
+        PsiElement(RPAR)(')')
-            BLOCK
-              <empty list>
-            PsiElement(RBRACE)('}')
-        PsiWhiteSpace(' ')
-        FUNCTION_LITERAL_EXPRESSION
-          FUNCTION_LITERAL
-            PsiElement(LBRACE)('{')
-            BLOCK
-              <empty list>
-            PsiElement(RBRACE)('}')
-        PsiWhiteSpace(' ')
-        FUNCTION_LITERAL_EXPRESSION
-          FUNCTION_LITERAL
-            PsiElement(LBRACE)('{')
-            BLOCK
-              <empty list>
-            PsiElement(RBRACE)('}')
-    PsiWhiteSpace('\n')
-    PROPERTY
-      PsiElement(val)('val')
       PsiWhiteSpace(' ')
-      PsiElement(IDENTIFIER)('a')
+      FUNCTION_LITERAL_EXPRESSION
+        FUNCTION_LITERAL
+          PsiElement(LBRACE)('{')
+          BLOCK
+            <empty list>
+          PsiElement(RBRACE)('}')
       PsiWhiteSpace(' ')
-      PsiElement(EQ)('=')
+      FUNCTION_LITERAL_EXPRESSION
+        FUNCTION_LITERAL
+          PsiElement(LBRACE)('{')
+          BLOCK
+            <empty list>
+          PsiElement(RBRACE)('}')
       PsiWhiteSpace(' ')
-      CALL_EXPRESSION
+      FUNCTION_LITERAL_EXPRESSION
+        FUNCTION_LITERAL
+          PsiElement(LBRACE)('{')
+          BLOCK
+            <empty list>
+          PsiElement(RBRACE)('}')
+  PsiWhiteSpace('\n')
+  PROPERTY
+    PsiElement(val)('val')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('a')
+    PsiWhiteSpace(' ')
+    PsiElement(EQ)('=')
+    PsiWhiteSpace(' ')
+    CALL_EXPRESSION
+      PARENTHESIZED
+        PsiElement(LPAR)('(')
         REFERENCE_EXPRESSION
           PsiElement(IDENTIFIER)('f')
-        PsiWhiteSpace(' ')
+        PsiElement(RPAR)(')')
-        FUNCTION_LITERAL_EXPRESSION
+      TYPE_ARGUMENT_LIST
-          FUNCTION_LITERAL
+        PsiElement(LT)('<')
-            PsiElement(LBRACE)('{')
+        TYPE_PROJECTION
-            BLOCK
+          TYPE_REFERENCE
-              <empty list>
+            USER_TYPE
-            PsiElement(RBRACE)('}')
+              REFERENCE_EXPRESSION
-    PsiWhiteSpace('\n')
+                PsiElement(IDENTIFIER)('A')
-    PROPERTY
+        PsiElement(GT)('>')
-      PsiElement(val)('val')
+      VALUE_ARGUMENT_LIST
+        PsiElement(LPAR)('(')
+        PsiElement(RPAR)(')')
       PsiWhiteSpace(' ')
-      PsiElement(IDENTIFIER)('a')
+      FUNCTION_LITERAL_EXPRESSION
+        FUNCTION_LITERAL
+          PsiElement(LBRACE)('{')
+          BLOCK
+            <empty list>
+          PsiElement(RBRACE)('}')
       PsiWhiteSpace(' ')
-      PsiElement(EQ)('=')
+      FUNCTION_LITERAL_EXPRESSION
+        FUNCTION_LITERAL
+          PsiElement(LBRACE)('{')
+          BLOCK
+            <empty list>
+          PsiElement(RBRACE)('}')
       PsiWhiteSpace(' ')
-      CALL_EXPRESSION
+      FUNCTION_LITERAL_EXPRESSION
-        REFERENCE_EXPRESSION
+        FUNCTION_LITERAL
-          PsiElement(IDENTIFIER)('f')
+          PsiElement(LBRACE)('{')
-        VALUE_ARGUMENT_LIST
+          BLOCK
-          PsiElement(LPAR)('(')
+            <empty list>
-          PsiElement(RPAR)(')')
+          PsiElement(RBRACE)('}')
-        PsiWhiteSpace(' ')
-        FUNCTION_LITERAL_EXPRESSION
-          FUNCTION_LITERAL
-            PsiElement(LBRACE)('{')
-            BLOCK
-              <empty list>
-            PsiElement(RBRACE)('}')
-    PsiWhiteSpace('\n')
-    PROPERTY
-      PsiElement(val)('val')
-      PsiWhiteSpace(' ')
-      PsiElement(IDENTIFIER)('a')
-      PsiWhiteSpace(' ')
-      PsiElement(EQ)('=')
-      PsiWhiteSpace(' ')
-      CALL_EXPRESSION
-        PARENTHESIZED
-          PsiElement(LPAR)('(')
-          REFERENCE_EXPRESSION
-            PsiElement(IDENTIFIER)('f')
-          PsiElement(RPAR)(')')
-        PsiWhiteSpace(' ')
-        FUNCTION_LITERAL_EXPRESSION
-          FUNCTION_LITERAL
-            PsiElement(LBRACE)('{')
-            BLOCK
-              <empty list>
-            PsiElement(RBRACE)('}')
-        PsiWhiteSpace(' ')
-        FUNCTION_LITERAL_EXPRESSION
-          FUNCTION_LITERAL
-            PsiElement(LBRACE)('{')
-            BLOCK
-              <empty list>
-            PsiElement(RBRACE)('}')
-        PsiWhiteSpace(' ')
-        FUNCTION_LITERAL_EXPRESSION
-          FUNCTION_LITERAL
-            PsiElement(LBRACE)('{')
-            BLOCK
-              <empty list>
-            PsiElement(RBRACE)('}')
-    PsiWhiteSpace('\n')
-    PROPERTY
-      PsiElement(val)('val')
-      PsiWhiteSpace(' ')
-      PsiElement(IDENTIFIER)('a')
-      PsiWhiteSpace(' ')
-      PsiElement(EQ)('=')
-      PsiWhiteSpace(' ')
-      CALL_EXPRESSION
-        PARENTHESIZED
-          PsiElement(LPAR)('(')
-          REFERENCE_EXPRESSION
-            PsiElement(IDENTIFIER)('f')
-          PsiElement(RPAR)(')')
-        VALUE_ARGUMENT_LIST
-          PsiElement(LPAR)('(')
-          PsiElement(RPAR)(')')
-        PsiWhiteSpace(' ')
-        FUNCTION_LITERAL_EXPRESSION
-          FUNCTION_LITERAL
-            PsiElement(LBRACE)('{')
-            BLOCK
-              <empty list>
-            PsiElement(RBRACE)('}')
-        PsiWhiteSpace(' ')
-        FUNCTION_LITERAL_EXPRESSION
-          FUNCTION_LITERAL
-            PsiElement(LBRACE)('{')
-            BLOCK
-              <empty list>
-            PsiElement(RBRACE)('}')
-        PsiWhiteSpace(' ')
-        FUNCTION_LITERAL_EXPRESSION
-          FUNCTION_LITERAL
-            PsiElement(LBRACE)('{')
-            BLOCK
-              <empty list>
-            PsiElement(RBRACE)('}')
-    PsiWhiteSpace('\n')
-    PROPERTY
-      PsiElement(val)('val')
-      PsiWhiteSpace(' ')
-      PsiElement(IDENTIFIER)('a')
-      PsiWhiteSpace(' ')
-      PsiElement(EQ)('=')
-      PsiWhiteSpace(' ')
-      CALL_EXPRESSION
-        PARENTHESIZED
-          PsiElement(LPAR)('(')
-          REFERENCE_EXPRESSION
-            PsiElement(IDENTIFIER)('f')
-          PsiElement(RPAR)(')')
-        TYPE_ARGUMENT_LIST
-          PsiElement(LT)('<')
-          TYPE_PROJECTION
-            TYPE_REFERENCE
-              USER_TYPE
-                REFERENCE_EXPRESSION
-                  PsiElement(IDENTIFIER)('A')
-          PsiElement(GT)('>')
-        VALUE_ARGUMENT_LIST
-          PsiElement(LPAR)('(')
-          PsiElement(RPAR)(')')
-        PsiWhiteSpace(' ')
-        FUNCTION_LITERAL_EXPRESSION
-          FUNCTION_LITERAL
-            PsiElement(LBRACE)('{')
-            BLOCK
-              <empty list>
-            PsiElement(RBRACE)('}')
-        PsiWhiteSpace(' ')
-        FUNCTION_LITERAL_EXPRESSION
-          FUNCTION_LITERAL
-            PsiElement(LBRACE)('{')
-            BLOCK
-              <empty list>
-            PsiElement(RBRACE)('}')
-        PsiWhiteSpace(' ')
-        FUNCTION_LITERAL_EXPRESSION
-          FUNCTION_LITERAL
-            PsiElement(LBRACE)('{')
-            BLOCK
-              <empty list>
-            PsiElement(RBRACE)('}')

compiler/testData/psi/CallsInWhen.txt

@@ -1,231 +1,230 @@
 JetFile: CallsInWhen.jet
-  NAMESPACE
+  NAMESPACE_HEADER
-    NAMESPACE_HEADER
+    <empty list>
-      <empty list>
+  FUN
-    FUN
+    PsiElement(fun)('fun')
-      PsiElement(fun)('fun')
+    PsiWhiteSpace(' ')
-      PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('foo')
-      PsiElement(IDENTIFIER)('foo')
+    VALUE_PARAMETER_LIST
-      VALUE_PARAMETER_LIST
+      PsiElement(LPAR)('(')
+      PsiElement(RPAR)(')')
+    PsiWhiteSpace(' ')
+    BLOCK
+      PsiElement(LBRACE)('{')
+      PsiWhiteSpace('\n  ')
+      WHEN
+        PsiElement(when)('when')
+        PsiWhiteSpace(' ')
         PsiElement(LPAR)('(')
+        REFERENCE_EXPRESSION
+          PsiElement(IDENTIFIER)('a')
         PsiElement(RPAR)(')')
-      PsiWhiteSpace(' ')
+        PsiWhiteSpace(' ')
-      BLOCK
         PsiElement(LBRACE)('{')
-        PsiWhiteSpace('\n  ')
+        PsiWhiteSpace('\n    ')
-        WHEN
+        WHEN_ENTRY
-          PsiElement(when)('when')
+          WHEN_CONDITION_IS_PATTERN
+            EXPRESSION_PATTERN
+              DOT_QUALIFIED_EXPRESSION
+                REFERENCE_EXPRESSION
+                  PsiElement(IDENTIFIER)('a')
+                PsiElement(DOT)('.')
+                REFERENCE_EXPRESSION
+                  PsiElement(IDENTIFIER)('foo')
+          PsiWhiteSpace(' ')
+          PsiElement(ARROW)('->')
           PsiWhiteSpace(' ')
-          PsiElement(LPAR)('(')
           REFERENCE_EXPRESSION
             PsiElement(IDENTIFIER)('a')
-          PsiElement(RPAR)(')')
+        PsiWhiteSpace('\n    ')
-          PsiWhiteSpace(' ')
+        WHEN_ENTRY
-          PsiElement(LBRACE)('{')
+          WHEN_CONDITION_IS_PATTERN
-          PsiWhiteSpace('\n    ')
+            EXPRESSION_PATTERN
-          WHEN_ENTRY
+              DOT_QUALIFIED_EXPRESSION
-            WHEN_CONDITION_IS_PATTERN
+                REFERENCE_EXPRESSION
-              EXPRESSION_PATTERN
+                  PsiElement(IDENTIFIER)('a')
-                DOT_QUALIFIED_EXPRESSION
+                PsiElement(DOT)('.')
-                  REFERENCE_EXPRESSION
+                CALL_EXPRESSION
-                    PsiElement(IDENTIFIER)('a')
-                  PsiElement(DOT)('.')
                   REFERENCE_EXPRESSION
                     PsiElement(IDENTIFIER)('foo')
-            PsiWhiteSpace(' ')
+                  VALUE_ARGUMENT_LIST
-            PsiElement(ARROW)('->')
+                    PsiElement(LPAR)('(')
-            PsiWhiteSpace(' ')
+                    PsiElement(RPAR)(')')
-            REFERENCE_EXPRESSION
+          PsiWhiteSpace(' ')
-              PsiElement(IDENTIFIER)('a')
+          PsiElement(ARROW)('->')
-          PsiWhiteSpace('\n    ')
+          PsiWhiteSpace(' ')
-          WHEN_ENTRY
+          REFERENCE_EXPRESSION
-            WHEN_CONDITION_IS_PATTERN
+            PsiElement(IDENTIFIER)('a')
-              EXPRESSION_PATTERN
+        PsiWhiteSpace('\n    ')
-                DOT_QUALIFIED_EXPRESSION
+        WHEN_ENTRY
+          WHEN_CONDITION_IS_PATTERN
+            EXPRESSION_PATTERN
+              DOT_QUALIFIED_EXPRESSION
+                REFERENCE_EXPRESSION
+                  PsiElement(IDENTIFIER)('a')
+                PsiElement(DOT)('.')
+                CALL_EXPRESSION
                   REFERENCE_EXPRESSION
-                    PsiElement(IDENTIFIER)('a')
+                    PsiElement(IDENTIFIER)('foo')
-                  PsiElement(DOT)('.')
+                  TYPE_ARGUMENT_LIST
-                  CALL_EXPRESSION
+                    PsiElement(LT)('<')
-                    REFERENCE_EXPRESSION
+                    TYPE_PROJECTION
-                      PsiElement(IDENTIFIER)('foo')
+                      TYPE_REFERENCE
-                    VALUE_ARGUMENT_LIST
+                        USER_TYPE
-                      PsiElement(LPAR)('(')
+                          REFERENCE_EXPRESSION
-                      PsiElement(RPAR)(')')
+                            PsiElement(IDENTIFIER)('T')
-            PsiWhiteSpace(' ')
+                    PsiElement(GT)('>')
-            PsiElement(ARROW)('->')
+          PsiWhiteSpace(' ')
-            PsiWhiteSpace(' ')
+          PsiElement(ARROW)('->')
-            REFERENCE_EXPRESSION
+          PsiWhiteSpace(' ')
-              PsiElement(IDENTIFIER)('a')
+          REFERENCE_EXPRESSION
-          PsiWhiteSpace('\n    ')
+            PsiElement(IDENTIFIER)('a')
-          WHEN_ENTRY
+        PsiWhiteSpace('\n    ')
-            WHEN_CONDITION_IS_PATTERN
+        WHEN_ENTRY
-              EXPRESSION_PATTERN
+          WHEN_CONDITION_IS_PATTERN
-                DOT_QUALIFIED_EXPRESSION
+            EXPRESSION_PATTERN
+              DOT_QUALIFIED_EXPRESSION
+                REFERENCE_EXPRESSION
+                  PsiElement(IDENTIFIER)('a')
+                PsiElement(DOT)('.')
+                CALL_EXPRESSION
                   REFERENCE_EXPRESSION
-                    PsiElement(IDENTIFIER)('a')
+                    PsiElement(IDENTIFIER)('foo')
-                  PsiElement(DOT)('.')
+                  TYPE_ARGUMENT_LIST
-                  CALL_EXPRESSION
+                    PsiElement(LT)('<')
-                    REFERENCE_EXPRESSION
+                    TYPE_PROJECTION
-                      PsiElement(IDENTIFIER)('foo')
+                      TYPE_REFERENCE
-                    TYPE_ARGUMENT_LIST
+                        USER_TYPE
-                      PsiElement(LT)('<')
+                          REFERENCE_EXPRESSION
-                      TYPE_PROJECTION
+                            PsiElement(IDENTIFIER)('T')
-                        TYPE_REFERENCE
+                    PsiElement(GT)('>')
-                          USER_TYPE
+                  VALUE_ARGUMENT_LIST
-                            REFERENCE_EXPRESSION
+                    PsiElement(LPAR)('(')
-                              PsiElement(IDENTIFIER)('T')
+                    VALUE_ARGUMENT
-                      PsiElement(GT)('>')
+                      REFERENCE_EXPRESSION
-            PsiWhiteSpace(' ')
+                        PsiElement(IDENTIFIER)('a')
-            PsiElement(ARROW)('->')
+                    PsiElement(RPAR)(')')
-            PsiWhiteSpace(' ')
+          PsiWhiteSpace(' ')
-            REFERENCE_EXPRESSION
+          PsiElement(ARROW)('->')
-              PsiElement(IDENTIFIER)('a')
+          PsiWhiteSpace(' ')
-          PsiWhiteSpace('\n    ')
+          REFERENCE_EXPRESSION
-          WHEN_ENTRY
+            PsiElement(IDENTIFIER)('a')
-            WHEN_CONDITION_IS_PATTERN
+        PsiWhiteSpace('\n    ')
-              EXPRESSION_PATTERN
+        WHEN_ENTRY
-                DOT_QUALIFIED_EXPRESSION
+          WHEN_CONDITION_IS_PATTERN
+            EXPRESSION_PATTERN
+              DOT_QUALIFIED_EXPRESSION
+                REFERENCE_EXPRESSION
+                  PsiElement(IDENTIFIER)('a')
+                PsiElement(DOT)('.')
+                CALL_EXPRESSION
                   REFERENCE_EXPRESSION
-                    PsiElement(IDENTIFIER)('a')
+                    PsiElement(IDENTIFIER)('foo')
-                  PsiElement(DOT)('.')
+                  TYPE_ARGUMENT_LIST
-                  CALL_EXPRESSION
+                    PsiElement(LT)('<')
-                    REFERENCE_EXPRESSION
+                    TYPE_PROJECTION
-                      PsiElement(IDENTIFIER)('foo')
+                      TYPE_REFERENCE
-                    TYPE_ARGUMENT_LIST
+                        USER_TYPE
-                      PsiElement(LT)('<')
+                          REFERENCE_EXPRESSION
-                      TYPE_PROJECTION
+                            PsiElement(IDENTIFIER)('T')
-                        TYPE_REFERENCE
+                    PsiElement(GT)('>')
-                          USER_TYPE
+                  VALUE_ARGUMENT_LIST
-                            REFERENCE_EXPRESSION
+                    PsiElement(LPAR)('(')
-                              PsiElement(IDENTIFIER)('T')
+                    VALUE_ARGUMENT
-                      PsiElement(GT)('>')
+                      REFERENCE_EXPRESSION
-                    VALUE_ARGUMENT_LIST
+                        PsiElement(IDENTIFIER)('a')
-                      PsiElement(LPAR)('(')
+                    PsiElement(COMMA)(',')
-                      VALUE_ARGUMENT
+                    PsiWhiteSpace(' ')
-                        REFERENCE_EXPRESSION
+                    VALUE_ARGUMENT
-                          PsiElement(IDENTIFIER)('a')
+                      REFERENCE_EXPRESSION
-                      PsiElement(RPAR)(')')
+                        PsiElement(IDENTIFIER)('d')
-            PsiWhiteSpace(' ')
+                    PsiElement(RPAR)(')')
-            PsiElement(ARROW)('->')
+          PsiWhiteSpace(' ')
-            PsiWhiteSpace(' ')
+          PsiElement(ARROW)('->')
-            REFERENCE_EXPRESSION
+          PsiWhiteSpace(' ')
-              PsiElement(IDENTIFIER)('a')
+          REFERENCE_EXPRESSION
-          PsiWhiteSpace('\n    ')
+            PsiElement(IDENTIFIER)('a')
-          WHEN_ENTRY
+        PsiWhiteSpace('\n    ')
-            WHEN_CONDITION_IS_PATTERN
+        WHEN_ENTRY
-              EXPRESSION_PATTERN
+          WHEN_CONDITION_IS_PATTERN
-                DOT_QUALIFIED_EXPRESSION
+            EXPRESSION_PATTERN
-                  REFERENCE_EXPRESSION
+              DOT_QUALIFIED_EXPRESSION
-                    PsiElement(IDENTIFIER)('a')
+                REFERENCE_EXPRESSION
-                  PsiElement(DOT)('.')
+                  PsiElement(IDENTIFIER)('a')
-                  CALL_EXPRESSION
+                PsiElement(DOT)('.')
-                    REFERENCE_EXPRESSION
+                FUNCTION_LITERAL_EXPRESSION
-                      PsiElement(IDENTIFIER)('foo')
+                  FUNCTION_LITERAL
-                    TYPE_ARGUMENT_LIST
+                    PsiElement(LBRACE)('{')
-                      PsiElement(LT)('<')
+                    BLOCK
-                      TYPE_PROJECTION
+                      REFERENCE_EXPRESSION
-                        TYPE_REFERENCE
+                        PsiElement(IDENTIFIER)('bar')
-                          USER_TYPE
+                    PsiElement(RBRACE)('}')
-                            REFERENCE_EXPRESSION
+          PsiWhiteSpace(' ')
-                              PsiElement(IDENTIFIER)('T')
+          PsiElement(ARROW)('->')
-                      PsiElement(GT)('>')
+          PsiWhiteSpace(' ')
-                    VALUE_ARGUMENT_LIST
+          REFERENCE_EXPRESSION
-                      PsiElement(LPAR)('(')
+            PsiElement(IDENTIFIER)('a')
-                      VALUE_ARGUMENT
+        PsiWhiteSpace('\n    ')
-                        REFERENCE_EXPRESSION
+        WHEN_ENTRY
-                          PsiElement(IDENTIFIER)('a')
+          WHEN_CONDITION_IS_PATTERN
-                      PsiElement(COMMA)(',')
+            EXPRESSION_PATTERN
-                      PsiWhiteSpace(' ')
+              DOT_QUALIFIED_EXPRESSION
-                      VALUE_ARGUMENT
+                REFERENCE_EXPRESSION
-                        REFERENCE_EXPRESSION
+                  PsiElement(IDENTIFIER)('a')
-                          PsiElement(IDENTIFIER)('d')
+                PsiElement(DOT)('.')
-                      PsiElement(RPAR)(')')
+                FUNCTION_LITERAL_EXPRESSION
-            PsiWhiteSpace(' ')
+                  FUNCTION_LITERAL
-            PsiElement(ARROW)('->')
+                    PsiElement(LBRACE)('{')
-            PsiWhiteSpace(' ')
+                    BLOCK
-            REFERENCE_EXPRESSION
+                      PREFIX_EXPRESSION
-              PsiElement(IDENTIFIER)('a')
+                        OPERATION_REFERENCE
-          PsiWhiteSpace('\n    ')
+                          PsiElement(EXCL)('!')
-          WHEN_ENTRY
-            WHEN_CONDITION_IS_PATTERN
-              EXPRESSION_PATTERN
-                DOT_QUALIFIED_EXPRESSION
-                  REFERENCE_EXPRESSION
-                    PsiElement(IDENTIFIER)('a')
-                  PsiElement(DOT)('.')
-                  FUNCTION_LITERAL_EXPRESSION
-                    FUNCTION_LITERAL
-                      PsiElement(LBRACE)('{')
-                      BLOCK
                         REFERENCE_EXPRESSION
                           PsiElement(IDENTIFIER)('bar')
-                      PsiElement(RBRACE)('}')
+                    PsiElement(RBRACE)('}')
-            PsiWhiteSpace(' ')
+          PsiWhiteSpace(' ')
-            PsiElement(ARROW)('->')
+          PsiElement(ARROW)('->')
-            PsiWhiteSpace(' ')
+          PsiWhiteSpace(' ')
-            REFERENCE_EXPRESSION
+          REFERENCE_EXPRESSION
-              PsiElement(IDENTIFIER)('a')
+            PsiElement(IDENTIFIER)('a')
-          PsiWhiteSpace('\n    ')
+        PsiWhiteSpace('\n    ')
-          WHEN_ENTRY
+        WHEN_ENTRY
-            WHEN_CONDITION_IS_PATTERN
+          WHEN_CONDITION_IS_PATTERN
-              EXPRESSION_PATTERN
+            EXPRESSION_PATTERN
-                DOT_QUALIFIED_EXPRESSION
+              DOT_QUALIFIED_EXPRESSION
-                  REFERENCE_EXPRESSION
+                REFERENCE_EXPRESSION
-                    PsiElement(IDENTIFIER)('a')
+                  PsiElement(IDENTIFIER)('a')
-                  PsiElement(DOT)('.')
+                PsiElement(DOT)('.')
-                  FUNCTION_LITERAL_EXPRESSION
+                FUNCTION_LITERAL_EXPRESSION
-                    FUNCTION_LITERAL
+                  FUNCTION_LITERAL
-                      PsiElement(LBRACE)('{')
+                    PsiElement(LBRACE)('{')
-                      BLOCK
+                    VALUE_PARAMETER_LIST
-                        PREFIX_EXPRESSION
+                      PsiElement(LPAR)('(')
-                          OPERATION_REFERENCE
+                      PsiElement(RPAR)(')')
-                            PsiElement(EXCL)('!')
+                    PsiWhiteSpace(' ')
-                          REFERENCE_EXPRESSION
+                    PsiElement(ARROW)('->')
-                            PsiElement(IDENTIFIER)('bar')
+                    PsiWhiteSpace(' ')
-                      PsiElement(RBRACE)('}')
+                    BLOCK
-            PsiWhiteSpace(' ')
+                      PREFIX_EXPRESSION
-            PsiElement(ARROW)('->')
+                        OPERATION_REFERENCE
-            PsiWhiteSpace(' ')
+                          PsiElement(EXCL)('!')
-            REFERENCE_EXPRESSION
+                        REFERENCE_EXPRESSION
-              PsiElement(IDENTIFIER)('a')
+                          PsiElement(IDENTIFIER)('bar')
-          PsiWhiteSpace('\n    ')
+                    PsiElement(RBRACE)('}')
-          WHEN_ENTRY
+          PsiWhiteSpace(' ')
-            WHEN_CONDITION_IS_PATTERN
+          PsiElement(ARROW)('->')
-              EXPRESSION_PATTERN
+          PsiWhiteSpace(' ')
-                DOT_QUALIFIED_EXPRESSION
+          REFERENCE_EXPRESSION
-                  REFERENCE_EXPRESSION
+            PsiElement(IDENTIFIER)('a')
-                    PsiElement(IDENTIFIER)('a')
+        PsiWhiteSpace('\n    ')
-                  PsiElement(DOT)('.')
+        WHEN_ENTRY
-                  FUNCTION_LITERAL_EXPRESSION
+          PsiElement(else)('else')
-                    FUNCTION_LITERAL
+          PsiWhiteSpace(' ')
-                      PsiElement(LBRACE)('{')
+          PsiElement(ARROW)('->')
-                      VALUE_PARAMETER_LIST
+          PsiWhiteSpace(' ')
-                        PsiElement(LPAR)('(')
+          REFERENCE_EXPRESSION
-                        PsiElement(RPAR)(')')
+            PsiElement(IDENTIFIER)('a')
-                      PsiWhiteSpace(' ')
+        PsiWhiteSpace('\n  ')
-                      PsiElement(ARROW)('->')
+        PsiElement(RBRACE)('}')
-                      PsiWhiteSpace(' ')
+      PsiWhiteSpace('\n')
-                      BLOCK
+      PsiElement(RBRACE)('}')
-                        PREFIX_EXPRESSION
-                          OPERATION_REFERENCE
-                            PsiElement(EXCL)('!')
-                          REFERENCE_EXPRESSION
-                            PsiElement(IDENTIFIER)('bar')
-                      PsiElement(RBRACE)('}')
-            PsiWhiteSpace(' ')
-            PsiElement(ARROW)('->')
-            PsiWhiteSpace(' ')
-            REFERENCE_EXPRESSION
-              PsiElement(IDENTIFIER)('a')
-          PsiWhiteSpace('\n    ')
-          WHEN_ENTRY
-            PsiElement(else)('else')
-            PsiWhiteSpace(' ')
-            PsiElement(ARROW)('->')
-            PsiWhiteSpace(' ')
-            REFERENCE_EXPRESSION
-              PsiElement(IDENTIFIER)('a')
-          PsiWhiteSpace('\n  ')
-          PsiElement(RBRACE)('}')
-        PsiWhiteSpace('\n')
-        PsiElement(RBRACE)('}')

compiler/testData/psi/Constructors.txt

@@ -1,233 +1,232 @@
 JetFile: Constructors.jet
-  NAMESPACE
+  NAMESPACE_HEADER
-    NAMESPACE_HEADER
+    <empty list>
+  CLASS
+    PsiElement(class)('class')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('foo')
+    PsiWhiteSpace(' ')
+    TYPE_PARAMETER_LIST
       <empty list>
-    CLASS
+    CLASS_BODY
-      PsiElement(class)('class')
+      PsiElement(LBRACE)('{')
-      PsiWhiteSpace(' ')
+      PsiWhiteSpace('\n\n    ')
-      PsiElement(IDENTIFIER)('foo')
+      CONSTRUCTOR
-      PsiWhiteSpace(' ')
+        PsiElement(this)('this')
-      TYPE_PARAMETER_LIST
+        VALUE_PARAMETER_LIST
-        <empty list>
+          PsiElement(LPAR)('(')
-      CLASS_BODY
+          PsiElement(RPAR)(')')
-        PsiElement(LBRACE)('{')
+        PsiWhiteSpace(' ')
-        PsiWhiteSpace('\n\n    ')
+        PsiElement(COLON)(':')
-        CONSTRUCTOR
+        PsiWhiteSpace(' ')
-          PsiElement(this)('this')
+        INITIALIZER_LIST
-          VALUE_PARAMETER_LIST
+          THIS_CALL
-            PsiElement(LPAR)('(')
+            THIS_CONSTRUCTOR_REFERENCE
-            PsiElement(RPAR)(')')
+              PsiElement(this)('this')
-          PsiWhiteSpace(' ')
+            VALUE_ARGUMENT_LIST
-          PsiElement(COLON)(':')
+              PsiElement(LPAR)('(')
-          PsiWhiteSpace(' ')
+              VALUE_ARGUMENT
-          INITIALIZER_LIST
+                REFERENCE_EXPRESSION
-            THIS_CALL
+                  PsiElement(IDENTIFIER)('a')
-              THIS_CONSTRUCTOR_REFERENCE
+              PsiElement(COMMA)(',')
-                PsiElement(this)('this')
-              VALUE_ARGUMENT_LIST
-                PsiElement(LPAR)('(')
-                VALUE_ARGUMENT
-                  REFERENCE_EXPRESSION
-                    PsiElement(IDENTIFIER)('a')
-                PsiElement(COMMA)(',')
-                PsiWhiteSpace(' ')
-                VALUE_ARGUMENT
-                  REFERENCE_EXPRESSION
-                    PsiElement(IDENTIFIER)('b')
-                PsiElement(COMMA)(',')
-                PsiWhiteSpace(' ')
-                VALUE_ARGUMENT
-                  REFERENCE_EXPRESSION
-                    PsiElement(IDENTIFIER)('c')
-                PsiElement(RPAR)(')')
-            PsiElement(COMMA)(',')
-            PsiWhiteSpace(' ')
-            DELEGATOR_SUPER_CALL
-              CONSTRUCTOR_CALLEE
-                TYPE_REFERENCE
-                  USER_TYPE
-                    REFERENCE_EXPRESSION
-                      PsiElement(IDENTIFIER)('Foo')
-                    TYPE_ARGUMENT_LIST
-                      PsiElement(LT)('<')
-                      TYPE_PROJECTION
-                        TYPE_REFERENCE
-                          USER_TYPE
-                            REFERENCE_EXPRESSION
-                              PsiElement(IDENTIFIER)('T')
-                      PsiElement(GT)('>')
-              VALUE_ARGUMENT_LIST
-                PsiElement(LPAR)('(')
-                VALUE_ARGUMENT
-                  REFERENCE_EXPRESSION
-                    PsiElement(IDENTIFIER)('bar')
-                PsiElement(RPAR)(')')
-        PsiWhiteSpace('\n\n    ')
-        CONSTRUCTOR
-          PsiElement(this)('this')
-          VALUE_PARAMETER_LIST
-            PsiElement(LPAR)('(')
-            VALUE_PARAMETER
-              PsiElement(IDENTIFIER)('foo')
               PsiWhiteSpace(' ')
-              PsiElement(COLON)(':')
+              VALUE_ARGUMENT
+                REFERENCE_EXPRESSION
+                  PsiElement(IDENTIFIER)('b')
+              PsiElement(COMMA)(',')
               PsiWhiteSpace(' ')
+              VALUE_ARGUMENT
+                REFERENCE_EXPRESSION
+                  PsiElement(IDENTIFIER)('c')
+              PsiElement(RPAR)(')')
+          PsiElement(COMMA)(',')
+          PsiWhiteSpace(' ')
+          DELEGATOR_SUPER_CALL
+            CONSTRUCTOR_CALLEE
               TYPE_REFERENCE
                 USER_TYPE
                   REFERENCE_EXPRESSION
-                    PsiElement(IDENTIFIER)('bar')
+                    PsiElement(IDENTIFIER)('Foo')
-            PsiElement(RPAR)(')')
+                  TYPE_ARGUMENT_LIST
-          PsiWhiteSpace(' ')
+                    PsiElement(LT)('<')
-          PsiElement(COLON)(':')
+                    TYPE_PROJECTION
-          PsiWhiteSpace(' ')
+                      TYPE_REFERENCE
-          INITIALIZER_LIST
+                        USER_TYPE
-            THIS_CALL
+                          REFERENCE_EXPRESSION
-              THIS_CONSTRUCTOR_REFERENCE
+                            PsiElement(IDENTIFIER)('T')
-                PsiElement(this)('this')
+                    PsiElement(GT)('>')
-              VALUE_ARGUMENT_LIST
+            VALUE_ARGUMENT_LIST
-                PsiElement(LPAR)('(')
+              PsiElement(LPAR)('(')
-                VALUE_ARGUMENT
+              VALUE_ARGUMENT
-                  REFERENCE_EXPRESSION
+                REFERENCE_EXPRESSION
-                    PsiElement(IDENTIFIER)('a')
+                  PsiElement(IDENTIFIER)('bar')
-                PsiElement(COMMA)(',')
+              PsiElement(RPAR)(')')
-                PsiWhiteSpace(' ')
+      PsiWhiteSpace('\n\n    ')
-                VALUE_ARGUMENT
+      CONSTRUCTOR
-                  REFERENCE_EXPRESSION
+        PsiElement(this)('this')
-                    PsiElement(IDENTIFIER)('b')
+        VALUE_PARAMETER_LIST
-                PsiElement(COMMA)(',')
+          PsiElement(LPAR)('(')
-                PsiWhiteSpace(' ')
+          VALUE_PARAMETER
-                VALUE_ARGUMENT
+            PsiElement(IDENTIFIER)('foo')
-                  REFERENCE_EXPRESSION
-                    PsiElement(IDENTIFIER)('c')
-                PsiElement(RPAR)(')')
-            PsiElement(COMMA)(',')
             PsiWhiteSpace(' ')
-            DELEGATOR_SUPER_CALL
+            PsiElement(COLON)(':')
-              CONSTRUCTOR_CALLEE
+            PsiWhiteSpace(' ')
-                TYPE_REFERENCE
+            TYPE_REFERENCE
-                  USER_TYPE
+              USER_TYPE
-                    REFERENCE_EXPRESSION
+                REFERENCE_EXPRESSION
-                      PsiElement(IDENTIFIER)('Foo')
+                  PsiElement(IDENTIFIER)('bar')
-                    TYPE_ARGUMENT_LIST
+          PsiElement(RPAR)(')')
-                      PsiElement(LT)('<')
+        PsiWhiteSpace(' ')
-                      TYPE_PROJECTION
+        PsiElement(COLON)(':')
-                        TYPE_REFERENCE
+        PsiWhiteSpace(' ')
-                          USER_TYPE
+        INITIALIZER_LIST
-                            REFERENCE_EXPRESSION
+          THIS_CALL
-                              PsiElement(IDENTIFIER)('T')
+            THIS_CONSTRUCTOR_REFERENCE
-                      PsiElement(GT)('>')
+              PsiElement(this)('this')
-              VALUE_ARGUMENT_LIST
+            VALUE_ARGUMENT_LIST
-                PsiElement(LPAR)('(')
+              PsiElement(LPAR)('(')
-                VALUE_ARGUMENT
+              VALUE_ARGUMENT
-                  REFERENCE_EXPRESSION
+                REFERENCE_EXPRESSION
-                    PsiElement(IDENTIFIER)('bar')
+                  PsiElement(IDENTIFIER)('a')
-                PsiElement(RPAR)(')')
+              PsiElement(COMMA)(',')
+              PsiWhiteSpace(' ')
+              VALUE_ARGUMENT
+                REFERENCE_EXPRESSION
+                  PsiElement(IDENTIFIER)('b')
+              PsiElement(COMMA)(',')
+              PsiWhiteSpace(' ')
+              VALUE_ARGUMENT
+                REFERENCE_EXPRESSION
+                  PsiElement(IDENTIFIER)('c')
+              PsiElement(RPAR)(')')
+          PsiElement(COMMA)(',')
           PsiWhiteSpace(' ')
-          BLOCK
+          DELEGATOR_SUPER_CALL
-            PsiElement(LBRACE)('{')
+            CONSTRUCTOR_CALLEE
-            PsiWhiteSpace('\n\n    ')
+              TYPE_REFERENCE
-            PsiElement(RBRACE)('}')
+                USER_TYPE
-        PsiWhiteSpace('\n\n')
+                  REFERENCE_EXPRESSION
-        PsiElement(RBRACE)('}')
+                    PsiElement(IDENTIFIER)('Foo')
-    PsiWhiteSpace('\n\n')
+                  TYPE_ARGUMENT_LIST
-    CLASS
+                    PsiElement(LT)('<')
-      MODIFIER_LIST
+                    TYPE_PROJECTION
-        PsiElement(public)('public')
+                      TYPE_REFERENCE
-      PsiWhiteSpace(' ')
+                        USER_TYPE
-      PsiElement(class)('class')
+                          REFERENCE_EXPRESSION
-      PsiWhiteSpace(' ')
+                            PsiElement(IDENTIFIER)('T')
-      PsiElement(IDENTIFIER)('foo')
+                    PsiElement(GT)('>')
-      TYPE_PARAMETER_LIST
+            VALUE_ARGUMENT_LIST
-        <empty list>
+              PsiElement(LPAR)('(')
-      VALUE_PARAMETER_LIST
+              VALUE_ARGUMENT
-        PsiElement(LPAR)('(')
+                REFERENCE_EXPRESSION
-        PsiElement(RPAR)(')')
+                  PsiElement(IDENTIFIER)('bar')
-      PsiWhiteSpace(' ')
+              PsiElement(RPAR)(')')
-      PsiElement(COLON)(':')
+        PsiWhiteSpace(' ')
-      PsiWhiteSpace(' ')
+        BLOCK
-      DELEGATION_SPECIFIER_LIST
+          PsiElement(LBRACE)('{')
-        DELEGATOR_SUPER_CLASS
+          PsiWhiteSpace('\n\n    ')
-          TYPE_REFERENCE
+          PsiElement(RBRACE)('}')
-            USER_TYPE
+      PsiWhiteSpace('\n\n')
-              REFERENCE_EXPRESSION
+      PsiElement(RBRACE)('}')
-                PsiElement(IDENTIFIER)('Bar')
+  PsiWhiteSpace('\n\n')
-    PsiWhiteSpace('\n')
+  CLASS
-    CLASS
+    MODIFIER_LIST
-      MODIFIER_LIST
+      PsiElement(public)('public')
-        PsiElement(protected)('protected')
+    PsiWhiteSpace(' ')
-      PsiWhiteSpace(' ')
+    PsiElement(class)('class')
-      PsiElement(class)('class')
+    PsiWhiteSpace(' ')
-      PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('foo')
-      PsiElement(IDENTIFIER)('foo')
+    TYPE_PARAMETER_LIST
-      PsiWhiteSpace(' ')
+      <empty list>
-      TYPE_PARAMETER_LIST
+    VALUE_PARAMETER_LIST
-        <empty list>
+      PsiElement(LPAR)('(')
-      PRIMARY_CONSTRUCTOR_MODIFIER_LIST
+      PsiElement(RPAR)(')')
-        PsiElement(private)('private')
+    PsiWhiteSpace(' ')
-      PsiWhiteSpace(' ')
+    PsiElement(COLON)(':')
-      VALUE_PARAMETER_LIST
+    PsiWhiteSpace(' ')
-        PsiElement(LPAR)('(')
+    DELEGATION_SPECIFIER_LIST
-        PsiElement(RPAR)(')')
+      DELEGATOR_SUPER_CLASS
-      PsiWhiteSpace(' ')
+        TYPE_REFERENCE
-      PsiElement(COLON)(':')
+          USER_TYPE
-      PsiWhiteSpace(' ')
+            REFERENCE_EXPRESSION
-      DELEGATION_SPECIFIER_LIST
+              PsiElement(IDENTIFIER)('Bar')
-        DELEGATOR_SUPER_CLASS
+  PsiWhiteSpace('\n')
-          TYPE_REFERENCE
+  CLASS
-            USER_TYPE
+    MODIFIER_LIST
-              REFERENCE_EXPRESSION
+      PsiElement(protected)('protected')
-                PsiElement(IDENTIFIER)('Bar')
+    PsiWhiteSpace(' ')
-    PsiWhiteSpace('\n')
+    PsiElement(class)('class')
-    CLASS
+    PsiWhiteSpace(' ')
-      MODIFIER_LIST
+    PsiElement(IDENTIFIER)('foo')
-        PsiElement(private)('private')
+    PsiWhiteSpace(' ')
-      PsiWhiteSpace(' ')
+    TYPE_PARAMETER_LIST
-      PsiElement(class)('class')
+      <empty list>
-      PsiWhiteSpace(' ')
+    PRIMARY_CONSTRUCTOR_MODIFIER_LIST
-      PsiElement(IDENTIFIER)('foo')
+      PsiElement(private)('private')
-      TYPE_PARAMETER_LIST
+    PsiWhiteSpace(' ')
-        PsiElement(LT)('<')
+    VALUE_PARAMETER_LIST
-        TYPE_PARAMETER
+      PsiElement(LPAR)('(')
-          PsiElement(IDENTIFIER)('T')
+      PsiElement(RPAR)(')')
-        PsiElement(GT)('>')
+    PsiWhiteSpace(' ')
-      VALUE_PARAMETER_LIST
+    PsiElement(COLON)(':')
-        PsiElement(LPAR)('(')
+    PsiWhiteSpace(' ')
-        PsiElement(RPAR)(')')
+    DELEGATION_SPECIFIER_LIST
-      PsiWhiteSpace(' ')
+      DELEGATOR_SUPER_CLASS
-      PsiElement(COLON)(':')
+        TYPE_REFERENCE
-      PsiWhiteSpace(' ')
+          USER_TYPE
-      DELEGATION_SPECIFIER_LIST
+            REFERENCE_EXPRESSION
-        DELEGATOR_SUPER_CLASS
+              PsiElement(IDENTIFIER)('Bar')
-          TYPE_REFERENCE
+  PsiWhiteSpace('\n')
-            USER_TYPE
+  CLASS
-              REFERENCE_EXPRESSION
+    MODIFIER_LIST
-                PsiElement(IDENTIFIER)('Bar')
+      PsiElement(private)('private')
-    PsiWhiteSpace('\n')
+    PsiWhiteSpace(' ')
-    CLASS
+    PsiElement(class)('class')
-      MODIFIER_LIST
+    PsiWhiteSpace(' ')
-        PsiElement(internal)('internal')
+    PsiElement(IDENTIFIER)('foo')
-      PsiWhiteSpace(' ')
+    TYPE_PARAMETER_LIST
-      PsiElement(class)('class')
+      PsiElement(LT)('<')
-      PsiWhiteSpace(' ')
+      TYPE_PARAMETER
-      PsiElement(IDENTIFIER)('foo')
+        PsiElement(IDENTIFIER)('T')
-      TYPE_PARAMETER_LIST
+      PsiElement(GT)('>')
-        PsiElement(LT)('<')
+    VALUE_PARAMETER_LIST
-        TYPE_PARAMETER
+      PsiElement(LPAR)('(')
-          PsiElement(IDENTIFIER)('T')
+      PsiElement(RPAR)(')')
-        PsiElement(GT)('>')
+    PsiWhiteSpace(' ')
-      PsiWhiteSpace(' ')
+    PsiElement(COLON)(':')
-      PRIMARY_CONSTRUCTOR_MODIFIER_LIST
+    PsiWhiteSpace(' ')
-        PsiElement(private)('private')
+    DELEGATION_SPECIFIER_LIST
-      PsiWhiteSpace(' ')
+      DELEGATOR_SUPER_CLASS
-      VALUE_PARAMETER_LIST
+        TYPE_REFERENCE
-        PsiElement(LPAR)('(')
+          USER_TYPE
-        PsiElement(RPAR)(')')
+            REFERENCE_EXPRESSION
-      PsiWhiteSpace(' ')
+              PsiElement(IDENTIFIER)('Bar')
-      PsiElement(COLON)(':')
+  PsiWhiteSpace('\n')
-      PsiWhiteSpace(' ')
+  CLASS
-      DELEGATION_SPECIFIER_LIST
+    MODIFIER_LIST
-        DELEGATOR_SUPER_CLASS
+      PsiElement(internal)('internal')
-          TYPE_REFERENCE
+    PsiWhiteSpace(' ')
-            USER_TYPE
+    PsiElement(class)('class')
-              REFERENCE_EXPRESSION
+    PsiWhiteSpace(' ')
-                PsiElement(IDENTIFIER)('Bar')
+    PsiElement(IDENTIFIER)('foo')
+    TYPE_PARAMETER_LIST
+      PsiElement(LT)('<')
+      TYPE_PARAMETER
+        PsiElement(IDENTIFIER)('T')
+      PsiElement(GT)('>')
+    PsiWhiteSpace(' ')
+    PRIMARY_CONSTRUCTOR_MODIFIER_LIST
+      PsiElement(private)('private')
+    PsiWhiteSpace(' ')
+    VALUE_PARAMETER_LIST
+      PsiElement(LPAR)('(')
+      PsiElement(RPAR)(')')
+    PsiWhiteSpace(' ')
+    PsiElement(COLON)(':')
+    PsiWhiteSpace(' ')
+    DELEGATION_SPECIFIER_LIST
+      DELEGATOR_SUPER_CLASS
+        TYPE_REFERENCE
+          USER_TYPE
+            REFERENCE_EXPRESSION
+              PsiElement(IDENTIFIER)('Bar')

compiler/testData/psi/EOLsInComments.txt

@@ -1,108 +1,107 @@
 JetFile: EOLsInComments.jet
-  NAMESPACE
+  NAMESPACE_HEADER
-    NAMESPACE_HEADER
+    <empty list>
-      <empty list>
+  FUN
-    FUN
+    PsiElement(fun)('fun')
-      PsiElement(fun)('fun')
+    PsiWhiteSpace(' ')
-      PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('foo')
-      PsiElement(IDENTIFIER)('foo')
+    VALUE_PARAMETER_LIST
-      VALUE_PARAMETER_LIST
+      PsiElement(LPAR)('(')
-        PsiElement(LPAR)('(')
+      PsiElement(RPAR)(')')
-        PsiElement(RPAR)(')')
+    PsiWhiteSpace(' ')
-      PsiWhiteSpace(' ')
+    BLOCK
-      BLOCK
+      PsiElement(LBRACE)('{')
-        PsiElement(LBRACE)('{')
+      PsiWhiteSpace('\n  ')
-        PsiWhiteSpace('\n  ')
+      REFERENCE_EXPRESSION
+        PsiElement(IDENTIFIER)('a')
+      PsiWhiteSpace('\n  ')
+      PREFIX_EXPRESSION
+        OPERATION_REFERENCE
+          PsiElement(PLUS)('+')
+        PsiWhiteSpace(' ')
+        REFERENCE_EXPRESSION
+          PsiElement(IDENTIFIER)('b')
+      PsiWhiteSpace('\n  ')
+      REFERENCE_EXPRESSION
+        PsiElement(IDENTIFIER)('a')
+      PsiWhiteSpace('\n  ')
+      PsiComment(DOC_COMMENT)('/** */')
+      PREFIX_EXPRESSION
+        OPERATION_REFERENCE
+          PsiElement(PLUS)('+')
+        PsiWhiteSpace(' ')
+        REFERENCE_EXPRESSION
+          PsiElement(IDENTIFIER)('b')
+      PsiWhiteSpace('\n  ')
+      REFERENCE_EXPRESSION
+        PsiElement(IDENTIFIER)('a')
+      PsiWhiteSpace('\n  ')
+      PsiComment(BLOCK_COMMENT)('/* */')
+      PREFIX_EXPRESSION
+        OPERATION_REFERENCE
+          PsiElement(PLUS)('+')
+        PsiWhiteSpace(' ')
+        REFERENCE_EXPRESSION
+          PsiElement(IDENTIFIER)('b')
+      PsiWhiteSpace('\n  ')
+      BINARY_EXPRESSION
         REFERENCE_EXPRESSION
           PsiElement(IDENTIFIER)('a')
-        PsiWhiteSpace('\n  ')
+        PsiWhiteSpace(' ')
-        PREFIX_EXPRESSION
-          OPERATION_REFERENCE
-            PsiElement(PLUS)('+')
-          PsiWhiteSpace(' ')
-          REFERENCE_EXPRESSION
-            PsiElement(IDENTIFIER)('b')
-        PsiWhiteSpace('\n  ')
-        REFERENCE_EXPRESSION
-          PsiElement(IDENTIFIER)('a')
-        PsiWhiteSpace('\n  ')
-        PsiComment(DOC_COMMENT)('/** */')
-        PREFIX_EXPRESSION
-          OPERATION_REFERENCE
-            PsiElement(PLUS)('+')
-          PsiWhiteSpace(' ')
-          REFERENCE_EXPRESSION
-            PsiElement(IDENTIFIER)('b')
-        PsiWhiteSpace('\n  ')
-        REFERENCE_EXPRESSION
-          PsiElement(IDENTIFIER)('a')
-        PsiWhiteSpace('\n  ')
-        PsiComment(BLOCK_COMMENT)('/* */')
-        PREFIX_EXPRESSION
-          OPERATION_REFERENCE
-            PsiElement(PLUS)('+')
-          PsiWhiteSpace(' ')
-          REFERENCE_EXPRESSION
-            PsiElement(IDENTIFIER)('b')
-        PsiWhiteSpace('\n  ')
-        BINARY_EXPRESSION
-          REFERENCE_EXPRESSION
-            PsiElement(IDENTIFIER)('a')
-          PsiWhiteSpace(' ')
-          PsiComment(BLOCK_COMMENT)('/*\n  */')
-          PsiWhiteSpace('  ')
-          OPERATION_REFERENCE
-            PsiElement(PLUS)('+')
-          PsiWhiteSpace(' ')
-          REFERENCE_EXPRESSION
-            PsiElement(IDENTIFIER)('b')
-        PsiWhiteSpace('\n  ')
-        REFERENCE_EXPRESSION
-          PsiElement(IDENTIFIER)('a')
-        PsiWhiteSpace('\n  ')
         PsiComment(BLOCK_COMMENT)('/*\n  */')
         PsiWhiteSpace('  ')
-        PREFIX_EXPRESSION
+        OPERATION_REFERENCE
-          OPERATION_REFERENCE
+          PsiElement(PLUS)('+')
-            PsiElement(PLUS)('+')
+        PsiWhiteSpace(' ')
-          PsiWhiteSpace(' ')
+        REFERENCE_EXPRESSION
-          REFERENCE_EXPRESSION
+          PsiElement(IDENTIFIER)('b')
-            PsiElement(IDENTIFIER)('b')
+      PsiWhiteSpace('\n  ')
-        PsiWhiteSpace('\n  ')
+      REFERENCE_EXPRESSION
-        BINARY_EXPRESSION
+        PsiElement(IDENTIFIER)('a')
-          REFERENCE_EXPRESSION
+      PsiWhiteSpace('\n  ')
-            PsiElement(IDENTIFIER)('a')
+      PsiComment(BLOCK_COMMENT)('/*\n  */')
-          PsiWhiteSpace(' ')
+      PsiWhiteSpace('  ')
-          PsiComment(DOC_COMMENT)('/**\n  */')
+      PREFIX_EXPRESSION
-          PsiWhiteSpace('  ')
+        OPERATION_REFERENCE
-          OPERATION_REFERENCE
+          PsiElement(PLUS)('+')
-            PsiElement(PLUS)('+')
+        PsiWhiteSpace(' ')
-          PsiWhiteSpace(' ')
+        REFERENCE_EXPRESSION
-          REFERENCE_EXPRESSION
+          PsiElement(IDENTIFIER)('b')
-            PsiElement(IDENTIFIER)('b')
+      PsiWhiteSpace('\n  ')
-        PsiWhiteSpace('\n  ')
+      BINARY_EXPRESSION
         REFERENCE_EXPRESSION
           PsiElement(IDENTIFIER)('a')
         PsiWhiteSpace(' ')
-        PsiComment(EOL_COMMENT)('//')
+        PsiComment(DOC_COMMENT)('/**\n  */')
-        PsiWhiteSpace('\n  ')
+        PsiWhiteSpace('  ')
-        PREFIX_EXPRESSION
+        OPERATION_REFERENCE
-          OPERATION_REFERENCE
+          PsiElement(PLUS)('+')
-            PsiElement(PLUS)('+')
-          PsiWhiteSpace(' ')
-          REFERENCE_EXPRESSION
-            PsiElement(IDENTIFIER)('b')
-        PsiWhiteSpace('\n  ')
-        REFERENCE_EXPRESSION
-          PsiElement(IDENTIFIER)('a')
         PsiWhiteSpace(' ')
-        PsiComment(EOL_COMMENT)('//')
+        REFERENCE_EXPRESSION
-        PsiWhiteSpace('\n')
+          PsiElement(IDENTIFIER)('b')
-        PREFIX_EXPRESSION
+      PsiWhiteSpace('\n  ')
-          OPERATION_REFERENCE
+      REFERENCE_EXPRESSION
-            PsiElement(PLUS)('+')
+        PsiElement(IDENTIFIER)('a')
-          PsiWhiteSpace(' ')
+      PsiWhiteSpace(' ')
-          REFERENCE_EXPRESSION
+      PsiComment(EOL_COMMENT)('//')
-            PsiElement(IDENTIFIER)('b')
+      PsiWhiteSpace('\n  ')
-        PsiWhiteSpace('\n')
+      PREFIX_EXPRESSION
-        PsiElement(RBRACE)('}')
+        OPERATION_REFERENCE
+          PsiElement(PLUS)('+')
+        PsiWhiteSpace(' ')
+        REFERENCE_EXPRESSION
+          PsiElement(IDENTIFIER)('b')
+      PsiWhiteSpace('\n  ')
+      REFERENCE_EXPRESSION
+        PsiElement(IDENTIFIER)('a')
+      PsiWhiteSpace(' ')
+      PsiComment(EOL_COMMENT)('//')
+      PsiWhiteSpace('\n')
+      PREFIX_EXPRESSION
+        OPERATION_REFERENCE
+          PsiElement(PLUS)('+')
+        PsiWhiteSpace(' ')
+        REFERENCE_EXPRESSION
+          PsiElement(IDENTIFIER)('b')
+      PsiWhiteSpace('\n')
+      PsiElement(RBRACE)('}')

compiler/testData/psi/EOLsOnRollback.txt

@@ -1,97 +1,96 @@
 JetFile: EOLsOnRollback.jet
-  NAMESPACE
+  NAMESPACE_HEADER
-    NAMESPACE_HEADER
+    <empty list>
-      <empty list>
+  FUN
-    FUN
+    PsiElement(fun)('fun')
-      PsiElement(fun)('fun')
+    PsiWhiteSpace(' ')
-      PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('foo')
-      PsiElement(IDENTIFIER)('foo')
+    VALUE_PARAMETER_LIST
-      VALUE_PARAMETER_LIST
+      PsiElement(LPAR)('(')
-        PsiElement(LPAR)('(')
+      PsiElement(RPAR)(')')
-        PsiElement(RPAR)(')')
+    PsiWhiteSpace(' ')
-      PsiWhiteSpace(' ')
+    BLOCK
-      BLOCK
+      PsiElement(LBRACE)('{')
-        PsiElement(LBRACE)('{')
+      PsiWhiteSpace('\n    ')
+      CLASS
+        PsiElement(class)('class')
+        PsiWhiteSpace(' ')
+        PsiElement(IDENTIFIER)('foo')
         PsiWhiteSpace('\n    ')
-        CLASS
+        TYPE_PARAMETER_LIST
-          PsiElement(class)('class')
+          <empty list>
-          PsiWhiteSpace(' ')
+      FUN
-          PsiElement(IDENTIFIER)('foo')
+        PsiElement(fun)('fun')
-          PsiWhiteSpace('\n    ')
+        PsiWhiteSpace(' ')
-          TYPE_PARAMETER_LIST
+        PsiElement(IDENTIFIER)('foo')
-            <empty list>
+        VALUE_PARAMETER_LIST
-        FUN
+          PsiElement(LPAR)('(')
-          PsiElement(fun)('fun')
+          PsiElement(RPAR)(')')
-          PsiWhiteSpace(' ')
+      PsiWhiteSpace('\n    ')
-          PsiElement(IDENTIFIER)('foo')
+      CLASS
-          VALUE_PARAMETER_LIST
+        PsiElement(class)('class')
-            PsiElement(LPAR)('(')
+        PsiWhiteSpace(' ')
-            PsiElement(RPAR)(')')
+        PsiElement(IDENTIFIER)('foo')
-        PsiWhiteSpace('\n    ')
-        CLASS
-          PsiElement(class)('class')
-          PsiWhiteSpace(' ')
-          PsiElement(IDENTIFIER)('foo')
-          PsiWhiteSpace('\n\n    ')
-          TYPE_PARAMETER_LIST
-            <empty list>
-        TYPEDEF
-          PsiElement(type)('type')
-          PsiWhiteSpace(' ')
-          PsiElement(IDENTIFIER)('x')
-          PsiWhiteSpace(' ')
-          TYPE_PARAMETER_LIST
-            <empty list>
-          PsiElement(EQ)('=')
-          PsiWhiteSpace(' ')
-          TYPE_REFERENCE
-            USER_TYPE
-              REFERENCE_EXPRESSION
-                PsiElement(IDENTIFIER)('t')
-        PsiWhiteSpace('\n    ')
-        PROPERTY
-          PsiElement(var)('var')
-          PsiWhiteSpace(' ')
-          PsiElement(IDENTIFIER)('r')
-        PsiWhiteSpace('\n\n    ')
-        PROPERTY
-          MODIFIER_LIST
-            ANNOTATION
-              PsiElement(LBRACKET)('[')
-              ANNOTATION_ENTRY
-                CONSTRUCTOR_CALLEE
-                  TYPE_REFERENCE
-                    USER_TYPE
-                      REFERENCE_EXPRESSION
-                        PsiElement(IDENTIFIER)('a')
-              PsiElement(RBRACKET)(']')
-          PsiWhiteSpace(' ')
-          PsiElement(var)('var')
-          PsiWhiteSpace(' ')
-          PsiElement(IDENTIFIER)('foo')
-          PsiWhiteSpace(' ')
-          PsiElement(EQ)('=')
-          PsiWhiteSpace(' ')
-          INTEGER_CONSTANT
-            PsiElement(INTEGER_LITERAL)('4')
         PsiWhiteSpace('\n\n    ')
+        TYPE_PARAMETER_LIST
+          <empty list>
+      TYPEDEF
+        PsiElement(type)('type')
+        PsiWhiteSpace(' ')
+        PsiElement(IDENTIFIER)('x')
+        PsiWhiteSpace(' ')
+        TYPE_PARAMETER_LIST
+          <empty list>
+        PsiElement(EQ)('=')
+        PsiWhiteSpace(' ')
+        TYPE_REFERENCE
+          USER_TYPE
+            REFERENCE_EXPRESSION
+              PsiElement(IDENTIFIER)('t')
+      PsiWhiteSpace('\n    ')
+      PROPERTY
+        PsiElement(var)('var')
+        PsiWhiteSpace(' ')
+        PsiElement(IDENTIFIER)('r')
+      PsiWhiteSpace('\n\n    ')
+      PROPERTY
+        MODIFIER_LIST
+          ANNOTATION
+            PsiElement(LBRACKET)('[')
+            ANNOTATION_ENTRY
+              CONSTRUCTOR_CALLEE
+                TYPE_REFERENCE
+                  USER_TYPE
+                    REFERENCE_EXPRESSION
+                      PsiElement(IDENTIFIER)('a')
+            PsiElement(RBRACKET)(']')
+        PsiWhiteSpace(' ')
+        PsiElement(var)('var')
+        PsiWhiteSpace(' ')
+        PsiElement(IDENTIFIER)('foo')
+        PsiWhiteSpace(' ')
+        PsiElement(EQ)('=')
+        PsiWhiteSpace(' ')
         INTEGER_CONSTANT
-          PsiElement(INTEGER_LITERAL)('1')
+          PsiElement(INTEGER_LITERAL)('4')
-        PsiWhiteSpace('\n    ')
+      PsiWhiteSpace('\n\n    ')
-        PROPERTY
+      INTEGER_CONSTANT
-          MODIFIER_LIST
+        PsiElement(INTEGER_LITERAL)('1')
-            ANNOTATION
+      PsiWhiteSpace('\n    ')
-              PsiElement(LBRACKET)('[')
+      PROPERTY
-              ANNOTATION_ENTRY
+        MODIFIER_LIST
-                CONSTRUCTOR_CALLEE
+          ANNOTATION
-                  TYPE_REFERENCE
+            PsiElement(LBRACKET)('[')
-                    USER_TYPE
+            ANNOTATION_ENTRY
-                      REFERENCE_EXPRESSION
+              CONSTRUCTOR_CALLEE
-                        PsiElement(IDENTIFIER)('a')
+                TYPE_REFERENCE
-              PsiElement(RBRACKET)(']')
+                  USER_TYPE
-          PsiWhiteSpace(' ')
+                    REFERENCE_EXPRESSION
-          PsiElement(val)('val')
+                      PsiElement(IDENTIFIER)('a')
-          PsiWhiteSpace(' ')
+            PsiElement(RBRACKET)(']')
-          PsiElement(IDENTIFIER)('f')
+        PsiWhiteSpace(' ')
-        PsiWhiteSpace('\n')
+        PsiElement(val)('val')
-        PsiElement(RBRACE)('}')
+        PsiWhiteSpace(' ')
+        PsiElement(IDENTIFIER)('f')
+      PsiWhiteSpace('\n')
+      PsiElement(RBRACE)('}')

compiler/testData/psi/EmptyFile.txt

@@ -1,4 +1,3 @@
 JetFile: EmptyFile.jet
-  NAMESPACE
+  NAMESPACE_HEADER
-    NAMESPACE_HEADER
+    <empty list>
-      <empty list>

compiler/testData/psi/Enums.txt

@@ -1,195 +1,213 @@
 JetFile: Enums.jet
-  NAMESPACE
+  NAMESPACE_HEADER
-    NAMESPACE_HEADER
+    <empty list>
+  CLASS
+    MODIFIER_LIST
+      PsiElement(enum)('enum')
+    PsiWhiteSpace(' ')
+    PsiElement(class)('class')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('Color')
+    TYPE_PARAMETER_LIST
       <empty list>
-    CLASS
+    VALUE_PARAMETER_LIST
-      MODIFIER_LIST
+      PsiElement(LPAR)('(')
-        PsiElement(enum)('enum')
+      VALUE_PARAMETER
-      PsiWhiteSpace(' ')
+        PsiElement(val)('val')
-      PsiElement(class)('class')
+        PsiWhiteSpace(' ')
-      PsiWhiteSpace(' ')
+        PsiElement(IDENTIFIER)('rgb')
-      PsiElement(IDENTIFIER)('Color')
+        PsiWhiteSpace(' ')
-      TYPE_PARAMETER_LIST
+        PsiElement(COLON)(':')
-        <empty list>
+        PsiWhiteSpace(' ')
-      VALUE_PARAMETER_LIST
+        TYPE_REFERENCE
-        PsiElement(LPAR)('(')
+          USER_TYPE
-        VALUE_PARAMETER
+            REFERENCE_EXPRESSION
-          PsiElement(val)('val')
+              PsiElement(IDENTIFIER)('Int')
-          PsiWhiteSpace(' ')
+      PsiElement(RPAR)(')')
-          PsiElement(IDENTIFIER)('rgb')
+    PsiWhiteSpace(' ')
-          PsiWhiteSpace(' ')
+    CLASS_BODY
-          PsiElement(COLON)(':')
+      PsiElement(LBRACE)('{')
-          PsiWhiteSpace(' ')
+      PsiWhiteSpace('\n    ')
-          TYPE_REFERENCE
+      ENUM_ENTRY
-            USER_TYPE
+        OBJECT_DECLARATION_NAME
-              REFERENCE_EXPRESSION
+          PsiElement(IDENTIFIER)('RED')
-                PsiElement(IDENTIFIER)('Int')
+        PsiWhiteSpace(' ')
-        PsiElement(RPAR)(')')
+        TYPE_PARAMETER_LIST
-      PsiWhiteSpace(' ')
+          <empty list>
-      CLASS_BODY
+        PsiElement(COLON)(':')
-        PsiElement(LBRACE)('{')
+        PsiWhiteSpace(' ')
-        PsiWhiteSpace('\n    ')
+        INITIALIZER_LIST
-        ENUM_ENTRY
+          DELEGATOR_SUPER_CALL
-          OBJECT_DECLARATION_NAME
+            CONSTRUCTOR_CALLEE
-            PsiElement(IDENTIFIER)('RED')
-          PsiWhiteSpace(' ')
-          TYPE_PARAMETER_LIST
-            <empty list>
-          PsiElement(COLON)(':')
-          PsiWhiteSpace(' ')
-          INITIALIZER_LIST
-            DELEGATOR_SUPER_CALL
-              CONSTRUCTOR_CALLEE
-                TYPE_REFERENCE
-                  USER_TYPE
-                    REFERENCE_EXPRESSION
-                      PsiElement(IDENTIFIER)('Color')
-              VALUE_ARGUMENT_LIST
-                PsiElement(LPAR)('(')
-                VALUE_ARGUMENT
-                  INTEGER_CONSTANT
-                    PsiElement(INTEGER_LITERAL)('0xFF000')
-                PsiElement(RPAR)(')')
-        PsiWhiteSpace('\n    ')
-        ENUM_ENTRY
-          OBJECT_DECLARATION_NAME
-            PsiElement(IDENTIFIER)('GREEN')
-          PsiWhiteSpace(' ')
-          TYPE_PARAMETER_LIST
-            <empty list>
-          PsiElement(COLON)(':')
-          PsiWhiteSpace(' ')
-          INITIALIZER_LIST
-            DELEGATOR_SUPER_CALL
-              CONSTRUCTOR_CALLEE
-                TYPE_REFERENCE
-                  USER_TYPE
-                    REFERENCE_EXPRESSION
-                      PsiElement(IDENTIFIER)('Color')
-              VALUE_ARGUMENT_LIST
-                PsiElement(LPAR)('(')
-                VALUE_ARGUMENT
-                  INTEGER_CONSTANT
-                    PsiElement(INTEGER_LITERAL)('0x00FF00')
-                PsiElement(RPAR)(')')
-        PsiWhiteSpace('\n    ')
-        ENUM_ENTRY
-          OBJECT_DECLARATION_NAME
-            PsiElement(IDENTIFIER)('BLUE')
-          PsiWhiteSpace(' ')
-          TYPE_PARAMETER_LIST
-            <empty list>
-          PsiElement(COLON)(':')
-          PsiWhiteSpace(' ')
-          INITIALIZER_LIST
-            DELEGATOR_SUPER_CALL
-              CONSTRUCTOR_CALLEE
-                TYPE_REFERENCE
-                  USER_TYPE
-                    REFERENCE_EXPRESSION
-                      PsiElement(IDENTIFIER)('Color')
-              VALUE_ARGUMENT_LIST
-                PsiElement(LPAR)('(')
-                VALUE_ARGUMENT
-                  INTEGER_CONSTANT
-                    PsiElement(INTEGER_LITERAL)('0x0000FF')
-                PsiElement(RPAR)(')')
-        PsiWhiteSpace('\n')
-        PsiElement(RBRACE)('}')
-    PsiWhiteSpace('\n\n')
-    CLASS
-      MODIFIER_LIST
-        PsiElement(enum)('enum')
-      PsiWhiteSpace(' ')
-      PsiElement(class)('class')
-      PsiWhiteSpace(' ')
-      PsiElement(IDENTIFIER)('List')
-      TYPE_PARAMETER_LIST
-        PsiElement(LT)('<')
-        TYPE_PARAMETER
-          MODIFIER_LIST
-            PsiElement(out)('out')
-          PsiWhiteSpace(' ')
-          PsiElement(IDENTIFIER)('T')
-        PsiElement(GT)('>')
-      VALUE_PARAMETER_LIST
-        PsiElement(LPAR)('(')
-        VALUE_PARAMETER
-          PsiElement(val)('val')
-          PsiWhiteSpace(' ')
-          PsiElement(IDENTIFIER)('size')
-          PsiWhiteSpace(' ')
-          PsiElement(COLON)(':')
-          PsiWhiteSpace(' ')
-          TYPE_REFERENCE
-            USER_TYPE
-              REFERENCE_EXPRESSION
-                PsiElement(IDENTIFIER)('Int')
-        PsiElement(RPAR)(')')
-      PsiWhiteSpace(' ')
-      CLASS_BODY
-        PsiElement(LBRACE)('{')
-        PsiWhiteSpace('\n    ')
-        ENUM_ENTRY
-          OBJECT_DECLARATION_NAME
-            PsiElement(IDENTIFIER)('Nil')
-          PsiWhiteSpace(' ')
-          TYPE_PARAMETER_LIST
-            <empty list>
-          PsiElement(COLON)(':')
-          PsiWhiteSpace(' ')
-          INITIALIZER_LIST
-            DELEGATOR_SUPER_CALL
-              CONSTRUCTOR_CALLEE
-                TYPE_REFERENCE
-                  USER_TYPE
-                    REFERENCE_EXPRESSION
-                      PsiElement(IDENTIFIER)('List')
-                    TYPE_ARGUMENT_LIST
-                      PsiElement(LT)('<')
-                      TYPE_PROJECTION
-                        TYPE_REFERENCE
-                          USER_TYPE
-                            REFERENCE_EXPRESSION
-                              PsiElement(IDENTIFIER)('Nothing')
-                      PsiElement(GT)('>')
-              VALUE_ARGUMENT_LIST
-                PsiElement(LPAR)('(')
-                VALUE_ARGUMENT
-                  INTEGER_CONSTANT
-                    PsiElement(INTEGER_LITERAL)('0')
-                PsiElement(RPAR)(')')
-        PsiWhiteSpace('\n\n    ')
-        ENUM_ENTRY
-          OBJECT_DECLARATION_NAME
-            PsiElement(IDENTIFIER)('Cons')
-          TYPE_PARAMETER_LIST
-            PsiElement(LT)('<')
-            TYPE_PARAMETER
-              PsiElement(IDENTIFIER)('T')
-            PsiElement(GT)('>')
-          VALUE_PARAMETER_LIST
-            PsiElement(LPAR)('(')
-            VALUE_PARAMETER
-              PsiElement(val)('val')
-              PsiWhiteSpace(' ')
-              PsiElement(IDENTIFIER)('value')
-              PsiWhiteSpace(' ')
-              PsiElement(COLON)(':')
-              PsiWhiteSpace(' ')
               TYPE_REFERENCE
                 USER_TYPE
                   REFERENCE_EXPRESSION
-                    PsiElement(IDENTIFIER)('T')
+                    PsiElement(IDENTIFIER)('Color')
-            PsiElement(COMMA)(',')
+            VALUE_ARGUMENT_LIST
+              PsiElement(LPAR)('(')
+              VALUE_ARGUMENT
+                INTEGER_CONSTANT
+                  PsiElement(INTEGER_LITERAL)('0xFF000')
+              PsiElement(RPAR)(')')
+      PsiWhiteSpace('\n    ')
+      ENUM_ENTRY
+        OBJECT_DECLARATION_NAME
+          PsiElement(IDENTIFIER)('GREEN')
+        PsiWhiteSpace(' ')
+        TYPE_PARAMETER_LIST
+          <empty list>
+        PsiElement(COLON)(':')
+        PsiWhiteSpace(' ')
+        INITIALIZER_LIST
+          DELEGATOR_SUPER_CALL
+            CONSTRUCTOR_CALLEE
+              TYPE_REFERENCE
+                USER_TYPE
+                  REFERENCE_EXPRESSION
+                    PsiElement(IDENTIFIER)('Color')
+            VALUE_ARGUMENT_LIST
+              PsiElement(LPAR)('(')
+              VALUE_ARGUMENT
+                INTEGER_CONSTANT
+                  PsiElement(INTEGER_LITERAL)('0x00FF00')
+              PsiElement(RPAR)(')')
+      PsiWhiteSpace('\n    ')
+      ENUM_ENTRY
+        OBJECT_DECLARATION_NAME
+          PsiElement(IDENTIFIER)('BLUE')
+        PsiWhiteSpace(' ')
+        TYPE_PARAMETER_LIST
+          <empty list>
+        PsiElement(COLON)(':')
+        PsiWhiteSpace(' ')
+        INITIALIZER_LIST
+          DELEGATOR_SUPER_CALL
+            CONSTRUCTOR_CALLEE
+              TYPE_REFERENCE
+                USER_TYPE
+                  REFERENCE_EXPRESSION
+                    PsiElement(IDENTIFIER)('Color')
+            VALUE_ARGUMENT_LIST
+              PsiElement(LPAR)('(')
+              VALUE_ARGUMENT
+                INTEGER_CONSTANT
+                  PsiElement(INTEGER_LITERAL)('0x0000FF')
+              PsiElement(RPAR)(')')
+      PsiWhiteSpace('\n')
+      PsiElement(RBRACE)('}')
+  PsiWhiteSpace('\n\n')
+  CLASS
+    MODIFIER_LIST
+      PsiElement(enum)('enum')
+    PsiWhiteSpace(' ')
+    PsiElement(class)('class')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('List')
+    TYPE_PARAMETER_LIST
+      PsiElement(LT)('<')
+      TYPE_PARAMETER
+        MODIFIER_LIST
+          PsiElement(out)('out')
+        PsiWhiteSpace(' ')
+        PsiElement(IDENTIFIER)('T')
+      PsiElement(GT)('>')
+    VALUE_PARAMETER_LIST
+      PsiElement(LPAR)('(')
+      VALUE_PARAMETER
+        PsiElement(val)('val')
+        PsiWhiteSpace(' ')
+        PsiElement(IDENTIFIER)('size')
+        PsiWhiteSpace(' ')
+        PsiElement(COLON)(':')
+        PsiWhiteSpace(' ')
+        TYPE_REFERENCE
+          USER_TYPE
+            REFERENCE_EXPRESSION
+              PsiElement(IDENTIFIER)('Int')
+      PsiElement(RPAR)(')')
+    PsiWhiteSpace(' ')
+    CLASS_BODY
+      PsiElement(LBRACE)('{')
+      PsiWhiteSpace('\n    ')
+      ENUM_ENTRY
+        OBJECT_DECLARATION_NAME
+          PsiElement(IDENTIFIER)('Nil')
+        PsiWhiteSpace(' ')
+        TYPE_PARAMETER_LIST
+          <empty list>
+        PsiElement(COLON)(':')
+        PsiWhiteSpace(' ')
+        INITIALIZER_LIST
+          DELEGATOR_SUPER_CALL
+            CONSTRUCTOR_CALLEE
+              TYPE_REFERENCE
+                USER_TYPE
+                  REFERENCE_EXPRESSION
+                    PsiElement(IDENTIFIER)('List')
+                  TYPE_ARGUMENT_LIST
+                    PsiElement(LT)('<')
+                    TYPE_PROJECTION
+                      TYPE_REFERENCE
+                        USER_TYPE
+                          REFERENCE_EXPRESSION
+                            PsiElement(IDENTIFIER)('Nothing')
+                    PsiElement(GT)('>')
+            VALUE_ARGUMENT_LIST
+              PsiElement(LPAR)('(')
+              VALUE_ARGUMENT
+                INTEGER_CONSTANT
+                  PsiElement(INTEGER_LITERAL)('0')
+              PsiElement(RPAR)(')')
+      PsiWhiteSpace('\n\n    ')
+      ENUM_ENTRY
+        OBJECT_DECLARATION_NAME
+          PsiElement(IDENTIFIER)('Cons')
+        TYPE_PARAMETER_LIST
+          PsiElement(LT)('<')
+          TYPE_PARAMETER
+            PsiElement(IDENTIFIER)('T')
+          PsiElement(GT)('>')
+        VALUE_PARAMETER_LIST
+          PsiElement(LPAR)('(')
+          VALUE_PARAMETER
+            PsiElement(val)('val')
             PsiWhiteSpace(' ')
-            VALUE_PARAMETER
+            PsiElement(IDENTIFIER)('value')
-              PsiElement(val)('val')
+            PsiWhiteSpace(' ')
-              PsiWhiteSpace(' ')
+            PsiElement(COLON)(':')
-              PsiElement(IDENTIFIER)('tail')
+            PsiWhiteSpace(' ')
-              PsiWhiteSpace(' ')
+            TYPE_REFERENCE
-              PsiElement(COLON)(':')
+              USER_TYPE
-              PsiWhiteSpace(' ')
+                REFERENCE_EXPRESSION
+                  PsiElement(IDENTIFIER)('T')
+          PsiElement(COMMA)(',')
+          PsiWhiteSpace(' ')
+          VALUE_PARAMETER
+            PsiElement(val)('val')
+            PsiWhiteSpace(' ')
+            PsiElement(IDENTIFIER)('tail')
+            PsiWhiteSpace(' ')
+            PsiElement(COLON)(':')
+            PsiWhiteSpace(' ')
+            TYPE_REFERENCE
+              USER_TYPE
+                REFERENCE_EXPRESSION
+                  PsiElement(IDENTIFIER)('List')
+                TYPE_ARGUMENT_LIST
+                  PsiElement(LT)('<')
+                  TYPE_PROJECTION
+                    TYPE_REFERENCE
+                      USER_TYPE
+                        REFERENCE_EXPRESSION
+                          PsiElement(IDENTIFIER)('T')
+                  PsiElement(GT)('>')
+          PsiElement(RPAR)(')')
+        PsiWhiteSpace(' ')
+        PsiElement(COLON)(':')
+        PsiWhiteSpace(' ')
+        INITIALIZER_LIST
+          DELEGATOR_SUPER_CALL
+            CONSTRUCTOR_CALLEE
               TYPE_REFERENCE
                 USER_TYPE
                   REFERENCE_EXPRESSION
@@ -202,55 +220,36 @@ JetFile: Enums.jet
                           REFERENCE_EXPRESSION
                             PsiElement(IDENTIFIER)('T')
                     PsiElement(GT)('>')
-            PsiElement(RPAR)(')')
+            VALUE_ARGUMENT_LIST
-          PsiWhiteSpace(' ')
+              PsiElement(LPAR)('(')
-          PsiElement(COLON)(':')
+              PsiComment(BLOCK_COMMENT)('/*tail.size + 1*/')
-          PsiWhiteSpace(' ')
+              VALUE_ARGUMENT
-          INITIALIZER_LIST
+                REFERENCE_EXPRESSION
-            DELEGATOR_SUPER_CALL
+                  PsiElement(IDENTIFIER)('a')
-              CONSTRUCTOR_CALLEE
+              PsiElement(RPAR)(')')
-                TYPE_REFERENCE
+      PsiWhiteSpace('\n\n    ')
-                  USER_TYPE
+      PROPERTY
-                    REFERENCE_EXPRESSION
+        PsiElement(val)('val')
-                      PsiElement(IDENTIFIER)('List')
-                    TYPE_ARGUMENT_LIST
-                      PsiElement(LT)('<')
-                      TYPE_PROJECTION
-                        TYPE_REFERENCE
-                          USER_TYPE
-                            REFERENCE_EXPRESSION
-                              PsiElement(IDENTIFIER)('T')
-                      PsiElement(GT)('>')
-              VALUE_ARGUMENT_LIST
-                PsiElement(LPAR)('(')
-                PsiComment(BLOCK_COMMENT)('/*tail.size + 1*/')
-                VALUE_ARGUMENT
-                  REFERENCE_EXPRESSION
-                    PsiElement(IDENTIFIER)('a')
-                PsiElement(RPAR)(')')
-        PsiWhiteSpace('\n\n    ')
-        PROPERTY
-          PsiElement(val)('val')
-          PsiWhiteSpace(' ')
-          PsiElement(IDENTIFIER)('isEmpty')
-          PsiWhiteSpace(' ')
-          PsiElement(COLON)(':')
-          PsiWhiteSpace(' ')
-          TYPE_REFERENCE
-            USER_TYPE
-              REFERENCE_EXPRESSION
-                PsiElement(IDENTIFIER)('Bool')
-          PsiWhiteSpace('\n      ')
-          PROPERTY_ACCESSOR
-            PsiElement(get)('get')
-            PsiElement(LPAR)('(')
-            PsiElement(RPAR)(')')
-            PsiWhiteSpace(' ')
-            PsiElement(EQ)('=')
-            PsiWhiteSpace(' ')
-            REFERENCE_EXPRESSION
-              PsiElement(IDENTIFIER)('size')
         PsiWhiteSpace(' ')
-        PsiComment(EOL_COMMENT)('//> 0')
+        PsiElement(IDENTIFIER)('isEmpty')
-        PsiWhiteSpace('\n')
+        PsiWhiteSpace(' ')
-        PsiElement(RBRACE)('}')
+        PsiElement(COLON)(':')
+        PsiWhiteSpace(' ')
+        TYPE_REFERENCE
+          USER_TYPE
+            REFERENCE_EXPRESSION
+              PsiElement(IDENTIFIER)('Bool')
+        PsiWhiteSpace('\n      ')
+        PROPERTY_ACCESSOR
+          PsiElement(get)('get')
+          PsiElement(LPAR)('(')
+          PsiElement(RPAR)(')')
+          PsiWhiteSpace(' ')
+          PsiElement(EQ)('=')
+          PsiWhiteSpace(' ')
+          REFERENCE_EXPRESSION
+            PsiElement(IDENTIFIER)('size')
+      PsiWhiteSpace(' ')
+      PsiComment(EOL_COMMENT)('//> 0')
+      PsiWhiteSpace('\n')
+      PsiElement(RBRACE)('}')

compiler/testData/psi/Expressions_ERR.txt

@@ -1,59 +1,58 @@
 JetFile: Expressions_ERR.jet
-  NAMESPACE
+  NAMESPACE_HEADER
-    NAMESPACE_HEADER
+    <empty list>
-      <empty list>
+  PROPERTY
-    PROPERTY
+    PsiElement(val)('val')
-      PsiElement(val)('val')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('f')
+    PsiWhiteSpace(' ')
+    PsiElement(EQ)('=')
+    PsiWhiteSpace(' ')
+    IF
+      PsiElement(if)('if')
       PsiWhiteSpace(' ')
-      PsiElement(IDENTIFIER)('f')
+      PsiElement(LPAR)('(')
+      CONDITION
+        BOOLEAN_CONSTANT
+          PsiElement(true)('true')
+      PsiElement(RPAR)(')')
       PsiWhiteSpace(' ')
-      PsiElement(EQ)('=')
+      THEN
+        RETURN
+          PsiElement(return)('return')
       PsiWhiteSpace(' ')
-      IF
+      PsiElement(else)('else')
-        PsiElement(if)('if')
+      PsiWhiteSpace(' ')
-        PsiWhiteSpace(' ')
+      ELSE
-        PsiElement(LPAR)('(')
+        BLOCK
-        CONDITION
+          PsiElement(LBRACE)('{')
-          BOOLEAN_CONSTANT
+          PsiWhiteSpace('\n  ')
-            PsiElement(true)('true')
+          REFERENCE_EXPRESSION
-        PsiElement(RPAR)(')')
+            PsiElement(IDENTIFIER)('dfsd')
-        PsiWhiteSpace(' ')
+          PsiWhiteSpace('\n  ')
-        THEN
+          PsiErrorElement:Expecting an element
-          RETURN
+            PsiElement(RPAR)(')')
-            PsiElement(return)('return')
+          PsiElement(SEMICOLON)(';')
-        PsiWhiteSpace(' ')
+          PsiElement(SEMICOLON)(';')
-        PsiElement(else)('else')
+          PsiElement(SEMICOLON)(';')
-        PsiWhiteSpace(' ')
+          PsiErrorElement:Expecting an element
-        ELSE
+            PsiElement(RPAR)(')')
-          BLOCK
+          PsiElement(SEMICOLON)(';')
-            PsiElement(LBRACE)('{')
+          PsiElement(SEMICOLON)(';')
-            PsiWhiteSpace('\n  ')
+          PsiElement(SEMICOLON)(';')
-            REFERENCE_EXPRESSION
+          PsiErrorElement:Expecting an element
-              PsiElement(IDENTIFIER)('dfsd')
+            PsiElement(BAD_CHARACTER)('~')
-            PsiWhiteSpace('\n  ')
+          PsiElement(SEMICOLON)(';')
-            PsiErrorElement:Expecting an element
+          PsiElement(SEMICOLON)(';')
-              PsiElement(RPAR)(')')
+          PsiElement(SEMICOLON)(';')
-            PsiElement(SEMICOLON)(';')
+          PsiWhiteSpace('\n  ')
-            PsiElement(SEMICOLON)(';')
+          REFERENCE_EXPRESSION
-            PsiElement(SEMICOLON)(';')
+            PsiElement(IDENTIFIER)('srgsdfg')
-            PsiErrorElement:Expecting an element
+          PsiWhiteSpace('\n\n  ')
-              PsiElement(RPAR)(')')
+          PsiErrorElement:Expecting an element
-            PsiElement(SEMICOLON)(';')
+            PsiElement(BAD_CHARACTER)('~')
-            PsiElement(SEMICOLON)(';')
+          PsiWhiteSpace('\n\n  ')
-            PsiElement(SEMICOLON)(';')
+          PsiErrorElement:Expecting an element
-            PsiErrorElement:Expecting an element
+            PsiElement(RBRACKET)(']')
-              PsiElement(BAD_CHARACTER)('~')
+          PsiWhiteSpace('\n')
-            PsiElement(SEMICOLON)(';')
+          PsiElement(RBRACE)('}')
-            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)('}')

compiler/testData/psi/ExtensionsWithQNReceiver.txt

@@ -1,77 +1,76 @@
 JetFile: ExtensionsWithQNReceiver.jet
-  NAMESPACE
+  NAMESPACE_HEADER
-    NAMESPACE_HEADER
+    <empty list>
-      <empty list>
+  PROPERTY
-    PROPERTY
+    PsiElement(val)('val')
-      PsiElement(val)('val')
+    PsiWhiteSpace(' ')
-      PsiWhiteSpace(' ')
+    TYPE_REFERENCE
-      TYPE_REFERENCE
+      USER_TYPE
         USER_TYPE
           USER_TYPE
-            USER_TYPE
-              REFERENCE_EXPRESSION
-                PsiElement(IDENTIFIER)('java')
-            PsiElement(DOT)('.')
             REFERENCE_EXPRESSION
-              PsiElement(IDENTIFIER)('util')
+              PsiElement(IDENTIFIER)('java')
           PsiElement(DOT)('.')
           REFERENCE_EXPRESSION
-            PsiElement(IDENTIFIER)('Map')
+            PsiElement(IDENTIFIER)('util')
-          TYPE_ARGUMENT_LIST
+        PsiElement(DOT)('.')
-            PsiElement(LT)('<')
+        REFERENCE_EXPRESSION
-            TYPE_PROJECTION
+          PsiElement(IDENTIFIER)('Map')
-              PsiElement(MUL)('*')
+        TYPE_ARGUMENT_LIST
-            PsiElement(COMMA)(',')
+          PsiElement(LT)('<')
-            TYPE_PROJECTION
+          TYPE_PROJECTION
-              PsiElement(MUL)('*')
+            PsiElement(MUL)('*')
-            PsiElement(GT)('>')
+          PsiElement(COMMA)(',')
-      PsiElement(DOT)('.')
+          TYPE_PROJECTION
-      PsiElement(IDENTIFIER)('size')
+            PsiElement(MUL)('*')
-      PsiWhiteSpace(' ')
+          PsiElement(GT)('>')
-      PsiElement(COLON)(':')
+    PsiElement(DOT)('.')
-      PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('size')
-      TYPE_REFERENCE
+    PsiWhiteSpace(' ')
-        USER_TYPE
+    PsiElement(COLON)(':')
-          REFERENCE_EXPRESSION
+    PsiWhiteSpace(' ')
-            PsiElement(IDENTIFIER)('Int')
+    TYPE_REFERENCE
-    PsiWhiteSpace('\n\n')
+      USER_TYPE
-    FUN
+        REFERENCE_EXPRESSION
-      PsiElement(fun)('fun')
+          PsiElement(IDENTIFIER)('Int')
-      PsiWhiteSpace(' ')
+  PsiWhiteSpace('\n\n')
-      TYPE_REFERENCE
+  FUN
+    PsiElement(fun)('fun')
+    PsiWhiteSpace(' ')
+    TYPE_REFERENCE
+      USER_TYPE
         USER_TYPE
           USER_TYPE
-            USER_TYPE
-              REFERENCE_EXPRESSION
-                PsiElement(IDENTIFIER)('java')
-            PsiElement(DOT)('.')
             REFERENCE_EXPRESSION
-              PsiElement(IDENTIFIER)('util')
+              PsiElement(IDENTIFIER)('java')
           PsiElement(DOT)('.')
           REFERENCE_EXPRESSION
-            PsiElement(IDENTIFIER)('Map')
+            PsiElement(IDENTIFIER)('util')
-          TYPE_ARGUMENT_LIST
+        PsiElement(DOT)('.')
-            PsiElement(LT)('<')
+        REFERENCE_EXPRESSION
-            TYPE_PROJECTION
+          PsiElement(IDENTIFIER)('Map')
-              PsiElement(MUL)('*')
+        TYPE_ARGUMENT_LIST
-            PsiElement(COMMA)(',')
+          PsiElement(LT)('<')
-            TYPE_PROJECTION
+          TYPE_PROJECTION
-              PsiElement(MUL)('*')
+            PsiElement(MUL)('*')
-            PsiElement(GT)('>')
+          PsiElement(COMMA)(',')
-      PsiElement(DOT)('.')
+          TYPE_PROJECTION
-      PsiElement(IDENTIFIER)('size')
+            PsiElement(MUL)('*')
-      VALUE_PARAMETER_LIST
+          PsiElement(GT)('>')
-        PsiElement(LPAR)('(')
+    PsiElement(DOT)('.')
-        PsiElement(RPAR)(')')
+    PsiElement(IDENTIFIER)('size')
-      PsiWhiteSpace(' ')
+    VALUE_PARAMETER_LIST
-      PsiElement(COLON)(':')
+      PsiElement(LPAR)('(')
-      PsiWhiteSpace(' ')
+      PsiElement(RPAR)(')')
-      TYPE_REFERENCE
+    PsiWhiteSpace(' ')
-        USER_TYPE
+    PsiElement(COLON)(':')
-          REFERENCE_EXPRESSION
+    PsiWhiteSpace(' ')
-            PsiElement(IDENTIFIER)('Int')
+    TYPE_REFERENCE
-      PsiWhiteSpace(' ')
+      USER_TYPE
-      PsiElement(EQ)('=')
+        REFERENCE_EXPRESSION
-      PsiWhiteSpace(' ')
+          PsiElement(IDENTIFIER)('Int')
-      INTEGER_CONSTANT
+    PsiWhiteSpace(' ')
-        PsiElement(INTEGER_LITERAL)('1')
+    PsiElement(EQ)('=')
+    PsiWhiteSpace(' ')
+    INTEGER_CONSTANT
+      PsiElement(INTEGER_LITERAL)('1')

compiler/testData/psi/FileStart_ERR.txt

@@ -1,36 +1,35 @@
 JetFile: FileStart_ERR.jet
-  NAMESPACE
+  NAMESPACE_HEADER
-    NAMESPACE_HEADER
+    <empty list>
-      <empty list>
+  PsiErrorElement:Expecting namespace or top level declaration
-    PsiErrorElement:Expecting namespace or top level declaration
+    PsiElement(DIV)('/')
-      PsiElement(DIV)('/')
+  PsiErrorElement:Expecting namespace or top level declaration
-    PsiErrorElement:Expecting namespace or top level declaration
+    PsiElement(namespace)('package')
-      PsiElement(namespace)('package')
+  PsiWhiteSpace(' ')
-    PsiWhiteSpace(' ')
+  MODIFIER_LIST
-    MODIFIER_LIST
+    ANNOTATION_ENTRY
-      ANNOTATION_ENTRY
+      CONSTRUCTOR_CALLEE
-        CONSTRUCTOR_CALLEE
+        TYPE_REFERENCE
-          TYPE_REFERENCE
+          USER_TYPE
-            USER_TYPE
-              USER_TYPE
-                REFERENCE_EXPRESSION
-                  PsiElement(IDENTIFIER)('foo')
-              PsiElement(DOT)('.')
-              REFERENCE_EXPRESSION
-                PsiElement(IDENTIFIER)('bar')
-      PsiWhiteSpace('\n')
-      ANNOTATION_ENTRY
-        CONSTRUCTOR_CALLEE
-          TYPE_REFERENCE
-            USER_TYPE
-              REFERENCE_EXPRESSION
-                PsiElement(IDENTIFIER)('import')
-      PsiWhiteSpace(' ')
-      ANNOTATION_ENTRY
-        CONSTRUCTOR_CALLEE
-          TYPE_REFERENCE
             USER_TYPE
               REFERENCE_EXPRESSION
                 PsiElement(IDENTIFIER)('foo')
-    PsiErrorElement:Expecting namespace or top level declaration
+            PsiElement(DOT)('.')
-      <empty list>
+            REFERENCE_EXPRESSION
+              PsiElement(IDENTIFIER)('bar')
+    PsiWhiteSpace('\n')
+    ANNOTATION_ENTRY
+      CONSTRUCTOR_CALLEE
+        TYPE_REFERENCE
+          USER_TYPE
+            REFERENCE_EXPRESSION
+              PsiElement(IDENTIFIER)('import')
+    PsiWhiteSpace(' ')
+    ANNOTATION_ENTRY
+      CONSTRUCTOR_CALLEE
+        TYPE_REFERENCE
+          USER_TYPE
+            REFERENCE_EXPRESSION
+              PsiElement(IDENTIFIER)('foo')
+  PsiErrorElement:Expecting namespace or top level declaration
+    <empty list>

compiler/testData/psi/FunctionCalls.txt

@@ -1,79 +1,67 @@
 JetFile: FunctionCalls.jet
-  NAMESPACE
+  NAMESPACE_HEADER
-    NAMESPACE_HEADER
+    <empty list>
-      <empty list>
+  FUN
-    FUN
+    PsiElement(fun)('fun')
-      PsiElement(fun)('fun')
+    PsiWhiteSpace(' ')
-      PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('foo')
-      PsiElement(IDENTIFIER)('foo')
+    VALUE_PARAMETER_LIST
-      VALUE_PARAMETER_LIST
+      PsiElement(LPAR)('(')
-        PsiElement(LPAR)('(')
+      PsiElement(RPAR)(')')
-        PsiElement(RPAR)(')')
+    PsiWhiteSpace(' ')
-      PsiWhiteSpace(' ')
+    BLOCK
-      BLOCK
+      PsiElement(LBRACE)('{')
-        PsiElement(LBRACE)('{')
+      PsiWhiteSpace('\n  ')
-        PsiWhiteSpace('\n  ')
+      CALL_EXPRESSION
-        CALL_EXPRESSION
-          REFERENCE_EXPRESSION
-            PsiElement(IDENTIFIER)('f')
-          VALUE_ARGUMENT_LIST
-            PsiElement(LPAR)('(')
-            VALUE_ARGUMENT
-              REFERENCE_EXPRESSION
-                PsiElement(IDENTIFIER)('a')
-            PsiElement(RPAR)(')')
-        PsiWhiteSpace('\n  ')
-        CALL_EXPRESSION
-          REFERENCE_EXPRESSION
-            PsiElement(IDENTIFIER)('f')
-          TYPE_ARGUMENT_LIST
-            PsiElement(LT)('<')
-            TYPE_PROJECTION
-              TYPE_REFERENCE
-                USER_TYPE
-                  REFERENCE_EXPRESSION
-                    PsiElement(IDENTIFIER)('foo')
-            PsiElement(GT)('>')
-          VALUE_ARGUMENT_LIST
-            PsiElement(LPAR)('(')
-            VALUE_ARGUMENT
-              REFERENCE_EXPRESSION
-                PsiElement(IDENTIFIER)('a')
-            PsiElement(RPAR)(')')
-        PsiWhiteSpace('\n  ')
-        CALL_EXPRESSION
-          REFERENCE_EXPRESSION
-            PsiElement(IDENTIFIER)('f')
-          TYPE_ARGUMENT_LIST
-            PsiElement(LT)('<')
-            TYPE_PROJECTION
-              TYPE_REFERENCE
-                USER_TYPE
-                  REFERENCE_EXPRESSION
-                    PsiElement(IDENTIFIER)('foo')
-            PsiElement(GT)('>')
-        PsiWhiteSpace('\n  ')
-        PARENTHESIZED
-          PsiElement(LPAR)('(')
-          REFERENCE_EXPRESSION
-            PsiElement(IDENTIFIER)('a')
-          PsiElement(RPAR)(')')
-        PsiWhiteSpace('\n  ')
-        CALL_EXPRESSION
-          REFERENCE_EXPRESSION
-            PsiElement(IDENTIFIER)('f')
-          PsiWhiteSpace(' ')
-          FUNCTION_LITERAL_EXPRESSION
-            FUNCTION_LITERAL
-              PsiElement(LBRACE)('{')
-              BLOCK
-                REFERENCE_EXPRESSION
-                  PsiElement(IDENTIFIER)('s')
-              PsiElement(RBRACE)('}')
-        PsiWhiteSpace('\n  ')
         REFERENCE_EXPRESSION
           PsiElement(IDENTIFIER)('f')
-        PsiWhiteSpace('\n  ')
+        VALUE_ARGUMENT_LIST
+          PsiElement(LPAR)('(')
+          VALUE_ARGUMENT
+            REFERENCE_EXPRESSION
+              PsiElement(IDENTIFIER)('a')
+          PsiElement(RPAR)(')')
+      PsiWhiteSpace('\n  ')
+      CALL_EXPRESSION
+        REFERENCE_EXPRESSION
+          PsiElement(IDENTIFIER)('f')
+        TYPE_ARGUMENT_LIST
+          PsiElement(LT)('<')
+          TYPE_PROJECTION
+            TYPE_REFERENCE
+              USER_TYPE
+                REFERENCE_EXPRESSION
+                  PsiElement(IDENTIFIER)('foo')
+          PsiElement(GT)('>')
+        VALUE_ARGUMENT_LIST
+          PsiElement(LPAR)('(')
+          VALUE_ARGUMENT
+            REFERENCE_EXPRESSION
+              PsiElement(IDENTIFIER)('a')
+          PsiElement(RPAR)(')')
+      PsiWhiteSpace('\n  ')
+      CALL_EXPRESSION
+        REFERENCE_EXPRESSION
+          PsiElement(IDENTIFIER)('f')
+        TYPE_ARGUMENT_LIST
+          PsiElement(LT)('<')
+          TYPE_PROJECTION
+            TYPE_REFERENCE
+              USER_TYPE
+                REFERENCE_EXPRESSION
+                  PsiElement(IDENTIFIER)('foo')
+          PsiElement(GT)('>')
+      PsiWhiteSpace('\n  ')
+      PARENTHESIZED
+        PsiElement(LPAR)('(')
+        REFERENCE_EXPRESSION
+          PsiElement(IDENTIFIER)('a')
+        PsiElement(RPAR)(')')
+      PsiWhiteSpace('\n  ')
+      CALL_EXPRESSION
+        REFERENCE_EXPRESSION
+          PsiElement(IDENTIFIER)('f')
+        PsiWhiteSpace(' ')
         FUNCTION_LITERAL_EXPRESSION
           FUNCTION_LITERAL
             PsiElement(LBRACE)('{')
@@ -81,51 +69,22 @@ JetFile: FunctionCalls.jet
               REFERENCE_EXPRESSION
                 PsiElement(IDENTIFIER)('s')
             PsiElement(RBRACE)('}')
-        PsiWhiteSpace('\n  ')
+      PsiWhiteSpace('\n  ')
-        CALL_EXPRESSION
+      REFERENCE_EXPRESSION
-          REFERENCE_EXPRESSION
+        PsiElement(IDENTIFIER)('f')
-            PsiElement(IDENTIFIER)('f')
+      PsiWhiteSpace('\n  ')
-          PsiWhiteSpace(' ')
+      FUNCTION_LITERAL_EXPRESSION
-          FUNCTION_LITERAL_EXPRESSION
+        FUNCTION_LITERAL
-            FUNCTION_LITERAL
+          PsiElement(LBRACE)('{')
-              PsiElement(LBRACE)('{')
+          BLOCK
-              PsiWhiteSpace('\n    ')
+            REFERENCE_EXPRESSION
-              BLOCK
+              PsiElement(IDENTIFIER)('s')
-                REFERENCE_EXPRESSION
+          PsiElement(RBRACE)('}')
-                  PsiElement(IDENTIFIER)('s')
+      PsiWhiteSpace('\n  ')
-              PsiWhiteSpace('\n  ')
+      CALL_EXPRESSION
-              PsiElement(RBRACE)('}')
+        REFERENCE_EXPRESSION
-        PsiWhiteSpace('\n  ')
+          PsiElement(IDENTIFIER)('f')
-        CALL_EXPRESSION
+        PsiWhiteSpace(' ')
-          REFERENCE_EXPRESSION
-            PsiElement(IDENTIFIER)('f')
-          VALUE_ARGUMENT_LIST
-            PsiElement(LPAR)('(')
-            VALUE_ARGUMENT
-              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  ')
-        CALL_EXPRESSION
-          REFERENCE_EXPRESSION
-            PsiElement(IDENTIFIER)('f')
-          VALUE_ARGUMENT_LIST
-            PsiElement(LPAR)('(')
-            VALUE_ARGUMENT
-              REFERENCE_EXPRESSION
-                PsiElement(IDENTIFIER)('a')
-            PsiElement(RPAR)(')')
-        PsiWhiteSpace('\n  ')
         FUNCTION_LITERAL_EXPRESSION
           FUNCTION_LITERAL
             PsiElement(LBRACE)('{')
@@ -135,53 +94,17 @@ JetFile: FunctionCalls.jet
                 PsiElement(IDENTIFIER)('s')
             PsiWhiteSpace('\n  ')
             PsiElement(RBRACE)('}')
-        PsiWhiteSpace('\n  ')
+      PsiWhiteSpace('\n  ')
-        CALL_EXPRESSION
+      CALL_EXPRESSION
-          REFERENCE_EXPRESSION
+        REFERENCE_EXPRESSION
-            PsiElement(IDENTIFIER)('f')
+          PsiElement(IDENTIFIER)('f')
-          TYPE_ARGUMENT_LIST
+        VALUE_ARGUMENT_LIST
-            PsiElement(LT)('<')
+          PsiElement(LPAR)('(')
-            TYPE_PROJECTION
+          VALUE_ARGUMENT
-              TYPE_REFERENCE
+            REFERENCE_EXPRESSION
-                USER_TYPE
+              PsiElement(IDENTIFIER)('a')
-                  REFERENCE_EXPRESSION
+          PsiElement(RPAR)(')')
-                    PsiElement(IDENTIFIER)('a')
+        PsiWhiteSpace(' ')
-            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    ')
-              BLOCK
-                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('\n  ')
         FUNCTION_LITERAL_EXPRESSION
           FUNCTION_LITERAL
             PsiElement(LBRACE)('{')
@@ -191,139 +114,215 @@ JetFile: FunctionCalls.jet
                 PsiElement(IDENTIFIER)('s')
             PsiWhiteSpace('\n  ')
             PsiElement(RBRACE)('}')
-        PsiWhiteSpace('\n  ')
+      PsiWhiteSpace('\n  ')
-        CALL_EXPRESSION
+      CALL_EXPRESSION
-          REFERENCE_EXPRESSION
+        REFERENCE_EXPRESSION
-            PsiElement(IDENTIFIER)('f')
+          PsiElement(IDENTIFIER)('f')
-          VALUE_ARGUMENT_LIST
+        VALUE_ARGUMENT_LIST
-            PsiElement(LPAR)('(')
+          PsiElement(LPAR)('(')
-            VALUE_ARGUMENT
+          VALUE_ARGUMENT
-              CALL_EXPRESSION
+            REFERENCE_EXPRESSION
-                REFERENCE_EXPRESSION
+              PsiElement(IDENTIFIER)('a')
-                  PsiElement(IDENTIFIER)('foo')
+          PsiElement(RPAR)(')')
-                TYPE_ARGUMENT_LIST
+      PsiWhiteSpace('\n  ')
-                  PsiElement(LT)('<')
+      FUNCTION_LITERAL_EXPRESSION
-                  TYPE_PROJECTION
+        FUNCTION_LITERAL
-                    TYPE_REFERENCE
+          PsiElement(LBRACE)('{')
-                      USER_TYPE
+          PsiWhiteSpace('\n    ')
-                        REFERENCE_EXPRESSION
+          BLOCK
-                          PsiElement(IDENTIFIER)('a')
+            REFERENCE_EXPRESSION
-                  PsiElement(COMMA)(',')
+              PsiElement(IDENTIFIER)('s')
-                  PsiWhiteSpace(' ')
+          PsiWhiteSpace('\n  ')
-                  TYPE_PROJECTION
+          PsiElement(RBRACE)('}')
-                    TYPE_REFERENCE
+      PsiWhiteSpace('\n  ')
-                      USER_TYPE
+      CALL_EXPRESSION
-                        REFERENCE_EXPRESSION
+        REFERENCE_EXPRESSION
-                          PsiElement(IDENTIFIER)('b')
+          PsiElement(IDENTIFIER)('f')
-                  PsiElement(GT)('>')
+        TYPE_ARGUMENT_LIST
-            PsiElement(RPAR)(')')
+          PsiElement(LT)('<')
-        PsiWhiteSpace('\n  ')
+          TYPE_PROJECTION
-        CALL_EXPRESSION
+            TYPE_REFERENCE
-          REFERENCE_EXPRESSION
+              USER_TYPE
-            PsiElement(IDENTIFIER)('f')
-          VALUE_ARGUMENT_LIST
-            PsiElement(LPAR)('(')
-            VALUE_ARGUMENT
-              CALL_EXPRESSION
-                REFERENCE_EXPRESSION
-                  PsiElement(IDENTIFIER)('foo')
-                TYPE_ARGUMENT_LIST
-                  PsiElement(LT)('<')
-                  TYPE_PROJECTION
-                    TYPE_REFERENCE
-                      USER_TYPE
-                        REFERENCE_EXPRESSION
-                          PsiElement(IDENTIFIER)('a')
-                  PsiElement(COMMA)(',')
-                  PsiWhiteSpace(' ')
-                  TYPE_PROJECTION
-                    TYPE_REFERENCE
-                      USER_TYPE
-                        REFERENCE_EXPRESSION
-                          PsiElement(IDENTIFIER)('b')
-                  PsiElement(GT)('>')
-                VALUE_ARGUMENT_LIST
-                  PsiElement(LPAR)('(')
-                  VALUE_ARGUMENT
-                    REFERENCE_EXPRESSION
-                      PsiElement(IDENTIFIER)('a')
-                  PsiElement(RPAR)(')')
-            PsiElement(RPAR)(')')
-        PsiWhiteSpace('\n  ')
-        CALL_EXPRESSION
-          REFERENCE_EXPRESSION
-            PsiElement(IDENTIFIER)('f')
-          VALUE_ARGUMENT_LIST
-            PsiElement(LPAR)('(')
-            VALUE_ARGUMENT
-              BINARY_EXPRESSION
-                REFERENCE_EXPRESSION
-                  PsiElement(IDENTIFIER)('foo')
-                OPERATION_REFERENCE
-                  PsiElement(LT)('<')
                 REFERENCE_EXPRESSION
                   PsiElement(IDENTIFIER)('a')
-            PsiElement(COMMA)(',')
+          PsiElement(GT)('>')
-            PsiWhiteSpace(' ')
+        VALUE_ARGUMENT_LIST
-            VALUE_ARGUMENT
+          PsiElement(LPAR)('(')
-              INTEGER_CONSTANT
+          VALUE_ARGUMENT
-                PsiElement(INTEGER_LITERAL)('1')
+            REFERENCE_EXPRESSION
-            PsiElement(COMMA)(',')
+              PsiElement(IDENTIFIER)('a')
-            PsiWhiteSpace(' ')
+          PsiElement(RPAR)(')')
-            VALUE_ARGUMENT
+        PsiWhiteSpace(' ')
-              BINARY_EXPRESSION
+        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')
+        TYPE_ARGUMENT_LIST
+          PsiElement(LT)('<')
+          TYPE_PROJECTION
+            TYPE_REFERENCE
+              USER_TYPE
                 REFERENCE_EXPRESSION
-                  PsiElement(IDENTIFIER)('b')
+                  PsiElement(IDENTIFIER)('a')
-                OPERATION_REFERENCE
+          PsiElement(GT)('>')
-                  PsiElement(GT)('>')
+        VALUE_ARGUMENT_LIST
-                PARENTHESIZED
+          PsiElement(LPAR)('(')
-                  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
+          PsiElement(IDENTIFIER)('f')
+        VALUE_ARGUMENT_LIST
+          PsiElement(LPAR)('(')
+          VALUE_ARGUMENT
+            CALL_EXPRESSION
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('foo')
+              TYPE_ARGUMENT_LIST
+                PsiElement(LT)('<')
+                TYPE_PROJECTION
+                  TYPE_REFERENCE
+                    USER_TYPE
+                      REFERENCE_EXPRESSION
+                        PsiElement(IDENTIFIER)('a')
+                PsiElement(COMMA)(',')
+                PsiWhiteSpace(' ')
+                TYPE_PROJECTION
+                  TYPE_REFERENCE
+                    USER_TYPE
+                      REFERENCE_EXPRESSION
+                        PsiElement(IDENTIFIER)('b')
+                PsiElement(GT)('>')
+          PsiElement(RPAR)(')')
+      PsiWhiteSpace('\n  ')
+      CALL_EXPRESSION
+        REFERENCE_EXPRESSION
+          PsiElement(IDENTIFIER)('f')
+        VALUE_ARGUMENT_LIST
+          PsiElement(LPAR)('(')
+          VALUE_ARGUMENT
+            CALL_EXPRESSION
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('foo')
+              TYPE_ARGUMENT_LIST
+                PsiElement(LT)('<')
+                TYPE_PROJECTION
+                  TYPE_REFERENCE
+                    USER_TYPE
+                      REFERENCE_EXPRESSION
+                        PsiElement(IDENTIFIER)('a')
+                PsiElement(COMMA)(',')
+                PsiWhiteSpace(' ')
+                TYPE_PROJECTION
+                  TYPE_REFERENCE
+                    USER_TYPE
+                      REFERENCE_EXPRESSION
+                        PsiElement(IDENTIFIER)('b')
+                PsiElement(GT)('>')
+              VALUE_ARGUMENT_LIST
+                PsiElement(LPAR)('(')
+                VALUE_ARGUMENT
                   REFERENCE_EXPRESSION
                     PsiElement(IDENTIFIER)('a')
-                  PsiElement(RPAR)(')')
+                PsiElement(RPAR)(')')
-            PsiElement(RPAR)(')')
+          PsiElement(RPAR)(')')
-        PsiWhiteSpace('\n  ')
+      PsiWhiteSpace('\n  ')
-        CALL_EXPRESSION
+      CALL_EXPRESSION
-          REFERENCE_EXPRESSION
+        REFERENCE_EXPRESSION
-            PsiElement(IDENTIFIER)('f')
+          PsiElement(IDENTIFIER)('f')
-          VALUE_ARGUMENT_LIST
+        VALUE_ARGUMENT_LIST
-            PsiElement(LPAR)('(')
+          PsiElement(LPAR)('(')
-            VALUE_ARGUMENT
+          VALUE_ARGUMENT
-              BINARY_EXPRESSION
+            BINARY_EXPRESSION
-                REFERENCE_EXPRESSION
+              REFERENCE_EXPRESSION
-                  PsiElement(IDENTIFIER)('foo')
+                PsiElement(IDENTIFIER)('foo')
-                OPERATION_REFERENCE
+              OPERATION_REFERENCE
-                  PsiElement(LT)('<')
+                PsiElement(LT)('<')
-                REFERENCE_EXPRESSION
+              REFERENCE_EXPRESSION
-                  PsiElement(IDENTIFIER)('a')
+                PsiElement(IDENTIFIER)('a')
-            PsiElement(COMMA)(',')
+          PsiElement(COMMA)(',')
-            PsiWhiteSpace(' ')
+          PsiWhiteSpace(' ')
-            VALUE_ARGUMENT
+          VALUE_ARGUMENT
+            INTEGER_CONSTANT
+              PsiElement(INTEGER_LITERAL)('1')
+          PsiElement(COMMA)(',')
+          PsiWhiteSpace(' ')
+          VALUE_ARGUMENT
+            BINARY_EXPRESSION
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('b')
+              OPERATION_REFERENCE
+                PsiElement(GT)('>')
               PARENTHESIZED
                 PsiElement(LPAR)('(')
-                BINARY_EXPRESSION
-                  INTEGER_CONSTANT
-                    PsiElement(INTEGER_LITERAL)('1')
-                  PsiWhiteSpace(' ')
-                  OPERATION_REFERENCE
-                    PsiElement(PLUS)('+')
-                  PsiWhiteSpace(' ')
-                  INTEGER_CONSTANT
-                    PsiElement(INTEGER_LITERAL)('2')
-                PsiElement(RPAR)(')')
-            PsiElement(COMMA)(',')
-            PsiWhiteSpace(' ')
-            VALUE_ARGUMENT
-              BINARY_EXPRESSION
                 REFERENCE_EXPRESSION
-                  PsiElement(IDENTIFIER)('b')
+                  PsiElement(IDENTIFIER)('a')
+                PsiElement(RPAR)(')')
+          PsiElement(RPAR)(')')
+      PsiWhiteSpace('\n  ')
+      CALL_EXPRESSION
+        REFERENCE_EXPRESSION
+          PsiElement(IDENTIFIER)('f')
+        VALUE_ARGUMENT_LIST
+          PsiElement(LPAR)('(')
+          VALUE_ARGUMENT
+            BINARY_EXPRESSION
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('foo')
+              OPERATION_REFERENCE
+                PsiElement(LT)('<')
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('a')
+          PsiElement(COMMA)(',')
+          PsiWhiteSpace(' ')
+          VALUE_ARGUMENT
+            PARENTHESIZED
+              PsiElement(LPAR)('(')
+              BINARY_EXPRESSION
+                INTEGER_CONSTANT
+                  PsiElement(INTEGER_LITERAL)('1')
+                PsiWhiteSpace(' ')
                 OPERATION_REFERENCE
-                  PsiElement(GT)('>')
+                  PsiElement(PLUS)('+')
-                PARENTHESIZED
+                PsiWhiteSpace(' ')
-                  PsiElement(LPAR)('(')
+                INTEGER_CONSTANT
-                  REFERENCE_EXPRESSION
+                  PsiElement(INTEGER_LITERAL)('2')
-                    PsiElement(IDENTIFIER)('a')
+              PsiElement(RPAR)(')')
-                  PsiElement(RPAR)(')')
+          PsiElement(COMMA)(',')
-            PsiElement(RPAR)(')')
+          PsiWhiteSpace(' ')
-        PsiWhiteSpace('\n')
+          VALUE_ARGUMENT
-        PsiElement(RBRACE)('}')
+            BINARY_EXPRESSION
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('b')
+              OPERATION_REFERENCE
+                PsiElement(GT)('>')
+              PARENTHESIZED
+                PsiElement(LPAR)('(')
+                REFERENCE_EXPRESSION
+                  PsiElement(IDENTIFIER)('a')
+                PsiElement(RPAR)(')')
+          PsiElement(RPAR)(')')
+      PsiWhiteSpace('\n')
+      PsiElement(RBRACE)('}')

compiler/testData/psi/FunctionLiterals.txt

@@ -1,499 +1,498 @@
 JetFile: FunctionLiterals.jet
-  NAMESPACE
+  NAMESPACE_HEADER
-    NAMESPACE_HEADER
+    <empty list>
-      <empty list>
+  FUN
-    FUN
+    PsiElement(fun)('fun')
-      PsiElement(fun)('fun')
+    PsiWhiteSpace(' ')
-      PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('foo')
-      PsiElement(IDENTIFIER)('foo')
+    VALUE_PARAMETER_LIST
-      VALUE_PARAMETER_LIST
+      PsiElement(LPAR)('(')
-        PsiElement(LPAR)('(')
+      PsiElement(RPAR)(')')
-        PsiElement(RPAR)(')')
+    PsiWhiteSpace(' ')
-      PsiWhiteSpace(' ')
+    BLOCK
-      BLOCK
+      PsiElement(LBRACE)('{')
-        PsiElement(LBRACE)('{')
+      PsiWhiteSpace('\n    ')
-        PsiWhiteSpace('\n    ')
+      FUNCTION_LITERAL_EXPRESSION
-        FUNCTION_LITERAL_EXPRESSION
+        FUNCTION_LITERAL
-          FUNCTION_LITERAL
+          PsiElement(LBRACE)('{')
-            PsiElement(LBRACE)('{')
+          BLOCK
-            BLOCK
+            <empty list>
-              <empty list>
+          PsiElement(RBRACE)('}')
-            PsiElement(RBRACE)('}')
+      PsiWhiteSpace('\n\n    ')
-        PsiWhiteSpace('\n\n    ')
+      FUNCTION_LITERAL_EXPRESSION
-        FUNCTION_LITERAL_EXPRESSION
+        FUNCTION_LITERAL
-          FUNCTION_LITERAL
+          PsiElement(LBRACE)('{')
-            PsiElement(LBRACE)('{')
+          BLOCK
-            BLOCK
+            REFERENCE_EXPRESSION
-              REFERENCE_EXPRESSION
+              PsiElement(IDENTIFIER)('foo')
-                PsiElement(IDENTIFIER)('foo')
+          PsiElement(RBRACE)('}')
-            PsiElement(RBRACE)('}')
+      PsiWhiteSpace('\n\n    ')
-        PsiWhiteSpace('\n\n    ')
+      FUNCTION_LITERAL_EXPRESSION
-        FUNCTION_LITERAL_EXPRESSION
+        FUNCTION_LITERAL
-          FUNCTION_LITERAL
+          PsiElement(LBRACE)('{')
-            PsiElement(LBRACE)('{')
+          VALUE_PARAMETER_LIST
-            VALUE_PARAMETER_LIST
+            VALUE_PARAMETER
-              VALUE_PARAMETER
+              PsiElement(IDENTIFIER)('a')
-                PsiElement(IDENTIFIER)('a')
+          PsiWhiteSpace(' ')
-            PsiWhiteSpace(' ')
+          PsiElement(ARROW)('->')
-            PsiElement(ARROW)('->')
+          PsiWhiteSpace(' ')
-            PsiWhiteSpace(' ')
+          BLOCK
-            BLOCK
+            REFERENCE_EXPRESSION
-              REFERENCE_EXPRESSION
+              PsiElement(IDENTIFIER)('a')
-                PsiElement(IDENTIFIER)('a')
+          PsiElement(RBRACE)('}')
-            PsiElement(RBRACE)('}')
+      PsiWhiteSpace('\n\n    ')
-        PsiWhiteSpace('\n\n    ')
+      FUNCTION_LITERAL_EXPRESSION
-        FUNCTION_LITERAL_EXPRESSION
+        FUNCTION_LITERAL
-          FUNCTION_LITERAL
+          PsiElement(LBRACE)('{')
-            PsiElement(LBRACE)('{')
+          VALUE_PARAMETER_LIST
-            VALUE_PARAMETER_LIST
+            PsiElement(LPAR)('(')
-              PsiElement(LPAR)('(')
+            VALUE_PARAMETER
-              VALUE_PARAMETER
+              PsiElement(IDENTIFIER)('a')
-                PsiElement(IDENTIFIER)('a')
+            PsiElement(RPAR)(')')
-              PsiElement(RPAR)(')')
+          PsiWhiteSpace(' ')
-            PsiWhiteSpace(' ')
+          PsiElement(ARROW)('->')
-            PsiElement(ARROW)('->')
+          PsiWhiteSpace(' ')
-            PsiWhiteSpace(' ')
+          BLOCK
-            BLOCK
+            REFERENCE_EXPRESSION
-              REFERENCE_EXPRESSION
+              PsiElement(IDENTIFIER)('a')
-                PsiElement(IDENTIFIER)('a')
+          PsiElement(RBRACE)('}')
-            PsiElement(RBRACE)('}')
+      PsiWhiteSpace('\n    ')
-        PsiWhiteSpace('\n    ')
+      FUNCTION_LITERAL_EXPRESSION
-        FUNCTION_LITERAL_EXPRESSION
+        FUNCTION_LITERAL
-          FUNCTION_LITERAL
+          PsiElement(LBRACE)('{')
-            PsiElement(LBRACE)('{')
+          VALUE_PARAMETER_LIST
-            VALUE_PARAMETER_LIST
+            PsiElement(LPAR)('(')
-              PsiElement(LPAR)('(')
+            VALUE_PARAMETER
-              VALUE_PARAMETER
+              PsiElement(IDENTIFIER)('a')
-                PsiElement(IDENTIFIER)('a')
-                PsiWhiteSpace(' ')
-                PsiElement(COLON)(':')
-                PsiWhiteSpace(' ')
-                TYPE_REFERENCE
-                  USER_TYPE
-                    REFERENCE_EXPRESSION
-                      PsiElement(IDENTIFIER)('A')
-              PsiElement(RPAR)(')')
-            PsiWhiteSpace(' ')
-            PsiElement(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)(':')
-            PsiWhiteSpace(' ')
-            TYPE_REFERENCE
-              USER_TYPE
-                REFERENCE_EXPRESSION
-                  PsiElement(IDENTIFIER)('T')
-            PsiWhiteSpace(' ')
-            PsiElement(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(ARROW)('->')
-            PsiWhiteSpace(' ')
-            BLOCK
-              REFERENCE_EXPRESSION
-                PsiElement(IDENTIFIER)('a')
-            PsiElement(RBRACE)('}')
-        PsiWhiteSpace('\n\n    ')
-        FUNCTION_LITERAL_EXPRESSION
-          FUNCTION_LITERAL
-            PsiElement(LBRACE)('{')
-            VALUE_PARAMETER_LIST
-              PsiElement(LPAR)('(')
-              VALUE_PARAMETER
-                PsiElement(IDENTIFIER)('a')
-              PsiElement(COMMA)(',')
               PsiWhiteSpace(' ')
-              VALUE_PARAMETER
+              PsiElement(COLON)(':')
-                PsiElement(IDENTIFIER)('a')
-              PsiElement(RPAR)(')')
-            PsiWhiteSpace(' ')
-            PsiElement(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(' ')
-              VALUE_PARAMETER
+              TYPE_REFERENCE
-                PsiElement(IDENTIFIER)('a')
+                USER_TYPE
-                PsiWhiteSpace(' ')
+                  REFERENCE_EXPRESSION
-                PsiElement(COLON)(':')
+                    PsiElement(IDENTIFIER)('A')
-                PsiWhiteSpace(' ')
+            PsiElement(RPAR)(')')
-                TYPE_REFERENCE
+          PsiWhiteSpace(' ')
-                  USER_TYPE
+          PsiElement(ARROW)('->')
-                    REFERENCE_EXPRESSION
+          PsiWhiteSpace(' ')
-                      PsiElement(IDENTIFIER)('B')
+          BLOCK
-              PsiElement(RPAR)(')')
+            REFERENCE_EXPRESSION
-            PsiWhiteSpace(' ')
+              PsiElement(IDENTIFIER)('a')
-            PsiElement(ARROW)('->')
+          PsiElement(RBRACE)('}')
-            PsiWhiteSpace(' ')
+      PsiWhiteSpace('\n    ')
-            BLOCK
+      FUNCTION_LITERAL_EXPRESSION
-              REFERENCE_EXPRESSION
+        FUNCTION_LITERAL
-                PsiElement(IDENTIFIER)('a')
+          PsiElement(LBRACE)('{')
-            PsiElement(RBRACE)('}')
+          VALUE_PARAMETER_LIST
-        PsiWhiteSpace('\n    ')
+            PsiElement(LPAR)('(')
-        FUNCTION_LITERAL_EXPRESSION
+            VALUE_PARAMETER
-          FUNCTION_LITERAL
+              PsiElement(IDENTIFIER)('a')
-            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(COLON)(':')
-                PsiElement(IDENTIFIER)('a')
-              PsiElement(RPAR)(')')
-            PsiWhiteSpace(' ')
-            PsiElement(COLON)(':')
-            PsiWhiteSpace(' ')
-            TYPE_REFERENCE
-              USER_TYPE
-                REFERENCE_EXPRESSION
-                  PsiElement(IDENTIFIER)('T')
-            PsiWhiteSpace(' ')
-            PsiElement(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(COMMA)(',')
               PsiWhiteSpace(' ')
-              VALUE_PARAMETER
+              TYPE_REFERENCE
-                PsiElement(IDENTIFIER)('a')
+                USER_TYPE
-                PsiWhiteSpace(' ')
+                  REFERENCE_EXPRESSION
-                PsiElement(COLON)(':')
+                    PsiElement(IDENTIFIER)('A')
-                PsiWhiteSpace(' ')
+            PsiElement(RPAR)(')')
-                TYPE_REFERENCE
+          PsiWhiteSpace(' ')
-                  USER_TYPE
+          PsiElement(COLON)(':')
-                    REFERENCE_EXPRESSION
+          PsiWhiteSpace(' ')
-                      PsiElement(IDENTIFIER)('B')
+          TYPE_REFERENCE
-              PsiElement(RPAR)(')')
+            USER_TYPE
-            PsiWhiteSpace(' ')
-            PsiElement(COLON)(':')
-            PsiWhiteSpace(' ')
-            TYPE_REFERENCE
-              USER_TYPE
-                REFERENCE_EXPRESSION
-                  PsiElement(IDENTIFIER)('T')
-            PsiWhiteSpace(' ')
-            PsiElement(ARROW)('->')
-            PsiWhiteSpace(' ')
-            BLOCK
               REFERENCE_EXPRESSION
-                PsiElement(IDENTIFIER)('a')
+                PsiElement(IDENTIFIER)('T')
-            PsiElement(RBRACE)('}')
+          PsiWhiteSpace(' ')
-        PsiWhiteSpace('\n\n    ')
+          PsiElement(ARROW)('->')
-        FUNCTION_LITERAL_EXPRESSION
+          PsiWhiteSpace(' ')
-          FUNCTION_LITERAL
+          BLOCK
-            PsiElement(LBRACE)('{')
+            REFERENCE_EXPRESSION
-            VALUE_PARAMETER_LIST
+              PsiElement(IDENTIFIER)('a')
-              PsiElement(LPAR)('(')
+          PsiElement(RBRACE)('}')
-              PsiElement(RPAR)(')')
+      PsiWhiteSpace('\n    ')
-            PsiWhiteSpace(' ')
+      FUNCTION_LITERAL_EXPRESSION
-            PsiElement(ARROW)('->')
+        FUNCTION_LITERAL
-            PsiWhiteSpace(' ')
+          PsiElement(LBRACE)('{')
-            BLOCK
+          VALUE_PARAMETER_LIST
+            PsiElement(LPAR)('(')
+            VALUE_PARAMETER
+              PsiElement(IDENTIFIER)('a')
+            PsiElement(RPAR)(')')
+          PsiWhiteSpace(' ')
+          PsiElement(COLON)(':')
+          PsiWhiteSpace(' ')
+          TYPE_REFERENCE
+            USER_TYPE
               REFERENCE_EXPRESSION
-                PsiElement(IDENTIFIER)('a')
+                PsiElement(IDENTIFIER)('T')
-            PsiElement(RBRACE)('}')
+          PsiWhiteSpace(' ')
-        PsiWhiteSpace('\n    ')
+          PsiElement(ARROW)('->')
-        FUNCTION_LITERAL_EXPRESSION
+          PsiWhiteSpace(' ')
-          FUNCTION_LITERAL
+          BLOCK
-            PsiElement(LBRACE)('{')
+            REFERENCE_EXPRESSION
-            VALUE_PARAMETER_LIST
+              PsiElement(IDENTIFIER)('a')
-              PsiElement(LPAR)('(')
+          PsiElement(RBRACE)('}')
-              PsiElement(RPAR)(')')
+      PsiWhiteSpace('\n\n    ')
+      FUNCTION_LITERAL_EXPRESSION
+        FUNCTION_LITERAL
+          PsiElement(LBRACE)('{')
+          VALUE_PARAMETER_LIST
+            PsiElement(LPAR)('(')
+            VALUE_PARAMETER
+              PsiElement(IDENTIFIER)('a')
+            PsiElement(COMMA)(',')
             PsiWhiteSpace(' ')
-            PsiElement(ARROW)('->')
+            VALUE_PARAMETER
+              PsiElement(IDENTIFIER)('a')
+            PsiElement(RPAR)(')')
+          PsiWhiteSpace(' ')
+          PsiElement(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(' ')
-            BLOCK
+            VALUE_PARAMETER
+              PsiElement(IDENTIFIER)('a')
+              PsiWhiteSpace(' ')
+              PsiElement(COLON)(':')
+              PsiWhiteSpace(' ')
+              TYPE_REFERENCE
+                USER_TYPE
+                  REFERENCE_EXPRESSION
+                    PsiElement(IDENTIFIER)('B')
+            PsiElement(RPAR)(')')
+          PsiWhiteSpace(' ')
+          PsiElement(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(' ')
+            VALUE_PARAMETER
+              PsiElement(IDENTIFIER)('a')
+            PsiElement(RPAR)(')')
+          PsiWhiteSpace(' ')
+          PsiElement(COLON)(':')
+          PsiWhiteSpace(' ')
+          TYPE_REFERENCE
+            USER_TYPE
               REFERENCE_EXPRESSION
-                PsiElement(IDENTIFIER)('a')
+                PsiElement(IDENTIFIER)('T')
-            PsiElement(RBRACE)('}')
+          PsiWhiteSpace(' ')
-        PsiWhiteSpace('\n    ')
+          PsiElement(ARROW)('->')
-        FUNCTION_LITERAL_EXPRESSION
+          PsiWhiteSpace(' ')
-          FUNCTION_LITERAL
+          BLOCK
-            PsiElement(LBRACE)('{')
+            REFERENCE_EXPRESSION
-            VALUE_PARAMETER_LIST
+              PsiElement(IDENTIFIER)('a')
-              PsiElement(LPAR)('(')
+          PsiElement(RBRACE)('}')
-              PsiElement(RPAR)(')')
+      PsiWhiteSpace('\n    ')
+      FUNCTION_LITERAL_EXPRESSION
+        FUNCTION_LITERAL
+          PsiElement(LBRACE)('{')
+          VALUE_PARAMETER_LIST
+            PsiElement(LPAR)('(')
+            VALUE_PARAMETER
+              PsiElement(IDENTIFIER)('a')
+            PsiElement(COMMA)(',')
             PsiWhiteSpace(' ')
-            PsiElement(COLON)(':')
+            VALUE_PARAMETER
-            PsiWhiteSpace(' ')
+              PsiElement(IDENTIFIER)('a')
-            TYPE_REFERENCE
+              PsiWhiteSpace(' ')
-              USER_TYPE
+              PsiElement(COLON)(':')
-                REFERENCE_EXPRESSION
+              PsiWhiteSpace(' ')
-                  PsiElement(IDENTIFIER)('T')
+              TYPE_REFERENCE
-            PsiWhiteSpace(' ')
+                USER_TYPE
-            PsiElement(ARROW)('->')
+                  REFERENCE_EXPRESSION
-            PsiWhiteSpace(' ')
+                    PsiElement(IDENTIFIER)('B')
-            BLOCK
+            PsiElement(RPAR)(')')
+          PsiWhiteSpace(' ')
+          PsiElement(COLON)(':')
+          PsiWhiteSpace(' ')
+          TYPE_REFERENCE
+            USER_TYPE
               REFERENCE_EXPRESSION
-                PsiElement(IDENTIFIER)('a')
+                PsiElement(IDENTIFIER)('T')
-            PsiElement(RBRACE)('}')
+          PsiWhiteSpace(' ')
-        PsiWhiteSpace('\n    ')
+          PsiElement(ARROW)('->')
-        FUNCTION_LITERAL_EXPRESSION
+          PsiWhiteSpace(' ')
-          FUNCTION_LITERAL
+          BLOCK
-            PsiElement(LBRACE)('{')
+            REFERENCE_EXPRESSION
-            VALUE_PARAMETER_LIST
+              PsiElement(IDENTIFIER)('a')
-              PsiElement(LPAR)('(')
+          PsiElement(RBRACE)('}')
-              PsiElement(RPAR)(')')
+      PsiWhiteSpace('\n\n    ')
-            PsiWhiteSpace(' ')
+      FUNCTION_LITERAL_EXPRESSION
-            PsiElement(COLON)(':')
+        FUNCTION_LITERAL
-            PsiWhiteSpace(' ')
+          PsiElement(LBRACE)('{')
-            TYPE_REFERENCE
+          VALUE_PARAMETER_LIST
-              USER_TYPE
+            PsiElement(LPAR)('(')
-                REFERENCE_EXPRESSION
+            PsiElement(RPAR)(')')
-                  PsiElement(IDENTIFIER)('T')
+          PsiWhiteSpace(' ')
-            PsiWhiteSpace(' ')
+          PsiElement(ARROW)('->')
-            PsiElement(ARROW)('->')
+          PsiWhiteSpace(' ')
-            PsiWhiteSpace(' ')
+          BLOCK
-            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(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)('a')
+                PsiElement(IDENTIFIER)('T')
-            PsiElement(RBRACE)('}')
+          PsiWhiteSpace(' ')
-        PsiWhiteSpace('\n\n    ')
+          PsiElement(ARROW)('->')
-        FUNCTION_LITERAL_EXPRESSION
+          PsiWhiteSpace(' ')
-          FUNCTION_LITERAL
+          BLOCK
-            PsiElement(LBRACE)('{')
+            REFERENCE_EXPRESSION
-            TYPE_REFERENCE
+              PsiElement(IDENTIFIER)('a')
-              USER_TYPE
+          PsiElement(RBRACE)('}')
-                REFERENCE_EXPRESSION
+      PsiWhiteSpace('\n    ')
-                  PsiElement(IDENTIFIER)('T')
+      FUNCTION_LITERAL_EXPRESSION
-            PsiElement(DOT)('.')
+        FUNCTION_LITERAL
-            VALUE_PARAMETER_LIST
+          PsiElement(LBRACE)('{')
-              PsiElement(LPAR)('(')
+          VALUE_PARAMETER_LIST
-              VALUE_PARAMETER
+            PsiElement(LPAR)('(')
-                PsiElement(IDENTIFIER)('a')
+            PsiElement(RPAR)(')')
-              PsiElement(RPAR)(')')
+          PsiWhiteSpace(' ')
-            PsiWhiteSpace(' ')
+          PsiElement(COLON)(':')
-            PsiElement(ARROW)('->')
+          PsiWhiteSpace(' ')
-            PsiWhiteSpace(' ')
+          TYPE_REFERENCE
-            BLOCK
+            USER_TYPE
               REFERENCE_EXPRESSION
-                PsiElement(IDENTIFIER)('a')
+                PsiElement(IDENTIFIER)('T')
-            PsiElement(RBRACE)('}')
+          PsiWhiteSpace(' ')
-        PsiWhiteSpace('\n    ')
+          PsiElement(ARROW)('->')
-        FUNCTION_LITERAL_EXPRESSION
+          PsiWhiteSpace(' ')
-          FUNCTION_LITERAL
+          BLOCK
-            PsiElement(LBRACE)('{')
+            REFERENCE_EXPRESSION
-            TYPE_REFERENCE
+              PsiElement(IDENTIFIER)('a')
-              USER_TYPE
+          PsiElement(RBRACE)('}')
-                REFERENCE_EXPRESSION
+      PsiWhiteSpace('\n\n    ')
-                  PsiElement(IDENTIFIER)('T')
+      FUNCTION_LITERAL_EXPRESSION
-            PsiElement(DOT)('.')
+        FUNCTION_LITERAL
-            VALUE_PARAMETER_LIST
+          PsiElement(LBRACE)('{')
-              PsiElement(LPAR)('(')
+          TYPE_REFERENCE
-              VALUE_PARAMETER
+            USER_TYPE
-                PsiElement(IDENTIFIER)('a')
-                PsiWhiteSpace(' ')
-                PsiElement(COLON)(':')
-                PsiWhiteSpace(' ')
-                TYPE_REFERENCE
-                  USER_TYPE
-                    REFERENCE_EXPRESSION
-                      PsiElement(IDENTIFIER)('A')
-              PsiElement(RPAR)(')')
-            PsiWhiteSpace(' ')
-            PsiElement(ARROW)('->')
-            PsiWhiteSpace(' ')
-            BLOCK
               REFERENCE_EXPRESSION
-                PsiElement(IDENTIFIER)('a')
+                PsiElement(IDENTIFIER)('T')
-            PsiElement(RBRACE)('}')
+          PsiElement(DOT)('.')
-        PsiWhiteSpace('\n    ')
+          VALUE_PARAMETER_LIST
-        FUNCTION_LITERAL_EXPRESSION
+            PsiElement(LPAR)('(')
-          FUNCTION_LITERAL
+            VALUE_PARAMETER
-            PsiElement(LBRACE)('{')
+              PsiElement(IDENTIFIER)('a')
-            TYPE_REFERENCE
+            PsiElement(RPAR)(')')
-              USER_TYPE
+          PsiWhiteSpace(' ')
-                REFERENCE_EXPRESSION
+          PsiElement(ARROW)('->')
-                  PsiElement(IDENTIFIER)('T')
+          PsiWhiteSpace(' ')
-            PsiElement(DOT)('.')
+          BLOCK
-            VALUE_PARAMETER_LIST
+            REFERENCE_EXPRESSION
-              PsiElement(LPAR)('(')
+              PsiElement(IDENTIFIER)('a')
-              VALUE_PARAMETER
+          PsiElement(RBRACE)('}')
-                PsiElement(IDENTIFIER)('a')
+      PsiWhiteSpace('\n    ')
-                PsiWhiteSpace(' ')
+      FUNCTION_LITERAL_EXPRESSION
-                PsiElement(COLON)(':')
+        FUNCTION_LITERAL
-                PsiWhiteSpace(' ')
+          PsiElement(LBRACE)('{')
-                TYPE_REFERENCE
+          TYPE_REFERENCE
-                  USER_TYPE
+            USER_TYPE
-                    REFERENCE_EXPRESSION
-                      PsiElement(IDENTIFIER)('A')
-              PsiElement(RPAR)(')')
-            PsiWhiteSpace(' ')
-            PsiElement(COLON)(':')
-            PsiWhiteSpace(' ')
-            TYPE_REFERENCE
-              USER_TYPE
-                REFERENCE_EXPRESSION
-                  PsiElement(IDENTIFIER)('T')
-            PsiWhiteSpace(' ')
-            PsiElement(ARROW)('->')
-            PsiWhiteSpace(' ')
-            BLOCK
               REFERENCE_EXPRESSION
-                PsiElement(IDENTIFIER)('a')
+                PsiElement(IDENTIFIER)('T')
-            PsiElement(RBRACE)('}')
+          PsiElement(DOT)('.')
-        PsiWhiteSpace('\n    ')
+          VALUE_PARAMETER_LIST
-        FUNCTION_LITERAL_EXPRESSION
+            PsiElement(LPAR)('(')
-          FUNCTION_LITERAL
+            VALUE_PARAMETER
-            PsiElement(LBRACE)('{')
+              PsiElement(IDENTIFIER)('a')
-            TYPE_REFERENCE
+              PsiWhiteSpace(' ')
-              USER_TYPE
+              PsiElement(COLON)(':')
-                REFERENCE_EXPRESSION
+              PsiWhiteSpace(' ')
-                  PsiElement(IDENTIFIER)('T')
+              TYPE_REFERENCE
-            PsiElement(DOT)('.')
+                USER_TYPE
-            VALUE_PARAMETER_LIST
+                  REFERENCE_EXPRESSION
-              PsiElement(LPAR)('(')
+                    PsiElement(IDENTIFIER)('A')
-              VALUE_PARAMETER
+            PsiElement(RPAR)(')')
-                PsiElement(IDENTIFIER)('a')
+          PsiWhiteSpace(' ')
-              PsiElement(RPAR)(')')
+          PsiElement(ARROW)('->')
-            PsiWhiteSpace(' ')
+          PsiWhiteSpace(' ')
-            PsiElement(COLON)(':')
+          BLOCK
-            PsiWhiteSpace(' ')
+            REFERENCE_EXPRESSION
-            TYPE_REFERENCE
+              PsiElement(IDENTIFIER)('a')
-              USER_TYPE
+          PsiElement(RBRACE)('}')
-                REFERENCE_EXPRESSION
+      PsiWhiteSpace('\n    ')
-                  PsiElement(IDENTIFIER)('T')
+      FUNCTION_LITERAL_EXPRESSION
-            PsiWhiteSpace(' ')
+        FUNCTION_LITERAL
-            PsiElement(ARROW)('->')
+          PsiElement(LBRACE)('{')
-            PsiWhiteSpace(' ')
+          TYPE_REFERENCE
-            BLOCK
+            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(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(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)('x')
+            PsiElement(COMMA)(',')
+            PsiWhiteSpace(' ')
+            VALUE_PARAMETER
+              PsiElement(IDENTIFIER)('y')
+          PsiWhiteSpace(' ')
+          PsiElement(ARROW)('->')
+          PsiWhiteSpace(' ')
+          BLOCK
+            INTEGER_CONSTANT
+              PsiElement(INTEGER_LITERAL)('1')
+          PsiElement(RBRACE)('}')
+      PsiWhiteSpace('\n    ')
+      FUNCTION_LITERAL_EXPRESSION
+        FUNCTION_LITERAL
+          PsiElement(LBRACE)('{')
+          BLOCK
+            ANNOTATED_EXPRESSION
+              ANNOTATION
+                PsiElement(LBRACKET)('[')
+                ANNOTATION_ENTRY
+                  CONSTRUCTOR_CALLEE
+                    TYPE_REFERENCE
+                      USER_TYPE
+                        REFERENCE_EXPRESSION
+                          PsiElement(IDENTIFIER)('a')
+                PsiElement(RBRACKET)(']')
+              PsiWhiteSpace(' ')
               REFERENCE_EXPRESSION
-                PsiElement(IDENTIFIER)('a')
-            PsiElement(RBRACE)('}')
-        PsiWhiteSpace('\n\n    ')
-        FUNCTION_LITERAL_EXPRESSION
-          FUNCTION_LITERAL
-            PsiElement(LBRACE)('{')
-            VALUE_PARAMETER_LIST
-              VALUE_PARAMETER
                 PsiElement(IDENTIFIER)('x')
+            PsiErrorElement:Unexpected tokens (use ';' to separate expressions on the same line)
               PsiElement(COMMA)(',')
               PsiWhiteSpace(' ')
-              VALUE_PARAMETER
+              PsiElement(LBRACKET)('[')
-                PsiElement(IDENTIFIER)('y')
+              PsiElement(IDENTIFIER)('b')
-            PsiWhiteSpace(' ')
+              PsiElement(RBRACKET)(']')
-            PsiElement(ARROW)('->')
+              PsiWhiteSpace(' ')
-            PsiWhiteSpace(' ')
+              PsiElement(IDENTIFIER)('y')
-            BLOCK
+              PsiElement(COMMA)(',')
-              INTEGER_CONSTANT
+              PsiWhiteSpace(' ')
-                PsiElement(INTEGER_LITERAL)('1')
+              PsiElement(LBRACKET)('[')
-            PsiElement(RBRACE)('}')
+              PsiElement(IDENTIFIER)('c')
-        PsiWhiteSpace('\n    ')
+              PsiElement(RBRACKET)(']')
-        FUNCTION_LITERAL_EXPRESSION
+              PsiWhiteSpace(' ')
-          FUNCTION_LITERAL
+              PsiElement(IDENTIFIER)('z')
-            PsiElement(LBRACE)('{')
+              PsiWhiteSpace(' ')
-            BLOCK
+              PsiElement(ARROW)('->')
-              ANNOTATED_EXPRESSION
+              PsiWhiteSpace(' ')
-                ANNOTATION
+              PsiElement(INTEGER_LITERAL)('1')
-                  PsiElement(LBRACKET)('[')
+              PsiElement(RBRACE)('}')
-                  ANNOTATION_ENTRY
+          PsiWhiteSpace('\n')
-                    CONSTRUCTOR_CALLEE
+          PsiElement(RBRACE)('}')
-                      TYPE_REFERENCE
+      PsiErrorElement:Expecting '}
-                        USER_TYPE
+        <empty list>
-                          REFERENCE_EXPRESSION
-                            PsiElement(IDENTIFIER)('a')
-                  PsiElement(RBRACKET)(']')
-                PsiWhiteSpace(' ')
-                REFERENCE_EXPRESSION
-                  PsiElement(IDENTIFIER)('x')
-              PsiErrorElement:Unexpected tokens (use ';' to separate expressions on the same line)
-                PsiElement(COMMA)(',')
-                PsiWhiteSpace(' ')
-                PsiElement(LBRACKET)('[')
-                PsiElement(IDENTIFIER)('b')
-                PsiElement(RBRACKET)(']')
-                PsiWhiteSpace(' ')
-                PsiElement(IDENTIFIER)('y')
-                PsiElement(COMMA)(',')
-                PsiWhiteSpace(' ')
-                PsiElement(LBRACKET)('[')
-                PsiElement(IDENTIFIER)('c')
-                PsiElement(RBRACKET)(']')
-                PsiWhiteSpace(' ')
-                PsiElement(IDENTIFIER)('z')
-                PsiWhiteSpace(' ')
-                PsiElement(ARROW)('->')
-                PsiWhiteSpace(' ')
-                PsiElement(INTEGER_LITERAL)('1')
-                PsiElement(RBRACE)('}')
-            PsiWhiteSpace('\n')
-            PsiElement(RBRACE)('}')
-        PsiErrorElement:Expecting '}
-          <empty list>

compiler/testData/psi/FunctionLiterals_ERR.txt

@@ -1,333 +1,332 @@
 JetFile: FunctionLiterals_ERR.jet
-  NAMESPACE
+  NAMESPACE_HEADER
-    NAMESPACE_HEADER
+    <empty list>
-      <empty list>
+  FUN
-    FUN
+    PsiElement(fun)('fun')
-      PsiElement(fun)('fun')
+    PsiWhiteSpace(' ')
-      PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('foo')
-      PsiElement(IDENTIFIER)('foo')
+    VALUE_PARAMETER_LIST
-      VALUE_PARAMETER_LIST
+      PsiElement(LPAR)('(')
-        PsiElement(LPAR)('(')
+      PsiElement(RPAR)(')')
-        PsiElement(RPAR)(')')
+    PsiWhiteSpace(' ')
-      PsiWhiteSpace(' ')
+    BLOCK
-      BLOCK
+      PsiElement(LBRACE)('{')
-        PsiElement(LBRACE)('{')
+      PsiWhiteSpace('\n    ')
-        PsiWhiteSpace('\n    ')
+      FUNCTION_LITERAL_EXPRESSION
-        FUNCTION_LITERAL_EXPRESSION
+        FUNCTION_LITERAL
-          FUNCTION_LITERAL
+          PsiElement(LBRACE)('{')
-            PsiElement(LBRACE)('{')
+          PsiWhiteSpace(' ')
-            PsiWhiteSpace(' ')
+          PsiElement(ARROW)('->')
-            PsiElement(ARROW)('->')
+          PsiWhiteSpace(' ')
-            PsiWhiteSpace(' ')
+          VALUE_PARAMETER_LIST
-            VALUE_PARAMETER_LIST
+            <empty list>
+          BLOCK
+            REFERENCE_EXPRESSION
+              PsiElement(IDENTIFIER)('a')
+          PsiElement(RBRACE)('}')
+      PsiWhiteSpace('\n\n    ')
+      FUNCTION_LITERAL_EXPRESSION
+        FUNCTION_LITERAL
+          PsiElement(LBRACE)('{')
+          VALUE_PARAMETER_LIST
+            PsiElement(LPAR)('(')
+            VALUE_PARAMETER
+              PsiElement(IDENTIFIER)('a')
+            PsiErrorElement:Expecting ')
               <empty list>
-            BLOCK
+          PsiWhiteSpace(' ')
-              REFERENCE_EXPRESSION
+          PsiElement(ARROW)('->')
-                PsiElement(IDENTIFIER)('a')
+          PsiWhiteSpace(' ')
-            PsiElement(RBRACE)('}')
+          BLOCK
-        PsiWhiteSpace('\n\n    ')
+            REFERENCE_EXPRESSION
-        FUNCTION_LITERAL_EXPRESSION
+              PsiElement(IDENTIFIER)('a')
-          FUNCTION_LITERAL
+          PsiElement(RBRACE)('}')
-            PsiElement(LBRACE)('{')
+      PsiWhiteSpace('\n    ')
-            VALUE_PARAMETER_LIST
+      FUNCTION_LITERAL_EXPRESSION
-              PsiElement(LPAR)('(')
+        FUNCTION_LITERAL
-              VALUE_PARAMETER
+          PsiElement(LBRACE)('{')
-                PsiElement(IDENTIFIER)('a')
+          VALUE_PARAMETER_LIST
-              PsiErrorElement:Expecting ')
+            PsiElement(LPAR)('(')
-                <empty list>
+            VALUE_PARAMETER
-            PsiWhiteSpace(' ')
+              PsiElement(IDENTIFIER)('a')
-            PsiElement(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(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(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(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)(')')
+              PsiElement(COLON)(':')
-            PsiWhiteSpace(' ')
-            PsiElement(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
+              TYPE_REFERENCE
-                PsiElement(COMMA)(',')
+                PsiErrorElement:Type expected
-              PsiWhiteSpace(' ')
-              VALUE_PARAMETER
-                PsiElement(IDENTIFIER)('a')
-                PsiWhiteSpace(' ')
-                PsiElement(COLON)(':')
-                PsiWhiteSpace(' ')
-                TYPE_REFERENCE
-                  USER_TYPE
-                    REFERENCE_EXPRESSION
-                      PsiElement(IDENTIFIER)('B')
-              PsiElement(RPAR)(')')
-            PsiWhiteSpace(' ')
-            PsiElement(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)(',')
+            PsiElement(RPAR)(')')
+          PsiWhiteSpace(' ')
+          PsiElement(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(' ')
-              VALUE_PARAMETER
+              PsiElement(COLON)(':')
-                PsiElement(IDENTIFIER)('a')
+              PsiWhiteSpace(' ')
-              PsiElement(RPAR)(')')
+              TYPE_REFERENCE
-            PsiWhiteSpace(' ')
+                USER_TYPE
-            PsiElement(COLON)(':')
-            PsiWhiteSpace(' ')
-            TYPE_REFERENCE
-              USER_TYPE
-                REFERENCE_EXPRESSION
-                  PsiElement(IDENTIFIER)('T')
-            PsiWhiteSpace(' ')
-            PsiElement(ARROW)('->')
-            PsiWhiteSpace(' ')
-            BLOCK
-              REFERENCE_EXPRESSION
-                PsiElement(IDENTIFIER)('a')
-            PsiElement(RBRACE)('}')
-        PsiWhiteSpace('\n\n    ')
-        FUNCTION_LITERAL_EXPRESSION
-          FUNCTION_LITERAL
-            PsiElement(LBRACE)('{')
-            BLOCK
-              DOT_QUALIFIED_EXPRESSION
-                REFERENCE_EXPRESSION
-                  PsiElement(IDENTIFIER)('T')
-                PsiElement(DOT)('.')
-                CALL_EXPRESSION
                   REFERENCE_EXPRESSION
-                    PsiElement(IDENTIFIER)('t')
+                    PsiElement(IDENTIFIER)('A')
-                  VALUE_ARGUMENT_LIST
+            PsiElement(RPAR)(')')
-                    PsiElement(LPAR)('(')
+          PsiWhiteSpace(' ')
-                    VALUE_ARGUMENT
+          PsiElement(COLON)(':')
-                      REFERENCE_EXPRESSION
+          PsiErrorElement:Expecting a type
-                        PsiElement(IDENTIFIER)('a')
+            <empty list>
-                    PsiElement(RPAR)(')')
+          PsiWhiteSpace(' ')
+          PsiElement(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(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(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(' ')
-              PsiErrorElement:Unexpected tokens (use ';' to separate expressions on the same line)
+              PsiElement(COLON)(':')
-                PsiElement(ARROW)('->')
+              PsiWhiteSpace(' ')
-                PsiWhiteSpace(' ')
+              TYPE_REFERENCE
-                PsiElement(IDENTIFIER)('a')
+                USER_TYPE
-                PsiElement(RBRACE)('}')
+                  REFERENCE_EXPRESSION
-              PsiWhiteSpace('\n    ')
+                    PsiElement(IDENTIFIER)('A')
-              FUNCTION_LITERAL_EXPRESSION
+            PsiElement(COMMA)(',')
-                FUNCTION_LITERAL
+            PsiWhiteSpace(' ')
-                  PsiElement(LBRACE)('{')
+            PsiErrorElement:Expecting a parameter declaration
-                  BLOCK
+              PsiElement(COMMA)(',')
-                    BINARY_EXPRESSION
+            PsiWhiteSpace(' ')
-                      DOT_QUALIFIED_EXPRESSION
+            VALUE_PARAMETER
+              PsiElement(IDENTIFIER)('a')
+              PsiWhiteSpace(' ')
+              PsiElement(COLON)(':')
+              PsiWhiteSpace(' ')
+              TYPE_REFERENCE
+                USER_TYPE
+                  REFERENCE_EXPRESSION
+                    PsiElement(IDENTIFIER)('B')
+            PsiElement(RPAR)(')')
+          PsiWhiteSpace(' ')
+          PsiElement(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(ARROW)('->')
+          PsiWhiteSpace(' ')
+          BLOCK
+            REFERENCE_EXPRESSION
+              PsiElement(IDENTIFIER)('a')
+          PsiElement(RBRACE)('}')
+      PsiWhiteSpace('\n\n    ')
+      FUNCTION_LITERAL_EXPRESSION
+        FUNCTION_LITERAL
+          PsiElement(LBRACE)('{')
+          BLOCK
+            DOT_QUALIFIED_EXPRESSION
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('T')
+              PsiElement(DOT)('.')
+              CALL_EXPRESSION
+                REFERENCE_EXPRESSION
+                  PsiElement(IDENTIFIER)('t')
+                VALUE_ARGUMENT_LIST
+                  PsiElement(LPAR)('(')
+                  VALUE_ARGUMENT
+                    REFERENCE_EXPRESSION
+                      PsiElement(IDENTIFIER)('a')
+                  PsiElement(RPAR)(')')
+            PsiWhiteSpace(' ')
+            PsiErrorElement:Unexpected tokens (use ';' to separate expressions on the same line)
+              PsiElement(ARROW)('->')
+              PsiWhiteSpace(' ')
+              PsiElement(IDENTIFIER)('a')
+              PsiElement(RBRACE)('}')
+            PsiWhiteSpace('\n    ')
+            FUNCTION_LITERAL_EXPRESSION
+              FUNCTION_LITERAL
+                PsiElement(LBRACE)('{')
+                BLOCK
+                  BINARY_EXPRESSION
+                    DOT_QUALIFIED_EXPRESSION
+                      REFERENCE_EXPRESSION
+                        PsiElement(IDENTIFIER)('T')
+                      PsiElement(DOT)('.')
+                      REFERENCE_EXPRESSION
+                        PsiElement(IDENTIFIER)('t')
+                    PsiWhiteSpace(' ')
+                    OPERATION_REFERENCE
+                      PsiElement(MINUS)('-')
+                    PARENTHESIZED
+                      PsiElement(LPAR)('(')
+                      BINARY_WITH_TYPE
                         REFERENCE_EXPRESSION
-                          PsiElement(IDENTIFIER)('T')
+                          PsiElement(IDENTIFIER)('a')
-                        PsiElement(DOT)('.')
+                        PsiWhiteSpace(' ')
-                        REFERENCE_EXPRESSION
+                        OPERATION_REFERENCE
-                          PsiElement(IDENTIFIER)('t')
+                          PsiElement(COLON)(':')
-                      PsiWhiteSpace(' ')
+                        PsiWhiteSpace(' ')
-                      OPERATION_REFERENCE
+                        TYPE_REFERENCE
-                        PsiElement(MINUS)('-')
+                          USER_TYPE
-                      PARENTHESIZED
+                            REFERENCE_EXPRESSION
-                        PsiElement(LPAR)('(')
+                              PsiElement(IDENTIFIER)('A')
-                        BINARY_WITH_TYPE
+                      PsiElement(RPAR)(')')
-                          REFERENCE_EXPRESSION
+                  PsiWhiteSpace(' ')
-                            PsiElement(IDENTIFIER)('a')
+                  PsiErrorElement:Unexpected tokens (use ';' to separate expressions on the same line)
-                          PsiWhiteSpace(' ')
+                    PsiElement(ARROW)('->')
-                          OPERATION_REFERENCE
+                    PsiWhiteSpace(' ')
-                            PsiElement(COLON)(':')
+                    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(' ')
                           TYPE_REFERENCE
                             USER_TYPE
                               REFERENCE_EXPRESSION
-                                PsiElement(IDENTIFIER)('A')
+                                PsiElement(IDENTIFIER)('b')
-                        PsiElement(RPAR)(')')
+                        PsiWhiteSpace(' ')
-                    PsiWhiteSpace(' ')
+                        VALUE_PARAMETER
-                    PsiErrorElement:Unexpected tokens (use ';' to separate expressions on the same line)
+                          PsiErrorElement:Expecting parameter name
+                            <empty list>
                       PsiElement(ARROW)('->')
                       PsiWhiteSpace(' ')
-                      PsiElement(IDENTIFIER)('a')
+                      BLOCK
+                        REFERENCE_EXPRESSION
+                          PsiElement(IDENTIFIER)('f')
                       PsiElement(RBRACE)('}')
-                    PsiWhiteSpace('\n\n    ')
+                  PsiWhiteSpace('\n    ')
-                    FUNCTION_LITERAL_EXPRESSION
+                  FUNCTION_LITERAL_EXPRESSION
-                      FUNCTION_LITERAL
+                    FUNCTION_LITERAL
-                        PsiElement(LBRACE)('{')
+                      PsiElement(LBRACE)('{')
-                        VALUE_PARAMETER_LIST
+                      TYPE_REFERENCE
-                          VALUE_PARAMETER
+                        USER_TYPE
-                            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(' ')
-                            TYPE_REFERENCE
-                              USER_TYPE
-                                REFERENCE_EXPRESSION
-                                  PsiElement(IDENTIFIER)('b')
-                          PsiWhiteSpace(' ')
-                          VALUE_PARAMETER
-                            PsiErrorElement:Expecting parameter name
-                              <empty list>
-                        PsiElement(ARROW)('->')
-                        PsiWhiteSpace(' ')
-                        BLOCK
                           REFERENCE_EXPRESSION
-                            PsiElement(IDENTIFIER)('f')
+                            PsiElement(IDENTIFIER)('T')
-                        PsiElement(RBRACE)('}')
+                      PsiElement(DOT)('.')
-                    PsiWhiteSpace('\n    ')
+                      VALUE_PARAMETER_LIST
-                    FUNCTION_LITERAL_EXPRESSION
+                        PsiErrorElement:Expecting a parameter list in parentheses (...)
-                      FUNCTION_LITERAL
+                          PsiElement(IDENTIFIER)('a')
-                        PsiElement(LBRACE)('{')
+                        PsiWhiteSpace(' ')
-                        TYPE_REFERENCE
+                        VALUE_PARAMETER
-                          USER_TYPE
+                          PsiErrorElement:Expecting parameter declaration
-                            REFERENCE_EXPRESSION
-                              PsiElement(IDENTIFIER)('T')
-                        PsiElement(DOT)('.')
-                        VALUE_PARAMETER_LIST
-                          PsiErrorElement:Expecting a parameter list in parentheses (...)
-                            PsiElement(IDENTIFIER)('a')
-                          PsiWhiteSpace(' ')
-                          VALUE_PARAMETER
-                            PsiErrorElement:Expecting parameter declaration
-                              <empty list>
-                            PsiElement(COLON)(':')
-                            PsiWhiteSpace(' ')
-                            TYPE_REFERENCE
-                              USER_TYPE
-                                REFERENCE_EXPRESSION
-                                  PsiElement(IDENTIFIER)('b')
-                          PsiErrorElement:Expecting ')
                             <empty list>
-                        PsiWhiteSpace(' ')
+                          PsiElement(COLON)(':')
-                        PsiElement(ARROW)('->')
+                          PsiWhiteSpace(' ')
-                        PsiWhiteSpace(' ')
+                          TYPE_REFERENCE
-                        BLOCK
+                            USER_TYPE
-                          REFERENCE_EXPRESSION
+                              REFERENCE_EXPRESSION
-                            PsiElement(IDENTIFIER)('f')
+                                PsiElement(IDENTIFIER)('b')
-                        PsiElement(RBRACE)('}')
+                        PsiErrorElement:Expecting ')
-                  PsiWhiteSpace('\n')
+                          <empty list>
-                  PsiElement(RBRACE)('}')
+                      PsiWhiteSpace(' ')
-            PsiErrorElement:Expecting '}'
+                      PsiElement(ARROW)('->')
-              <empty list>
+                      PsiWhiteSpace(' ')
+                      BLOCK
+                        REFERENCE_EXPRESSION
+                          PsiElement(IDENTIFIER)('f')
+                      PsiElement(RBRACE)('}')
+                PsiWhiteSpace('\n')
+                PsiElement(RBRACE)('}')
+          PsiErrorElement:Expecting '}'
+            <empty list>

compiler/testData/psi/FunctionTypes_ERR.txt

@@ -1,34 +1,33 @@
 JetFile: FunctionTypes_ERR.jet
-  NAMESPACE
+  NAMESPACE_HEADER
-    NAMESPACE_HEADER
+    <empty list>
+  TYPEDEF
+    PsiElement(type)('type')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('f')
+    PsiWhiteSpace(' ')
+    TYPE_PARAMETER_LIST
       <empty list>
-    TYPEDEF
+    PsiElement(EQ)('=')
-      PsiElement(type)('type')
+    PsiWhiteSpace('  ')
-      PsiWhiteSpace(' ')
+    TYPE_REFERENCE
-      PsiElement(IDENTIFIER)('f')
+      FUNCTION_TYPE
-      PsiWhiteSpace(' ')
+        VALUE_PARAMETER_LIST
-      TYPE_PARAMETER_LIST
+          PsiElement(LPAR)('(')
-        <empty list>
+          VALUE_PARAMETER
-      PsiElement(EQ)('=')
+            TYPE_REFERENCE
-      PsiWhiteSpace('  ')
+              USER_TYPE
-      TYPE_REFERENCE
+                REFERENCE_EXPRESSION
-        FUNCTION_TYPE
+                  PsiElement(IDENTIFIER)('a')
-          VALUE_PARAMETER_LIST
+          PsiElement(COMMA)(',')
-            PsiElement(LPAR)('(')
+          PsiErrorElement:Expecting a parameter declaration
-            VALUE_PARAMETER
+            <empty list>
-              TYPE_REFERENCE
-                USER_TYPE
-                  REFERENCE_EXPRESSION
-                    PsiElement(IDENTIFIER)('a')
-            PsiElement(COMMA)(',')
-            PsiErrorElement:Expecting a parameter declaration
-              <empty list>
-            PsiWhiteSpace(' ')
-            PsiElement(RPAR)(')')
           PsiWhiteSpace(' ')
-          PsiElement(ARROW)('->')
+          PsiElement(RPAR)(')')
-          PsiWhiteSpace(' ')
+        PsiWhiteSpace(' ')
-          TYPE_REFERENCE
+        PsiElement(ARROW)('->')
-            USER_TYPE
+        PsiWhiteSpace(' ')
-              REFERENCE_EXPRESSION
+        TYPE_REFERENCE
-                PsiElement(IDENTIFIER)('b')
+          USER_TYPE
+            REFERENCE_EXPRESSION
+              PsiElement(IDENTIFIER)('b')

compiler/testData/psi/Functions_ERR.txt

@@ -1,19 +1,44 @@
 JetFile: Functions_ERR.jet
-  NAMESPACE
+  NAMESPACE_HEADER
-    NAMESPACE_HEADER
+    <empty list>
-      <empty list>
+  FUN
-    FUN
+    PsiElement(fun)('fun')
-      PsiElement(fun)('fun')
+    PsiWhiteSpace(' ')
-      PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('foo')
-      PsiElement(IDENTIFIER)('foo')
+    VALUE_PARAMETER_LIST
-      VALUE_PARAMETER_LIST
+      PsiErrorElement:Expecting '(
-        PsiErrorElement:Expecting '(
+        <empty list>
+      PsiElement(RPAR)(')')
+  PsiWhiteSpace('\n')
+  FUN
+    PsiElement(fun)('fun')
+    PsiWhiteSpace(' ')
+    ANNOTATION
+      PsiElement(LBRACKET)('[')
+      ANNOTATION_ENTRY
+        CONSTRUCTOR_CALLEE
+          TYPE_REFERENCE
+            USER_TYPE
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('a')
+      PsiElement(RBRACKET)(']')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('f')
+    PsiWhiteSpace(' ')
+    VALUE_PARAMETER_LIST
+      PsiErrorElement:Expecting '(
+        PsiElement(IDENTIFIER)('foo')
+      VALUE_PARAMETER
+        PsiErrorElement:Parameter name expected
+          PsiElement(LPAR)('(')
+        PsiErrorElement:Parameters must have type annotation
           <empty list>
-        PsiElement(RPAR)(')')
+      PsiElement(RPAR)(')')
-    PsiWhiteSpace('\n')
+  PsiWhiteSpace('\n')
-    FUN
+  FUN
-      PsiElement(fun)('fun')
+    PsiElement(fun)('fun')
-      PsiWhiteSpace(' ')
+    PsiWhiteSpace(' ')
+    TYPE_REFERENCE
       ANNOTATION
         PsiElement(LBRACKET)('[')
         ANNOTATION_ENTRY
@@ -24,296 +49,270 @@ JetFile: Functions_ERR.jet
                   PsiElement(IDENTIFIER)('a')
         PsiElement(RBRACKET)(']')
       PsiWhiteSpace(' ')
-      PsiElement(IDENTIFIER)('f')
+      USER_TYPE
-      PsiWhiteSpace(' ')
+        REFERENCE_EXPRESSION
-      VALUE_PARAMETER_LIST
-        PsiErrorElement:Expecting '(
-          PsiElement(IDENTIFIER)('foo')
-        VALUE_PARAMETER
-          PsiErrorElement:Parameter name expected
-            PsiElement(LPAR)('(')
-          PsiErrorElement:Parameters must have type annotation
-            <empty list>
-        PsiElement(RPAR)(')')
-    PsiWhiteSpace('\n')
-    FUN
-      PsiElement(fun)('fun')
-      PsiWhiteSpace(' ')
-      TYPE_REFERENCE
-        ANNOTATION
-          PsiElement(LBRACKET)('[')
-          ANNOTATION_ENTRY
-            CONSTRUCTOR_CALLEE
-              TYPE_REFERENCE
-                USER_TYPE
-                  REFERENCE_EXPRESSION
-                    PsiElement(IDENTIFIER)('a')
-          PsiElement(RBRACKET)(']')
-        PsiWhiteSpace(' ')
-        USER_TYPE
-          REFERENCE_EXPRESSION
-            PsiElement(IDENTIFIER)('T')
-      PsiElement(DOT)('.')
-      PsiElement(IDENTIFIER)('foo')
-      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(COLON)(':')
-      PsiWhiteSpace(' ')
-      TYPE_REFERENCE
-        USER_TYPE
-          REFERENCE_EXPRESSION
-            PsiElement(IDENTIFIER)('bar')
-    PsiWhiteSpace('\n')
-    FUN
-      PsiElement(fun)('fun')
-      PsiWhiteSpace(' ')
-      TYPE_REFERENCE
-        ANNOTATION
-          PsiElement(LBRACKET)('[')
-          ANNOTATION_ENTRY
-            CONSTRUCTOR_CALLEE
-              TYPE_REFERENCE
-                USER_TYPE
-                  REFERENCE_EXPRESSION
-                    PsiElement(IDENTIFIER)('a')
-            VALUE_ARGUMENT_LIST
-              PsiElement(LPAR)('(')
-              PsiElement(RPAR)(')')
-          PsiElement(RBRACKET)(']')
-        PsiWhiteSpace(' ')
-        USER_TYPE
-          REFERENCE_EXPRESSION
-            PsiElement(IDENTIFIER)('T')
-      PsiElement(DOT)('.')
-      PsiElement(IDENTIFIER)('foo')
-      TYPE_PARAMETER_LIST
-        PsiElement(LT)('<')
-        PsiErrorElement:Type parameter declaration expected
-          <empty list>
-        PsiElement(GT)('>')
-      VALUE_PARAMETER_LIST
-        PsiElement(LPAR)('(')
-        VALUE_PARAMETER
-          PsiElement(IDENTIFIER)('a')
-          PsiWhiteSpace(' ')
-          PsiElement(COLON)(':')
-          PsiWhiteSpace(' ')
-          TYPE_REFERENCE
-            USER_TYPE
-              REFERENCE_EXPRESSION
-                PsiElement(IDENTIFIER)('foo')
-        PsiElement(RPAR)(')')
-      PsiWhiteSpace(' ')
-      PsiElement(COLON)(':')
-      PsiWhiteSpace(' ')
-      TYPE_REFERENCE
-        USER_TYPE
-          REFERENCE_EXPRESSION
-            PsiElement(IDENTIFIER)('bar')
-    PsiWhiteSpace('\n')
-    FUN
-      PsiElement(fun)('fun')
-      PsiWhiteSpace(' ')
-      TYPE_REFERENCE
-        ANNOTATION
-          PsiElement(LBRACKET)('[')
-          ANNOTATION_ENTRY
-            CONSTRUCTOR_CALLEE
-              TYPE_REFERENCE
-                USER_TYPE
-                  REFERENCE_EXPRESSION
-                    PsiElement(IDENTIFIER)('a')
-            VALUE_ARGUMENT_LIST
-              PsiElement(LPAR)('(')
-              PsiElement(RPAR)(')')
-          PsiElement(RBRACKET)(']')
-        PsiWhiteSpace(' ')
-        USER_TYPE
-          REFERENCE_EXPRESSION
-            PsiElement(IDENTIFIER)('T')
-      PsiElement(DOT)('.')
-      PsiElement(IDENTIFIER)('foo')
-      TYPE_PARAMETER_LIST
-        PsiElement(LT)('<')
-        TYPE_PARAMETER
           PsiElement(IDENTIFIER)('T')
-        PsiElement(COMMA)(',')
+    PsiElement(DOT)('.')
-        PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('foo')
-        PsiErrorElement:Expecting type parameter declaration
+    VALUE_PARAMETER_LIST
-          PsiElement(COMMA)(',')
+      PsiElement(LPAR)('(')
-        PsiWhiteSpace(' ')
+      VALUE_PARAMETER
-        TYPE_PARAMETER
-          PsiElement(IDENTIFIER)('T')
-        PsiElement(GT)('>')
-      VALUE_PARAMETER_LIST
-        PsiElement(LPAR)('(')
-        VALUE_PARAMETER
-          PsiElement(IDENTIFIER)('a')
-          PsiWhiteSpace(' ')
-          PsiElement(COLON)(':')
-          PsiWhiteSpace(' ')
-          TYPE_REFERENCE
-            USER_TYPE
-              REFERENCE_EXPRESSION
-                PsiElement(IDENTIFIER)('foo')
-        PsiElement(RPAR)(')')
-      PsiWhiteSpace(' ')
-      PsiElement(COLON)(':')
-      PsiWhiteSpace(' ')
-      TYPE_REFERENCE
-        USER_TYPE
-          REFERENCE_EXPRESSION
-            PsiElement(IDENTIFIER)('bar')
-    PsiWhiteSpace('\n')
-    FUN
-      PsiElement(fun)('fun')
-      PsiWhiteSpace(' ')
-      TYPE_REFERENCE
-        ANNOTATION
-          PsiElement(LBRACKET)('[')
-          ANNOTATION_ENTRY
-            CONSTRUCTOR_CALLEE
-              TYPE_REFERENCE
-                USER_TYPE
-                  REFERENCE_EXPRESSION
-                    PsiElement(IDENTIFIER)('a')
-            VALUE_ARGUMENT_LIST
-              PsiElement(LPAR)('(')
-              PsiElement(RPAR)(')')
-          PsiElement(RBRACKET)(']')
-        PsiWhiteSpace(' ')
-        USER_TYPE
-          REFERENCE_EXPRESSION
-            PsiElement(IDENTIFIER)('T')
-      PsiElement(DOT)('.')
-      PsiElement(IDENTIFIER)('foo')
-      TYPE_PARAMETER_LIST
-        PsiElement(LT)('<')
-        PsiErrorElement:Expecting type parameter declaration
-          PsiElement(COMMA)(',')
-        PsiWhiteSpace(' ')
-        TYPE_PARAMETER
-          PsiElement(IDENTIFIER)('T')
-        PsiElement(COMMA)(',')
-        PsiWhiteSpace(' ')
-        PsiErrorElement:Expecting type parameter declaration
-          PsiElement(COMMA)(',')
-        PsiWhiteSpace(' ')
-        TYPE_PARAMETER
-          PsiElement(IDENTIFIER)('T')
-        PsiElement(GT)('>')
-      VALUE_PARAMETER_LIST
-        PsiElement(LPAR)('(')
-        VALUE_PARAMETER
-          PsiElement(IDENTIFIER)('a')
-          PsiWhiteSpace(' ')
-          PsiElement(COLON)(':')
-          PsiWhiteSpace(' ')
-          TYPE_REFERENCE
-            USER_TYPE
-              REFERENCE_EXPRESSION
-                PsiElement(IDENTIFIER)('foo')
-        PsiElement(RPAR)(')')
-      PsiWhiteSpace(' ')
-      PsiElement(COLON)(':')
-      PsiWhiteSpace(' ')
-      TYPE_REFERENCE
-        USER_TYPE
-          REFERENCE_EXPRESSION
-            PsiElement(IDENTIFIER)('bar')
-    PsiWhiteSpace('\n')
-    FUN
-      PsiElement(fun)('fun')
-      PsiWhiteSpace(' ')
-      TYPE_REFERENCE
-        ANNOTATION
-          PsiElement(LBRACKET)('[')
-          ANNOTATION_ENTRY
-            CONSTRUCTOR_CALLEE
-              TYPE_REFERENCE
-                USER_TYPE
-                  REFERENCE_EXPRESSION
-                    PsiElement(IDENTIFIER)('a')
-            VALUE_ARGUMENT_LIST
-              PsiElement(LPAR)('(')
-              PsiElement(RPAR)(')')
-          PsiElement(RBRACKET)(']')
-        PsiWhiteSpace(' ')
-        USER_TYPE
-          REFERENCE_EXPRESSION
-            PsiElement(IDENTIFIER)('T')
-      PsiElement(DOT)('.')
-      PsiElement(IDENTIFIER)('foo')
-      TYPE_PARAMETER_LIST
-        PsiElement(LT)('<')
-        TYPE_PARAMETER
-          PsiElement(IDENTIFIER)('T')
-        PsiElement(COMMA)(',')
-        PsiWhiteSpace(' ')
-        TYPE_PARAMETER
-          PsiElement(IDENTIFIER)('T')
-        PsiElement(GT)('>')
-      VALUE_PARAMETER_LIST
-        PsiElement(LPAR)('(')
-        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)('foo')
-        PsiElement(COMMA)(',')
-        PsiWhiteSpace(' ')
-        PsiErrorElement:Expecting a parameter declaration
-          PsiElement(COMMA)(',')
-        PsiWhiteSpace(' ')
-        VALUE_PARAMETER
-          PsiElement(IDENTIFIER)('a')
-          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)('bar')
-    PsiWhiteSpace('\n\n')
-    FUN
-      PsiElement(fun)('fun')
-      PsiWhiteSpace(' ')
-      PsiElement(IDENTIFIER)('foo')
-      VALUE_PARAMETER_LIST
-        PsiElement(LPAR)('(')
-        PsiElement(RPAR)(')')
-      PsiWhiteSpace(' ')
-      PsiElement(COLON)(':')
-      PsiWhiteSpace(' ')
-      TYPE_REFERENCE
-        PsiErrorElement:Type expected
-          <empty list>
-      PsiElement(EQ)('=')
-      PsiWhiteSpace(' ')
-      REFERENCE_EXPRESSION
         PsiElement(IDENTIFIER)('a')
-      PsiElement(SEMICOLON)(';')
+        PsiWhiteSpace(' ')
+        PsiElement(COLON)(':')
+        PsiWhiteSpace(' ')
+        TYPE_REFERENCE
+          PsiErrorElement:Type expected
+            <empty list>
+      PsiElement(RPAR)(')')
+    PsiWhiteSpace(' ')
+    PsiElement(COLON)(':')
+    PsiWhiteSpace(' ')
+    TYPE_REFERENCE
+      USER_TYPE
+        REFERENCE_EXPRESSION
+          PsiElement(IDENTIFIER)('bar')
+  PsiWhiteSpace('\n')
+  FUN
+    PsiElement(fun)('fun')
+    PsiWhiteSpace(' ')
+    TYPE_REFERENCE
+      ANNOTATION
+        PsiElement(LBRACKET)('[')
+        ANNOTATION_ENTRY
+          CONSTRUCTOR_CALLEE
+            TYPE_REFERENCE
+              USER_TYPE
+                REFERENCE_EXPRESSION
+                  PsiElement(IDENTIFIER)('a')
+          VALUE_ARGUMENT_LIST
+            PsiElement(LPAR)('(')
+            PsiElement(RPAR)(')')
+        PsiElement(RBRACKET)(']')
+      PsiWhiteSpace(' ')
+      USER_TYPE
+        REFERENCE_EXPRESSION
+          PsiElement(IDENTIFIER)('T')
+    PsiElement(DOT)('.')
+    PsiElement(IDENTIFIER)('foo')
+    TYPE_PARAMETER_LIST
+      PsiElement(LT)('<')
+      PsiErrorElement:Type parameter declaration expected
+        <empty list>
+      PsiElement(GT)('>')
+    VALUE_PARAMETER_LIST
+      PsiElement(LPAR)('(')
+      VALUE_PARAMETER
+        PsiElement(IDENTIFIER)('a')
+        PsiWhiteSpace(' ')
+        PsiElement(COLON)(':')
+        PsiWhiteSpace(' ')
+        TYPE_REFERENCE
+          USER_TYPE
+            REFERENCE_EXPRESSION
+              PsiElement(IDENTIFIER)('foo')
+      PsiElement(RPAR)(')')
+    PsiWhiteSpace(' ')
+    PsiElement(COLON)(':')
+    PsiWhiteSpace(' ')
+    TYPE_REFERENCE
+      USER_TYPE
+        REFERENCE_EXPRESSION
+          PsiElement(IDENTIFIER)('bar')
+  PsiWhiteSpace('\n')
+  FUN
+    PsiElement(fun)('fun')
+    PsiWhiteSpace(' ')
+    TYPE_REFERENCE
+      ANNOTATION
+        PsiElement(LBRACKET)('[')
+        ANNOTATION_ENTRY
+          CONSTRUCTOR_CALLEE
+            TYPE_REFERENCE
+              USER_TYPE
+                REFERENCE_EXPRESSION
+                  PsiElement(IDENTIFIER)('a')
+          VALUE_ARGUMENT_LIST
+            PsiElement(LPAR)('(')
+            PsiElement(RPAR)(')')
+        PsiElement(RBRACKET)(']')
+      PsiWhiteSpace(' ')
+      USER_TYPE
+        REFERENCE_EXPRESSION
+          PsiElement(IDENTIFIER)('T')
+    PsiElement(DOT)('.')
+    PsiElement(IDENTIFIER)('foo')
+    TYPE_PARAMETER_LIST
+      PsiElement(LT)('<')
+      TYPE_PARAMETER
+        PsiElement(IDENTIFIER)('T')
+      PsiElement(COMMA)(',')
+      PsiWhiteSpace(' ')
+      PsiErrorElement:Expecting type parameter declaration
+        PsiElement(COMMA)(',')
+      PsiWhiteSpace(' ')
+      TYPE_PARAMETER
+        PsiElement(IDENTIFIER)('T')
+      PsiElement(GT)('>')
+    VALUE_PARAMETER_LIST
+      PsiElement(LPAR)('(')
+      VALUE_PARAMETER
+        PsiElement(IDENTIFIER)('a')
+        PsiWhiteSpace(' ')
+        PsiElement(COLON)(':')
+        PsiWhiteSpace(' ')
+        TYPE_REFERENCE
+          USER_TYPE
+            REFERENCE_EXPRESSION
+              PsiElement(IDENTIFIER)('foo')
+      PsiElement(RPAR)(')')
+    PsiWhiteSpace(' ')
+    PsiElement(COLON)(':')
+    PsiWhiteSpace(' ')
+    TYPE_REFERENCE
+      USER_TYPE
+        REFERENCE_EXPRESSION
+          PsiElement(IDENTIFIER)('bar')
+  PsiWhiteSpace('\n')
+  FUN
+    PsiElement(fun)('fun')
+    PsiWhiteSpace(' ')
+    TYPE_REFERENCE
+      ANNOTATION
+        PsiElement(LBRACKET)('[')
+        ANNOTATION_ENTRY
+          CONSTRUCTOR_CALLEE
+            TYPE_REFERENCE
+              USER_TYPE
+                REFERENCE_EXPRESSION
+                  PsiElement(IDENTIFIER)('a')
+          VALUE_ARGUMENT_LIST
+            PsiElement(LPAR)('(')
+            PsiElement(RPAR)(')')
+        PsiElement(RBRACKET)(']')
+      PsiWhiteSpace(' ')
+      USER_TYPE
+        REFERENCE_EXPRESSION
+          PsiElement(IDENTIFIER)('T')
+    PsiElement(DOT)('.')
+    PsiElement(IDENTIFIER)('foo')
+    TYPE_PARAMETER_LIST
+      PsiElement(LT)('<')
+      PsiErrorElement:Expecting type parameter declaration
+        PsiElement(COMMA)(',')
+      PsiWhiteSpace(' ')
+      TYPE_PARAMETER
+        PsiElement(IDENTIFIER)('T')
+      PsiElement(COMMA)(',')
+      PsiWhiteSpace(' ')
+      PsiErrorElement:Expecting type parameter declaration
+        PsiElement(COMMA)(',')
+      PsiWhiteSpace(' ')
+      TYPE_PARAMETER
+        PsiElement(IDENTIFIER)('T')
+      PsiElement(GT)('>')
+    VALUE_PARAMETER_LIST
+      PsiElement(LPAR)('(')
+      VALUE_PARAMETER
+        PsiElement(IDENTIFIER)('a')
+        PsiWhiteSpace(' ')
+        PsiElement(COLON)(':')
+        PsiWhiteSpace(' ')
+        TYPE_REFERENCE
+          USER_TYPE
+            REFERENCE_EXPRESSION
+              PsiElement(IDENTIFIER)('foo')
+      PsiElement(RPAR)(')')
+    PsiWhiteSpace(' ')
+    PsiElement(COLON)(':')
+    PsiWhiteSpace(' ')
+    TYPE_REFERENCE
+      USER_TYPE
+        REFERENCE_EXPRESSION
+          PsiElement(IDENTIFIER)('bar')
+  PsiWhiteSpace('\n')
+  FUN
+    PsiElement(fun)('fun')
+    PsiWhiteSpace(' ')
+    TYPE_REFERENCE
+      ANNOTATION
+        PsiElement(LBRACKET)('[')
+        ANNOTATION_ENTRY
+          CONSTRUCTOR_CALLEE
+            TYPE_REFERENCE
+              USER_TYPE
+                REFERENCE_EXPRESSION
+                  PsiElement(IDENTIFIER)('a')
+          VALUE_ARGUMENT_LIST
+            PsiElement(LPAR)('(')
+            PsiElement(RPAR)(')')
+        PsiElement(RBRACKET)(']')
+      PsiWhiteSpace(' ')
+      USER_TYPE
+        REFERENCE_EXPRESSION
+          PsiElement(IDENTIFIER)('T')
+    PsiElement(DOT)('.')
+    PsiElement(IDENTIFIER)('foo')
+    TYPE_PARAMETER_LIST
+      PsiElement(LT)('<')
+      TYPE_PARAMETER
+        PsiElement(IDENTIFIER)('T')
+      PsiElement(COMMA)(',')
+      PsiWhiteSpace(' ')
+      TYPE_PARAMETER
+        PsiElement(IDENTIFIER)('T')
+      PsiElement(GT)('>')
+    VALUE_PARAMETER_LIST
+      PsiElement(LPAR)('(')
+      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)('foo')
+      PsiElement(COMMA)(',')
+      PsiWhiteSpace(' ')
+      PsiErrorElement:Expecting a parameter declaration
+        PsiElement(COMMA)(',')
+      PsiWhiteSpace(' ')
+      VALUE_PARAMETER
+        PsiElement(IDENTIFIER)('a')
+        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)('bar')
+  PsiWhiteSpace('\n\n')
+  FUN
+    PsiElement(fun)('fun')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('foo')
+    VALUE_PARAMETER_LIST
+      PsiElement(LPAR)('(')
+      PsiElement(RPAR)(')')
+    PsiWhiteSpace(' ')
+    PsiElement(COLON)(':')
+    PsiWhiteSpace(' ')
+    TYPE_REFERENCE
+      PsiErrorElement:Type expected
+        <empty list>
+    PsiElement(EQ)('=')
+    PsiWhiteSpace(' ')
+    REFERENCE_EXPRESSION
+      PsiElement(IDENTIFIER)('a')
+    PsiElement(SEMICOLON)(';')

compiler/testData/psi/HangOnLonelyModifier.txt

@@ -1,19 +1,18 @@
 JetFile: HangOnLonelyModifier.jet
-  NAMESPACE
+  NAMESPACE_HEADER
-    NAMESPACE_HEADER
+    <empty list>
-      <empty list>
+  FUN
-    FUN
+    PsiElement(fun)('fun')
-      PsiElement(fun)('fun')
+    PsiWhiteSpace(' ')
-      PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('test')
-      PsiElement(IDENTIFIER)('test')
+    VALUE_PARAMETER_LIST
-      VALUE_PARAMETER_LIST
+      PsiElement(LPAR)('(')
-        PsiElement(LPAR)('(')
+      PsiElement(RPAR)(')')
-        PsiElement(RPAR)(')')
+    PsiWhiteSpace(' ')
-      PsiWhiteSpace(' ')
+    BLOCK
-      BLOCK
+      PsiElement(LBRACE)('{')
-        PsiElement(LBRACE)('{')
+      PsiWhiteSpace('\n')
-        PsiWhiteSpace('\n')
+      PsiErrorElement:Expecting a statement
-        PsiErrorElement:Expecting a statement
+        PsiElement(in)('in')
-          PsiElement(in)('in')
+      PsiWhiteSpace('\n')
-        PsiWhiteSpace('\n')
+      PsiElement(RBRACE)('}')
-        PsiElement(RBRACE)('}')

compiler/testData/psi/IfWithPropery.txt

@@ -1,88 +1,87 @@
 JetFile: IfWithPropery.jet
-  NAMESPACE
+  NAMESPACE_HEADER
-    NAMESPACE_HEADER
+    <empty list>
-      <empty list>
+  PROPERTY
-    PROPERTY
+    PsiElement(val)('val')
-      PsiElement(val)('val')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('a')
+    PsiWhiteSpace(' ')
+    PsiElement(EQ)('=')
+    PsiWhiteSpace(' ')
+    IF
+      PsiElement(if)('if')
+      PsiElement(LPAR)('(')
+      CONDITION
+        INTEGER_CONSTANT
+          PsiElement(INTEGER_LITERAL)('1')
+      PsiElement(RPAR)(')')
       PsiWhiteSpace(' ')
-      PsiElement(IDENTIFIER)('a')
+      THEN
-      PsiWhiteSpace(' ')
+        BLOCK
-      PsiElement(EQ)('=')
+          PsiElement(LBRACE)('{')
-      PsiWhiteSpace(' ')
+          PROPERTY
-      IF
+            PsiElement(var)('var')
-        PsiElement(if)('if')
+            PsiWhiteSpace(' ')
-        PsiElement(LPAR)('(')
+            PsiElement(IDENTIFIER)('f')
-        CONDITION
+            PsiWhiteSpace(' ')
-          INTEGER_CONSTANT
+            PsiElement(EQ)('=')
-            PsiElement(INTEGER_LITERAL)('1')
+            PsiWhiteSpace(' ')
-        PsiElement(RPAR)(')')
-        PsiWhiteSpace(' ')
-        THEN
-          BLOCK
-            PsiElement(LBRACE)('{')
-            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(RBRACE)('}')
+          PsiElement(SEMICOLON)(';')
-        PsiWhiteSpace(' ')
+          REFERENCE_EXPRESSION
-        PsiElement(else)('else')
+            PsiElement(IDENTIFIER)('a')
-        PsiWhiteSpace(' ')
+          PsiElement(RBRACE)('}')
-        ELSE
-          BLOCK
-            PsiElement(LBRACE)('{')
-            NULL
-              PsiElement(null)('null')
-            PsiElement(RBRACE)('}')
-    PsiWhiteSpace('\n')
-    PROPERTY
-      PsiElement(val)('val')
       PsiWhiteSpace(' ')
-      PsiElement(IDENTIFIER)('a')
+      PsiElement(else)('else')
       PsiWhiteSpace(' ')
-      PsiElement(EQ)('=')
+      ELSE
+        BLOCK
+          PsiElement(LBRACE)('{')
+          NULL
+            PsiElement(null)('null')
+          PsiElement(RBRACE)('}')
+  PsiWhiteSpace('\n')
+  PROPERTY
+    PsiElement(val)('val')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('a')
+    PsiWhiteSpace(' ')
+    PsiElement(EQ)('=')
+    PsiWhiteSpace(' ')
+    IF
+      PsiElement(if)('if')
+      PsiElement(LPAR)('(')
+      CONDITION
+        INTEGER_CONSTANT
+          PsiElement(INTEGER_LITERAL)('1')
+      PsiElement(RPAR)(')')
       PsiWhiteSpace(' ')
-      IF
+      THEN
-        PsiElement(if)('if')
+        BLOCK
-        PsiElement(LPAR)('(')
+          PsiElement(LBRACE)('{')
-        CONDITION
+          PsiWhiteSpace('\n  ')
-          INTEGER_CONSTANT
+          PROPERTY
-            PsiElement(INTEGER_LITERAL)('1')
+            PsiElement(var)('var')
-        PsiElement(RPAR)(')')
+            PsiWhiteSpace(' ')
-        PsiWhiteSpace(' ')
+            PsiElement(IDENTIFIER)('f')
-        THEN
+            PsiWhiteSpace(' ')
-          BLOCK
+            PsiElement(EQ)('=')
-            PsiElement(LBRACE)('{')
+            PsiWhiteSpace(' ')
-            PsiWhiteSpace('\n  ')
-            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')
-            PsiWhiteSpace('\n')
+          PsiElement(SEMICOLON)(';')
-            PsiElement(RBRACE)('}')
+          PsiWhiteSpace('\n  ')
-        PsiWhiteSpace(' ')
+          REFERENCE_EXPRESSION
-        PsiElement(else)('else')
+            PsiElement(IDENTIFIER)('a')
-        PsiWhiteSpace(' ')
+          PsiWhiteSpace('\n')
-        ELSE
+          PsiElement(RBRACE)('}')
-          BLOCK
+      PsiWhiteSpace(' ')
-            PsiElement(LBRACE)('{')
+      PsiElement(else)('else')
-            NULL
+      PsiWhiteSpace(' ')
-              PsiElement(null)('null')
+      ELSE
-            PsiElement(RBRACE)('}')
+        BLOCK
+          PsiElement(LBRACE)('{')
+          NULL
+            PsiElement(null)('null')
+          PsiElement(RBRACE)('}')

compiler/testData/psi/ImportSoftKW.txt

@@ -1,25 +1,24 @@
 JetFile: ImportSoftKW.jet
-  NAMESPACE
+  NAMESPACE_HEADER
-    NAMESPACE_HEADER
+    <empty list>
-      <empty list>
+  IMPORT_DIRECTIVE
-    IMPORT_DIRECTIVE
+    PsiElement(import)('import')
-      PsiElement(import)('import')
+    PsiWhiteSpace(' ')
-      PsiWhiteSpace(' ')
+    DOT_QUALIFIED_EXPRESSION
       DOT_QUALIFIED_EXPRESSION
         DOT_QUALIFIED_EXPRESSION
-          DOT_QUALIFIED_EXPRESSION
+          REFERENCE_EXPRESSION
-            REFERENCE_EXPRESSION
+            PsiElement(IDENTIFIER)('import')
-              PsiElement(IDENTIFIER)('import')
-            PsiElement(DOT)('.')
-            REFERENCE_EXPRESSION
-              PsiElement(IDENTIFIER)('import')
           PsiElement(DOT)('.')
           REFERENCE_EXPRESSION
             PsiElement(IDENTIFIER)('import')
         PsiElement(DOT)('.')
         REFERENCE_EXPRESSION
           PsiElement(IDENTIFIER)('import')
-      PsiWhiteSpace(' ')
+      PsiElement(DOT)('.')
-      PsiElement(as)('as')
+      REFERENCE_EXPRESSION
-      PsiWhiteSpace(' ')
+        PsiElement(IDENTIFIER)('import')
-      PsiElement(IDENTIFIER)('import')
+    PsiWhiteSpace(' ')
+    PsiElement(as)('as')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('import')

compiler/testData/psi/Imports.txt

@@ -1,77 +1,76 @@
 JetFile: Imports.jet
-  NAMESPACE
+  NAMESPACE_HEADER
-    NAMESPACE_HEADER
+    PsiElement(namespace)('package')
-      PsiElement(namespace)('package')
+    PsiWhiteSpace(' ')
-      PsiWhiteSpace(' ')
+    REFERENCE_EXPRESSION
+      PsiElement(IDENTIFIER)('foo')
+    PsiElement(DOT)('.')
+    REFERENCE_EXPRESSION
+      PsiElement(IDENTIFIER)('bar')
+    PsiElement(DOT)('.')
+    PsiElement(IDENTIFIER)('goo')
+  PsiWhiteSpace('\n\n')
+  IMPORT_DIRECTIVE
+    PsiElement(import)('import')
+    PsiWhiteSpace(' ')
+    PsiElement(namespace)('package')
+    PsiElement(DOT)('.')
+    REFERENCE_EXPRESSION
+      PsiElement(IDENTIFIER)('foo')
+  PsiWhiteSpace('\n')
+  IMPORT_DIRECTIVE
+    PsiElement(import)('import')
+    PsiWhiteSpace(' ')
+    REFERENCE_EXPRESSION
+      PsiElement(IDENTIFIER)('foo')
+  PsiWhiteSpace('\n')
+  IMPORT_DIRECTIVE
+    PsiElement(import)('import')
+    PsiWhiteSpace(' ')
+    DOT_QUALIFIED_EXPRESSION
       REFERENCE_EXPRESSION
         PsiElement(IDENTIFIER)('foo')
       PsiElement(DOT)('.')
       REFERENCE_EXPRESSION
         PsiElement(IDENTIFIER)('bar')
-      PsiElement(DOT)('.')
+  PsiWhiteSpace('\n')
-      PsiElement(IDENTIFIER)('goo')
+  IMPORT_DIRECTIVE
-    PsiWhiteSpace('\n\n')
+    PsiElement(import)('import')
-    IMPORT_DIRECTIVE
+    PsiWhiteSpace(' ')
-      PsiElement(import)('import')
+    REFERENCE_EXPRESSION
-      PsiWhiteSpace(' ')
+      PsiElement(IDENTIFIER)('foo')
-      PsiElement(namespace)('package')
+    PsiWhiteSpace(' ')
-      PsiElement(DOT)('.')
+    PsiElement(as)('as')
-      REFERENCE_EXPRESSION
+    PsiWhiteSpace(' ')
-        PsiElement(IDENTIFIER)('foo')
+    PsiElement(IDENTIFIER)('bar')
-    PsiWhiteSpace('\n')
+  PsiWhiteSpace('\n')
-    IMPORT_DIRECTIVE
+  IMPORT_DIRECTIVE
-      PsiElement(import)('import')
+    PsiElement(import)('import')
-      PsiWhiteSpace(' ')
+    PsiWhiteSpace(' ')
-      REFERENCE_EXPRESSION
+    DOT_QUALIFIED_EXPRESSION
-        PsiElement(IDENTIFIER)('foo')
-    PsiWhiteSpace('\n')
-    IMPORT_DIRECTIVE
-      PsiElement(import)('import')
-      PsiWhiteSpace(' ')
-      DOT_QUALIFIED_EXPRESSION
-        REFERENCE_EXPRESSION
-          PsiElement(IDENTIFIER)('foo')
-        PsiElement(DOT)('.')
-        REFERENCE_EXPRESSION
-          PsiElement(IDENTIFIER)('bar')
-    PsiWhiteSpace('\n')
-    IMPORT_DIRECTIVE
-      PsiElement(import)('import')
-      PsiWhiteSpace(' ')
-      REFERENCE_EXPRESSION
-        PsiElement(IDENTIFIER)('foo')
-      PsiWhiteSpace(' ')
-      PsiElement(as)('as')
-      PsiWhiteSpace(' ')
-      PsiElement(IDENTIFIER)('bar')
-    PsiWhiteSpace('\n')
-    IMPORT_DIRECTIVE
-      PsiElement(import)('import')
-      PsiWhiteSpace(' ')
-      DOT_QUALIFIED_EXPRESSION
-        REFERENCE_EXPRESSION
-          PsiElement(IDENTIFIER)('foo')
-        PsiElement(DOT)('.')
-        REFERENCE_EXPRESSION
-          PsiElement(IDENTIFIER)('bar')
-      PsiWhiteSpace(' ')
-      PsiElement(as)('as')
-      PsiWhiteSpace(' ')
-      PsiElement(IDENTIFIER)('bar')
-    PsiWhiteSpace('\n')
-    IMPORT_DIRECTIVE
-      PsiElement(import)('import')
-      PsiWhiteSpace(' ')
       REFERENCE_EXPRESSION
         PsiElement(IDENTIFIER)('foo')
       PsiElement(DOT)('.')
-      PsiElement(MUL)('*')
-    PsiWhiteSpace('\n')
-    IMPORT_DIRECTIVE
-      PsiElement(import)('import')
-      PsiWhiteSpace(' ')
       REFERENCE_EXPRESSION
-        PsiElement(IDENTIFIER)('foo')
+        PsiElement(IDENTIFIER)('bar')
-      PsiElement(DOT)('.')
+    PsiWhiteSpace(' ')
-      PsiWhiteSpace(' ')
+    PsiElement(as)('as')
-      PsiElement(MUL)('*')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('bar')
+  PsiWhiteSpace('\n')
+  IMPORT_DIRECTIVE
+    PsiElement(import)('import')
+    PsiWhiteSpace(' ')
+    REFERENCE_EXPRESSION
+      PsiElement(IDENTIFIER)('foo')
+    PsiElement(DOT)('.')
+    PsiElement(MUL)('*')
+  PsiWhiteSpace('\n')
+  IMPORT_DIRECTIVE
+    PsiElement(import)('import')
+    PsiWhiteSpace(' ')
+    REFERENCE_EXPRESSION
+      PsiElement(IDENTIFIER)('foo')
+    PsiElement(DOT)('.')
+    PsiWhiteSpace(' ')
+    PsiElement(MUL)('*')

compiler/testData/psi/Imports_ERR.txt

@@ -1,271 +1,270 @@
 JetFile: Imports_ERR.jet
-  NAMESPACE
+  NAMESPACE_HEADER
-    NAMESPACE_HEADER
+    PsiElement(namespace)('package')
-      PsiElement(namespace)('package')
+    PsiWhiteSpace(' ')
+    REFERENCE_EXPRESSION
+      PsiElement(IDENTIFIER)('foo')
+    PsiElement(DOT)('.')
+    REFERENCE_EXPRESSION
+      PsiElement(IDENTIFIER)('bar')
+    PsiElement(DOT)('.')
+    PsiElement(IDENTIFIER)('goo')
+  PsiWhiteSpace('\n\n')
+  IMPORT_DIRECTIVE
+    PsiElement(import)('import')
+    PsiWhiteSpace(' ')
+    PsiElement(namespace)('package')
+    PsiErrorElement:Expecting '.'
+      <empty list>
+    PsiWhiteSpace(' ')
+    REFERENCE_EXPRESSION
+      PsiErrorElement:Expecting qualified name
+        <empty list>
+    PsiElement(SEMICOLON)(';')
+  PsiWhiteSpace('\n')
+  IMPORT_DIRECTIVE
+    PsiElement(import)('import')
+    PsiWhiteSpace(' ')
+    PsiElement(namespace)('package')
+    PsiElement(DOT)('.')
+    REFERENCE_EXPRESSION
+      PsiErrorElement:Expecting qualified name
+        <empty list>
+  PsiErrorElement:Expecting namespace or top level declaration
+    PsiElement(MUL)('*')
+  PsiWhiteSpace('\n')
+  IMPORT_DIRECTIVE
+    PsiElement(import)('import')
+    PsiWhiteSpace(' ')
+    PsiElement(namespace)('package')
+    PsiElement(DOT)('.')
+    PsiWhiteSpace(' ')
+    REFERENCE_EXPRESSION
+      PsiErrorElement:Expecting qualified name
+        <empty list>
+    PsiElement(SEMICOLON)(';')
+  PsiWhiteSpace('\n\n')
+  IMPORT_DIRECTIVE
+    PsiElement(import)('import')
+    PsiWhiteSpace(' ')
+    REFERENCE_EXPRESSION
+      PsiElement(IDENTIFIER)('foo')
+    PsiWhiteSpace(' ')
+    PsiElement(as)('as')
+    PsiWhiteSpace('\n')
+    PsiElement(IDENTIFIER)('import')
+  PsiWhiteSpace(' ')
+  MODIFIER_LIST
+    ANNOTATION_ENTRY
+      CONSTRUCTOR_CALLEE
+        TYPE_REFERENCE
+          USER_TYPE
+            USER_TYPE
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('foo')
+            PsiElement(DOT)('.')
+            PsiWhiteSpace('\n')
+            REFERENCE_EXPRESSION
+              PsiElement(IDENTIFIER)('import')
+    PsiWhiteSpace(' ')
+    ANNOTATION_ENTRY
+      CONSTRUCTOR_CALLEE
+        TYPE_REFERENCE
+          USER_TYPE
+            USER_TYPE
+              USER_TYPE
+                REFERENCE_EXPRESSION
+                  PsiElement(IDENTIFIER)('foo')
+              PsiElement(DOT)('.')
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('bar')
+            PsiElement(DOT)('.')
+            PsiWhiteSpace('\n')
+            REFERENCE_EXPRESSION
+              PsiElement(IDENTIFIER)('import')
+    PsiWhiteSpace(' ')
+    ANNOTATION_ENTRY
+      CONSTRUCTOR_CALLEE
+        TYPE_REFERENCE
+          USER_TYPE
+            USER_TYPE
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('foo')
+            PsiElement(DOT)('.')
+            PsiWhiteSpace(' ')
+            REFERENCE_EXPRESSION
+              PsiErrorElement:Expecting type name
+                PsiElement(as)('as')
+    PsiWhiteSpace(' ')
+    ANNOTATION_ENTRY
+      CONSTRUCTOR_CALLEE
+        TYPE_REFERENCE
+          USER_TYPE
+            REFERENCE_EXPRESSION
+              PsiElement(IDENTIFIER)('bar')
+    PsiWhiteSpace('\n')
+    ANNOTATION_ENTRY
+      CONSTRUCTOR_CALLEE
+        TYPE_REFERENCE
+          USER_TYPE
+            REFERENCE_EXPRESSION
+              PsiElement(IDENTIFIER)('import')
+    PsiWhiteSpace(' ')
+    ANNOTATION_ENTRY
+      CONSTRUCTOR_CALLEE
+        TYPE_REFERENCE
+          USER_TYPE
+            USER_TYPE
+              USER_TYPE
+                REFERENCE_EXPRESSION
+                  PsiElement(IDENTIFIER)('foo')
+              PsiElement(DOT)('.')
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('bar')
+            PsiElement(DOT)('.')
+            REFERENCE_EXPRESSION
+              PsiErrorElement:Expecting type name
+                PsiElement(MUL)('*')
+  PsiWhiteSpace(' ')
+  PsiErrorElement:Expecting namespace or top level declaration
+    PsiElement(as)('as')
+  PsiWhiteSpace(' ')
+  MODIFIER_LIST
+    ANNOTATION_ENTRY
+      CONSTRUCTOR_CALLEE
+        TYPE_REFERENCE
+          USER_TYPE
+            REFERENCE_EXPRESSION
+              PsiElement(IDENTIFIER)('bar')
+    PsiWhiteSpace('\n')
+    ANNOTATION_ENTRY
+      CONSTRUCTOR_CALLEE
+        TYPE_REFERENCE
+          USER_TYPE
+            REFERENCE_EXPRESSION
+              PsiElement(IDENTIFIER)('import')
+    PsiWhiteSpace(' ')
+    ANNOTATION_ENTRY
+      CONSTRUCTOR_CALLEE
+        TYPE_REFERENCE
+          USER_TYPE
+            USER_TYPE
+              USER_TYPE
+                REFERENCE_EXPRESSION
+                  PsiElement(IDENTIFIER)('foo')
+              PsiElement(DOT)('.')
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('bar')
+            PsiElement(DOT)('.')
+            REFERENCE_EXPRESSION
+              PsiErrorElement:Expecting type name
+                PsiElement(MUL)('*')
+  PsiWhiteSpace(' ')
+  PsiErrorElement:Expecting namespace or top level declaration
+    PsiElement(as)('as')
+  PsiWhiteSpace('\n\n')
+  IMPORT_DIRECTIVE
+    PsiElement(import)('import')
+    PsiWhiteSpace(' ')
+    REFERENCE_EXPRESSION
+      PsiElement(IDENTIFIER)('foo')
+    PsiWhiteSpace(' ')
+    PsiElement(as)('as')
+    PsiErrorElement:Expecting identifier
+      <empty list>
+    PsiWhiteSpace(' ')
+    PsiElement(SEMICOLON)(';')
+  PsiWhiteSpace('\n')
+  IMPORT_DIRECTIVE
+    PsiElement(import)('import')
+    PsiWhiteSpace(' ')
+    DOT_QUALIFIED_EXPRESSION
+      REFERENCE_EXPRESSION
+        PsiElement(IDENTIFIER)('foo')
+      PsiElement(DOT)('.')
       PsiWhiteSpace(' ')
+      REFERENCE_EXPRESSION
+        PsiErrorElement:Qualified name must be a '.'-separated identifier list
+          <empty list>
+    PsiElement(SEMICOLON)(';')
+  PsiWhiteSpace('\n')
+  IMPORT_DIRECTIVE
+    PsiElement(import)('import')
+    PsiWhiteSpace(' ')
+    DOT_QUALIFIED_EXPRESSION
+      DOT_QUALIFIED_EXPRESSION
+        REFERENCE_EXPRESSION
+          PsiElement(IDENTIFIER)('foo')
+        PsiElement(DOT)('.')
+        REFERENCE_EXPRESSION
+          PsiElement(IDENTIFIER)('bar')
+      PsiElement(DOT)('.')
+      PsiWhiteSpace(' ')
+      REFERENCE_EXPRESSION
+        PsiErrorElement:Qualified name must be a '.'-separated identifier list
+          <empty list>
+    PsiElement(SEMICOLON)(';')
+  PsiWhiteSpace('\n')
+  IMPORT_DIRECTIVE
+    PsiElement(import)('import')
+    PsiWhiteSpace(' ')
+    DOT_QUALIFIED_EXPRESSION
+      REFERENCE_EXPRESSION
+        PsiElement(IDENTIFIER)('foo')
+      PsiElement(DOT)('.')
+      PsiWhiteSpace(' ')
+      REFERENCE_EXPRESSION
+        PsiErrorElement:Qualified name must be a '.'-separated identifier list
+          <empty list>
+    PsiElement(as)('as')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('bar')
+    PsiWhiteSpace(' ')
+    PsiElement(SEMICOLON)(';')
+  PsiWhiteSpace('\n')
+  IMPORT_DIRECTIVE
+    PsiElement(import)('import')
+    PsiWhiteSpace(' ')
+    DOT_QUALIFIED_EXPRESSION
       REFERENCE_EXPRESSION
         PsiElement(IDENTIFIER)('foo')
       PsiElement(DOT)('.')
       REFERENCE_EXPRESSION
         PsiElement(IDENTIFIER)('bar')
-      PsiElement(DOT)('.')
+    PsiElement(DOT)('.')
-      PsiElement(IDENTIFIER)('goo')
+    PsiElement(MUL)('*')
-    PsiWhiteSpace('\n\n')
-    IMPORT_DIRECTIVE
-      PsiElement(import)('import')
-      PsiWhiteSpace(' ')
-      PsiElement(namespace)('package')
-      PsiErrorElement:Expecting '.'
-        <empty list>
-      PsiWhiteSpace(' ')
-      REFERENCE_EXPRESSION
-        PsiErrorElement:Expecting qualified name
-          <empty list>
-      PsiElement(SEMICOLON)(';')
-    PsiWhiteSpace('\n')
-    IMPORT_DIRECTIVE
-      PsiElement(import)('import')
-      PsiWhiteSpace(' ')
-      PsiElement(namespace)('package')
-      PsiElement(DOT)('.')
-      REFERENCE_EXPRESSION
-        PsiErrorElement:Expecting qualified name
-          <empty list>
-    PsiErrorElement:Expecting namespace or top level declaration
-      PsiElement(MUL)('*')
-    PsiWhiteSpace('\n')
-    IMPORT_DIRECTIVE
-      PsiElement(import)('import')
-      PsiWhiteSpace(' ')
-      PsiElement(namespace)('package')
-      PsiElement(DOT)('.')
-      PsiWhiteSpace(' ')
-      REFERENCE_EXPRESSION
-        PsiErrorElement:Expecting qualified name
-          <empty list>
-      PsiElement(SEMICOLON)(';')
-    PsiWhiteSpace('\n\n')
-    IMPORT_DIRECTIVE
-      PsiElement(import)('import')
-      PsiWhiteSpace(' ')
-      REFERENCE_EXPRESSION
-        PsiElement(IDENTIFIER)('foo')
-      PsiWhiteSpace(' ')
-      PsiElement(as)('as')
-      PsiWhiteSpace('\n')
-      PsiElement(IDENTIFIER)('import')
     PsiWhiteSpace(' ')
-    MODIFIER_LIST
+    PsiErrorElement:Cannot rename a all imported items to one identifier
-      ANNOTATION_ENTRY
-        CONSTRUCTOR_CALLEE
-          TYPE_REFERENCE
-            USER_TYPE
-              USER_TYPE
-                REFERENCE_EXPRESSION
-                  PsiElement(IDENTIFIER)('foo')
-              PsiElement(DOT)('.')
-              PsiWhiteSpace('\n')
-              REFERENCE_EXPRESSION
-                PsiElement(IDENTIFIER)('import')
-      PsiWhiteSpace(' ')
-      ANNOTATION_ENTRY
-        CONSTRUCTOR_CALLEE
-          TYPE_REFERENCE
-            USER_TYPE
-              USER_TYPE
-                USER_TYPE
-                  REFERENCE_EXPRESSION
-                    PsiElement(IDENTIFIER)('foo')
-                PsiElement(DOT)('.')
-                REFERENCE_EXPRESSION
-                  PsiElement(IDENTIFIER)('bar')
-              PsiElement(DOT)('.')
-              PsiWhiteSpace('\n')
-              REFERENCE_EXPRESSION
-                PsiElement(IDENTIFIER)('import')
-      PsiWhiteSpace(' ')
-      ANNOTATION_ENTRY
-        CONSTRUCTOR_CALLEE
-          TYPE_REFERENCE
-            USER_TYPE
-              USER_TYPE
-                REFERENCE_EXPRESSION
-                  PsiElement(IDENTIFIER)('foo')
-              PsiElement(DOT)('.')
-              PsiWhiteSpace(' ')
-              REFERENCE_EXPRESSION
-                PsiErrorElement:Expecting type name
-                  PsiElement(as)('as')
-      PsiWhiteSpace(' ')
-      ANNOTATION_ENTRY
-        CONSTRUCTOR_CALLEE
-          TYPE_REFERENCE
-            USER_TYPE
-              REFERENCE_EXPRESSION
-                PsiElement(IDENTIFIER)('bar')
-      PsiWhiteSpace('\n')
-      ANNOTATION_ENTRY
-        CONSTRUCTOR_CALLEE
-          TYPE_REFERENCE
-            USER_TYPE
-              REFERENCE_EXPRESSION
-                PsiElement(IDENTIFIER)('import')
-      PsiWhiteSpace(' ')
-      ANNOTATION_ENTRY
-        CONSTRUCTOR_CALLEE
-          TYPE_REFERENCE
-            USER_TYPE
-              USER_TYPE
-                USER_TYPE
-                  REFERENCE_EXPRESSION
-                    PsiElement(IDENTIFIER)('foo')
-                PsiElement(DOT)('.')
-                REFERENCE_EXPRESSION
-                  PsiElement(IDENTIFIER)('bar')
-              PsiElement(DOT)('.')
-              REFERENCE_EXPRESSION
-                PsiErrorElement:Expecting type name
-                  PsiElement(MUL)('*')
-    PsiWhiteSpace(' ')
-    PsiErrorElement:Expecting namespace or top level declaration
-      PsiElement(as)('as')
-    PsiWhiteSpace(' ')
-    MODIFIER_LIST
-      ANNOTATION_ENTRY
-        CONSTRUCTOR_CALLEE
-          TYPE_REFERENCE
-            USER_TYPE
-              REFERENCE_EXPRESSION
-                PsiElement(IDENTIFIER)('bar')
-      PsiWhiteSpace('\n')
-      ANNOTATION_ENTRY
-        CONSTRUCTOR_CALLEE
-          TYPE_REFERENCE
-            USER_TYPE
-              REFERENCE_EXPRESSION
-                PsiElement(IDENTIFIER)('import')
-      PsiWhiteSpace(' ')
-      ANNOTATION_ENTRY
-        CONSTRUCTOR_CALLEE
-          TYPE_REFERENCE
-            USER_TYPE
-              USER_TYPE
-                USER_TYPE
-                  REFERENCE_EXPRESSION
-                    PsiElement(IDENTIFIER)('foo')
-                PsiElement(DOT)('.')
-                REFERENCE_EXPRESSION
-                  PsiElement(IDENTIFIER)('bar')
-              PsiElement(DOT)('.')
-              REFERENCE_EXPRESSION
-                PsiErrorElement:Expecting type name
-                  PsiElement(MUL)('*')
-    PsiWhiteSpace(' ')
-    PsiErrorElement:Expecting namespace or top level declaration
-      PsiElement(as)('as')
-    PsiWhiteSpace('\n\n')
-    IMPORT_DIRECTIVE
-      PsiElement(import)('import')
-      PsiWhiteSpace(' ')
-      REFERENCE_EXPRESSION
-        PsiElement(IDENTIFIER)('foo')
-      PsiWhiteSpace(' ')
-      PsiElement(as)('as')
-      PsiErrorElement:Expecting identifier
-        <empty list>
-      PsiWhiteSpace(' ')
-      PsiElement(SEMICOLON)(';')
-    PsiWhiteSpace('\n')
-    IMPORT_DIRECTIVE
-      PsiElement(import)('import')
-      PsiWhiteSpace(' ')
-      DOT_QUALIFIED_EXPRESSION
-        REFERENCE_EXPRESSION
-          PsiElement(IDENTIFIER)('foo')
-        PsiElement(DOT)('.')
-        PsiWhiteSpace(' ')
-        REFERENCE_EXPRESSION
-          PsiErrorElement:Qualified name must be a '.'-separated identifier list
-            <empty list>
-      PsiElement(SEMICOLON)(';')
-    PsiWhiteSpace('\n')
-    IMPORT_DIRECTIVE
-      PsiElement(import)('import')
-      PsiWhiteSpace(' ')
-      DOT_QUALIFIED_EXPRESSION
-        DOT_QUALIFIED_EXPRESSION
-          REFERENCE_EXPRESSION
-            PsiElement(IDENTIFIER)('foo')
-          PsiElement(DOT)('.')
-          REFERENCE_EXPRESSION
-            PsiElement(IDENTIFIER)('bar')
-        PsiElement(DOT)('.')
-        PsiWhiteSpace(' ')
-        REFERENCE_EXPRESSION
-          PsiErrorElement:Qualified name must be a '.'-separated identifier list
-            <empty list>
-      PsiElement(SEMICOLON)(';')
-    PsiWhiteSpace('\n')
-    IMPORT_DIRECTIVE
-      PsiElement(import)('import')
-      PsiWhiteSpace(' ')
-      DOT_QUALIFIED_EXPRESSION
-        REFERENCE_EXPRESSION
-          PsiElement(IDENTIFIER)('foo')
-        PsiElement(DOT)('.')
-        PsiWhiteSpace(' ')
-        REFERENCE_EXPRESSION
-          PsiErrorElement:Qualified name must be a '.'-separated identifier list
-            <empty list>
       PsiElement(as)('as')
       PsiWhiteSpace(' ')
       PsiElement(IDENTIFIER)('bar')
-      PsiWhiteSpace(' ')
+    PsiWhiteSpace(' ')
-      PsiElement(SEMICOLON)(';')
+    PsiElement(SEMICOLON)(';')
-    PsiWhiteSpace('\n')
+  PsiWhiteSpace('\n')
-    IMPORT_DIRECTIVE
+  IMPORT_DIRECTIVE
-      PsiElement(import)('import')
+    PsiElement(import)('import')
-      PsiWhiteSpace(' ')
+    PsiWhiteSpace(' ')
-      DOT_QUALIFIED_EXPRESSION
+    DOT_QUALIFIED_EXPRESSION
-        REFERENCE_EXPRESSION
+      REFERENCE_EXPRESSION
-          PsiElement(IDENTIFIER)('foo')
+        PsiElement(IDENTIFIER)('foo')
-        PsiElement(DOT)('.')
-        REFERENCE_EXPRESSION
-          PsiElement(IDENTIFIER)('bar')
       PsiElement(DOT)('.')
-      PsiElement(MUL)('*')
+      REFERENCE_EXPRESSION
-      PsiWhiteSpace(' ')
-      PsiErrorElement:Cannot rename a all imported items to one identifier
-        PsiElement(as)('as')
-        PsiWhiteSpace(' ')
         PsiElement(IDENTIFIER)('bar')
-      PsiWhiteSpace(' ')
+    PsiElement(DOT)('.')
-      PsiElement(SEMICOLON)(';')
+    PsiElement(MUL)('*')
-    PsiWhiteSpace('\n')
+    PsiWhiteSpace(' ')
-    IMPORT_DIRECTIVE
+    PsiErrorElement:Cannot rename a all imported items to one identifier
-      PsiElement(import)('import')
+      PsiElement(as)('as')
-      PsiWhiteSpace(' ')
+    PsiWhiteSpace(' ')
-      DOT_QUALIFIED_EXPRESSION
+    PsiElement(SEMICOLON)(';')
-        REFERENCE_EXPRESSION
+  PsiWhiteSpace('\n\n')
-          PsiElement(IDENTIFIER)('foo')
+  CLASS
-        PsiElement(DOT)('.')
+    PsiElement(class)('class')
-        REFERENCE_EXPRESSION
+    PsiWhiteSpace(' ')
-          PsiElement(IDENTIFIER)('bar')
+    PsiElement(IDENTIFIER)('Foo')
-      PsiElement(DOT)('.')
+    PsiWhiteSpace(' ')
-      PsiElement(MUL)('*')
+    TYPE_PARAMETER_LIST
-      PsiWhiteSpace(' ')
+      <empty list>
-      PsiErrorElement:Cannot rename a all imported items to one identifier
+    CLASS_BODY
-        PsiElement(as)('as')
+      PsiElement(LBRACE)('{')
-      PsiWhiteSpace(' ')
+      PsiElement(RBRACE)('}')
-      PsiElement(SEMICOLON)(';')
-    PsiWhiteSpace('\n\n')
-    CLASS
-      PsiElement(class)('class')
-      PsiWhiteSpace(' ')
-      PsiElement(IDENTIFIER)('Foo')
-      PsiWhiteSpace(' ')
-      TYPE_PARAMETER_LIST
-        <empty list>
-      CLASS_BODY
-        PsiElement(LBRACE)('{')
-        PsiElement(RBRACE)('}')

compiler/testData/psi/Labels.txt

@@ -1,134 +1,185 @@
 JetFile: Labels.jet
-  NAMESPACE
+  NAMESPACE_HEADER
-    NAMESPACE_HEADER
+    <empty list>
-      <empty list>
+  FUN
-    FUN
+    PsiElement(fun)('fun')
-      PsiElement(fun)('fun')
+    PsiWhiteSpace(' ')
-      PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('foo')
-      PsiElement(IDENTIFIER)('foo')
+    VALUE_PARAMETER_LIST
-      VALUE_PARAMETER_LIST
+      PsiElement(LPAR)('(')
-        PsiElement(LPAR)('(')
+      PsiElement(RPAR)(')')
-        PsiElement(RPAR)(')')
+    PsiWhiteSpace(' ')
-      PsiWhiteSpace(' ')
+    BLOCK
-      BLOCK
+      PsiElement(LBRACE)('{')
-        PsiElement(LBRACE)('{')
+      PsiWhiteSpace('\n  ')
-        PsiWhiteSpace('\n  ')
+      RETURN
-        RETURN
+        PsiElement(return)('return')
-          PsiElement(return)('return')
+      PsiWhiteSpace('\n  ')
-        PsiWhiteSpace('\n  ')
+      RETURN
-        RETURN
+        PsiElement(return)('return')
-          PsiElement(return)('return')
+        PsiWhiteSpace(' ')
-          PsiWhiteSpace(' ')
+        INTEGER_CONSTANT
-          INTEGER_CONSTANT
+          PsiElement(INTEGER_LITERAL)('1')
-            PsiElement(INTEGER_LITERAL)('1')
+      PsiWhiteSpace('\n  ')
-        PsiWhiteSpace('\n  ')
+      RETURN
-        RETURN
+        PsiElement(return)('return')
-          PsiElement(return)('return')
+        PsiWhiteSpace(' ')
-          PsiWhiteSpace(' ')
+        PARENTHESIZED
-          PARENTHESIZED
+          PsiElement(LPAR)('(')
-            PsiElement(LPAR)('(')
-            PREFIX_EXPRESSION
-              OPERATION_REFERENCE
-                PsiElement(LABEL_IDENTIFIER)('@a')
-              PsiWhiteSpace(' ')
-              INTEGER_CONSTANT
-                PsiElement(INTEGER_LITERAL)('1')
-            PsiElement(RPAR)(')')
-        PsiWhiteSpace('\n\n  ')
-        RETURN
-          PsiElement(return)('return')
-          LABEL_QUALIFIER
-            LABEL_REFERENCE
-              PsiElement(AT)('@')
-        PsiWhiteSpace('\n  ')
-        RETURN
-          PsiElement(return)('return')
-          LABEL_QUALIFIER
-            LABEL_REFERENCE
-              PsiElement(AT)('@')
-          PsiWhiteSpace(' ')
-          INTEGER_CONSTANT
-            PsiElement(INTEGER_LITERAL)('1')
-        PsiWhiteSpace('\n  ')
-        RETURN
-          PsiElement(return)('return')
-          LABEL_QUALIFIER
-            LABEL_REFERENCE
-              PsiElement(AT)('@')
-          PsiWhiteSpace(' ')
-          PARENTHESIZED
-            PsiElement(LPAR)('(')
-            PREFIX_EXPRESSION
-              OPERATION_REFERENCE
-                PsiElement(AT)('@')
-              PsiWhiteSpace(' ')
-              INTEGER_CONSTANT
-                PsiElement(INTEGER_LITERAL)('1')
-            PsiElement(RPAR)(')')
-        PsiWhiteSpace('\n  ')
-        RETURN
-          PsiElement(return)('return')
-          LABEL_QUALIFIER
-            LABEL_REFERENCE
-              PsiElement(AT)('@')
-          PsiWhiteSpace(' ')
-          PREFIX_EXPRESSION
-            OPERATION_REFERENCE
-              PsiElement(AT)('@')
-            PsiWhiteSpace(' ')
-            INTEGER_CONSTANT
-              PsiElement(INTEGER_LITERAL)('1')
-        PsiWhiteSpace('\n\n  ')
-        RETURN
-          PsiElement(return)('return')
-          LABEL_QUALIFIER
-            LABEL_REFERENCE
-              PsiElement(LABEL_IDENTIFIER)('@a')
-        PsiWhiteSpace('\n  ')
-        RETURN
-          PsiElement(return)('return')
-          LABEL_QUALIFIER
-            LABEL_REFERENCE
-              PsiElement(LABEL_IDENTIFIER)('@a')
-          PsiWhiteSpace(' ')
-          INTEGER_CONSTANT
-            PsiElement(INTEGER_LITERAL)('1')
-        PsiWhiteSpace('\n  ')
-        RETURN
-          PsiElement(return)('return')
-          LABEL_QUALIFIER
-            LABEL_REFERENCE
-              PsiElement(LABEL_IDENTIFIER)('@a')
-          PsiWhiteSpace(' ')
-          PARENTHESIZED
-            PsiElement(LPAR)('(')
-            PREFIX_EXPRESSION
-              OPERATION_REFERENCE
-                PsiElement(LABEL_IDENTIFIER)('@a')
-              PsiWhiteSpace(' ')
-              INTEGER_CONSTANT
-                PsiElement(INTEGER_LITERAL)('1')
-            PsiElement(RPAR)(')')
-        PsiWhiteSpace('\n  ')
-        RETURN
-          PsiElement(return)('return')
-          LABEL_QUALIFIER
-            LABEL_REFERENCE
-              PsiElement(LABEL_IDENTIFIER)('@a')
-          PsiWhiteSpace(' ')
           PREFIX_EXPRESSION
             OPERATION_REFERENCE
               PsiElement(LABEL_IDENTIFIER)('@a')
             PsiWhiteSpace(' ')
             INTEGER_CONSTANT
               PsiElement(INTEGER_LITERAL)('1')
-        PsiWhiteSpace('\n\n  ')
+          PsiElement(RPAR)(')')
+      PsiWhiteSpace('\n\n  ')
+      RETURN
+        PsiElement(return)('return')
+        LABEL_QUALIFIER
+          LABEL_REFERENCE
+            PsiElement(AT)('@')
+      PsiWhiteSpace('\n  ')
+      RETURN
+        PsiElement(return)('return')
+        LABEL_QUALIFIER
+          LABEL_REFERENCE
+            PsiElement(AT)('@')
+        PsiWhiteSpace(' ')
+        INTEGER_CONSTANT
+          PsiElement(INTEGER_LITERAL)('1')
+      PsiWhiteSpace('\n  ')
+      RETURN
+        PsiElement(return)('return')
+        LABEL_QUALIFIER
+          LABEL_REFERENCE
+            PsiElement(AT)('@')
+        PsiWhiteSpace(' ')
+        PARENTHESIZED
+          PsiElement(LPAR)('(')
+          PREFIX_EXPRESSION
+            OPERATION_REFERENCE
+              PsiElement(AT)('@')
+            PsiWhiteSpace(' ')
+            INTEGER_CONSTANT
+              PsiElement(INTEGER_LITERAL)('1')
+          PsiElement(RPAR)(')')
+      PsiWhiteSpace('\n  ')
+      RETURN
+        PsiElement(return)('return')
+        LABEL_QUALIFIER
+          LABEL_REFERENCE
+            PsiElement(AT)('@')
+        PsiWhiteSpace(' ')
+        PREFIX_EXPRESSION
+          OPERATION_REFERENCE
+            PsiElement(AT)('@')
+          PsiWhiteSpace(' ')
+          INTEGER_CONSTANT
+            PsiElement(INTEGER_LITERAL)('1')
+      PsiWhiteSpace('\n\n  ')
+      RETURN
+        PsiElement(return)('return')
+        LABEL_QUALIFIER
+          LABEL_REFERENCE
+            PsiElement(LABEL_IDENTIFIER)('@a')
+      PsiWhiteSpace('\n  ')
+      RETURN
+        PsiElement(return)('return')
+        LABEL_QUALIFIER
+          LABEL_REFERENCE
+            PsiElement(LABEL_IDENTIFIER)('@a')
+        PsiWhiteSpace(' ')
+        INTEGER_CONSTANT
+          PsiElement(INTEGER_LITERAL)('1')
+      PsiWhiteSpace('\n  ')
+      RETURN
+        PsiElement(return)('return')
+        LABEL_QUALIFIER
+          LABEL_REFERENCE
+            PsiElement(LABEL_IDENTIFIER)('@a')
+        PsiWhiteSpace(' ')
+        PARENTHESIZED
+          PsiElement(LPAR)('(')
+          PREFIX_EXPRESSION
+            OPERATION_REFERENCE
+              PsiElement(LABEL_IDENTIFIER)('@a')
+            PsiWhiteSpace(' ')
+            INTEGER_CONSTANT
+              PsiElement(INTEGER_LITERAL)('1')
+          PsiElement(RPAR)(')')
+      PsiWhiteSpace('\n  ')
+      RETURN
+        PsiElement(return)('return')
+        LABEL_QUALIFIER
+          LABEL_REFERENCE
+            PsiElement(LABEL_IDENTIFIER)('@a')
+        PsiWhiteSpace(' ')
+        PREFIX_EXPRESSION
+          OPERATION_REFERENCE
+            PsiElement(LABEL_IDENTIFIER)('@a')
+          PsiWhiteSpace(' ')
+          INTEGER_CONSTANT
+            PsiElement(INTEGER_LITERAL)('1')
+      PsiWhiteSpace('\n\n  ')
+      RETURN
+        PsiElement(return)('return')
+        LABEL_QUALIFIER
+          LABEL_REFERENCE
+            PsiElement(ATAT)('@@')
+      PsiWhiteSpace('\n  ')
+      RETURN
+        PsiElement(return)('return')
+        LABEL_QUALIFIER
+          LABEL_REFERENCE
+            PsiElement(ATAT)('@@')
+        PsiWhiteSpace(' ')
+        INTEGER_CONSTANT
+          PsiElement(INTEGER_LITERAL)('1')
+      PsiWhiteSpace('\n  ')
+      RETURN
+        PsiElement(return)('return')
+        LABEL_QUALIFIER
+          LABEL_REFERENCE
+            PsiElement(ATAT)('@@')
+        PsiWhiteSpace(' ')
+        PARENTHESIZED
+          PsiElement(LPAR)('(')
+          PREFIX_EXPRESSION
+            OPERATION_REFERENCE
+              PsiElement(ATAT)('@@')
+            PsiWhiteSpace(' ')
+            INTEGER_CONSTANT
+              PsiElement(INTEGER_LITERAL)('1')
+          PsiElement(RPAR)(')')
+      PsiWhiteSpace('\n  ')
+      RETURN
+        PsiElement(return)('return')
+        LABEL_QUALIFIER
+          LABEL_REFERENCE
+            PsiElement(ATAT)('@@')
+        PsiWhiteSpace(' ')
+        PREFIX_EXPRESSION
+          OPERATION_REFERENCE
+            PsiElement(ATAT)('@@')
+          PsiWhiteSpace(' ')
+          INTEGER_CONSTANT
+            PsiElement(INTEGER_LITERAL)('1')
+      PsiWhiteSpace('\n\n  ')
+      PREFIX_EXPRESSION
+        OPERATION_REFERENCE
+          PsiElement(LABEL_IDENTIFIER)('@a')
+        PsiWhiteSpace(' ')
         RETURN
           PsiElement(return)('return')
           LABEL_QUALIFIER
             LABEL_REFERENCE
               PsiElement(ATAT)('@@')
-        PsiWhiteSpace('\n  ')
+      PsiWhiteSpace('\n  ')
+      PREFIX_EXPRESSION
+        OPERATION_REFERENCE
+          PsiElement(LABEL_IDENTIFIER)('@a')
+        PsiWhiteSpace(' ')
         RETURN
           PsiElement(return)('return')
           LABEL_QUALIFIER
@@ -137,7 +188,11 @@ JetFile: Labels.jet
           PsiWhiteSpace(' ')
           INTEGER_CONSTANT
             PsiElement(INTEGER_LITERAL)('1')
-        PsiWhiteSpace('\n  ')
+      PsiWhiteSpace('\n  ')
+      PREFIX_EXPRESSION
+        OPERATION_REFERENCE
+          PsiElement(LABEL_IDENTIFIER)('@a')
+        PsiWhiteSpace(' ')
         RETURN
           PsiElement(return)('return')
           LABEL_QUALIFIER
@@ -153,7 +208,11 @@ JetFile: Labels.jet
               INTEGER_CONSTANT
                 PsiElement(INTEGER_LITERAL)('1')
             PsiElement(RPAR)(')')
-        PsiWhiteSpace('\n  ')
+      PsiWhiteSpace('\n  ')
+      PREFIX_EXPRESSION
+        OPERATION_REFERENCE
+          PsiElement(LABEL_IDENTIFIER)('@a')
+        PsiWhiteSpace(' ')
         RETURN
           PsiElement(return)('return')
           LABEL_QUALIFIER
@@ -166,301 +225,241 @@ JetFile: Labels.jet
             PsiWhiteSpace(' ')
             INTEGER_CONSTANT
               PsiElement(INTEGER_LITERAL)('1')
-        PsiWhiteSpace('\n\n  ')
+      PsiWhiteSpace('\n\n  ')
-        PREFIX_EXPRESSION
+      BREAK
-          OPERATION_REFERENCE
+        PsiElement(break)('break')
+      PsiWhiteSpace('\n  ')
+      BREAK
+        PsiElement(break)('break')
+        LABEL_QUALIFIER
+          LABEL_REFERENCE
+            PsiElement(AT)('@')
+      PsiWhiteSpace('\n  ')
+      BREAK
+        PsiElement(break)('break')
+        LABEL_QUALIFIER
+          LABEL_REFERENCE
             PsiElement(LABEL_IDENTIFIER)('@a')
-          PsiWhiteSpace(' ')
+      PsiWhiteSpace('\n  ')
-          RETURN
+      BREAK
-            PsiElement(return)('return')
+        PsiElement(break)('break')
-            LABEL_QUALIFIER
+        LABEL_QUALIFIER
-              LABEL_REFERENCE
+          LABEL_REFERENCE
-                PsiElement(ATAT)('@@')
+            PsiElement(ATAT)('@@')
-        PsiWhiteSpace('\n  ')
+      PsiWhiteSpace('\n\n  ')
-        PREFIX_EXPRESSION
+      CONTINUE
-          OPERATION_REFERENCE
+        PsiElement(continue)('continue')
+      PsiWhiteSpace('\n  ')
+      CONTINUE
+        PsiElement(continue)('continue')
+        LABEL_QUALIFIER
+          LABEL_REFERENCE
+            PsiElement(AT)('@')
+      PsiWhiteSpace('\n  ')
+      CONTINUE
+        PsiElement(continue)('continue')
+        LABEL_QUALIFIER
+          LABEL_REFERENCE
             PsiElement(LABEL_IDENTIFIER)('@a')
-          PsiWhiteSpace(' ')
+      PsiWhiteSpace('\n  ')
-          RETURN
+      CONTINUE
-            PsiElement(return)('return')
+        PsiElement(continue)('continue')
-            LABEL_QUALIFIER
+        LABEL_QUALIFIER
-              LABEL_REFERENCE
+          LABEL_REFERENCE
-                PsiElement(ATAT)('@@')
+            PsiElement(ATAT)('@@')
-            PsiWhiteSpace(' ')
+      PsiWhiteSpace('\n\n  ')
-            INTEGER_CONSTANT
+      DOT_QUALIFIED_EXPRESSION
-              PsiElement(INTEGER_LITERAL)('1')
+        REFERENCE_EXPRESSION
-        PsiWhiteSpace('\n  ')
+          PsiElement(IDENTIFIER)('a')
-        PREFIX_EXPRESSION
+        PsiElement(DOT)('.')
-          OPERATION_REFERENCE
+        CALL_EXPRESSION
-            PsiElement(LABEL_IDENTIFIER)('@a')
-          PsiWhiteSpace(' ')
-          RETURN
-            PsiElement(return)('return')
-            LABEL_QUALIFIER
-              LABEL_REFERENCE
-                PsiElement(ATAT)('@@')
-            PsiWhiteSpace(' ')
-            PARENTHESIZED
-              PsiElement(LPAR)('(')
-              PREFIX_EXPRESSION
-                OPERATION_REFERENCE
-                  PsiElement(ATAT)('@@')
-                PsiWhiteSpace(' ')
-                INTEGER_CONSTANT
-                  PsiElement(INTEGER_LITERAL)('1')
-              PsiElement(RPAR)(')')
-        PsiWhiteSpace('\n  ')
-        PREFIX_EXPRESSION
-          OPERATION_REFERENCE
-            PsiElement(LABEL_IDENTIFIER)('@a')
-          PsiWhiteSpace(' ')
-          RETURN
-            PsiElement(return)('return')
-            LABEL_QUALIFIER
-              LABEL_REFERENCE
-                PsiElement(ATAT)('@@')
-            PsiWhiteSpace(' ')
-            PREFIX_EXPRESSION
-              OPERATION_REFERENCE
-                PsiElement(ATAT)('@@')
-              PsiWhiteSpace(' ')
-              INTEGER_CONSTANT
-                PsiElement(INTEGER_LITERAL)('1')
-        PsiWhiteSpace('\n\n  ')
-        BREAK
-          PsiElement(break)('break')
-        PsiWhiteSpace('\n  ')
-        BREAK
-          PsiElement(break)('break')
-          LABEL_QUALIFIER
-            LABEL_REFERENCE
-              PsiElement(AT)('@')
-        PsiWhiteSpace('\n  ')
-        BREAK
-          PsiElement(break)('break')
-          LABEL_QUALIFIER
-            LABEL_REFERENCE
-              PsiElement(LABEL_IDENTIFIER)('@a')
-        PsiWhiteSpace('\n  ')
-        BREAK
-          PsiElement(break)('break')
-          LABEL_QUALIFIER
-            LABEL_REFERENCE
-              PsiElement(ATAT)('@@')
-        PsiWhiteSpace('\n\n  ')
-        CONTINUE
-          PsiElement(continue)('continue')
-        PsiWhiteSpace('\n  ')
-        CONTINUE
-          PsiElement(continue)('continue')
-          LABEL_QUALIFIER
-            LABEL_REFERENCE
-              PsiElement(AT)('@')
-        PsiWhiteSpace('\n  ')
-        CONTINUE
-          PsiElement(continue)('continue')
-          LABEL_QUALIFIER
-            LABEL_REFERENCE
-              PsiElement(LABEL_IDENTIFIER)('@a')
-        PsiWhiteSpace('\n  ')
-        CONTINUE
-          PsiElement(continue)('continue')
-          LABEL_QUALIFIER
-            LABEL_REFERENCE
-              PsiElement(ATAT)('@@')
-        PsiWhiteSpace('\n\n  ')
-        DOT_QUALIFIED_EXPRESSION
           REFERENCE_EXPRESSION
-            PsiElement(IDENTIFIER)('a')
+            PsiElement(IDENTIFIER)('filter')
-          PsiElement(DOT)('.')
+          PsiWhiteSpace(' ')
-          CALL_EXPRESSION
+          PREFIX_EXPRESSION
-            REFERENCE_EXPRESSION
+            OPERATION_REFERENCE
-              PsiElement(IDENTIFIER)('filter')
+              PsiElement(LABEL_IDENTIFIER)('@f')
-            PsiWhiteSpace(' ')
+            FUNCTION_LITERAL_EXPRESSION
-            PREFIX_EXPRESSION
+              FUNCTION_LITERAL
-              OPERATION_REFERENCE
+                PsiElement(LBRACE)('{')
-                PsiElement(LABEL_IDENTIFIER)('@f')
+                PsiWhiteSpace('\n      ')
-              FUNCTION_LITERAL_EXPRESSION
+                BLOCK
-                FUNCTION_LITERAL
+                  IF
-                  PsiElement(LBRACE)('{')
+                    PsiElement(if)('if')
+                    PsiWhiteSpace(' ')
+                    PsiElement(LPAR)('(')
+                    CONDITION
+                      INTEGER_CONSTANT
+                        PsiElement(INTEGER_LITERAL)('1')
+                    PsiElement(RPAR)(')')
+                    PsiWhiteSpace(' ')
+                    THEN
+                      RETURN
+                        PsiElement(return)('return')
                   PsiWhiteSpace('\n      ')
-                  BLOCK
+                  RETURN
-                    IF
+                    PsiElement(return)('return')
-                      PsiElement(if)('if')
+                    LABEL_QUALIFIER
-                      PsiWhiteSpace(' ')
+                      LABEL_REFERENCE
-                      PsiElement(LPAR)('(')
+                        PsiElement(LABEL_IDENTIFIER)('@f')
-                      CONDITION
+                    PsiWhiteSpace(' ')
-                        INTEGER_CONSTANT
+                    BOOLEAN_CONSTANT
-                          PsiElement(INTEGER_LITERAL)('1')
+                      PsiElement(true)('true')
-                      PsiElement(RPAR)(')')
+                PsiWhiteSpace('\n  ')
-                      PsiWhiteSpace(' ')
+                PsiElement(RBRACE)('}')
-                      THEN
+      PsiWhiteSpace('\n\n  ')
-                        RETURN
+      DOT_QUALIFIED_EXPRESSION
-                          PsiElement(return)('return')
+        REFERENCE_EXPRESSION
-                    PsiWhiteSpace('\n      ')
+          PsiElement(IDENTIFIER)('a')
-                    RETURN
+        PsiElement(DOT)('.')
-                      PsiElement(return)('return')
+        CALL_EXPRESSION
-                      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
-            PsiElement(IDENTIFIER)('a')
+            PsiElement(IDENTIFIER)('filter')
-          PsiElement(DOT)('.')
+          PsiWhiteSpace(' ')
-          CALL_EXPRESSION
+          PREFIX_EXPRESSION
-            REFERENCE_EXPRESSION
+            OPERATION_REFERENCE
-              PsiElement(IDENTIFIER)('filter')
-            PsiWhiteSpace(' ')
-            PREFIX_EXPRESSION
-              OPERATION_REFERENCE
-                PsiElement(AT)('@')
-              FUNCTION_LITERAL_EXPRESSION
-                FUNCTION_LITERAL
-                  PsiElement(LBRACE)('{')
-                  PsiWhiteSpace('\n      ')
-                  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
-            PsiElement(IDENTIFIER)('a')
-          PsiElement(DOT)('.')
-          CALL_EXPRESSION
-            REFERENCE_EXPRESSION
-              PsiElement(IDENTIFIER)('filter')
-            PsiWhiteSpace(' ')
-            PREFIX_EXPRESSION
-              OPERATION_REFERENCE
-                PsiElement(ATAT)('@@')
-              FUNCTION_LITERAL_EXPRESSION
-                FUNCTION_LITERAL
-                  PsiElement(LBRACE)('{')
-                  PsiWhiteSpace('\n      ')
-                  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
-            PsiElement(this)('this')
-        PsiWhiteSpace('\n  ')
-        THIS_EXPRESSION
-          REFERENCE_EXPRESSION
-            PsiElement(this)('this')
-          LABEL_QUALIFIER
-            LABEL_REFERENCE
               PsiElement(AT)('@')
-        PsiWhiteSpace('\n  ')
+            FUNCTION_LITERAL_EXPRESSION
-        THIS_EXPRESSION
+              FUNCTION_LITERAL
+                PsiElement(LBRACE)('{')
+                PsiWhiteSpace('\n      ')
+                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
+          PsiElement(IDENTIFIER)('a')
+        PsiElement(DOT)('.')
+        CALL_EXPRESSION
           REFERENCE_EXPRESSION
-            PsiElement(this)('this')
+            PsiElement(IDENTIFIER)('filter')
-          LABEL_QUALIFIER
+          PsiWhiteSpace(' ')
-            LABEL_REFERENCE
+          PREFIX_EXPRESSION
-              PsiElement(LABEL_IDENTIFIER)('@a')
+            OPERATION_REFERENCE
-        PsiWhiteSpace('\n  ')
-        THIS_EXPRESSION
-          REFERENCE_EXPRESSION
-            PsiElement(this)('this')
-          LABEL_QUALIFIER
-            LABEL_REFERENCE
               PsiElement(ATAT)('@@')
-        PsiWhiteSpace('\n\n  ')
+            FUNCTION_LITERAL_EXPRESSION
-        SUPER_EXPRESSION
+              FUNCTION_LITERAL
-          REFERENCE_EXPRESSION
+                PsiElement(LBRACE)('{')
-            PsiElement(super)('super')
+                PsiWhiteSpace('\n      ')
-          PsiElement(LT)('<')
+                BLOCK
-          TYPE_REFERENCE
+                  IF
-            USER_TYPE
+                    PsiElement(if)('if')
-              REFERENCE_EXPRESSION
+                    PsiWhiteSpace(' ')
-                PsiElement(IDENTIFIER)('A')
+                    PsiElement(LPAR)('(')
-          PsiElement(GT)('>')
+                    CONDITION
-        PsiWhiteSpace('\n  ')
+                      INTEGER_CONSTANT
-        SUPER_EXPRESSION
+                        PsiElement(INTEGER_LITERAL)('1')
-          REFERENCE_EXPRESSION
+                    PsiElement(RPAR)(')')
-            PsiElement(super)('super')
+                    PsiWhiteSpace(' ')
-          PsiElement(LT)('<')
+                    THEN
-          TYPE_REFERENCE
+                      RETURN
-            USER_TYPE
+                        PsiElement(return)('return')
-              REFERENCE_EXPRESSION
+                  PsiWhiteSpace('\n      ')
-                PsiElement(IDENTIFIER)('A')
+                  RETURN
-          PsiElement(GT)('>')
+                    PsiElement(return)('return')
-          LABEL_QUALIFIER
+                    LABEL_QUALIFIER
-            LABEL_REFERENCE
+                      LABEL_REFERENCE
-              PsiElement(AT)('@')
+                        PsiElement(ATAT)('@@')
-        PsiWhiteSpace('\n  ')
+                    PsiWhiteSpace(' ')
-        SUPER_EXPRESSION
+                    BOOLEAN_CONSTANT
-          REFERENCE_EXPRESSION
+                      PsiElement(true)('true')
-            PsiElement(super)('super')
+                PsiWhiteSpace('\n  ')
-          PsiElement(LT)('<')
+                PsiElement(RBRACE)('}')
-          TYPE_REFERENCE
+      PsiWhiteSpace('\n\n  ')
-            USER_TYPE
+      THIS_EXPRESSION
-              REFERENCE_EXPRESSION
+        REFERENCE_EXPRESSION
-                PsiElement(IDENTIFIER)('A')
+          PsiElement(this)('this')
-          PsiElement(GT)('>')
+      PsiWhiteSpace('\n  ')
-          LABEL_QUALIFIER
+      THIS_EXPRESSION
-            LABEL_REFERENCE
+        REFERENCE_EXPRESSION
-              PsiElement(LABEL_IDENTIFIER)('@a')
+          PsiElement(this)('this')
-        PsiWhiteSpace('\n  ')
+        LABEL_QUALIFIER
-        SUPER_EXPRESSION
+          LABEL_REFERENCE
-          REFERENCE_EXPRESSION
+            PsiElement(AT)('@')
-            PsiElement(super)('super')
+      PsiWhiteSpace('\n  ')
-          PsiElement(LT)('<')
+      THIS_EXPRESSION
-          TYPE_REFERENCE
+        REFERENCE_EXPRESSION
-            USER_TYPE
+          PsiElement(this)('this')
-              REFERENCE_EXPRESSION
+        LABEL_QUALIFIER
-                PsiElement(IDENTIFIER)('A')
+          LABEL_REFERENCE
-          PsiElement(GT)('>')
+            PsiElement(LABEL_IDENTIFIER)('@a')
-          LABEL_QUALIFIER
+      PsiWhiteSpace('\n  ')
-            LABEL_REFERENCE
+      THIS_EXPRESSION
-              PsiElement(ATAT)('@@')
+        REFERENCE_EXPRESSION
-        PsiWhiteSpace('\n')
+          PsiElement(this)('this')
-        PsiElement(RBRACE)('}')
+        LABEL_QUALIFIER
+          LABEL_REFERENCE
+            PsiElement(ATAT)('@@')
+      PsiWhiteSpace('\n\n  ')
+      SUPER_EXPRESSION
+        REFERENCE_EXPRESSION
+          PsiElement(super)('super')
+        PsiElement(LT)('<')
+        TYPE_REFERENCE
+          USER_TYPE
+            REFERENCE_EXPRESSION
+              PsiElement(IDENTIFIER)('A')
+        PsiElement(GT)('>')
+      PsiWhiteSpace('\n  ')
+      SUPER_EXPRESSION
+        REFERENCE_EXPRESSION
+          PsiElement(super)('super')
+        PsiElement(LT)('<')
+        TYPE_REFERENCE
+          USER_TYPE
+            REFERENCE_EXPRESSION
+              PsiElement(IDENTIFIER)('A')
+        PsiElement(GT)('>')
+        LABEL_QUALIFIER
+          LABEL_REFERENCE
+            PsiElement(AT)('@')
+      PsiWhiteSpace('\n  ')
+      SUPER_EXPRESSION
+        REFERENCE_EXPRESSION
+          PsiElement(super)('super')
+        PsiElement(LT)('<')
+        TYPE_REFERENCE
+          USER_TYPE
+            REFERENCE_EXPRESSION
+              PsiElement(IDENTIFIER)('A')
+        PsiElement(GT)('>')
+        LABEL_QUALIFIER
+          LABEL_REFERENCE
+            PsiElement(LABEL_IDENTIFIER)('@a')
+      PsiWhiteSpace('\n  ')
+      SUPER_EXPRESSION
+        REFERENCE_EXPRESSION
+          PsiElement(super)('super')
+        PsiElement(LT)('<')
+        TYPE_REFERENCE
+          USER_TYPE
+            REFERENCE_EXPRESSION
+              PsiElement(IDENTIFIER)('A')
+        PsiElement(GT)('>')
+        LABEL_QUALIFIER
+          LABEL_REFERENCE
+            PsiElement(ATAT)('@@')
+      PsiWhiteSpace('\n')
+      PsiElement(RBRACE)('}')

compiler/testData/psi/LocalDeclarations.txt

@@ -1,132 +1,131 @@
 JetFile: LocalDeclarations.jet
-  NAMESPACE
+  NAMESPACE_HEADER
-    NAMESPACE_HEADER
+    <empty list>
-      <empty list>
+  FUN
-    FUN
+    PsiElement(fun)('fun')
-      PsiElement(fun)('fun')
+    PsiWhiteSpace(' ')
-      PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('foo')
-      PsiElement(IDENTIFIER)('foo')
+    VALUE_PARAMETER_LIST
-      VALUE_PARAMETER_LIST
+      PsiElement(LPAR)('(')
-        PsiElement(LPAR)('(')
+      PsiElement(RPAR)(')')
-        PsiElement(RPAR)(')')
+    PsiWhiteSpace(' ')
-      PsiWhiteSpace(' ')
+    BLOCK
-      BLOCK
+      PsiElement(LBRACE)('{')
-        PsiElement(LBRACE)('{')
+      PsiWhiteSpace('\n    ')
-        PsiWhiteSpace('\n    ')
+      REFERENCE_EXPRESSION
-        REFERENCE_EXPRESSION
+        PsiElement(IDENTIFIER)('out')
-          PsiElement(IDENTIFIER)('out')
+      PsiWhiteSpace('\n    ')
-        PsiWhiteSpace('\n    ')
+      INTEGER_CONSTANT
+        PsiElement(INTEGER_LITERAL)('1')
+      PsiWhiteSpace('\n    ')
+      CLASS
+        MODIFIER_LIST
+          ANNOTATION
+            PsiElement(LBRACKET)('[')
+            ANNOTATION_ENTRY
+              CONSTRUCTOR_CALLEE
+                TYPE_REFERENCE
+                  USER_TYPE
+                    REFERENCE_EXPRESSION
+                      PsiElement(IDENTIFIER)('a')
+            PsiElement(RBRACKET)(']')
+          PsiWhiteSpace(' ')
+          PsiElement(abstract)('abstract')
+        PsiWhiteSpace(' ')
+        PsiElement(class)('class')
+        PsiWhiteSpace(' ')
+        PsiElement(IDENTIFIER)('foof')
+        PsiWhiteSpace(' ')
+        TYPE_PARAMETER_LIST
+          <empty list>
+        CLASS_BODY
+          PsiElement(LBRACE)('{')
+          PsiElement(RBRACE)('}')
+      PsiWhiteSpace('\n    ')
+      CLASS
+        MODIFIER_LIST
+          PsiElement(abstract)('abstract')
+          PsiWhiteSpace(' ')
+          ANNOTATION
+            PsiElement(LBRACKET)('[')
+            ANNOTATION_ENTRY
+              CONSTRUCTOR_CALLEE
+                TYPE_REFERENCE
+                  USER_TYPE
+                    REFERENCE_EXPRESSION
+                      PsiElement(IDENTIFIER)('a')
+            PsiElement(RBRACKET)(']')
+        PsiWhiteSpace(' ')
+        PsiElement(class)('class')
+        PsiWhiteSpace(' ')
+        PsiElement(IDENTIFIER)('foof')
+        PsiWhiteSpace(' ')
+        TYPE_PARAMETER_LIST
+          <empty list>
+        CLASS_BODY
+          PsiElement(LBRACE)('{')
+          PsiElement(RBRACE)('}')
+      PsiWhiteSpace('\n\n    ')
+      PROPERTY
+        MODIFIER_LIST
+          PsiElement(out)('out')
+        PsiWhiteSpace(' ')
+        PsiElement(val)('val')
+        PsiWhiteSpace(' ')
+        PsiElement(IDENTIFIER)('foo')
+        PsiWhiteSpace(' ')
+        PsiElement(EQ)('=')
+        PsiWhiteSpace(' ')
         INTEGER_CONSTANT
-          PsiElement(INTEGER_LITERAL)('1')
+          PsiElement(INTEGER_LITERAL)('5')
-        PsiWhiteSpace('\n    ')
+      PsiWhiteSpace('\n    ')
-        CLASS
+      PROPERTY
-          MODIFIER_LIST
+        MODIFIER_LIST
-            ANNOTATION
+          ANNOTATION
-              PsiElement(LBRACKET)('[')
+            PsiElement(LBRACKET)('[')
-              ANNOTATION_ENTRY
+            ANNOTATION_ENTRY
-                CONSTRUCTOR_CALLEE
+              CONSTRUCTOR_CALLEE
-                  TYPE_REFERENCE
+                TYPE_REFERENCE
-                    USER_TYPE
+                  USER_TYPE
-                      REFERENCE_EXPRESSION
+                    REFERENCE_EXPRESSION
-                        PsiElement(IDENTIFIER)('a')
+                      PsiElement(IDENTIFIER)('a')
-              PsiElement(RBRACKET)(']')
+            PsiElement(RBRACKET)(']')
+        PsiWhiteSpace(' ')
+        PsiElement(var)('var')
+        PsiWhiteSpace(' ')
+        PsiElement(IDENTIFIER)('foo')
+        PsiWhiteSpace(' ')
+        PsiElement(EQ)('=')
+        PsiWhiteSpace(' ')
+        INTEGER_CONSTANT
+          PsiElement(INTEGER_LITERAL)('4')
+      PsiWhiteSpace('\n    ')
+      TYPEDEF
+        PsiElement(type)('type')
+        PsiWhiteSpace(' ')
+        PsiElement(IDENTIFIER)('f')
+        PsiWhiteSpace(' ')
+        TYPE_PARAMETER_LIST
+          <empty list>
+        PsiElement(EQ)('=')
+        PsiWhiteSpace('  ')
+        TYPE_REFERENCE
+          FUNCTION_TYPE
+            TYPE_REFERENCE
+              USER_TYPE
+                REFERENCE_EXPRESSION
+                  PsiElement(IDENTIFIER)('T')
+            PsiElement(DOT)('.')
+            VALUE_PARAMETER_LIST
+              PsiElement(LPAR)('(')
+              PsiElement(RPAR)(')')
             PsiWhiteSpace(' ')
-            PsiElement(abstract)('abstract')
+            PsiElement(ARROW)('->')
-          PsiWhiteSpace(' ')
-          PsiElement(class)('class')
-          PsiWhiteSpace(' ')
-          PsiElement(IDENTIFIER)('foof')
-          PsiWhiteSpace(' ')
-          TYPE_PARAMETER_LIST
-            <empty list>
-          CLASS_BODY
-            PsiElement(LBRACE)('{')
-            PsiElement(RBRACE)('}')
-        PsiWhiteSpace('\n    ')
-        CLASS
-          MODIFIER_LIST
-            PsiElement(abstract)('abstract')
             PsiWhiteSpace(' ')
-            ANNOTATION
+            TYPE_REFERENCE
-              PsiElement(LBRACKET)('[')
+              TUPLE_TYPE
-              ANNOTATION_ENTRY
+                PsiElement(HASH)('#')
-                CONSTRUCTOR_CALLEE
-                  TYPE_REFERENCE
-                    USER_TYPE
-                      REFERENCE_EXPRESSION
-                        PsiElement(IDENTIFIER)('a')
-              PsiElement(RBRACKET)(']')
-          PsiWhiteSpace(' ')
-          PsiElement(class)('class')
-          PsiWhiteSpace(' ')
-          PsiElement(IDENTIFIER)('foof')
-          PsiWhiteSpace(' ')
-          TYPE_PARAMETER_LIST
-            <empty list>
-          CLASS_BODY
-            PsiElement(LBRACE)('{')
-            PsiElement(RBRACE)('}')
-        PsiWhiteSpace('\n\n    ')
-        PROPERTY
-          MODIFIER_LIST
-            PsiElement(out)('out')
-          PsiWhiteSpace(' ')
-          PsiElement(val)('val')
-          PsiWhiteSpace(' ')
-          PsiElement(IDENTIFIER)('foo')
-          PsiWhiteSpace(' ')
-          PsiElement(EQ)('=')
-          PsiWhiteSpace(' ')
-          INTEGER_CONSTANT
-            PsiElement(INTEGER_LITERAL)('5')
-        PsiWhiteSpace('\n    ')
-        PROPERTY
-          MODIFIER_LIST
-            ANNOTATION
-              PsiElement(LBRACKET)('[')
-              ANNOTATION_ENTRY
-                CONSTRUCTOR_CALLEE
-                  TYPE_REFERENCE
-                    USER_TYPE
-                      REFERENCE_EXPRESSION
-                        PsiElement(IDENTIFIER)('a')
-              PsiElement(RBRACKET)(']')
-          PsiWhiteSpace(' ')
-          PsiElement(var)('var')
-          PsiWhiteSpace(' ')
-          PsiElement(IDENTIFIER)('foo')
-          PsiWhiteSpace(' ')
-          PsiElement(EQ)('=')
-          PsiWhiteSpace(' ')
-          INTEGER_CONSTANT
-            PsiElement(INTEGER_LITERAL)('4')
-        PsiWhiteSpace('\n    ')
-        TYPEDEF
-          PsiElement(type)('type')
-          PsiWhiteSpace(' ')
-          PsiElement(IDENTIFIER)('f')
-          PsiWhiteSpace(' ')
-          TYPE_PARAMETER_LIST
-            <empty list>
-          PsiElement(EQ)('=')
-          PsiWhiteSpace('  ')
-          TYPE_REFERENCE
-            FUNCTION_TYPE
-              TYPE_REFERENCE
-                USER_TYPE
-                  REFERENCE_EXPRESSION
-                    PsiElement(IDENTIFIER)('T')
-              PsiElement(DOT)('.')
-              VALUE_PARAMETER_LIST
                 PsiElement(LPAR)('(')
                 PsiElement(RPAR)(')')
-              PsiWhiteSpace(' ')
+      PsiWhiteSpace('\n\n')
-              PsiElement(ARROW)('->')
+      PsiElement(RBRACE)('}')
-              PsiWhiteSpace(' ')
-              TYPE_REFERENCE
-                TUPLE_TYPE
-                  PsiElement(HASH)('#')
-                  PsiElement(LPAR)('(')
-                  PsiElement(RPAR)(')')
-        PsiWhiteSpace('\n\n')
-        PsiElement(RBRACE)('}')

compiler/testData/psi/ModifierAsSelector.txt

@@ -1,43 +1,42 @@
 JetFile: ModifierAsSelector.jet
   PsiComment(EOL_COMMENT)('// JET-1')
   PsiWhiteSpace('\n\n')
-  NAMESPACE
+  NAMESPACE_HEADER
-    NAMESPACE_HEADER
+    <empty list>
-      <empty list>
+  PROPERTY
-    PROPERTY
+    PsiElement(val)('val')
-      PsiElement(val)('val')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('z')
+    PsiWhiteSpace(' ')
+    PsiElement(EQ)('=')
+    PsiWhiteSpace(' ')
+    DOT_QUALIFIED_EXPRESSION
+      REFERENCE_EXPRESSION
+        PsiElement(IDENTIFIER)('System')
+      PsiElement(DOT)('.')
+      REFERENCE_EXPRESSION
+        PsiElement(IDENTIFIER)('out')
+  PsiWhiteSpace('\n\n')
+  FUN
+    PsiElement(fun)('fun')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('foo')
+    VALUE_PARAMETER_LIST
+      PsiElement(LPAR)('(')
+      PsiElement(RPAR)(')')
+    PsiWhiteSpace(' ')
+    BLOCK
+      PsiElement(LBRACE)('{')
       PsiWhiteSpace(' ')
-      PsiElement(IDENTIFIER)('z')
+      THROW
-      PsiWhiteSpace(' ')
+        PsiElement(throw)('throw')
-      PsiElement(EQ)('=')
-      PsiWhiteSpace(' ')
-      DOT_QUALIFIED_EXPRESSION
-        REFERENCE_EXPRESSION
-          PsiElement(IDENTIFIER)('System')
-        PsiElement(DOT)('.')
-        REFERENCE_EXPRESSION
-          PsiElement(IDENTIFIER)('out')
-    PsiWhiteSpace('\n\n')
-    FUN
-      PsiElement(fun)('fun')
-      PsiWhiteSpace(' ')
-      PsiElement(IDENTIFIER)('foo')
-      VALUE_PARAMETER_LIST
-        PsiElement(LPAR)('(')
-        PsiElement(RPAR)(')')
-      PsiWhiteSpace(' ')
-      BLOCK
-        PsiElement(LBRACE)('{')
         PsiWhiteSpace(' ')
-        THROW
+        CALL_EXPRESSION
-          PsiElement(throw)('throw')
+          REFERENCE_EXPRESSION
-          PsiWhiteSpace(' ')
+            PsiElement(IDENTIFIER)('Exception')
-          CALL_EXPRESSION
+          VALUE_ARGUMENT_LIST
-            REFERENCE_EXPRESSION
+            PsiElement(LPAR)('(')
-              PsiElement(IDENTIFIER)('Exception')
+            PsiElement(RPAR)(')')
-            VALUE_ARGUMENT_LIST
+      PsiElement(SEMICOLON)(';')
-              PsiElement(LPAR)('(')
+      PsiWhiteSpace(' ')
-              PsiElement(RPAR)(')')
+      PsiElement(RBRACE)('}')
-        PsiElement(SEMICOLON)(';')
-        PsiWhiteSpace(' ')
-        PsiElement(RBRACE)('}')

compiler/testData/psi/NamespaceBlockFirst.txt

@@ -1,44 +1,43 @@
 JetFile: NamespaceBlockFirst.jet
-  NAMESPACE
+  NAMESPACE_HEADER
-    NAMESPACE_HEADER
+    <empty list>
-      <empty list>
+  PsiErrorElement:Expecting namespace or top level declaration
-    PsiErrorElement:Expecting namespace or top level declaration
+    PsiElement(namespace)('package')
-      PsiElement(namespace)('package')
+  PsiWhiteSpace(' ')
+  MODIFIER_LIST
+    ANNOTATION_ENTRY
+      CONSTRUCTOR_CALLEE
+        TYPE_REFERENCE
+          USER_TYPE
+            REFERENCE_EXPRESSION
+              PsiElement(IDENTIFIER)('foobar')
+  PsiWhiteSpace(' ')
+  PsiErrorElement:Expecting namespace or top level declaration
+    PsiElement(LBRACE)('{')
+  PsiWhiteSpace('\n  ')
+  PROPERTY
+    PsiElement(val)('val')
     PsiWhiteSpace(' ')
-    MODIFIER_LIST
+    PsiElement(IDENTIFIER)('a')
-      ANNOTATION_ENTRY
-        CONSTRUCTOR_CALLEE
-          TYPE_REFERENCE
-            USER_TYPE
-              REFERENCE_EXPRESSION
-                PsiElement(IDENTIFIER)('foobar')
     PsiWhiteSpace(' ')
-    PsiErrorElement:Expecting namespace or top level declaration
+    PsiElement(EQ)('=')
-      PsiElement(LBRACE)('{')
+    PsiWhiteSpace(' ')
-    PsiWhiteSpace('\n  ')
+    INTEGER_CONSTANT
-    PROPERTY
+      PsiElement(INTEGER_LITERAL)('1')
-      PsiElement(val)('val')
+  PsiWhiteSpace('\n  ')
-      PsiWhiteSpace(' ')
+  PROPERTY
-      PsiElement(IDENTIFIER)('a')
+    PsiElement(val)('val')
-      PsiWhiteSpace(' ')
+    PsiWhiteSpace(' ')
-      PsiElement(EQ)('=')
+    PsiElement(IDENTIFIER)('b')
-      PsiWhiteSpace(' ')
+    PsiWhiteSpace(' ')
-      INTEGER_CONSTANT
+    PsiElement(EQ)('=')
-        PsiElement(INTEGER_LITERAL)('1')
+    PsiWhiteSpace(' ')
-    PsiWhiteSpace('\n  ')
+    DOT_QUALIFIED_EXPRESSION
-    PROPERTY
+      REFERENCE_EXPRESSION
-      PsiElement(val)('val')
+        PsiElement(IDENTIFIER)('foobar')
-      PsiWhiteSpace(' ')
+      PsiElement(DOT)('.')
-      PsiElement(IDENTIFIER)('b')
+      REFERENCE_EXPRESSION
-      PsiWhiteSpace(' ')
+        PsiElement(IDENTIFIER)('a')
-      PsiElement(EQ)('=')
+  PsiWhiteSpace('\n')
-      PsiWhiteSpace(' ')
+  PsiErrorElement:Expecting namespace or top level declaration
-      DOT_QUALIFIED_EXPRESSION
+    PsiElement(RBRACE)('}')
-        REFERENCE_EXPRESSION
-          PsiElement(IDENTIFIER)('foobar')
-        PsiElement(DOT)('.')
-        REFERENCE_EXPRESSION
-          PsiElement(IDENTIFIER)('a')
-    PsiWhiteSpace('\n')
-    PsiErrorElement:Expecting namespace or top level declaration
-      PsiElement(RBRACE)('}')

compiler/testData/psi/NamespaceModifiers.txt

@@ -1,19 +1,18 @@
 JetFile: NamespaceModifiers.jet
-  NAMESPACE
+  NAMESPACE_HEADER
-    NAMESPACE_HEADER
+    MODIFIER_LIST
-      MODIFIER_LIST
+      PsiElement(public)('public')
-        PsiElement(public)('public')
-        PsiWhiteSpace(' ')
-        ANNOTATION
-          PsiElement(LBRACKET)('[')
-          ANNOTATION_ENTRY
-            CONSTRUCTOR_CALLEE
-              TYPE_REFERENCE
-                USER_TYPE
-                  REFERENCE_EXPRESSION
-                    PsiElement(IDENTIFIER)('a')
-          PsiElement(RBRACKET)(']')
       PsiWhiteSpace(' ')
-      PsiElement(namespace)('package')
+      ANNOTATION
-      PsiWhiteSpace(' ')
+        PsiElement(LBRACKET)('[')
-      PsiElement(IDENTIFIER)('name')
+        ANNOTATION_ENTRY
+          CONSTRUCTOR_CALLEE
+            TYPE_REFERENCE
+              USER_TYPE
+                REFERENCE_EXPRESSION
+                  PsiElement(IDENTIFIER)('a')
+        PsiElement(RBRACKET)(']')
+    PsiWhiteSpace(' ')
+    PsiElement(namespace)('package')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('name')

compiler/testData/psi/NewLinesValidOperations.txt

@@ -1,43 +1,42 @@
 JetFile: NewLinesValidOperations.jet
-  NAMESPACE
+  NAMESPACE_HEADER
-    NAMESPACE_HEADER
+    <empty list>
-      <empty list>
+  FUN
-    FUN
+    PsiElement(fun)('fun')
-      PsiElement(fun)('fun')
+    PsiWhiteSpace(' ')
-      PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('test')
-      PsiElement(IDENTIFIER)('test')
+    VALUE_PARAMETER_LIST
-      VALUE_PARAMETER_LIST
+      PsiElement(LPAR)('(')
-        PsiElement(LPAR)('(')
+      PsiElement(RPAR)(')')
-        PsiElement(RPAR)(')')
+    PsiWhiteSpace(' ')
-      PsiWhiteSpace(' ')
+    BLOCK
-      BLOCK
+      PsiElement(LBRACE)('{')
-        PsiElement(LBRACE)('{')
+      PsiWhiteSpace('\n    ')
-        PsiWhiteSpace('\n    ')
+      PROPERTY
-        PROPERTY
+        PsiElement(val)('val')
-          PsiElement(val)('val')
+        PsiWhiteSpace(' ')
-          PsiWhiteSpace(' ')
+        PsiElement(IDENTIFIER)('str')
+        PsiWhiteSpace(' ')
+        PsiElement(EQ)('=')
+        PsiWhiteSpace(' ')
+        STRING_TEMPLATE
+          PsiElement(OPEN_QUOTE)('"')
+          PsiElement(CLOSING_QUOTE)('"')
+      PsiWhiteSpace('\n\n    ')
+      DOT_QUALIFIED_EXPRESSION
+        REFERENCE_EXPRESSION
           PsiElement(IDENTIFIER)('str')
-          PsiWhiteSpace(' ')
+        PsiWhiteSpace('\n\n        ')
-          PsiElement(EQ)('=')
+        PsiElement(DOT)('.')
-          PsiWhiteSpace(' ')
+        REFERENCE_EXPRESSION
-          STRING_TEMPLATE
+          PsiElement(IDENTIFIER)('length')
-            PsiElement(OPEN_QUOTE)('"')
+      PsiWhiteSpace('\n\n    ')
-            PsiElement(CLOSING_QUOTE)('"')
+      SAFE_ACCESS_EXPRESSION
-        PsiWhiteSpace('\n\n    ')
+        REFERENCE_EXPRESSION
-        DOT_QUALIFIED_EXPRESSION
+          PsiElement(IDENTIFIER)('str')
-          REFERENCE_EXPRESSION
+        PsiWhiteSpace('\n\n        ')
-            PsiElement(IDENTIFIER)('str')
+        PsiElement(SAFE_ACCESS)('?.')
-          PsiWhiteSpace('\n\n        ')
+        REFERENCE_EXPRESSION
-          PsiElement(DOT)('.')
+          PsiElement(IDENTIFIER)('length')
-          REFERENCE_EXPRESSION
+      PsiWhiteSpace('\n')
-            PsiElement(IDENTIFIER)('length')
+      PsiElement(RBRACE)('}')
-        PsiWhiteSpace('\n\n    ')
-        SAFE_ACCESS_EXPRESSION
-          REFERENCE_EXPRESSION
-            PsiElement(IDENTIFIER)('str')
-          PsiWhiteSpace('\n\n        ')
-          PsiElement(SAFE_ACCESS)('?.')
-          REFERENCE_EXPRESSION
-            PsiElement(IDENTIFIER)('length')
-        PsiWhiteSpace('\n')
-        PsiElement(RBRACE)('}')

compiler/testData/psi/NewlinesInParentheses.txt

@@ -1,98 +1,123 @@
 JetFile: NewlinesInParentheses.jet
-  NAMESPACE
+  NAMESPACE_HEADER
-    NAMESPACE_HEADER
+    <empty list>
-      <empty list>
+  FUN
-    FUN
+    PsiElement(fun)('fun')
-      PsiElement(fun)('fun')
+    PsiWhiteSpace(' ')
-      PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('foo')
-      PsiElement(IDENTIFIER)('foo')
+    VALUE_PARAMETER_LIST
-      VALUE_PARAMETER_LIST
+      PsiElement(LPAR)('(')
-        PsiElement(LPAR)('(')
+      PsiElement(RPAR)(')')
-        PsiElement(RPAR)(')')
+    PsiWhiteSpace(' ')
-      PsiWhiteSpace(' ')
+    BLOCK
-      BLOCK
+      PsiElement(LBRACE)('{')
-        PsiElement(LBRACE)('{')
+      PsiWhiteSpace('\n  ')
-        PsiWhiteSpace('\n  ')
+      PROPERTY
-        PROPERTY
+        PsiElement(val)('val')
-          PsiElement(val)('val')
+        PsiWhiteSpace(' ')
-          PsiWhiteSpace(' ')
+        PsiElement(IDENTIFIER)('a')
-          PsiElement(IDENTIFIER)('a')
+        PsiWhiteSpace(' ')
-          PsiWhiteSpace(' ')
+        PsiElement(EQ)('=')
-          PsiElement(EQ)('=')
+        PsiWhiteSpace(' ')
-          PsiWhiteSpace(' ')
+        BINARY_EXPRESSION
-          BINARY_EXPRESSION
-            REFERENCE_EXPRESSION
-              PsiElement(IDENTIFIER)('a')
-            PsiWhiteSpace(' ')
-            OPERATION_REFERENCE
-              PsiElement(PLUS)('+')
-            PsiWhiteSpace(' ')
-            REFERENCE_EXPRESSION
-              PsiElement(IDENTIFIER)('b')
-        PsiWhiteSpace('\n  ')
-        PROPERTY
-          PsiElement(val)('val')
-          PsiWhiteSpace(' ')
-          PsiElement(IDENTIFIER)('a')
-          PsiWhiteSpace(' ')
-          PsiElement(EQ)('=')
-          PsiWhiteSpace(' ')
-          BINARY_EXPRESSION
-            REFERENCE_EXPRESSION
-              PsiElement(IDENTIFIER)('a')
-            PsiWhiteSpace(' ')
-            OPERATION_REFERENCE
-              PsiElement(PLUS)('+')
-            PsiWhiteSpace('\n    ')
-            REFERENCE_EXPRESSION
-              PsiElement(IDENTIFIER)('b')
-        PsiWhiteSpace('\n  ')
-        PROPERTY
-          PsiElement(val)('val')
-          PsiWhiteSpace(' ')
-          PsiElement(IDENTIFIER)('a')
-          PsiWhiteSpace(' ')
-          PsiElement(EQ)('=')
-          PsiWhiteSpace(' ')
           REFERENCE_EXPRESSION
             PsiElement(IDENTIFIER)('a')
-        PsiWhiteSpace('\n  ')
+          PsiWhiteSpace(' ')
-        PREFIX_EXPRESSION
           OPERATION_REFERENCE
             PsiElement(PLUS)('+')
           PsiWhiteSpace(' ')
           REFERENCE_EXPRESSION
             PsiElement(IDENTIFIER)('b')
-        PsiWhiteSpace('\n  ')
+      PsiWhiteSpace('\n  ')
-        PROPERTY
+      PROPERTY
-          PsiElement(val)('val')
+        PsiElement(val)('val')
+        PsiWhiteSpace(' ')
+        PsiElement(IDENTIFIER)('a')
+        PsiWhiteSpace(' ')
+        PsiElement(EQ)('=')
+        PsiWhiteSpace(' ')
+        BINARY_EXPRESSION
+          REFERENCE_EXPRESSION
+            PsiElement(IDENTIFIER)('a')
           PsiWhiteSpace(' ')
+          OPERATION_REFERENCE
+            PsiElement(PLUS)('+')
+          PsiWhiteSpace('\n    ')
+          REFERENCE_EXPRESSION
+            PsiElement(IDENTIFIER)('b')
+      PsiWhiteSpace('\n  ')
+      PROPERTY
+        PsiElement(val)('val')
+        PsiWhiteSpace(' ')
+        PsiElement(IDENTIFIER)('a')
+        PsiWhiteSpace(' ')
+        PsiElement(EQ)('=')
+        PsiWhiteSpace(' ')
+        REFERENCE_EXPRESSION
           PsiElement(IDENTIFIER)('a')
-          PsiWhiteSpace(' ')
+      PsiWhiteSpace('\n  ')
-          PsiElement(EQ)('=')
+      PREFIX_EXPRESSION
-          PsiWhiteSpace(' ')
+        OPERATION_REFERENCE
-          PARENTHESIZED
+          PsiElement(PLUS)('+')
-            PsiElement(LPAR)('(')
+        PsiWhiteSpace(' ')
-            BINARY_EXPRESSION
+        REFERENCE_EXPRESSION
-              REFERENCE_EXPRESSION
+          PsiElement(IDENTIFIER)('b')
-                PsiElement(IDENTIFIER)('a')
+      PsiWhiteSpace('\n  ')
-              PsiWhiteSpace('\n  ')
+      PROPERTY
-              OPERATION_REFERENCE
+        PsiElement(val)('val')
-                PsiElement(PLUS)('+')
+        PsiWhiteSpace(' ')
-              PsiWhiteSpace(' ')
+        PsiElement(IDENTIFIER)('a')
-              REFERENCE_EXPRESSION
+        PsiWhiteSpace(' ')
-                PsiElement(IDENTIFIER)('b')
+        PsiElement(EQ)('=')
-            PsiElement(RPAR)(')')
+        PsiWhiteSpace(' ')
-        PsiWhiteSpace('\n  ')
+        PARENTHESIZED
-        PROPERTY
+          PsiElement(LPAR)('(')
-          PsiElement(val)('val')
+          BINARY_EXPRESSION
-          PsiWhiteSpace(' ')
+            REFERENCE_EXPRESSION
-          PsiElement(IDENTIFIER)('a')
+              PsiElement(IDENTIFIER)('a')
-          PsiWhiteSpace(' ')
+            PsiWhiteSpace('\n  ')
-          PsiElement(EQ)('=')
+            OPERATION_REFERENCE
-          PsiWhiteSpace(' ')
+              PsiElement(PLUS)('+')
-          PARENTHESIZED
+            PsiWhiteSpace(' ')
-            PsiElement(LPAR)('(')
+            REFERENCE_EXPRESSION
+              PsiElement(IDENTIFIER)('b')
+          PsiElement(RPAR)(')')
+      PsiWhiteSpace('\n  ')
+      PROPERTY
+        PsiElement(val)('val')
+        PsiWhiteSpace(' ')
+        PsiElement(IDENTIFIER)('a')
+        PsiWhiteSpace(' ')
+        PsiElement(EQ)('=')
+        PsiWhiteSpace(' ')
+        PARENTHESIZED
+          PsiElement(LPAR)('(')
+          FUNCTION_LITERAL_EXPRESSION
+            FUNCTION_LITERAL
+              PsiElement(LBRACE)('{')
+              BLOCK
+                REFERENCE_EXPRESSION
+                  PsiElement(IDENTIFIER)('a')
+                PsiWhiteSpace('\n  ')
+                PREFIX_EXPRESSION
+                  OPERATION_REFERENCE
+                    PsiElement(PLUS)('+')
+                  PsiWhiteSpace(' ')
+                  REFERENCE_EXPRESSION
+                    PsiElement(IDENTIFIER)('b')
+              PsiElement(RBRACE)('}')
+          PsiElement(RPAR)(')')
+      PsiWhiteSpace('\n  ')
+      PROPERTY
+        PsiElement(val)('val')
+        PsiWhiteSpace(' ')
+        PsiElement(IDENTIFIER)('a')
+        PsiWhiteSpace(' ')
+        PsiElement(EQ)('=')
+        PsiWhiteSpace(' ')
+        PARENTHESIZED
+          PsiElement(LPAR)('(')
+          BINARY_EXPRESSION
             FUNCTION_LITERAL_EXPRESSION
               FUNCTION_LITERAL
                 PsiElement(LBRACE)('{')
@@ -107,75 +132,78 @@ JetFile: NewlinesInParentheses.jet
                     REFERENCE_EXPRESSION
                       PsiElement(IDENTIFIER)('b')
                 PsiElement(RBRACE)('}')
-            PsiElement(RPAR)(')')
+            PsiWhiteSpace('\n  ')
-        PsiWhiteSpace('\n  ')
+            OPERATION_REFERENCE
-        PROPERTY
+              PsiElement(PLUS)('+')
-          PsiElement(val)('val')
+            PsiWhiteSpace(' ')
-          PsiWhiteSpace(' ')
+            REFERENCE_EXPRESSION
-          PsiElement(IDENTIFIER)('a')
+              PsiElement(IDENTIFIER)('b')
-          PsiWhiteSpace(' ')
+          PsiElement(RPAR)(')')
-          PsiElement(EQ)('=')
+      PsiWhiteSpace('\n\n  ')
-          PsiWhiteSpace(' ')
+      PROPERTY
-          PARENTHESIZED
+        PsiElement(val)('val')
-            PsiElement(LPAR)('(')
+        PsiWhiteSpace(' ')
+        PsiElement(IDENTIFIER)('a')
+        PsiWhiteSpace(' ')
+        PsiElement(EQ)('=')
+        PsiWhiteSpace(' ')
+        ARRAY_ACCESS_EXPRESSION
+          REFERENCE_EXPRESSION
+            PsiElement(IDENTIFIER)('b')
+          INDICES
+            PsiElement(LBRACKET)('[')
             BINARY_EXPRESSION
-              FUNCTION_LITERAL_EXPRESSION
+              REFERENCE_EXPRESSION
-                FUNCTION_LITERAL
+                PsiElement(IDENTIFIER)('c')
-                  PsiElement(LBRACE)('{')
+              PsiWhiteSpace('\n    ')
-                  BLOCK
-                    REFERENCE_EXPRESSION
-                      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)('+')
               PsiWhiteSpace(' ')
               REFERENCE_EXPRESSION
-                PsiElement(IDENTIFIER)('b')
+                PsiElement(IDENTIFIER)('d')
-            PsiElement(RPAR)(')')
+            PsiElement(RBRACKET)(']')
-        PsiWhiteSpace('\n\n  ')
+      PsiWhiteSpace('\n  ')
-        PROPERTY
+      PROPERTY
-          PsiElement(val)('val')
+        PsiElement(val)('val')
-          PsiWhiteSpace(' ')
+        PsiWhiteSpace(' ')
-          PsiElement(IDENTIFIER)('a')
+        PsiElement(IDENTIFIER)('a')
-          PsiWhiteSpace(' ')
+        PsiWhiteSpace(' ')
-          PsiElement(EQ)('=')
+        PsiElement(EQ)('=')
-          PsiWhiteSpace(' ')
+        PsiWhiteSpace(' ')
-          ARRAY_ACCESS_EXPRESSION
+        ARRAY_ACCESS_EXPRESSION
-            REFERENCE_EXPRESSION
+          REFERENCE_EXPRESSION
-              PsiElement(IDENTIFIER)('b')
+            PsiElement(IDENTIFIER)('b')
-            INDICES
+          INDICES
-              PsiElement(LBRACKET)('[')
+            PsiElement(LBRACKET)('[')
-              BINARY_EXPRESSION
+            FUNCTION_LITERAL_EXPRESSION
-                REFERENCE_EXPRESSION
+              FUNCTION_LITERAL
-                  PsiElement(IDENTIFIER)('c')
+                PsiElement(LBRACE)('{')
-                PsiWhiteSpace('\n    ')
+                BLOCK
-                OPERATION_REFERENCE
+                  REFERENCE_EXPRESSION
-                  PsiElement(PLUS)('+')
+                    PsiElement(IDENTIFIER)('c')
-                PsiWhiteSpace(' ')
+                  PsiWhiteSpace('\n    ')
-                REFERENCE_EXPRESSION
+                  PREFIX_EXPRESSION
-                  PsiElement(IDENTIFIER)('d')
+                    OPERATION_REFERENCE
-              PsiElement(RBRACKET)(']')
+                      PsiElement(PLUS)('+')
-        PsiWhiteSpace('\n  ')
+                    PsiWhiteSpace(' ')
-        PROPERTY
+                    REFERENCE_EXPRESSION
-          PsiElement(val)('val')
+                      PsiElement(IDENTIFIER)('d')
-          PsiWhiteSpace(' ')
+                PsiElement(RBRACE)('}')
-          PsiElement(IDENTIFIER)('a')
+            PsiElement(RBRACKET)(']')
-          PsiWhiteSpace(' ')
+      PsiWhiteSpace('\n  ')
-          PsiElement(EQ)('=')
+      PROPERTY
-          PsiWhiteSpace(' ')
+        PsiElement(val)('val')
-          ARRAY_ACCESS_EXPRESSION
+        PsiWhiteSpace(' ')
-            REFERENCE_EXPRESSION
+        PsiElement(IDENTIFIER)('a')
-              PsiElement(IDENTIFIER)('b')
+        PsiWhiteSpace(' ')
-            INDICES
+        PsiElement(EQ)('=')
-              PsiElement(LBRACKET)('[')
+        PsiWhiteSpace(' ')
+        ARRAY_ACCESS_EXPRESSION
+          REFERENCE_EXPRESSION
+            PsiElement(IDENTIFIER)('b')
+          INDICES
+            PsiElement(LBRACKET)('[')
+            BINARY_EXPRESSION
               FUNCTION_LITERAL_EXPRESSION
                 FUNCTION_LITERAL
                   PsiElement(LBRACE)('{')
@@ -190,164 +218,135 @@ JetFile: NewlinesInParentheses.jet
                       REFERENCE_EXPRESSION
                         PsiElement(IDENTIFIER)('d')
                   PsiElement(RBRACE)('}')
-              PsiElement(RBRACKET)(']')
+              PsiWhiteSpace('\n    ')
-        PsiWhiteSpace('\n  ')
-        PROPERTY
-          PsiElement(val)('val')
-          PsiWhiteSpace(' ')
-          PsiElement(IDENTIFIER)('a')
-          PsiWhiteSpace(' ')
-          PsiElement(EQ)('=')
-          PsiWhiteSpace(' ')
-          ARRAY_ACCESS_EXPRESSION
-            REFERENCE_EXPRESSION
-              PsiElement(IDENTIFIER)('b')
-            INDICES
-              PsiElement(LBRACKET)('[')
-              BINARY_EXPRESSION
-                FUNCTION_LITERAL_EXPRESSION
-                  FUNCTION_LITERAL
-                    PsiElement(LBRACE)('{')
-                    BLOCK
-                      REFERENCE_EXPRESSION
-                        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)('+')
-                PsiWhiteSpace(' ')
-                REFERENCE_EXPRESSION
-                  PsiElement(IDENTIFIER)('d')
-              PsiElement(RBRACKET)(']')
-        PsiWhiteSpace('\n\n  ')
-        WHEN
-          PsiElement(when)('when')
-          PsiWhiteSpace(' ')
-          PsiElement(LPAR)('(')
-          REFERENCE_EXPRESSION
-            PsiElement(IDENTIFIER)('e')
-          PsiElement(RPAR)(')')
-          PsiWhiteSpace(' ')
-          PsiElement(LBRACE)('{')
-          PsiWhiteSpace('\n    ')
-          WHEN_ENTRY
-            WHEN_CONDITION_IS_PATTERN
-              PsiElement(is)('is')
-              PsiWhiteSpace(' ')
-              DECOMPOSER_PATTERN
-                REFERENCE_EXPRESSION
-                  PsiElement(IDENTIFIER)('T')
-                PsiWhiteSpace(' \n    ')
-                DECOMPOSER_ARGUMENT_LIST
-                  PsiElement(HASH)('#')
-                  PsiElement(LPAR)('(')
-                  PsiElement(RPAR)(')')
-            PsiWhiteSpace(' ')
-            PsiElement(ARROW)('->')
-            PsiWhiteSpace(' ')
-            REFERENCE_EXPRESSION
-              PsiElement(IDENTIFIER)('a')
-          PsiWhiteSpace('\n    ')
-          WHEN_ENTRY
-            WHEN_CONDITION_IN_RANGE
               OPERATION_REFERENCE
-                PsiElement(in)('in')
+                PsiElement(PLUS)('+')
               PsiWhiteSpace(' ')
-              CALL_EXPRESSION
+              REFERENCE_EXPRESSION
-                REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('d')
-                  PsiElement(IDENTIFIER)('f')
+            PsiElement(RBRACKET)(']')
-                PsiWhiteSpace('\n    ')
+      PsiWhiteSpace('\n\n  ')
-                VALUE_ARGUMENT_LIST
+      WHEN
-                  PsiElement(LPAR)('(')
+        PsiElement(when)('when')
-                  PsiElement(RPAR)(')')
+        PsiWhiteSpace(' ')
-            PsiWhiteSpace(' ')
+        PsiElement(LPAR)('(')
-            PsiElement(ARROW)('->')
+        REFERENCE_EXPRESSION
-            PsiWhiteSpace(' ')
+          PsiElement(IDENTIFIER)('e')
-            REFERENCE_EXPRESSION
+        PsiElement(RPAR)(')')
-              PsiElement(IDENTIFIER)('a')
+        PsiWhiteSpace(' ')
-          PsiWhiteSpace('\n    ')
+        PsiElement(LBRACE)('{')
-          WHEN_ENTRY
+        PsiWhiteSpace('\n    ')
-            WHEN_CONDITION_IS_PATTERN
+        WHEN_ENTRY
-              PsiElement(NOT_IS)('!is')
+          WHEN_CONDITION_IS_PATTERN
-              PsiWhiteSpace(' ')
+            PsiElement(is)('is')
-              DECOMPOSER_PATTERN
-                REFERENCE_EXPRESSION
-                  PsiElement(IDENTIFIER)('T')
-                PsiWhiteSpace('\n     ')
-                DECOMPOSER_ARGUMENT_LIST
-                  PsiElement(HASH)('#')
-                  PsiElement(LPAR)('(')
-                  PsiElement(RPAR)(')')
-            PsiWhiteSpace(' ')
-            PsiElement(ARROW)('->')
-            PsiWhiteSpace(' ')
-            REFERENCE_EXPRESSION
-              PsiElement(IDENTIFIER)('a')
-          PsiWhiteSpace('\n    ')
-          WHEN_ENTRY
-            WHEN_CONDITION_IN_RANGE
-              OPERATION_REFERENCE
-                PsiElement(NOT_IN)('!in')
-              PsiWhiteSpace(' ')
-              CALL_EXPRESSION
-                REFERENCE_EXPRESSION
-                  PsiElement(IDENTIFIER)('f')
-                PsiWhiteSpace('\n    ')
-                VALUE_ARGUMENT_LIST
-                  PsiElement(LPAR)('(')
-                  PsiElement(RPAR)(')')
-            PsiWhiteSpace(' ')
-            PsiElement(ARROW)('->')
-            PsiWhiteSpace(' ')
-            REFERENCE_EXPRESSION
-              PsiElement(IDENTIFIER)('a')
-          PsiWhiteSpace('\n    ')
-          WHEN_ENTRY
-            WHEN_CONDITION_IS_PATTERN
-              EXPRESSION_PATTERN
-                CALL_EXPRESSION
-                  REFERENCE_EXPRESSION
-                    PsiElement(IDENTIFIER)('f')
-                  PsiWhiteSpace('\n    ')
-                  VALUE_ARGUMENT_LIST
-                    PsiElement(LPAR)('(')
-                    PsiElement(RPAR)(')')
-            PsiWhiteSpace(' ')
-            PsiElement(ARROW)('->')
-            PsiWhiteSpace(' ')
-            REFERENCE_EXPRESSION
-              PsiElement(IDENTIFIER)('a')
-          PsiWhiteSpace('\n  ')
-          PsiElement(RBRACE)('}')
-        PsiWhiteSpace('\n  ')
-        PROPERTY
-          PsiElement(val)('val')
-          PsiWhiteSpace(' ')
-          PsiElement(IDENTIFIER)('f')
-          PsiWhiteSpace(' ')
-          PsiElement(EQ)('=')
-          PsiWhiteSpace(' ')
-          BINARY_WITH_PATTERN
-            REFERENCE_EXPRESSION
-              PsiElement(IDENTIFIER)('a')
-            PsiWhiteSpace(' ')
-            OPERATION_REFERENCE
-              PsiElement(is)('is')
             PsiWhiteSpace(' ')
             DECOMPOSER_PATTERN
               REFERENCE_EXPRESSION
                 PsiElement(IDENTIFIER)('T')
-              PsiWhiteSpace('\n  ')
+              PsiWhiteSpace(' \n    ')
               DECOMPOSER_ARGUMENT_LIST
                 PsiElement(HASH)('#')
                 PsiElement(LPAR)('(')
                 PsiElement(RPAR)(')')
-        PsiWhiteSpace('\n')
+          PsiWhiteSpace(' ')
-        PsiElement(RBRACE)('}')
+          PsiElement(ARROW)('->')
+          PsiWhiteSpace(' ')
+          REFERENCE_EXPRESSION
+            PsiElement(IDENTIFIER)('a')
+        PsiWhiteSpace('\n    ')
+        WHEN_ENTRY
+          WHEN_CONDITION_IN_RANGE
+            OPERATION_REFERENCE
+              PsiElement(in)('in')
+            PsiWhiteSpace(' ')
+            CALL_EXPRESSION
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('f')
+              PsiWhiteSpace('\n    ')
+              VALUE_ARGUMENT_LIST
+                PsiElement(LPAR)('(')
+                PsiElement(RPAR)(')')
+          PsiWhiteSpace(' ')
+          PsiElement(ARROW)('->')
+          PsiWhiteSpace(' ')
+          REFERENCE_EXPRESSION
+            PsiElement(IDENTIFIER)('a')
+        PsiWhiteSpace('\n    ')
+        WHEN_ENTRY
+          WHEN_CONDITION_IS_PATTERN
+            PsiElement(NOT_IS)('!is')
+            PsiWhiteSpace(' ')
+            DECOMPOSER_PATTERN
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('T')
+              PsiWhiteSpace('\n     ')
+              DECOMPOSER_ARGUMENT_LIST
+                PsiElement(HASH)('#')
+                PsiElement(LPAR)('(')
+                PsiElement(RPAR)(')')
+          PsiWhiteSpace(' ')
+          PsiElement(ARROW)('->')
+          PsiWhiteSpace(' ')
+          REFERENCE_EXPRESSION
+            PsiElement(IDENTIFIER)('a')
+        PsiWhiteSpace('\n    ')
+        WHEN_ENTRY
+          WHEN_CONDITION_IN_RANGE
+            OPERATION_REFERENCE
+              PsiElement(NOT_IN)('!in')
+            PsiWhiteSpace(' ')
+            CALL_EXPRESSION
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('f')
+              PsiWhiteSpace('\n    ')
+              VALUE_ARGUMENT_LIST
+                PsiElement(LPAR)('(')
+                PsiElement(RPAR)(')')
+          PsiWhiteSpace(' ')
+          PsiElement(ARROW)('->')
+          PsiWhiteSpace(' ')
+          REFERENCE_EXPRESSION
+            PsiElement(IDENTIFIER)('a')
+        PsiWhiteSpace('\n    ')
+        WHEN_ENTRY
+          WHEN_CONDITION_IS_PATTERN
+            EXPRESSION_PATTERN
+              CALL_EXPRESSION
+                REFERENCE_EXPRESSION
+                  PsiElement(IDENTIFIER)('f')
+                PsiWhiteSpace('\n    ')
+                VALUE_ARGUMENT_LIST
+                  PsiElement(LPAR)('(')
+                  PsiElement(RPAR)(')')
+          PsiWhiteSpace(' ')
+          PsiElement(ARROW)('->')
+          PsiWhiteSpace(' ')
+          REFERENCE_EXPRESSION
+            PsiElement(IDENTIFIER)('a')
+        PsiWhiteSpace('\n  ')
+        PsiElement(RBRACE)('}')
+      PsiWhiteSpace('\n  ')
+      PROPERTY
+        PsiElement(val)('val')
+        PsiWhiteSpace(' ')
+        PsiElement(IDENTIFIER)('f')
+        PsiWhiteSpace(' ')
+        PsiElement(EQ)('=')
+        PsiWhiteSpace(' ')
+        BINARY_WITH_PATTERN
+          REFERENCE_EXPRESSION
+            PsiElement(IDENTIFIER)('a')
+          PsiWhiteSpace(' ')
+          OPERATION_REFERENCE
+            PsiElement(is)('is')
+          PsiWhiteSpace(' ')
+          DECOMPOSER_PATTERN
+            REFERENCE_EXPRESSION
+              PsiElement(IDENTIFIER)('T')
+            PsiWhiteSpace('\n  ')
+            DECOMPOSER_ARGUMENT_LIST
+              PsiElement(HASH)('#')
+              PsiElement(LPAR)('(')
+              PsiElement(RPAR)(')')
+      PsiWhiteSpace('\n')
+      PsiElement(RBRACE)('}')

compiler/testData/psi/NotIsAndNotIn.txt

@@ -1,65 +1,64 @@
 JetFile: NotIsAndNotIn.jet
-  NAMESPACE
+  NAMESPACE_HEADER
-    NAMESPACE_HEADER
+    <empty list>
-      <empty list>
+  FUN
-    FUN
+    PsiElement(fun)('fun')
-      PsiElement(fun)('fun')
+    PsiWhiteSpace(' ')
-      PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('test')
-      PsiElement(IDENTIFIER)('test')
+    VALUE_PARAMETER_LIST
-      VALUE_PARAMETER_LIST
+      PsiElement(LPAR)('(')
-        PsiElement(LPAR)('(')
+      PsiElement(RPAR)(')')
-        PsiElement(RPAR)(')')
+    PsiWhiteSpace(' ')
-      PsiWhiteSpace(' ')
+    BLOCK
-      BLOCK
+      PsiElement(LBRACE)('{')
-        PsiElement(LBRACE)('{')
+      PsiWhiteSpace('\n  ')
-        PsiWhiteSpace('\n  ')
+      BINARY_WITH_PATTERN
-        BINARY_WITH_PATTERN
+        REFERENCE_EXPRESSION
+          PsiElement(IDENTIFIER)('a')
+        PsiWhiteSpace(' ')
+        OPERATION_REFERENCE
+          PsiElement(NOT_IS)('!is')
+        PsiWhiteSpace(' ')
+        TYPE_PATTERN
+          TYPE_REFERENCE
+            USER_TYPE
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('B')
+      PsiWhiteSpace('\n  ')
+      BINARY_EXPRESSION
+        REFERENCE_EXPRESSION
+          PsiElement(IDENTIFIER)('a')
+        PsiWhiteSpace(' ')
+        OPERATION_REFERENCE
+          PsiElement(NOT_IN)('!in')
+        PsiWhiteSpace(' ')
+        REFERENCE_EXPRESSION
+          PsiElement(IDENTIFIER)('B')
+      PsiWhiteSpace('\n  ')
+      PREFIX_EXPRESSION
+        OPERATION_REFERENCE
+          PsiElement(EXCL)('!')
+        CALL_EXPRESSION
           REFERENCE_EXPRESSION
-            PsiElement(IDENTIFIER)('a')
+            PsiElement(IDENTIFIER)('isBoolean')
-          PsiWhiteSpace(' ')
+          VALUE_ARGUMENT_LIST
-          OPERATION_REFERENCE
+            PsiElement(LPAR)('(')
-            PsiElement(NOT_IS)('!is')
+            VALUE_ARGUMENT
-          PsiWhiteSpace(' ')
+              REFERENCE_EXPRESSION
-          TYPE_PATTERN
+                PsiElement(IDENTIFIER)('a')
-            TYPE_REFERENCE
+            PsiElement(RPAR)(')')
-              USER_TYPE
+      PsiWhiteSpace('\n  ')
-                REFERENCE_EXPRESSION
+      PREFIX_EXPRESSION
-                  PsiElement(IDENTIFIER)('B')
+        OPERATION_REFERENCE
-        PsiWhiteSpace('\n  ')
+          PsiElement(EXCL)('!')
-        BINARY_EXPRESSION
+        CALL_EXPRESSION
           REFERENCE_EXPRESSION
-            PsiElement(IDENTIFIER)('a')
+            PsiElement(IDENTIFIER)('inRange')
-          PsiWhiteSpace(' ')
+          VALUE_ARGUMENT_LIST
-          OPERATION_REFERENCE
+            PsiElement(LPAR)('(')
-            PsiElement(NOT_IN)('!in')
+            VALUE_ARGUMENT
-          PsiWhiteSpace(' ')
+              REFERENCE_EXPRESSION
-          REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('a')
-            PsiElement(IDENTIFIER)('B')
+            PsiElement(RPAR)(')')
-        PsiWhiteSpace('\n  ')
+      PsiWhiteSpace('\n')
-        PREFIX_EXPRESSION
+      PsiElement(RBRACE)('}')
-          OPERATION_REFERENCE
-            PsiElement(EXCL)('!')
-          CALL_EXPRESSION
-            REFERENCE_EXPRESSION
-              PsiElement(IDENTIFIER)('isBoolean')
-            VALUE_ARGUMENT_LIST
-              PsiElement(LPAR)('(')
-              VALUE_ARGUMENT
-                REFERENCE_EXPRESSION
-                  PsiElement(IDENTIFIER)('a')
-              PsiElement(RPAR)(')')
-        PsiWhiteSpace('\n  ')
-        PREFIX_EXPRESSION
-          OPERATION_REFERENCE
-            PsiElement(EXCL)('!')
-          CALL_EXPRESSION
-            REFERENCE_EXPRESSION
-              PsiElement(IDENTIFIER)('inRange')
-            VALUE_ARGUMENT_LIST
-              PsiElement(LPAR)('(')
-              VALUE_ARGUMENT
-                REFERENCE_EXPRESSION
-                  PsiElement(IDENTIFIER)('a')
-              PsiElement(RPAR)(')')
-        PsiWhiteSpace('\n')
-        PsiElement(RBRACE)('}')

compiler/testData/psi/PredicateExpression.txt

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

compiler/testData/psi/PrimaryConstructorModifiers_ERR.txt

@@ -1,89 +1,88 @@
 JetFile: PrimaryConstructorModifiers_ERR.jet
-  NAMESPACE
+  NAMESPACE_HEADER
-    NAMESPACE_HEADER
+    <empty list>
+  CLASS
+    MODIFIER_LIST
+      PsiElement(open)('open')
+    PsiWhiteSpace(' ')
+    PsiElement(class)('class')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('A')
+    PsiWhiteSpace('\n\n')
+    TYPE_PARAMETER_LIST
       <empty list>
-    CLASS
+  CLASS
-      MODIFIER_LIST
+    MODIFIER_LIST
-        PsiElement(open)('open')
+      PsiElement(open)('open')
-      PsiWhiteSpace(' ')
+    PsiWhiteSpace(' ')
-      PsiElement(class)('class')
+    PsiElement(class)('class')
-      PsiWhiteSpace(' ')
+    PsiWhiteSpace(' ')
-      PsiElement(IDENTIFIER)('A')
+    PsiElement(IDENTIFIER)('AB')
+    PsiWhiteSpace(' ')
+    TYPE_PARAMETER_LIST
+      <empty list>
+    PRIMARY_CONSTRUCTOR_MODIFIER_LIST
+      PsiElement(private)('private')
+    PsiErrorElement:Expecting primary constructor parameter list
+      <empty list>
+    PsiWhiteSpace(' ')
+    CLASS_BODY
+      PsiElement(LBRACE)('{')
+      PsiWhiteSpace('\n    ')
+      FUN
+        PsiElement(fun)('fun')
+        PsiWhiteSpace(' ')
+        PsiElement(IDENTIFIER)('foo')
+        VALUE_PARAMETER_LIST
+          PsiElement(LPAR)('(')
+          PsiElement(RPAR)(')')
+        PsiWhiteSpace(' ')
+        BLOCK
+          PsiElement(LBRACE)('{')
+          PsiElement(RBRACE)('}')
+      PsiWhiteSpace('\n')
+      PsiElement(RBRACE)('}')
+  PsiWhiteSpace('\n\n')
+  CLASS
+    PsiElement(class)('class')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('A1')
+    PsiWhiteSpace(' ')
+    TYPE_PARAMETER_LIST
+      <empty list>
+    CLASS_BODY
+      PsiElement(LBRACE)('{')
       PsiWhiteSpace('\n\n')
-      TYPE_PARAMETER_LIST
+      PsiElement(RBRACE)('}')
-        <empty list>
+  PsiWhiteSpace('\n\n')
-    CLASS
+  CLASS
-      MODIFIER_LIST
+    MODIFIER_LIST
-        PsiElement(open)('open')
+      PsiElement(open)('open')
-      PsiWhiteSpace(' ')
+    PsiWhiteSpace(' ')
-      PsiElement(class)('class')
+    PsiElement(class)('class')
-      PsiWhiteSpace(' ')
+    PsiWhiteSpace(' ')
-      PsiElement(IDENTIFIER)('AB')
+    PsiElement(IDENTIFIER)('B')
-      PsiWhiteSpace(' ')
+    TYPE_PARAMETER_LIST
-      TYPE_PARAMETER_LIST
+      PsiElement(LT)('<')
-        <empty list>
+      TYPE_PARAMETER
-      PRIMARY_CONSTRUCTOR_MODIFIER_LIST
+        PsiElement(IDENTIFIER)('T')
-        PsiElement(private)('private')
+        PsiWhiteSpace(' ')
-      PsiErrorElement:Expecting primary constructor parameter list
+        PsiElement(COLON)(':')
-        <empty list>
+        PsiWhiteSpace(' ')
-      PsiWhiteSpace(' ')
+        TYPE_REFERENCE
-      CLASS_BODY
+          USER_TYPE
-        PsiElement(LBRACE)('{')
+            REFERENCE_EXPRESSION
-        PsiWhiteSpace('\n    ')
+              PsiElement(IDENTIFIER)('A')
-        FUN
+      PsiElement(GT)('>')
-          PsiElement(fun)('fun')
+    PsiWhiteSpace(' ')
-          PsiWhiteSpace(' ')
+    PRIMARY_CONSTRUCTOR_MODIFIER_LIST
-          PsiElement(IDENTIFIER)('foo')
+      PsiElement(private)('private')
-          VALUE_PARAMETER_LIST
+    PsiWhiteSpace(' ')
-            PsiElement(LPAR)('(')
+    VALUE_PARAMETER_LIST
-            PsiElement(RPAR)(')')
+      PsiElement(LPAR)('(')
-          PsiWhiteSpace(' ')
+      PsiElement(RPAR)(')')
-          BLOCK
+    PsiWhiteSpace(' ')
-            PsiElement(LBRACE)('{')
+    CLASS_BODY
-            PsiElement(RBRACE)('}')
+      PsiElement(LBRACE)('{')
-        PsiWhiteSpace('\n')
+      PsiWhiteSpace('\n\n')
-        PsiElement(RBRACE)('}')
+      PsiElement(RBRACE)('}')
-    PsiWhiteSpace('\n\n')
-    CLASS
-      PsiElement(class)('class')
-      PsiWhiteSpace(' ')
-      PsiElement(IDENTIFIER)('A1')
-      PsiWhiteSpace(' ')
-      TYPE_PARAMETER_LIST
-        <empty list>
-      CLASS_BODY
-        PsiElement(LBRACE)('{')
-        PsiWhiteSpace('\n\n')
-        PsiElement(RBRACE)('}')
-    PsiWhiteSpace('\n\n')
-    CLASS
-      MODIFIER_LIST
-        PsiElement(open)('open')
-      PsiWhiteSpace(' ')
-      PsiElement(class)('class')
-      PsiWhiteSpace(' ')
-      PsiElement(IDENTIFIER)('B')
-      TYPE_PARAMETER_LIST
-        PsiElement(LT)('<')
-        TYPE_PARAMETER
-          PsiElement(IDENTIFIER)('T')
-          PsiWhiteSpace(' ')
-          PsiElement(COLON)(':')
-          PsiWhiteSpace(' ')
-          TYPE_REFERENCE
-            USER_TYPE
-              REFERENCE_EXPRESSION
-                PsiElement(IDENTIFIER)('A')
-        PsiElement(GT)('>')
-      PsiWhiteSpace(' ')
-      PRIMARY_CONSTRUCTOR_MODIFIER_LIST
-        PsiElement(private)('private')
-      PsiWhiteSpace(' ')
-      VALUE_PARAMETER_LIST
-        PsiElement(LPAR)('(')
-        PsiElement(RPAR)(')')
-      PsiWhiteSpace(' ')
-      CLASS_BODY
-        PsiElement(LBRACE)('{')
-        PsiWhiteSpace('\n\n')
-        PsiElement(RBRACE)('}')

compiler/testData/psi/Properties.txt

@@ -1,449 +1,448 @@
 JetFile: Properties.jet
-  NAMESPACE
+  NAMESPACE_HEADER
-    NAMESPACE_HEADER
+    <empty list>
-      <empty list>
+  PROPERTY
-    PROPERTY
+    PsiElement(val)('val')
-      PsiElement(val)('val')
+    PsiWhiteSpace(' ')
-      PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('foo')
-      PsiElement(IDENTIFIER)('foo')
+    PsiWhiteSpace(' ')
-      PsiWhiteSpace(' ')
+    PsiElement(EQ)('=')
-      PsiElement(EQ)('=')
+    PsiWhiteSpace(' ')
-      PsiWhiteSpace(' ')
+    DOT_QUALIFIED_EXPRESSION
       DOT_QUALIFIED_EXPRESSION
-        DOT_QUALIFIED_EXPRESSION
-          REFERENCE_EXPRESSION
-            PsiElement(IDENTIFIER)('bar')
-          PsiElement(DOT)('.')
-          REFERENCE_EXPRESSION
-            PsiElement(IDENTIFIER)('foo')
-        PsiElement(DOT)('.')
         REFERENCE_EXPRESSION
           PsiElement(IDENTIFIER)('bar')
-    PsiWhiteSpace('\n\n')
+        PsiElement(DOT)('.')
-    PROPERTY
+        REFERENCE_EXPRESSION
-      PsiElement(val)('val')
+          PsiElement(IDENTIFIER)('foo')
-      PsiWhiteSpace(' ')
-      PsiElement(IDENTIFIER)('foo')
-    PsiWhiteSpace('\n')
-    PROPERTY
-      PsiElement(val)('val')
-      PsiWhiteSpace(' ')
-      ANNOTATION
-        PsiElement(LBRACKET)('[')
-        ANNOTATION_ENTRY
-          CONSTRUCTOR_CALLEE
-            TYPE_REFERENCE
-              USER_TYPE
-                REFERENCE_EXPRESSION
-                  PsiElement(IDENTIFIER)('a')
-        PsiElement(RBRACKET)(']')
-      PsiWhiteSpace(' ')
-      PsiElement(IDENTIFIER)('foo')
-    PsiWhiteSpace('\n')
-    PROPERTY
-      PsiElement(val)('val')
-      PsiWhiteSpace(' ')
-      TYPE_REFERENCE
-        USER_TYPE
-          REFERENCE_EXPRESSION
-            PsiElement(IDENTIFIER)('foo')
       PsiElement(DOT)('.')
+      REFERENCE_EXPRESSION
+        PsiElement(IDENTIFIER)('bar')
+  PsiWhiteSpace('\n\n')
+  PROPERTY
+    PsiElement(val)('val')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('foo')
+  PsiWhiteSpace('\n')
+  PROPERTY
+    PsiElement(val)('val')
+    PsiWhiteSpace(' ')
+    ANNOTATION
+      PsiElement(LBRACKET)('[')
+      ANNOTATION_ENTRY
+        CONSTRUCTOR_CALLEE
+          TYPE_REFERENCE
+            USER_TYPE
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('a')
+      PsiElement(RBRACKET)(']')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('foo')
+  PsiWhiteSpace('\n')
+  PROPERTY
+    PsiElement(val)('val')
+    PsiWhiteSpace(' ')
+    TYPE_REFERENCE
+      USER_TYPE
+        REFERENCE_EXPRESSION
+          PsiElement(IDENTIFIER)('foo')
+    PsiElement(DOT)('.')
+    PsiElement(IDENTIFIER)('bar')
+  PsiWhiteSpace('\n\n')
+  PROPERTY
+    PsiElement(val)('val')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('foo')
+    PsiWhiteSpace(' ')
+    PsiElement(COLON)(':')
+    PsiWhiteSpace(' ')
+    TYPE_REFERENCE
+      USER_TYPE
+        REFERENCE_EXPRESSION
+          PsiElement(IDENTIFIER)('T')
+  PsiWhiteSpace('\n')
+  PROPERTY
+    PsiElement(val)('val')
+    PsiWhiteSpace(' ')
+    ANNOTATION
+      PsiElement(LBRACKET)('[')
+      ANNOTATION_ENTRY
+        CONSTRUCTOR_CALLEE
+          TYPE_REFERENCE
+            USER_TYPE
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('a')
+      PsiElement(RBRACKET)(']')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('foo')
+    PsiWhiteSpace(' ')
+    PsiElement(EQ)('=')
+    PsiWhiteSpace(' ')
+    REFERENCE_EXPRESSION
       PsiElement(IDENTIFIER)('bar')
-    PsiWhiteSpace('\n\n')
+  PsiWhiteSpace('\n')
-    PROPERTY
+  PROPERTY
-      PsiElement(val)('val')
+    PsiElement(val)('val')
+    PsiWhiteSpace(' ')
+    TYPE_REFERENCE
+      USER_TYPE
+        REFERENCE_EXPRESSION
+          PsiElement(IDENTIFIER)('foo')
+    PsiElement(DOT)('.')
+    PsiElement(IDENTIFIER)('bar')
+    PsiWhiteSpace('\n   ')
+    PROPERTY_ACCESSOR
+      PsiElement(get)('get')
+      PsiElement(LPAR)('(')
+      PsiElement(RPAR)(')')
       PsiWhiteSpace(' ')
-      PsiElement(IDENTIFIER)('foo')
+      BLOCK
-      PsiWhiteSpace(' ')
+        PsiElement(LBRACE)('{')
-      PsiElement(COLON)(':')
+        PsiElement(RBRACE)('}')
-      PsiWhiteSpace(' ')
+    PsiWhiteSpace('\n   ')
-      TYPE_REFERENCE
+    PROPERTY_ACCESSOR
-        USER_TYPE
+      PsiElement(set)('set')
-          REFERENCE_EXPRESSION
+      PsiElement(LPAR)('(')
-            PsiElement(IDENTIFIER)('T')
+      VALUE_PARAMETER_LIST
-    PsiWhiteSpace('\n')
+        VALUE_PARAMETER
-    PROPERTY
+          PsiElement(IDENTIFIER)('sad')
-      PsiElement(val)('val')
+      PsiElement(RPAR)(')')
-      PsiWhiteSpace(' ')
-      ANNOTATION
-        PsiElement(LBRACKET)('[')
-        ANNOTATION_ENTRY
-          CONSTRUCTOR_CALLEE
-            TYPE_REFERENCE
-              USER_TYPE
-                REFERENCE_EXPRESSION
-                  PsiElement(IDENTIFIER)('a')
-        PsiElement(RBRACKET)(']')
-      PsiWhiteSpace(' ')
-      PsiElement(IDENTIFIER)('foo')
       PsiWhiteSpace(' ')
       PsiElement(EQ)('=')
       PsiWhiteSpace(' ')
       REFERENCE_EXPRESSION
-        PsiElement(IDENTIFIER)('bar')
+        PsiElement(IDENTIFIER)('foo')
-    PsiWhiteSpace('\n')
+  PsiWhiteSpace('\n\n\n')
-    PROPERTY
+  PROPERTY
-      PsiElement(val)('val')
+    PsiElement(val)('val')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('foo')
+    PsiWhiteSpace(' ')
+    PROPERTY_ACCESSOR
+      PsiElement(get)('get')
+  PsiWhiteSpace('\n')
+  PROPERTY
+    PsiElement(val)('val')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('foo')
+    PsiWhiteSpace(' ')
+    PROPERTY_ACCESSOR
+      PsiElement(set)('set')
+  PsiWhiteSpace('\n\n')
+  PROPERTY
+    PsiElement(var)('var')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('foo')
+    PsiWhiteSpace('\n  ')
+    PROPERTY_ACCESSOR
+      PsiElement(get)('get')
+    PsiWhiteSpace('\n  ')
+    PROPERTY_ACCESSOR
+      MODIFIER_LIST
+        PsiElement(private)('private')
       PsiWhiteSpace(' ')
-      TYPE_REFERENCE
+      PsiElement(set)('set')
-        USER_TYPE
+  PsiWhiteSpace('\n\n')
-          REFERENCE_EXPRESSION
+  PROPERTY
-            PsiElement(IDENTIFIER)('foo')
+    PsiElement(val)('val')
-      PsiElement(DOT)('.')
+    PsiWhiteSpace(' ')
-      PsiElement(IDENTIFIER)('bar')
+    TYPE_REFERENCE
-      PsiWhiteSpace('\n   ')
+      USER_TYPE
-      PROPERTY_ACCESSOR
-        PsiElement(get)('get')
-        PsiElement(LPAR)('(')
-        PsiElement(RPAR)(')')
-        PsiWhiteSpace(' ')
-        BLOCK
-          PsiElement(LBRACE)('{')
-          PsiElement(RBRACE)('}')
-      PsiWhiteSpace('\n   ')
-      PROPERTY_ACCESSOR
-        PsiElement(set)('set')
-        PsiElement(LPAR)('(')
-        VALUE_PARAMETER_LIST
-          VALUE_PARAMETER
-            PsiElement(IDENTIFIER)('sad')
-        PsiElement(RPAR)(')')
-        PsiWhiteSpace(' ')
-        PsiElement(EQ)('=')
-        PsiWhiteSpace(' ')
         REFERENCE_EXPRESSION
           PsiElement(IDENTIFIER)('foo')
-    PsiWhiteSpace('\n\n\n')
+    PsiElement(DOT)('.')
-    PROPERTY
+    PsiElement(IDENTIFIER)('bar')
-      PsiElement(val)('val')
+    PsiWhiteSpace('\n   ')
-      PsiWhiteSpace(' ')
+    PROPERTY_ACCESSOR
-      PsiElement(IDENTIFIER)('foo')
+      PsiElement(get)('get')
-      PsiWhiteSpace(' ')
+      PsiElement(LPAR)('(')
-      PROPERTY_ACCESSOR
+      PsiElement(RPAR)(')')
-        PsiElement(get)('get')
-    PsiWhiteSpace('\n')
-    PROPERTY
-      PsiElement(val)('val')
-      PsiWhiteSpace(' ')
-      PsiElement(IDENTIFIER)('foo')
-      PsiWhiteSpace(' ')
-      PROPERTY_ACCESSOR
-        PsiElement(set)('set')
-    PsiWhiteSpace('\n\n')
-    PROPERTY
-      PsiElement(var)('var')
-      PsiWhiteSpace(' ')
-      PsiElement(IDENTIFIER)('foo')
-      PsiWhiteSpace('\n  ')
-      PROPERTY_ACCESSOR
-        PsiElement(get)('get')
-      PsiWhiteSpace('\n  ')
-      PROPERTY_ACCESSOR
-        MODIFIER_LIST
-          PsiElement(private)('private')
-        PsiWhiteSpace(' ')
-        PsiElement(set)('set')
-    PsiWhiteSpace('\n\n')
-    PROPERTY
-      PsiElement(val)('val')
-      PsiWhiteSpace(' ')
-      TYPE_REFERENCE
-        USER_TYPE
-          REFERENCE_EXPRESSION
-            PsiElement(IDENTIFIER)('foo')
-      PsiElement(DOT)('.')
-      PsiElement(IDENTIFIER)('bar')
-      PsiWhiteSpace('\n   ')
-      PROPERTY_ACCESSOR
-        PsiElement(get)('get')
-        PsiElement(LPAR)('(')
-        PsiElement(RPAR)(')')
-        PsiWhiteSpace(' ')
-        BLOCK
-          PsiElement(LBRACE)('{')
-          PsiElement(RBRACE)('}')
-      PsiWhiteSpace('\n   ')
-      PROPERTY_ACCESSOR
-        PsiElement(set)('set')
-    PsiWhiteSpace('\n\n')
-    PROPERTY
-      PsiElement(val)('val')
-      PsiWhiteSpace(' ')
-      TYPE_REFERENCE
-        USER_TYPE
-          REFERENCE_EXPRESSION
-            PsiElement(IDENTIFIER)('foo')
-      PsiElement(DOT)('.')
-      PsiElement(IDENTIFIER)('bar')
-      PsiWhiteSpace('\n   ')
-      PROPERTY_ACCESSOR
-        PsiElement(get)('get')
-      PsiWhiteSpace('\n   ')
-      PROPERTY_ACCESSOR
-        PsiElement(set)('set')
-        PsiElement(LPAR)('(')
-        VALUE_PARAMETER_LIST
-          VALUE_PARAMETER
-            PsiElement(IDENTIFIER)('sad')
-        PsiElement(RPAR)(')')
-        PsiWhiteSpace(' ')
-        PsiElement(EQ)('=')
-        PsiWhiteSpace(' ')
-        REFERENCE_EXPRESSION
-          PsiElement(IDENTIFIER)('foo')
-    PsiWhiteSpace('\n\n')
-    PROPERTY
-      PsiElement(val)('val')
-      PsiWhiteSpace(' ')
-      PsiElement(IDENTIFIER)('foo')
-      PsiWhiteSpace(' ')
-      PsiElement(EQ)('=')
-      PsiWhiteSpace(' ')
-      INTEGER_CONSTANT
-        PsiElement(INTEGER_LITERAL)('5')
-      PsiElement(SEMICOLON)(';')
-      PsiWhiteSpace(' ')
-      PROPERTY_ACCESSOR
-        PsiElement(get)('get')
-    PsiWhiteSpace('\n')
-    PROPERTY
-      PsiElement(val)('val')
-      PsiWhiteSpace(' ')
-      PsiElement(IDENTIFIER)('foo')
-      PsiWhiteSpace(' ')
-      PsiElement(EQ)('=')
-      INTEGER_CONSTANT
-        PsiElement(INTEGER_LITERAL)('1')
-      PsiElement(SEMICOLON)(';')
-      PsiWhiteSpace(' ')
-      PROPERTY_ACCESSOR
-        PsiElement(get)('get')
-      PsiWhiteSpace(' ')
-      PROPERTY_ACCESSOR
-        PsiElement(set)('set')
-    PsiWhiteSpace('\n\n')
-    PROPERTY
-      PsiElement(var)('var')
-      PsiWhiteSpace(' ')
-      PsiElement(IDENTIFIER)('foo')
-      PsiWhiteSpace(' ')
-      PsiElement(EQ)('=')
-      PsiWhiteSpace(' ')
-      INTEGER_CONSTANT
-        PsiElement(INTEGER_LITERAL)('5')
-      PsiWhiteSpace('\n  ')
-      PROPERTY_ACCESSOR
-        PsiElement(get)('get')
-      PsiWhiteSpace('\n  ')
-      PROPERTY_ACCESSOR
-        MODIFIER_LIST
-          PsiElement(private)('private')
-        PsiWhiteSpace(' ')
-        PsiElement(set)('set')
-    PsiWhiteSpace('\n\n')
-    PROPERTY
-      PsiElement(val)('val')
-      PsiWhiteSpace(' ')
-      TYPE_REFERENCE
-        USER_TYPE
-          REFERENCE_EXPRESSION
-            PsiElement(IDENTIFIER)('foo')
-      PsiElement(DOT)('.')
-      PsiElement(IDENTIFIER)('bar')
-      PsiWhiteSpace(' ')
-      PsiElement(EQ)('=')
-      PsiWhiteSpace(' ')
-      INTEGER_CONSTANT
-        PsiElement(INTEGER_LITERAL)('5')
-      PsiWhiteSpace('\n   ')
-      PROPERTY_ACCESSOR
-        PsiElement(get)('get')
-        PsiElement(LPAR)('(')
-        PsiElement(RPAR)(')')
-        PsiWhiteSpace(' ')
-        BLOCK
-          PsiElement(LBRACE)('{')
-          PsiElement(RBRACE)('}')
-      PsiWhiteSpace('\n   ')
-      PROPERTY_ACCESSOR
-        PsiElement(set)('set')
-    PsiWhiteSpace('\n\n')
-    PROPERTY
-      PsiElement(val)('val')
-      PsiWhiteSpace(' ')
-      TYPE_REFERENCE
-        USER_TYPE
-          REFERENCE_EXPRESSION
-            PsiElement(IDENTIFIER)('foo')
-      PsiElement(DOT)('.')
-      PsiElement(IDENTIFIER)('bar')
-      PsiWhiteSpace(' ')
-      PsiElement(EQ)('=')
-      PsiWhiteSpace(' ')
-      INTEGER_CONSTANT
-        PsiElement(INTEGER_LITERAL)('5')
-      PsiWhiteSpace('\n   ')
-      PROPERTY_ACCESSOR
-        PsiElement(get)('get')
-      PsiWhiteSpace('\n   ')
-      PROPERTY_ACCESSOR
-        PsiElement(set)('set')
-        PsiElement(LPAR)('(')
-        VALUE_PARAMETER_LIST
-          VALUE_PARAMETER
-            PsiElement(IDENTIFIER)('sad')
-        PsiElement(RPAR)(')')
-        PsiWhiteSpace(' ')
-        PsiElement(EQ)('=')
-        PsiWhiteSpace(' ')
-        REFERENCE_EXPRESSION
-          PsiElement(IDENTIFIER)('foo')
-    PsiWhiteSpace('\n\n')
-    FUN
-      PsiElement(fun)('fun')
-      PsiWhiteSpace(' ')
-      PsiElement(IDENTIFIER)('foo')
-      VALUE_PARAMETER_LIST
-        PsiElement(LPAR)('(')
-        PsiElement(RPAR)(')')
       PsiWhiteSpace(' ')
       BLOCK
         PsiElement(LBRACE)('{')
-        PsiWhiteSpace('\n  ')
-        PROPERTY
-          PsiElement(val)('val')
-          PsiWhiteSpace(' ')
-          PsiElement(IDENTIFIER)('foo')
-          PsiWhiteSpace(' ')
-          PsiElement(EQ)('=')
-          PsiWhiteSpace(' ')
-          INTEGER_CONSTANT
-            PsiElement(INTEGER_LITERAL)('5')
-        PsiWhiteSpace('\n  ')
-        BINARY_EXPRESSION
-          CALL_EXPRESSION
-            REFERENCE_EXPRESSION
-              PsiElement(IDENTIFIER)('get')
-            VALUE_ARGUMENT_LIST
-              PsiElement(LPAR)('(')
-              PsiElement(RPAR)(')')
-          PsiWhiteSpace(' ')
-          OPERATION_REFERENCE
-            PsiElement(EQ)('=')
-          PsiWhiteSpace(' ')
-          INTEGER_CONSTANT
-            PsiElement(INTEGER_LITERAL)('5')
-        PsiWhiteSpace('\n  ')
-        BINARY_EXPRESSION
-          CALL_EXPRESSION
-            REFERENCE_EXPRESSION
-              PsiElement(IDENTIFIER)('set')
-            VALUE_ARGUMENT_LIST
-              PsiElement(LPAR)('(')
-              VALUE_ARGUMENT
-                BINARY_WITH_TYPE
-                  REFERENCE_EXPRESSION
-                    PsiElement(IDENTIFIER)('int')
-                  PsiWhiteSpace(' ')
-                  OPERATION_REFERENCE
-                    PsiElement(COLON)(':')
-                  PsiWhiteSpace(' ')
-                  TYPE_REFERENCE
-                    USER_TYPE
-                      REFERENCE_EXPRESSION
-                        PsiElement(IDENTIFIER)('x')
-              PsiElement(RPAR)(')')
-          PsiWhiteSpace(' ')
-          OPERATION_REFERENCE
-            PsiElement(EQ)('=')
-          PsiWhiteSpace(' ')
-          INTEGER_CONSTANT
-            PsiElement(INTEGER_LITERAL)('5')
-        PsiWhiteSpace('\n')
         PsiElement(RBRACE)('}')
-    PsiWhiteSpace('\n\n')
+    PsiWhiteSpace('\n   ')
-    PROPERTY
+    PROPERTY_ACCESSOR
-      PsiElement(val)('val')
+      PsiElement(set)('set')
+  PsiWhiteSpace('\n\n')
+  PROPERTY
+    PsiElement(val)('val')
+    PsiWhiteSpace(' ')
+    TYPE_REFERENCE
+      USER_TYPE
+        REFERENCE_EXPRESSION
+          PsiElement(IDENTIFIER)('foo')
+    PsiElement(DOT)('.')
+    PsiElement(IDENTIFIER)('bar')
+    PsiWhiteSpace('\n   ')
+    PROPERTY_ACCESSOR
+      PsiElement(get)('get')
+    PsiWhiteSpace('\n   ')
+    PROPERTY_ACCESSOR
+      PsiElement(set)('set')
+      PsiElement(LPAR)('(')
+      VALUE_PARAMETER_LIST
+        VALUE_PARAMETER
+          PsiElement(IDENTIFIER)('sad')
+      PsiElement(RPAR)(')')
       PsiWhiteSpace(' ')
-      TYPE_REFERENCE
+      PsiElement(EQ)('=')
-        USER_TYPE
-          REFERENCE_EXPRESSION
-            PsiElement(IDENTIFIER)('IList')
-          TYPE_ARGUMENT_LIST
-            PsiElement(LT)('<')
-            TYPE_PROJECTION
-              TYPE_REFERENCE
-                USER_TYPE
-                  REFERENCE_EXPRESSION
-                    PsiElement(IDENTIFIER)('T')
-            PsiElement(GT)('>')
-      PsiElement(DOT)('.')
-      PsiElement(IDENTIFIER)('lastIndex')
       PsiWhiteSpace(' ')
-      PsiElement(COLON)(':')
+      REFERENCE_EXPRESSION
+        PsiElement(IDENTIFIER)('foo')
+  PsiWhiteSpace('\n\n')
+  PROPERTY
+    PsiElement(val)('val')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('foo')
+    PsiWhiteSpace(' ')
+    PsiElement(EQ)('=')
+    PsiWhiteSpace(' ')
+    INTEGER_CONSTANT
+      PsiElement(INTEGER_LITERAL)('5')
+    PsiElement(SEMICOLON)(';')
+    PsiWhiteSpace(' ')
+    PROPERTY_ACCESSOR
+      PsiElement(get)('get')
+  PsiWhiteSpace('\n')
+  PROPERTY
+    PsiElement(val)('val')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('foo')
+    PsiWhiteSpace(' ')
+    PsiElement(EQ)('=')
+    INTEGER_CONSTANT
+      PsiElement(INTEGER_LITERAL)('1')
+    PsiElement(SEMICOLON)(';')
+    PsiWhiteSpace(' ')
+    PROPERTY_ACCESSOR
+      PsiElement(get)('get')
+    PsiWhiteSpace(' ')
+    PROPERTY_ACCESSOR
+      PsiElement(set)('set')
+  PsiWhiteSpace('\n\n')
+  PROPERTY
+    PsiElement(var)('var')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('foo')
+    PsiWhiteSpace(' ')
+    PsiElement(EQ)('=')
+    PsiWhiteSpace(' ')
+    INTEGER_CONSTANT
+      PsiElement(INTEGER_LITERAL)('5')
+    PsiWhiteSpace('\n  ')
+    PROPERTY_ACCESSOR
+      PsiElement(get)('get')
+    PsiWhiteSpace('\n  ')
+    PROPERTY_ACCESSOR
+      MODIFIER_LIST
+        PsiElement(private)('private')
       PsiWhiteSpace(' ')
-      TYPE_REFERENCE
+      PsiElement(set)('set')
-        USER_TYPE
+  PsiWhiteSpace('\n\n')
-          REFERENCE_EXPRESSION
+  PROPERTY
-            PsiElement(IDENTIFIER)('Int')
+    PsiElement(val)('val')
+    PsiWhiteSpace(' ')
+    TYPE_REFERENCE
+      USER_TYPE
+        REFERENCE_EXPRESSION
+          PsiElement(IDENTIFIER)('foo')
+    PsiElement(DOT)('.')
+    PsiElement(IDENTIFIER)('bar')
+    PsiWhiteSpace(' ')
+    PsiElement(EQ)('=')
+    PsiWhiteSpace(' ')
+    INTEGER_CONSTANT
+      PsiElement(INTEGER_LITERAL)('5')
+    PsiWhiteSpace('\n   ')
+    PROPERTY_ACCESSOR
+      PsiElement(get)('get')
+      PsiElement(LPAR)('(')
+      PsiElement(RPAR)(')')
+      PsiWhiteSpace(' ')
+      BLOCK
+        PsiElement(LBRACE)('{')
+        PsiElement(RBRACE)('}')
+    PsiWhiteSpace('\n   ')
+    PROPERTY_ACCESSOR
+      PsiElement(set)('set')
+  PsiWhiteSpace('\n\n')
+  PROPERTY
+    PsiElement(val)('val')
+    PsiWhiteSpace(' ')
+    TYPE_REFERENCE
+      USER_TYPE
+        REFERENCE_EXPRESSION
+          PsiElement(IDENTIFIER)('foo')
+    PsiElement(DOT)('.')
+    PsiElement(IDENTIFIER)('bar')
+    PsiWhiteSpace(' ')
+    PsiElement(EQ)('=')
+    PsiWhiteSpace(' ')
+    INTEGER_CONSTANT
+      PsiElement(INTEGER_LITERAL)('5')
+    PsiWhiteSpace('\n   ')
+    PROPERTY_ACCESSOR
+      PsiElement(get)('get')
+    PsiWhiteSpace('\n   ')
+    PROPERTY_ACCESSOR
+      PsiElement(set)('set')
+      PsiElement(LPAR)('(')
+      VALUE_PARAMETER_LIST
+        VALUE_PARAMETER
+          PsiElement(IDENTIFIER)('sad')
+      PsiElement(RPAR)(')')
+      PsiWhiteSpace(' ')
+      PsiElement(EQ)('=')
+      PsiWhiteSpace(' ')
+      REFERENCE_EXPRESSION
+        PsiElement(IDENTIFIER)('foo')
+  PsiWhiteSpace('\n\n')
+  FUN
+    PsiElement(fun)('fun')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('foo')
+    VALUE_PARAMETER_LIST
+      PsiElement(LPAR)('(')
+      PsiElement(RPAR)(')')
+    PsiWhiteSpace(' ')
+    BLOCK
+      PsiElement(LBRACE)('{')
       PsiWhiteSpace('\n  ')
-      PROPERTY_ACCESSOR
+      PROPERTY
-        PsiElement(get)('get')
+        PsiElement(val)('val')
-        PsiElement(LPAR)('(')
+        PsiWhiteSpace(' ')
-        PsiElement(RPAR)(')')
+        PsiElement(IDENTIFIER)('foo')
         PsiWhiteSpace(' ')
         PsiElement(EQ)('=')
         PsiWhiteSpace(' ')
-        BINARY_EXPRESSION
+        INTEGER_CONSTANT
-          DOT_QUALIFIED_EXPRESSION
+          PsiElement(INTEGER_LITERAL)('5')
-            THIS_EXPRESSION
+      PsiWhiteSpace('\n  ')
-              REFERENCE_EXPRESSION
+      BINARY_EXPRESSION
-                PsiElement(this)('this')
+        CALL_EXPRESSION
-            PsiElement(DOT)('.')
+          REFERENCE_EXPRESSION
+            PsiElement(IDENTIFIER)('get')
+          VALUE_ARGUMENT_LIST
+            PsiElement(LPAR)('(')
+            PsiElement(RPAR)(')')
+        PsiWhiteSpace(' ')
+        OPERATION_REFERENCE
+          PsiElement(EQ)('=')
+        PsiWhiteSpace(' ')
+        INTEGER_CONSTANT
+          PsiElement(INTEGER_LITERAL)('5')
+      PsiWhiteSpace('\n  ')
+      BINARY_EXPRESSION
+        CALL_EXPRESSION
+          REFERENCE_EXPRESSION
+            PsiElement(IDENTIFIER)('set')
+          VALUE_ARGUMENT_LIST
+            PsiElement(LPAR)('(')
+            VALUE_ARGUMENT
+              BINARY_WITH_TYPE
+                REFERENCE_EXPRESSION
+                  PsiElement(IDENTIFIER)('int')
+                PsiWhiteSpace(' ')
+                OPERATION_REFERENCE
+                  PsiElement(COLON)(':')
+                PsiWhiteSpace(' ')
+                TYPE_REFERENCE
+                  USER_TYPE
+                    REFERENCE_EXPRESSION
+                      PsiElement(IDENTIFIER)('x')
+            PsiElement(RPAR)(')')
+        PsiWhiteSpace(' ')
+        OPERATION_REFERENCE
+          PsiElement(EQ)('=')
+        PsiWhiteSpace(' ')
+        INTEGER_CONSTANT
+          PsiElement(INTEGER_LITERAL)('5')
+      PsiWhiteSpace('\n')
+      PsiElement(RBRACE)('}')
+  PsiWhiteSpace('\n\n')
+  PROPERTY
+    PsiElement(val)('val')
+    PsiWhiteSpace(' ')
+    TYPE_REFERENCE
+      USER_TYPE
+        REFERENCE_EXPRESSION
+          PsiElement(IDENTIFIER)('IList')
+        TYPE_ARGUMENT_LIST
+          PsiElement(LT)('<')
+          TYPE_PROJECTION
+            TYPE_REFERENCE
+              USER_TYPE
+                REFERENCE_EXPRESSION
+                  PsiElement(IDENTIFIER)('T')
+          PsiElement(GT)('>')
+    PsiElement(DOT)('.')
+    PsiElement(IDENTIFIER)('lastIndex')
+    PsiWhiteSpace(' ')
+    PsiElement(COLON)(':')
+    PsiWhiteSpace(' ')
+    TYPE_REFERENCE
+      USER_TYPE
+        REFERENCE_EXPRESSION
+          PsiElement(IDENTIFIER)('Int')
+    PsiWhiteSpace('\n  ')
+    PROPERTY_ACCESSOR
+      PsiElement(get)('get')
+      PsiElement(LPAR)('(')
+      PsiElement(RPAR)(')')
+      PsiWhiteSpace(' ')
+      PsiElement(EQ)('=')
+      PsiWhiteSpace(' ')
+      BINARY_EXPRESSION
+        DOT_QUALIFIED_EXPRESSION
+          THIS_EXPRESSION
             REFERENCE_EXPRESSION
-              PsiElement(IDENTIFIER)('size')
+              PsiElement(this)('this')
-          PsiWhiteSpace(' ')
+          PsiElement(DOT)('.')
-          OPERATION_REFERENCE
+          REFERENCE_EXPRESSION
-            PsiElement(MINUS)('-')
+            PsiElement(IDENTIFIER)('size')
-          PsiWhiteSpace(' ')
+        PsiWhiteSpace(' ')
-          INTEGER_CONSTANT
+        OPERATION_REFERENCE
-            PsiElement(INTEGER_LITERAL)('1')
+          PsiElement(MINUS)('-')
-    PsiWhiteSpace('\n\n')
+        PsiWhiteSpace(' ')
-    PROPERTY
+        INTEGER_CONSTANT
-      PsiElement(val)('val')
+          PsiElement(INTEGER_LITERAL)('1')
-      PsiWhiteSpace(' ')
+  PsiWhiteSpace('\n\n')
-      TYPE_REFERENCE
+  PROPERTY
-        NULLABLE_TYPE
+    PsiElement(val)('val')
-          USER_TYPE
+    PsiWhiteSpace(' ')
-            REFERENCE_EXPRESSION
+    TYPE_REFERENCE
-              PsiElement(IDENTIFIER)('Int')
+      NULLABLE_TYPE
-          PsiElement(QUEST)('?')
-      PsiElement(DOT)('.')
-      PsiElement(IDENTIFIER)('opt')
-      PsiWhiteSpace(' ')
-      PsiElement(COLON)(':')
-      PsiWhiteSpace(' ')
-      TYPE_REFERENCE
         USER_TYPE
           REFERENCE_EXPRESSION
             PsiElement(IDENTIFIER)('Int')
-    PsiWhiteSpace('\n')
+        PsiElement(QUEST)('?')
-    PROPERTY
+    PsiElement(DOT)('.')
-      PsiElement(val)('val')
+    PsiElement(IDENTIFIER)('opt')
-      PsiWhiteSpace(' ')
+    PsiWhiteSpace(' ')
-      TYPE_REFERENCE
+    PsiElement(COLON)(':')
-        NULLABLE_TYPE
+    PsiWhiteSpace(' ')
-          USER_TYPE
+    TYPE_REFERENCE
-            REFERENCE_EXPRESSION
+      USER_TYPE
-              PsiElement(IDENTIFIER)('Int')
+        REFERENCE_EXPRESSION
-          PsiElement(QUEST)('?')
+          PsiElement(IDENTIFIER)('Int')
-      PsiWhiteSpace(' ')
+  PsiWhiteSpace('\n')
-      PsiElement(DOT)('.')
+  PROPERTY
-      PsiElement(IDENTIFIER)('opt')
+    PsiElement(val)('val')
-      PsiWhiteSpace(' ')
+    PsiWhiteSpace(' ')
-      PsiElement(COLON)(':')
+    TYPE_REFERENCE
-      PsiWhiteSpace(' ')
+      NULLABLE_TYPE
-      TYPE_REFERENCE
         USER_TYPE
           REFERENCE_EXPRESSION
-            PsiElement(IDENTIFIER)('Int')
+            PsiElement(IDENTIFIER)('Int')
+        PsiElement(QUEST)('?')
+    PsiWhiteSpace(' ')
+    PsiElement(DOT)('.')
+    PsiElement(IDENTIFIER)('opt')
+    PsiWhiteSpace(' ')
+    PsiElement(COLON)(':')
+    PsiWhiteSpace(' ')
+    TYPE_REFERENCE
+      USER_TYPE
+        REFERENCE_EXPRESSION
+          PsiElement(IDENTIFIER)('Int')

compiler/testData/psi/PropertiesFollowedByInitializers.txt

@@ -1,463 +1,462 @@
 JetFile: PropertiesFollowedByInitializers.jet
-  NAMESPACE
+  NAMESPACE_HEADER
-    NAMESPACE_HEADER
+    <empty list>
+  CLASS
+    PsiElement(class)('class')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('Foo')
+    TYPE_PARAMETER_LIST
       <empty list>
-    CLASS
+    VALUE_PARAMETER_LIST
-      PsiElement(class)('class')
+      PsiElement(LPAR)('(')
-      PsiWhiteSpace(' ')
+      PsiElement(RPAR)(')')
-      PsiElement(IDENTIFIER)('Foo')
+    PsiWhiteSpace(' ')
-      TYPE_PARAMETER_LIST
+    CLASS_BODY
-        <empty list>
+      PsiElement(LBRACE)('{')
-      VALUE_PARAMETER_LIST
+      PsiWhiteSpace('\n  ')
-        PsiElement(LPAR)('(')
+      PROPERTY
-        PsiElement(RPAR)(')')
+        PsiElement(val)('val')
-      PsiWhiteSpace(' ')
+        PsiWhiteSpace(' ')
-      CLASS_BODY
+        PsiElement(IDENTIFIER)('a')
-        PsiElement(LBRACE)('{')
+        PsiWhiteSpace(' ')
-        PsiWhiteSpace('\n  ')
+        PsiElement(COLON)(':')
-        PROPERTY
+        PsiWhiteSpace(' ')
-          PsiElement(val)('val')
+        TYPE_REFERENCE
+          USER_TYPE
+            REFERENCE_EXPRESSION
+              PsiElement(IDENTIFIER)('Int')
+        PsiWhiteSpace(' ')
+        PROPERTY_ACCESSOR
+          PsiElement(get)('get')
+          PsiErrorElement:Accessor body expected
+            <empty list>
+          PsiErrorElement:Expecting '('
+            <empty list>
+          PsiErrorElement:Expecting ')'
+            <empty list>
           PsiWhiteSpace(' ')
-          PsiElement(IDENTIFIER)('a')
+          PsiElement(EQ)('=')
           PsiWhiteSpace(' ')
-          PsiElement(COLON)(':')
+          INTEGER_CONSTANT
+            PsiElement(INTEGER_LITERAL)('1')
+      PsiWhiteSpace('\n  ')
+      PROPERTY
+        PsiElement(var)('var')
+        PsiWhiteSpace(' ')
+        PsiElement(IDENTIFIER)('b')
+        PsiWhiteSpace(' ')
+        PsiElement(COLON)(':')
+        PsiWhiteSpace(' ')
+        TYPE_REFERENCE
+          USER_TYPE
+            REFERENCE_EXPRESSION
+              PsiElement(IDENTIFIER)('Int')
+        PsiWhiteSpace(' ')
+        PROPERTY_ACCESSOR
+          PsiElement(get)('get')
+          PsiElement(LPAR)('(')
+          PsiElement(RPAR)(')')
           PsiWhiteSpace(' ')
-          TYPE_REFERENCE
+          PsiElement(EQ)('=')
-            USER_TYPE
-              REFERENCE_EXPRESSION
-                PsiElement(IDENTIFIER)('Int')
           PsiWhiteSpace(' ')
-          PROPERTY_ACCESSOR
+          INTEGER_CONSTANT
-            PsiElement(get)('get')
+            PsiElement(INTEGER_LITERAL)('1')
-            PsiErrorElement:Accessor body expected
+          PsiElement(SEMICOLON)(';')
-              <empty list>
+        PsiWhiteSpace(' ')
-            PsiErrorElement:Expecting '('
+        PROPERTY_ACCESSOR
-              <empty list>
+          PsiElement(set)('set')
-            PsiErrorElement:Expecting ')'
+      PsiWhiteSpace('\n  ')
-              <empty list>
+      PROPERTY
-            PsiWhiteSpace(' ')
+        PsiElement(var)('var')
-            PsiElement(EQ)('=')
+        PsiWhiteSpace(' ')
-            PsiWhiteSpace(' ')
+        PsiElement(IDENTIFIER)('b1')
+        PsiWhiteSpace(' ')
+        PsiElement(COLON)(':')
+        PsiWhiteSpace(' ')
+        TYPE_REFERENCE
+          USER_TYPE
+            REFERENCE_EXPRESSION
+              PsiElement(IDENTIFIER)('Int')
+        PsiWhiteSpace(' ')
+        PROPERTY_ACCESSOR
+          PsiElement(get)('get')
+          PsiElement(LPAR)('(')
+          PsiElement(RPAR)(')')
+          PsiWhiteSpace(' ')
+          PsiElement(EQ)('=')
+          PsiWhiteSpace(' ')
+          INTEGER_CONSTANT
+            PsiElement(INTEGER_LITERAL)('1')
+          PsiElement(SEMICOLON)(';')
+        PsiWhiteSpace(' ')
+        PROPERTY_ACCESSOR
+          PsiElement(set)('set')
+          PsiErrorElement:Accessor body expected
+            <empty list>
+          PsiErrorElement:Expecting '('
+            <empty list>
+          PsiWhiteSpace(' ')
+          VALUE_PARAMETER_LIST
+            VALUE_PARAMETER
+              PsiErrorElement:Expecting parameter name
+                <empty list>
+          PsiErrorElement:Expecting ')'
+            <empty list>
+          BLOCK
+            PsiElement(LBRACE)('{')
             INTEGER_CONSTANT
               PsiElement(INTEGER_LITERAL)('1')
-        PsiWhiteSpace('\n  ')
+            PsiElement(RBRACE)('}')
-        PROPERTY
+      PsiWhiteSpace('\n  ')
-          PsiElement(var)('var')
+      PROPERTY
+        PsiElement(val)('val')
+        PsiWhiteSpace(' ')
+        PsiElement(IDENTIFIER)('b2')
+        PsiWhiteSpace(' ')
+        PsiElement(COLON)(':')
+        PsiWhiteSpace(' ')
+        TYPE_REFERENCE
+          USER_TYPE
+            REFERENCE_EXPRESSION
+              PsiElement(IDENTIFIER)('Int')
+        PsiWhiteSpace(' ')
+        PROPERTY_ACCESSOR
+          PsiElement(get)('get')
+      PsiWhiteSpace('\n  ')
+      ANONYMOUS_INITIALIZER
+        BLOCK
+          PsiElement(LBRACE)('{')
+          PsiWhiteSpace('\n\n  ')
+          PsiElement(RBRACE)('}')
+      PsiWhiteSpace('\n  ')
+      PROPERTY
+        PsiElement(val)('val')
+        PsiWhiteSpace(' ')
+        PsiElement(IDENTIFIER)('b3')
+        PsiWhiteSpace(' ')
+        PsiElement(COLON)(':')
+        PsiWhiteSpace(' ')
+        TYPE_REFERENCE
+          USER_TYPE
+            REFERENCE_EXPRESSION
+              PsiElement(IDENTIFIER)('Int')
+        PsiWhiteSpace(' ')
+        PROPERTY_ACCESSOR
+          PsiElement(get)('get')
+          PsiErrorElement:Accessor body expected
+            <empty list>
+          PsiErrorElement:Expecting '('
+            <empty list>
+          PsiErrorElement:Expecting ')'
+            <empty list>
           PsiWhiteSpace(' ')
-          PsiElement(IDENTIFIER)('b')
+          BLOCK
-          PsiWhiteSpace(' ')
+            PsiElement(LBRACE)('{')
-          PsiElement(COLON)(':')
+            PsiWhiteSpace('\n    ')
-          PsiWhiteSpace(' ')
+            RETURN
-          TYPE_REFERENCE
+              PsiElement(return)('return')
-            USER_TYPE
+              PsiWhiteSpace(' ')
-              REFERENCE_EXPRESSION
-                PsiElement(IDENTIFIER)('Int')
-          PsiWhiteSpace(' ')
-          PROPERTY_ACCESSOR
-            PsiElement(get)('get')
-            PsiElement(LPAR)('(')
-            PsiElement(RPAR)(')')
-            PsiWhiteSpace(' ')
-            PsiElement(EQ)('=')
-            PsiWhiteSpace(' ')
-            INTEGER_CONSTANT
-              PsiElement(INTEGER_LITERAL)('1')
-            PsiElement(SEMICOLON)(';')
-          PsiWhiteSpace(' ')
-          PROPERTY_ACCESSOR
-            PsiElement(set)('set')
-        PsiWhiteSpace('\n  ')
-        PROPERTY
-          PsiElement(var)('var')
-          PsiWhiteSpace(' ')
-          PsiElement(IDENTIFIER)('b1')
-          PsiWhiteSpace(' ')
-          PsiElement(COLON)(':')
-          PsiWhiteSpace(' ')
-          TYPE_REFERENCE
-            USER_TYPE
-              REFERENCE_EXPRESSION
-                PsiElement(IDENTIFIER)('Int')
-          PsiWhiteSpace(' ')
-          PROPERTY_ACCESSOR
-            PsiElement(get)('get')
-            PsiElement(LPAR)('(')
-            PsiElement(RPAR)(')')
-            PsiWhiteSpace(' ')
-            PsiElement(EQ)('=')
-            PsiWhiteSpace(' ')
-            INTEGER_CONSTANT
-              PsiElement(INTEGER_LITERAL)('1')
-            PsiElement(SEMICOLON)(';')
-          PsiWhiteSpace(' ')
-          PROPERTY_ACCESSOR
-            PsiElement(set)('set')
-            PsiErrorElement:Accessor body expected
-              <empty list>
-            PsiErrorElement:Expecting '('
-              <empty list>
-            PsiWhiteSpace(' ')
-            VALUE_PARAMETER_LIST
-              VALUE_PARAMETER
-                PsiErrorElement:Expecting parameter name
-                  <empty list>
-            PsiErrorElement:Expecting ')'
-              <empty list>
-            BLOCK
-              PsiElement(LBRACE)('{')
               INTEGER_CONSTANT
                 PsiElement(INTEGER_LITERAL)('1')
-              PsiElement(RBRACE)('}')
-        PsiWhiteSpace('\n  ')
-        PROPERTY
-          PsiElement(val)('val')
-          PsiWhiteSpace(' ')
-          PsiElement(IDENTIFIER)('b2')
-          PsiWhiteSpace(' ')
-          PsiElement(COLON)(':')
-          PsiWhiteSpace(' ')
-          TYPE_REFERENCE
-            USER_TYPE
-              REFERENCE_EXPRESSION
-                PsiElement(IDENTIFIER)('Int')
-          PsiWhiteSpace(' ')
-          PROPERTY_ACCESSOR
-            PsiElement(get)('get')
-        PsiWhiteSpace('\n  ')
-        ANONYMOUS_INITIALIZER
-          BLOCK
-            PsiElement(LBRACE)('{')
-            PsiWhiteSpace('\n\n  ')
-            PsiElement(RBRACE)('}')
-        PsiWhiteSpace('\n  ')
-        PROPERTY
-          PsiElement(val)('val')
-          PsiWhiteSpace(' ')
-          PsiElement(IDENTIFIER)('b3')
-          PsiWhiteSpace(' ')
-          PsiElement(COLON)(':')
-          PsiWhiteSpace(' ')
-          TYPE_REFERENCE
-            USER_TYPE
-              REFERENCE_EXPRESSION
-                PsiElement(IDENTIFIER)('Int')
-          PsiWhiteSpace(' ')
-          PROPERTY_ACCESSOR
-            PsiElement(get)('get')
-            PsiErrorElement:Accessor body expected
-              <empty list>
-            PsiErrorElement:Expecting '('
-              <empty list>
-            PsiErrorElement:Expecting ')'
-              <empty list>
-            PsiWhiteSpace(' ')
-            BLOCK
-              PsiElement(LBRACE)('{')
-              PsiWhiteSpace('\n    ')
-              RETURN
-                PsiElement(return)('return')
-                PsiWhiteSpace(' ')
-                INTEGER_CONSTANT
-                  PsiElement(INTEGER_LITERAL)('1')
-              PsiWhiteSpace('\n  ')
-              PsiElement(RBRACE)('}')
-        PsiWhiteSpace('\n  ')
-        PROPERTY
-          PsiElement(val)('val')
-          PsiWhiteSpace(' ')
-          PsiElement(IDENTIFIER)('b4')
-          PsiWhiteSpace(' ')
-          PsiElement(COLON)(':')
-          PsiWhiteSpace(' ')
-          TYPE_REFERENCE
-            USER_TYPE
-              REFERENCE_EXPRESSION
-                PsiElement(IDENTIFIER)('Int')
-          PsiWhiteSpace(' ')
-          PROPERTY_ACCESSOR
-            PsiElement(get)('get')
-          PsiElement(SEMICOLON)(';')
-        PsiWhiteSpace(' ')
-        ANONYMOUS_INITIALIZER
-          BLOCK
-            PsiElement(LBRACE)('{')
             PsiWhiteSpace('\n  ')
             PsiElement(RBRACE)('}')
-        PsiWhiteSpace('\n\n  ')
+      PsiWhiteSpace('\n  ')
-        PROPERTY
+      PROPERTY
-          PsiElement(var)('var')
+        PsiElement(val)('val')
+        PsiWhiteSpace(' ')
+        PsiElement(IDENTIFIER)('b4')
+        PsiWhiteSpace(' ')
+        PsiElement(COLON)(':')
+        PsiWhiteSpace(' ')
+        TYPE_REFERENCE
+          USER_TYPE
+            REFERENCE_EXPRESSION
+              PsiElement(IDENTIFIER)('Int')
+        PsiWhiteSpace(' ')
+        PROPERTY_ACCESSOR
+          PsiElement(get)('get')
+        PsiElement(SEMICOLON)(';')
+      PsiWhiteSpace(' ')
+      ANONYMOUS_INITIALIZER
+        BLOCK
+          PsiElement(LBRACE)('{')
+          PsiWhiteSpace('\n  ')
+          PsiElement(RBRACE)('}')
+      PsiWhiteSpace('\n\n  ')
+      PROPERTY
+        PsiElement(var)('var')
+        PsiWhiteSpace(' ')
+        PsiElement(IDENTIFIER)('b5')
+        PsiWhiteSpace(' ')
+        PsiElement(COLON)(':')
+        PsiWhiteSpace(' ')
+        TYPE_REFERENCE
+          USER_TYPE
+            REFERENCE_EXPRESSION
+              PsiElement(IDENTIFIER)('Int')
+        PsiWhiteSpace(' ')
+        PROPERTY_ACCESSOR
+          PsiElement(get)('get')
+        PsiWhiteSpace(' ')
+        PROPERTY_ACCESSOR
+          MODIFIER_LIST
+            PsiElement(abstract)('abstract')
           PsiWhiteSpace(' ')
-          PsiElement(IDENTIFIER)('b5')
+          PsiElement(set)('set')
-          PsiWhiteSpace(' ')
+      PsiWhiteSpace('\n  ')
-          PsiElement(COLON)(':')
+      PROPERTY
-          PsiWhiteSpace(' ')
+        PsiElement(var)('var')
-          TYPE_REFERENCE
+        PsiWhiteSpace(' ')
-            USER_TYPE
+        PsiElement(IDENTIFIER)('b6')
-              REFERENCE_EXPRESSION
+        PsiWhiteSpace(' ')
-                PsiElement(IDENTIFIER)('Int')
+        PsiElement(COLON)(':')
-          PsiWhiteSpace(' ')
+        PsiWhiteSpace(' ')
-          PROPERTY_ACCESSOR
+        TYPE_REFERENCE
-            PsiElement(get)('get')
+          USER_TYPE
-          PsiWhiteSpace(' ')
+            REFERENCE_EXPRESSION
-          PROPERTY_ACCESSOR
+              PsiElement(IDENTIFIER)('Int')
-            MODIFIER_LIST
+        PsiWhiteSpace(' ')
-              PsiElement(abstract)('abstract')
+        PROPERTY_ACCESSOR
-            PsiWhiteSpace(' ')
+          PsiElement(get)('get')
-            PsiElement(set)('set')
+        PsiWhiteSpace(' ')
-        PsiWhiteSpace('\n  ')
+        PROPERTY_ACCESSOR
-        PROPERTY
+          MODIFIER_LIST
-          PsiElement(var)('var')
+            ANNOTATION
-          PsiWhiteSpace(' ')
+              PsiElement(LBRACKET)('[')
-          PsiElement(IDENTIFIER)('b6')
+              ANNOTATION_ENTRY
-          PsiWhiteSpace(' ')
+                CONSTRUCTOR_CALLEE
-          PsiElement(COLON)(':')
+                  TYPE_REFERENCE
-          PsiWhiteSpace(' ')
+                    USER_TYPE
-          TYPE_REFERENCE
+                      REFERENCE_EXPRESSION
-            USER_TYPE
+                        PsiElement(IDENTIFIER)('a')
-              REFERENCE_EXPRESSION
+              PsiElement(RBRACKET)(']')
-                PsiElement(IDENTIFIER)('Int')
-          PsiWhiteSpace(' ')
-          PROPERTY_ACCESSOR
-            PsiElement(get)('get')
-          PsiWhiteSpace(' ')
-          PROPERTY_ACCESSOR
-            MODIFIER_LIST
-              ANNOTATION
-                PsiElement(LBRACKET)('[')
-                ANNOTATION_ENTRY
-                  CONSTRUCTOR_CALLEE
-                    TYPE_REFERENCE
-                      USER_TYPE
-                        REFERENCE_EXPRESSION
-                          PsiElement(IDENTIFIER)('a')
-                PsiElement(RBRACKET)(']')
-              PsiWhiteSpace(' ')
-              PsiElement(abstract)('abstract')
-            PsiWhiteSpace(' ')
-            PsiElement(set)('set')
-        PsiWhiteSpace('\n  ')
-        PROPERTY
-          PsiElement(var)('var')
-          PsiWhiteSpace(' ')
-          PsiElement(IDENTIFIER)('b7')
-          PsiWhiteSpace(' ')
-          PsiElement(COLON)(':')
-          PsiWhiteSpace(' ')
-          TYPE_REFERENCE
-            USER_TYPE
-              REFERENCE_EXPRESSION
-                PsiElement(IDENTIFIER)('Int')
-          PsiWhiteSpace(' ')
-          PROPERTY_ACCESSOR
-            PsiElement(get)('get')
-          PsiWhiteSpace(' ')
-          PsiErrorElement:Property getter or setter expected
-            PsiElement(LBRACKET)('[')
-            PsiElement(IDENTIFIER)('a')
-            PsiElement(RBRACKET)(']')
             PsiWhiteSpace(' ')
             PsiElement(abstract)('abstract')
-            PsiWhiteSpace(' ')
+          PsiWhiteSpace(' ')
-            PsiElement(LBRACE)('{')
+          PsiElement(set)('set')
-            PsiElement(RBRACE)('}')
+      PsiWhiteSpace('\n  ')
-        PsiWhiteSpace('\n')
+      PROPERTY
-        PsiElement(RBRACE)('}')
+        PsiElement(var)('var')
-    PsiWhiteSpace('\n\n')
-    CLASS
-      PsiElement(class)('class')
-      PsiWhiteSpace(' ')
-      PsiElement(IDENTIFIER)('PublicVar')
-      TYPE_PARAMETER_LIST
-        <empty list>
-      VALUE_PARAMETER_LIST
-        PsiElement(LPAR)('(')
-        PsiElement(RPAR)(')')
-      PsiWhiteSpace(' ')
-      CLASS_BODY
-        PsiElement(LBRACE)('{')
         PsiWhiteSpace(' ')
-        PROPERTY
+        PsiElement(IDENTIFIER)('b7')
-          MODIFIER_LIST
-            PsiElement(public)('public')
-          PsiWhiteSpace(' ')
-          PsiElement(var)('var')
-          PsiWhiteSpace(' ')
-          PsiElement(IDENTIFIER)('foo')
-          PsiWhiteSpace(' ')
-          PsiElement(EQ)('=')
-          PsiWhiteSpace(' ')
-          INTEGER_CONSTANT
-            PsiElement(INTEGER_LITERAL)('0')
-          PsiElement(SEMICOLON)(';')
         PsiWhiteSpace(' ')
-        PsiElement(RBRACE)('}')
+        PsiElement(COLON)(':')
-    PsiWhiteSpace('\n')
-    CLASS
-      PsiElement(class)('class')
-      PsiWhiteSpace(' ')
-      PsiElement(IDENTIFIER)('PublicVar')
-      TYPE_PARAMETER_LIST
-        <empty list>
-      VALUE_PARAMETER_LIST
-        PsiElement(LPAR)('(')
-        PsiElement(RPAR)(')')
-      PsiWhiteSpace(' ')
-      CLASS_BODY
-        PsiElement(LBRACE)('{')
         PsiWhiteSpace(' ')
-        PROPERTY
+        TYPE_REFERENCE
-          MODIFIER_LIST
+          USER_TYPE
-            PsiElement(public)('public')
+            REFERENCE_EXPRESSION
-          PsiWhiteSpace(' ')
+              PsiElement(IDENTIFIER)('Int')
-          PsiElement(var)('var')
-          PsiWhiteSpace(' ')
-          PsiElement(IDENTIFIER)('foo')
-          PsiWhiteSpace(' ')
-          PsiElement(EQ)('=')
-          PsiWhiteSpace(' ')
-          INTEGER_CONSTANT
-            PsiElement(INTEGER_LITERAL)('0')
-          PsiElement(SEMICOLON)(';')
         PsiWhiteSpace(' ')
-        PROPERTY
+        PROPERTY_ACCESSOR
-          PsiElement(var)('var')
+          PsiElement(get)('get')
-          PsiWhiteSpace(' ')
-          PsiElement(IDENTIFIER)('x')
-          PsiWhiteSpace(' ')
-          PsiElement(COLON)(':')
-          PsiWhiteSpace(' ')
-          TYPE_REFERENCE
-            USER_TYPE
-              REFERENCE_EXPRESSION
-                PsiElement(IDENTIFIER)('Int')
         PsiWhiteSpace(' ')
-        PsiElement(RBRACE)('}')
+        PsiErrorElement:Property getter or setter expected
-    PsiWhiteSpace('\n')
+          PsiElement(LBRACKET)('[')
-    CLASS
+          PsiElement(IDENTIFIER)('a')
-      PsiElement(class)('class')
+          PsiElement(RBRACKET)(']')
+          PsiWhiteSpace(' ')
+          PsiElement(abstract)('abstract')
+          PsiWhiteSpace(' ')
+          PsiElement(LBRACE)('{')
+          PsiElement(RBRACE)('}')
+      PsiWhiteSpace('\n')
+      PsiElement(RBRACE)('}')
+  PsiWhiteSpace('\n\n')
+  CLASS
+    PsiElement(class)('class')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('PublicVar')
+    TYPE_PARAMETER_LIST
+      <empty list>
+    VALUE_PARAMETER_LIST
+      PsiElement(LPAR)('(')
+      PsiElement(RPAR)(')')
+    PsiWhiteSpace(' ')
+    CLASS_BODY
+      PsiElement(LBRACE)('{')
       PsiWhiteSpace(' ')
-      PsiElement(IDENTIFIER)('PublicVar')
+      PROPERTY
-      TYPE_PARAMETER_LIST
+        MODIFIER_LIST
-        <empty list>
+          PsiElement(public)('public')
-      VALUE_PARAMETER_LIST
-        PsiElement(LPAR)('(')
-        PsiElement(RPAR)(')')
-      PsiWhiteSpace(' ')
-      CLASS_BODY
-        PsiElement(LBRACE)('{')
         PsiWhiteSpace(' ')
-        PROPERTY
+        PsiElement(var)('var')
-          MODIFIER_LIST
-            PsiElement(public)('public')
-          PsiWhiteSpace(' ')
-          PsiElement(var)('var')
-          PsiWhiteSpace(' ')
-          PsiElement(IDENTIFIER)('foo')
-          PsiWhiteSpace(' ')
-          PsiElement(EQ)('=')
-          PsiWhiteSpace(' ')
-          INTEGER_CONSTANT
-            PsiElement(INTEGER_LITERAL)('0')
         PsiWhiteSpace(' ')
-        PsiElement(RBRACE)('}')
+        PsiElement(IDENTIFIER)('foo')
-    PsiWhiteSpace('\n')
-    CLASS
-      PsiElement(class)('class')
-      PsiWhiteSpace(' ')
-      PsiElement(IDENTIFIER)('PublicVar')
-      TYPE_PARAMETER_LIST
-        <empty list>
-      VALUE_PARAMETER_LIST
-        PsiElement(LPAR)('(')
-        PsiElement(RPAR)(')')
-      PsiWhiteSpace(' ')
-      CLASS_BODY
-        PsiElement(LBRACE)('{')
-        PsiWhiteSpace(' ')
-        PROPERTY
-          MODIFIER_LIST
-            PsiElement(public)('public')
-          PsiWhiteSpace(' ')
-          PsiElement(var)('var')
-          PsiWhiteSpace(' ')
-          PsiElement(IDENTIFIER)('foo')
-          PsiWhiteSpace(' ')
-          PROPERTY_ACCESSOR
-            PsiElement(get)('get')
-          PsiWhiteSpace(' ')
-          PROPERTY_ACCESSOR
-            PsiElement(set)('set')
-        PsiWhiteSpace(' ')
-        PsiElement(RBRACE)('}')
-    PsiWhiteSpace('\n')
-    CLASS
-      PsiElement(class)('class')
-      PsiWhiteSpace(' ')
-      PsiElement(IDENTIFIER)('PublicVar')
-      TYPE_PARAMETER_LIST
-        <empty list>
-      VALUE_PARAMETER_LIST
-        PsiElement(LPAR)('(')
-        PsiElement(RPAR)(')')
-      PsiWhiteSpace(' ')
-      CLASS_BODY
-        PsiElement(LBRACE)('{')
-        PsiWhiteSpace(' ')
-        PROPERTY
-          MODIFIER_LIST
-            PsiElement(public)('public')
-          PsiWhiteSpace(' ')
-          PsiElement(var)('var')
-          PsiWhiteSpace(' ')
-          PsiElement(IDENTIFIER)('foo')
-          PsiWhiteSpace(' ')
-          PROPERTY_ACCESSOR
-            PsiElement(get)('get')
-          PsiWhiteSpace(' ')
-          PROPERTY_ACCESSOR
-            PsiElement(set)('set')
-        PsiWhiteSpace(' ')
-        PsiElement(RBRACE)('}')
-    PsiWhiteSpace('\n\n')
-    PROPERTY
-      PsiElement(val)('val')
-      PsiWhiteSpace(' ')
-      PsiElement(IDENTIFIER)('now')
-      PsiElement(COLON)(':')
-      PsiWhiteSpace(' ')
-      TYPE_REFERENCE
-        USER_TYPE
-          REFERENCE_EXPRESSION
-            PsiElement(IDENTIFIER)('Long')
-      PsiWhiteSpace(' ')
-      PROPERTY_ACCESSOR
-        PsiElement(get)('get')
-        PsiElement(LPAR)('(')
-        PsiElement(RPAR)(')')
         PsiWhiteSpace(' ')
         PsiElement(EQ)('=')
         PsiWhiteSpace(' ')
-        DOT_QUALIFIED_EXPRESSION
+        INTEGER_CONSTANT
-          REFERENCE_EXPRESSION
+          PsiElement(INTEGER_LITERAL)('0')
-            PsiElement(IDENTIFIER)('System')
-          PsiElement(DOT)('.')
-          CALL_EXPRESSION
-            REFERENCE_EXPRESSION
-              PsiElement(IDENTIFIER)('currentTimeMillis')
-            VALUE_ARGUMENT_LIST
-              PsiElement(LPAR)('(')
-              PsiElement(RPAR)(')')
         PsiElement(SEMICOLON)(';')
-    PsiWhiteSpace(' ')
-    FUN
-      PsiElement(fun)('fun')
       PsiWhiteSpace(' ')
-      PsiElement(IDENTIFIER)('foo')
+      PsiElement(RBRACE)('}')
-      VALUE_PARAMETER_LIST
+  PsiWhiteSpace('\n')
-        PsiElement(LPAR)('(')
+  CLASS
-        PsiElement(RPAR)(')')
+    PsiElement(class)('class')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('PublicVar')
+    TYPE_PARAMETER_LIST
+      <empty list>
+    VALUE_PARAMETER_LIST
+      PsiElement(LPAR)('(')
+      PsiElement(RPAR)(')')
+    PsiWhiteSpace(' ')
+    CLASS_BODY
+      PsiElement(LBRACE)('{')
+      PsiWhiteSpace(' ')
+      PROPERTY
+        MODIFIER_LIST
+          PsiElement(public)('public')
+        PsiWhiteSpace(' ')
+        PsiElement(var)('var')
+        PsiWhiteSpace(' ')
+        PsiElement(IDENTIFIER)('foo')
+        PsiWhiteSpace(' ')
+        PsiElement(EQ)('=')
+        PsiWhiteSpace(' ')
+        INTEGER_CONSTANT
+          PsiElement(INTEGER_LITERAL)('0')
+        PsiElement(SEMICOLON)(';')
+      PsiWhiteSpace(' ')
+      PROPERTY
+        PsiElement(var)('var')
+        PsiWhiteSpace(' ')
+        PsiElement(IDENTIFIER)('x')
+        PsiWhiteSpace(' ')
+        PsiElement(COLON)(':')
+        PsiWhiteSpace(' ')
+        TYPE_REFERENCE
+          USER_TYPE
+            REFERENCE_EXPRESSION
+              PsiElement(IDENTIFIER)('Int')
+      PsiWhiteSpace(' ')
+      PsiElement(RBRACE)('}')
+  PsiWhiteSpace('\n')
+  CLASS
+    PsiElement(class)('class')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('PublicVar')
+    TYPE_PARAMETER_LIST
+      <empty list>
+    VALUE_PARAMETER_LIST
+      PsiElement(LPAR)('(')
+      PsiElement(RPAR)(')')
+    PsiWhiteSpace(' ')
+    CLASS_BODY
+      PsiElement(LBRACE)('{')
+      PsiWhiteSpace(' ')
+      PROPERTY
+        MODIFIER_LIST
+          PsiElement(public)('public')
+        PsiWhiteSpace(' ')
+        PsiElement(var)('var')
+        PsiWhiteSpace(' ')
+        PsiElement(IDENTIFIER)('foo')
+        PsiWhiteSpace(' ')
+        PsiElement(EQ)('=')
+        PsiWhiteSpace(' ')
+        INTEGER_CONSTANT
+          PsiElement(INTEGER_LITERAL)('0')
+      PsiWhiteSpace(' ')
+      PsiElement(RBRACE)('}')
+  PsiWhiteSpace('\n')
+  CLASS
+    PsiElement(class)('class')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('PublicVar')
+    TYPE_PARAMETER_LIST
+      <empty list>
+    VALUE_PARAMETER_LIST
+      PsiElement(LPAR)('(')
+      PsiElement(RPAR)(')')
+    PsiWhiteSpace(' ')
+    CLASS_BODY
+      PsiElement(LBRACE)('{')
+      PsiWhiteSpace(' ')
+      PROPERTY
+        MODIFIER_LIST
+          PsiElement(public)('public')
+        PsiWhiteSpace(' ')
+        PsiElement(var)('var')
+        PsiWhiteSpace(' ')
+        PsiElement(IDENTIFIER)('foo')
+        PsiWhiteSpace(' ')
+        PROPERTY_ACCESSOR
+          PsiElement(get)('get')
+        PsiWhiteSpace(' ')
+        PROPERTY_ACCESSOR
+          PsiElement(set)('set')
+      PsiWhiteSpace(' ')
+      PsiElement(RBRACE)('}')
+  PsiWhiteSpace('\n')
+  CLASS
+    PsiElement(class)('class')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('PublicVar')
+    TYPE_PARAMETER_LIST
+      <empty list>
+    VALUE_PARAMETER_LIST
+      PsiElement(LPAR)('(')
+      PsiElement(RPAR)(')')
+    PsiWhiteSpace(' ')
+    CLASS_BODY
+      PsiElement(LBRACE)('{')
+      PsiWhiteSpace(' ')
+      PROPERTY
+        MODIFIER_LIST
+          PsiElement(public)('public')
+        PsiWhiteSpace(' ')
+        PsiElement(var)('var')
+        PsiWhiteSpace(' ')
+        PsiElement(IDENTIFIER)('foo')
+        PsiWhiteSpace(' ')
+        PROPERTY_ACCESSOR
+          PsiElement(get)('get')
+        PsiWhiteSpace(' ')
+        PROPERTY_ACCESSOR
+          PsiElement(set)('set')
+      PsiWhiteSpace(' ')
+      PsiElement(RBRACE)('}')
+  PsiWhiteSpace('\n\n')
+  PROPERTY
+    PsiElement(val)('val')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('now')
+    PsiElement(COLON)(':')
+    PsiWhiteSpace(' ')
+    TYPE_REFERENCE
+      USER_TYPE
+        REFERENCE_EXPRESSION
+          PsiElement(IDENTIFIER)('Long')
+    PsiWhiteSpace(' ')
+    PROPERTY_ACCESSOR
+      PsiElement(get)('get')
+      PsiElement(LPAR)('(')
+      PsiElement(RPAR)(')')
       PsiWhiteSpace(' ')
       PsiElement(EQ)('=')
       PsiWhiteSpace(' ')
-      REFERENCE_EXPRESSION
+      DOT_QUALIFIED_EXPRESSION
-        PsiElement(IDENTIFIER)('now')
+        REFERENCE_EXPRESSION
+          PsiElement(IDENTIFIER)('System')
+        PsiElement(DOT)('.')
+        CALL_EXPRESSION
+          REFERENCE_EXPRESSION
+            PsiElement(IDENTIFIER)('currentTimeMillis')
+          VALUE_ARGUMENT_LIST
+            PsiElement(LPAR)('(')
+            PsiElement(RPAR)(')')
+      PsiElement(SEMICOLON)(';')
+  PsiWhiteSpace(' ')
+  FUN
+    PsiElement(fun)('fun')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('foo')
+    VALUE_PARAMETER_LIST
+      PsiElement(LPAR)('(')
+      PsiElement(RPAR)(')')
+    PsiWhiteSpace(' ')
+    PsiElement(EQ)('=')
+    PsiWhiteSpace(' ')
+    REFERENCE_EXPRESSION
+      PsiElement(IDENTIFIER)('now')

compiler/testData/psi/Properties_ERR.txt

@@ -1,180 +1,179 @@
 JetFile: Properties_ERR.jet
-  NAMESPACE
+  NAMESPACE_HEADER
-    NAMESPACE_HEADER
+    <empty list>
-      <empty list>
+  PROPERTY
-    PROPERTY
+    PsiElement(var)('var')
-      PsiElement(var)('var')
+    PsiWhiteSpace(' ')
-      PsiWhiteSpace(' ')
+    PsiErrorElement:Expecting property name or receiver type
-      PsiErrorElement:Expecting property name or receiver type
+      PsiElement(MINUS)('-')
-        PsiElement(MINUS)('-')
+    PsiWhiteSpace(' ')
-      PsiWhiteSpace(' ')
+    PsiErrorElement:Property getter or setter expected
-      PsiErrorElement:Property getter or setter expected
+      PsiElement(LBRACE)('{')
-        PsiElement(LBRACE)('{')
+      PsiElement(RBRACE)('}')
-        PsiElement(RBRACE)('}')
+  PsiWhiteSpace('\n')
+  PROPERTY
+    PsiElement(var)('var')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('f')
+    PsiWhiteSpace(' ')
+    PsiErrorElement:Property getter or setter expected
+      PsiElement(LBRACE)('{')
+      PsiElement(RBRACE)('}')
+  PsiWhiteSpace('\n')
+  PROPERTY
+    PsiElement(var)('var')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('f')
+    PsiWhiteSpace(' ')
+    PsiElement(COLON)(':')
     PsiWhiteSpace('\n')
-    PROPERTY
+    TYPE_REFERENCE
-      PsiElement(var)('var')
+      PsiErrorElement:Type expected
-      PsiWhiteSpace(' ')
-      PsiElement(IDENTIFIER)('f')
-      PsiWhiteSpace(' ')
-      PsiErrorElement:Property getter or setter expected
-        PsiElement(LBRACE)('{')
-        PsiElement(RBRACE)('}')
-    PsiWhiteSpace('\n')
-    PROPERTY
-      PsiElement(var)('var')
-      PsiWhiteSpace(' ')
-      PsiElement(IDENTIFIER)('f')
-      PsiWhiteSpace(' ')
-      PsiElement(COLON)(':')
-      PsiWhiteSpace('\n')
-      TYPE_REFERENCE
-        PsiErrorElement:Type expected
-          <empty list>
-    PROPERTY
-      PsiElement(val)('val')
-      PsiWhiteSpace(' ')
-      PsiElement(IDENTIFIER)('foo')
-      PsiWhiteSpace(' ')
-      PsiElement(COLON)(':')
-      PsiWhiteSpace('\n')
-      TYPE_REFERENCE
-        PsiErrorElement:Type expected
-          <empty list>
-    PROPERTY
-      PsiElement(val)('val')
-      PsiWhiteSpace(' ')
-      ANNOTATION
-        PsiElement(LBRACKET)('[')
-        ANNOTATION_ENTRY
-          CONSTRUCTOR_CALLEE
-            TYPE_REFERENCE
-              USER_TYPE
-                REFERENCE_EXPRESSION
-                  PsiElement(IDENTIFIER)('a')
-        PsiWhiteSpace(' ')
-        ANNOTATION_ENTRY
-          CONSTRUCTOR_CALLEE
-            TYPE_REFERENCE
-              USER_TYPE
-                REFERENCE_EXPRESSION
-                  PsiElement(IDENTIFIER)('foo')
-        PsiErrorElement:Expecting ']' to close an attribute annotation
-          <empty list>
-      PsiWhiteSpace(' ')
-      PsiElement(EQ)('=')
-      PsiWhiteSpace(' ')
-      REFERENCE_EXPRESSION
-        PsiElement(IDENTIFIER)('foo')
-    PsiWhiteSpace('\n')
-    PROPERTY
-      PsiElement(val)('val')
-      PsiWhiteSpace(' ')
-      TYPE_REFERENCE
-        USER_TYPE
-          USER_TYPE
-            REFERENCE_EXPRESSION
-              PsiElement(IDENTIFIER)('foo')
-          PsiElement(DOT)('.')
-          REFERENCE_EXPRESSION
-            PsiElement(IDENTIFIER)('bar')
-      PsiElement(DOT)('.')
-      PsiErrorElement:Expecting property name
         <empty list>
+  PROPERTY
+    PsiElement(val)('val')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('foo')
+    PsiWhiteSpace(' ')
+    PsiElement(COLON)(':')
     PsiWhiteSpace('\n')
-    PROPERTY
+    TYPE_REFERENCE
-      PsiElement(val)('val')
+      PsiErrorElement:Type expected
-      PsiWhiteSpace(' ')
+        <empty list>
-      ANNOTATION
+  PROPERTY
-        PsiElement(LBRACKET)('[')
+    PsiElement(val)('val')
-        ANNOTATION_ENTRY
+    PsiWhiteSpace(' ')
-          CONSTRUCTOR_CALLEE
+    ANNOTATION
-            TYPE_REFERENCE
+      PsiElement(LBRACKET)('[')
-              USER_TYPE
+      ANNOTATION_ENTRY
-                REFERENCE_EXPRESSION
+        CONSTRUCTOR_CALLEE
-                  PsiElement(IDENTIFIER)('a')
+          TYPE_REFERENCE
-        PsiElement(RBRACKET)(']')
+            USER_TYPE
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('a')
       PsiWhiteSpace(' ')
+      ANNOTATION_ENTRY
+        CONSTRUCTOR_CALLEE
+          TYPE_REFERENCE
+            USER_TYPE
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('foo')
+      PsiErrorElement:Expecting ']' to close an attribute annotation
+        <empty list>
+    PsiWhiteSpace(' ')
+    PsiElement(EQ)('=')
+    PsiWhiteSpace(' ')
+    REFERENCE_EXPRESSION
       PsiElement(IDENTIFIER)('foo')
-      PsiWhiteSpace(' ')
+  PsiWhiteSpace('\n')
-      PsiElement(COLON)(':')
+  PROPERTY
-      PsiWhiteSpace(' ')
+    PsiElement(val)('val')
-      TYPE_REFERENCE
+    PsiWhiteSpace(' ')
-        PsiErrorElement:Type expected
+    TYPE_REFERENCE
-          <empty list>
+      USER_TYPE
-      PsiElement(EQ)('=')
-      PsiWhiteSpace(' ')
-      REFERENCE_EXPRESSION
-        PsiElement(IDENTIFIER)('bar')
-    PsiWhiteSpace('\n')
-    PROPERTY
-      PsiElement(val)('val')
-      PsiWhiteSpace(' ')
-      TYPE_REFERENCE
         USER_TYPE
           REFERENCE_EXPRESSION
             PsiElement(IDENTIFIER)('foo')
-      PsiElement(DOT)('.')
+        PsiElement(DOT)('.')
+        REFERENCE_EXPRESSION
+          PsiElement(IDENTIFIER)('bar')
+    PsiElement(DOT)('.')
+    PsiErrorElement:Expecting property name
+      <empty list>
+  PsiWhiteSpace('\n')
+  PROPERTY
+    PsiElement(val)('val')
+    PsiWhiteSpace(' ')
+    ANNOTATION
+      PsiElement(LBRACKET)('[')
+      ANNOTATION_ENTRY
+        CONSTRUCTOR_CALLEE
+          TYPE_REFERENCE
+            USER_TYPE
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('a')
+      PsiElement(RBRACKET)(']')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('foo')
+    PsiWhiteSpace(' ')
+    PsiElement(COLON)(':')
+    PsiWhiteSpace(' ')
+    TYPE_REFERENCE
+      PsiErrorElement:Type expected
+        <empty list>
+    PsiElement(EQ)('=')
+    PsiWhiteSpace(' ')
+    REFERENCE_EXPRESSION
       PsiElement(IDENTIFIER)('bar')
-    PsiWhiteSpace('\n   ')
+  PsiWhiteSpace('\n')
+  PROPERTY
+    PsiElement(val)('val')
+    PsiWhiteSpace(' ')
+    TYPE_REFERENCE
+      USER_TYPE
+        REFERENCE_EXPRESSION
+          PsiElement(IDENTIFIER)('foo')
+    PsiElement(DOT)('.')
+    PsiElement(IDENTIFIER)('bar')
+  PsiWhiteSpace('\n   ')
+  MODIFIER_LIST
+    PsiElement(public)('public')
+  PsiWhiteSpace(' ')
+  PsiErrorElement:Expecting namespace or top level declaration
+    PsiElement(LPAR)('(')
+  PsiErrorElement:Expecting namespace or top level declaration
+    PsiElement(RPAR)(')')
+  PsiWhiteSpace(' ')
+  PsiErrorElement:Expecting namespace or top level declaration
+    PsiElement(LBRACE)('{')
+  PsiErrorElement:Expecting namespace or top level declaration
+    PsiElement(RBRACE)('}')
+  PsiWhiteSpace('\n   ')
+  PsiErrorElement:Expecting namespace or top level declaration
+    PsiElement(LPAR)('(')
+  PsiErrorElement:Expecting namespace or top level declaration
+    PsiElement(RPAR)(')')
+  PsiWhiteSpace(' ')
+  PsiErrorElement:Expecting namespace or top level declaration
+    PsiElement(EQ)('=')
+  PsiWhiteSpace(' ')
+  PROPERTY
     MODIFIER_LIST
-      PsiElement(public)('public')
+      ANNOTATION_ENTRY
-    PsiWhiteSpace(' ')
+        CONSTRUCTOR_CALLEE
-    PsiErrorElement:Expecting namespace or top level declaration
+          TYPE_REFERENCE
-      PsiElement(LPAR)('(')
+            USER_TYPE
-    PsiErrorElement:Expecting namespace or top level declaration
+              REFERENCE_EXPRESSION
-      PsiElement(RPAR)(')')
+                PsiElement(IDENTIFIER)('foo')
-    PsiWhiteSpace(' ')
-    PsiErrorElement:Expecting namespace or top level declaration
-      PsiElement(LBRACE)('{')
-    PsiErrorElement:Expecting namespace or top level declaration
-      PsiElement(RBRACE)('}')
-    PsiWhiteSpace('\n   ')
-    PsiErrorElement:Expecting namespace or top level declaration
-      PsiElement(LPAR)('(')
-    PsiErrorElement:Expecting namespace or top level declaration
-      PsiElement(RPAR)(')')
-    PsiWhiteSpace(' ')
-    PsiErrorElement:Expecting namespace or top level declaration
-      PsiElement(EQ)('=')
-    PsiWhiteSpace(' ')
-    PROPERTY
-      MODIFIER_LIST
-        ANNOTATION_ENTRY
-          CONSTRUCTOR_CALLEE
-            TYPE_REFERENCE
-              USER_TYPE
-                REFERENCE_EXPRESSION
-                  PsiElement(IDENTIFIER)('foo')
-      PsiWhiteSpace('\n\n')
-      PsiElement(val)('val')
-      PsiWhiteSpace(' ')
-      TYPE_REFERENCE
-        USER_TYPE
-          USER_TYPE
-            REFERENCE_EXPRESSION
-              PsiElement(IDENTIFIER)('f')
-          PsiElement(DOT)('.')
-          REFERENCE_EXPRESSION
-            PsiElement(IDENTIFIER)('d')
-      PsiElement(DOT)('.')
-      PsiErrorElement:Expecting property name
-        PsiElement(MINUS)('-')
-      PsiWhiteSpace(' ')
-      PsiElement(EQ)('=')
-      PsiWhiteSpace(' ')
-      REFERENCE_EXPRESSION
-        PsiElement(IDENTIFIER)('f')
     PsiWhiteSpace('\n\n')
-    PROPERTY
+    PsiElement(val)('val')
-      PsiElement(val)('val')
+    PsiWhiteSpace(' ')
+    TYPE_REFERENCE
+      USER_TYPE
+        USER_TYPE
+          REFERENCE_EXPRESSION
+            PsiElement(IDENTIFIER)('f')
+        PsiElement(DOT)('.')
+        REFERENCE_EXPRESSION
+          PsiElement(IDENTIFIER)('d')
+    PsiElement(DOT)('.')
+    PsiErrorElement:Expecting property name
+      PsiElement(MINUS)('-')
+    PsiWhiteSpace(' ')
+    PsiElement(EQ)('=')
+    PsiWhiteSpace(' ')
+    REFERENCE_EXPRESSION
+      PsiElement(IDENTIFIER)('f')
+  PsiWhiteSpace('\n\n')
+  PROPERTY
+    PsiElement(val)('val')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('foo')
+    PsiWhiteSpace('\n    ')
+    PROPERTY_ACCESSOR
+      PsiElement(get)('get')
+      PsiElement(LPAR)('(')
+      PsiElement(RPAR)(')')
       PsiWhiteSpace(' ')
-      PsiElement(IDENTIFIER)('foo')
+      PsiErrorElement:Expecting function body
-      PsiWhiteSpace('\n    ')
+        PsiElement(MINUS)('-')
-      PROPERTY_ACCESSOR
-        PsiElement(get)('get')
-        PsiElement(LPAR)('(')
-        PsiElement(RPAR)(')')
-        PsiWhiteSpace(' ')
-        PsiErrorElement:Expecting function body
-          PsiElement(MINUS)('-')

compiler/testData/psi/QuotedIdentifiers.txt

@@ -1,62 +1,61 @@
 JetFile: QuotedIdentifiers.jet
-  NAMESPACE
+  NAMESPACE_HEADER
-    NAMESPACE_HEADER
+    <empty list>
+  FUN
+    MODIFIER_LIST
+      ANNOTATION
+        PsiElement(LBRACKET)('[')
+        ANNOTATION_ENTRY
+          CONSTRUCTOR_CALLEE
+            TYPE_REFERENCE
+              USER_TYPE
+                REFERENCE_EXPRESSION
+                  PsiElement(IDENTIFIER)('`return`')
+        PsiElement(RBRACKET)(']')
+    PsiWhiteSpace(' ')
+    PsiElement(fun)('fun')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('`namespace`')
+    VALUE_PARAMETER_LIST
+      PsiElement(LPAR)('(')
+      PsiElement(RPAR)(')')
+    PsiWhiteSpace(' ')
+    BLOCK
+      PsiElement(LBRACE)('{')
+      PsiWhiteSpace('\n  ')
+      CALL_EXPRESSION
+        REFERENCE_EXPRESSION
+          PsiElement(IDENTIFIER)('`class`')
+        VALUE_ARGUMENT_LIST
+          PsiElement(LPAR)('(')
+          PsiElement(RPAR)(')')
+      PsiWhiteSpace('\n')
+      PsiElement(RBRACE)('}')
+  PsiWhiteSpace('\n\n')
+  CLASS
+    PsiElement(class)('class')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('`$`')
+    PsiWhiteSpace('\n')
+    TYPE_PARAMETER_LIST
       <empty list>
-    FUN
+  CLASS
-      MODIFIER_LIST
+    PsiElement(class)('class')
-        ANNOTATION
+    PsiWhiteSpace(' ')
-          PsiElement(LBRACKET)('[')
+    PsiElement(IDENTIFIER)('`$$`')
-          ANNOTATION_ENTRY
+    PsiWhiteSpace('\n')
-            CONSTRUCTOR_CALLEE
+    TYPE_PARAMETER_LIST
-              TYPE_REFERENCE
+      <empty list>
-                USER_TYPE
+  CLASS
-                  REFERENCE_EXPRESSION
+    PsiElement(class)('class')
-                    PsiElement(IDENTIFIER)('`return`')
+    PsiWhiteSpace(' ')
-          PsiElement(RBRACKET)(']')
+    PsiElement(IDENTIFIER)('` `')
-      PsiWhiteSpace(' ')
+    PsiWhiteSpace('\n')
-      PsiElement(fun)('fun')
+    TYPE_PARAMETER_LIST
-      PsiWhiteSpace(' ')
+      <empty list>
-      PsiElement(IDENTIFIER)('`namespace`')
+  CLASS
-      VALUE_PARAMETER_LIST
+    PsiElement(class)('class')
-        PsiElement(LPAR)('(')
+    PsiWhiteSpace(' ')
-        PsiElement(RPAR)(')')
+    PsiElement(IDENTIFIER)('`1`')
-      PsiWhiteSpace(' ')
+    TYPE_PARAMETER_LIST
-      BLOCK
+      <empty list>
-        PsiElement(LBRACE)('{')
-        PsiWhiteSpace('\n  ')
-        CALL_EXPRESSION
-          REFERENCE_EXPRESSION
-            PsiElement(IDENTIFIER)('`class`')
-          VALUE_ARGUMENT_LIST
-            PsiElement(LPAR)('(')
-            PsiElement(RPAR)(')')
-        PsiWhiteSpace('\n')
-        PsiElement(RBRACE)('}')
-    PsiWhiteSpace('\n\n')
-    CLASS
-      PsiElement(class)('class')
-      PsiWhiteSpace(' ')
-      PsiElement(IDENTIFIER)('`$`')
-      PsiWhiteSpace('\n')
-      TYPE_PARAMETER_LIST
-        <empty list>
-    CLASS
-      PsiElement(class)('class')
-      PsiWhiteSpace(' ')
-      PsiElement(IDENTIFIER)('`$$`')
-      PsiWhiteSpace('\n')
-      TYPE_PARAMETER_LIST
-        <empty list>
-    CLASS
-      PsiElement(class)('class')
-      PsiWhiteSpace(' ')
-      PsiElement(IDENTIFIER)('` `')
-      PsiWhiteSpace('\n')
-      TYPE_PARAMETER_LIST
-        <empty list>
-    CLASS
-      PsiElement(class)('class')
-      PsiWhiteSpace(' ')
-      PsiElement(IDENTIFIER)('`1`')
-      TYPE_PARAMETER_LIST
-        <empty list>

compiler/testData/psi/RootNamespace.txt

@@ -1,134 +1,133 @@
 JetFile: RootNamespace.jet
-  NAMESPACE
+  NAMESPACE_HEADER
-    NAMESPACE_HEADER
+    PsiElement(namespace)('package')
-      PsiElement(namespace)('package')
-      PsiWhiteSpace(' ')
-      REFERENCE_EXPRESSION
-        PsiElement(IDENTIFIER)('foo')
-      PsiElement(DOT)('.')
-      PsiElement(IDENTIFIER)('bar')
-      PsiElement(SEMICOLON)(';')
-    PsiWhiteSpace('\n\n')
-    CLASS
-      PsiElement(class)('class')
-      PsiWhiteSpace(' ')
-      PsiElement(IDENTIFIER)('X')
-      PsiWhiteSpace('\n\n')
-      TYPE_PARAMETER_LIST
-        <empty list>
-    PsiErrorElement:Expecting namespace or top level declaration
-      PsiElement(namespace)('package')
     PsiWhiteSpace(' ')
-    MODIFIER_LIST
+    REFERENCE_EXPRESSION
-      ANNOTATION_ENTRY
-        CONSTRUCTOR_CALLEE
-          TYPE_REFERENCE
-            USER_TYPE
-              USER_TYPE
-                REFERENCE_EXPRESSION
-                  PsiElement(IDENTIFIER)('foo')
-              PsiElement(DOT)('.')
-              REFERENCE_EXPRESSION
-                PsiElement(IDENTIFIER)('bar')
-    PsiWhiteSpace(' ')
-    PsiErrorElement:Expecting namespace or top level declaration
-      PsiElement(LBRACE)('{')
-    PsiWhiteSpace('\n  ')
-    FUN
-      PsiElement(fun)('fun')
-      PsiWhiteSpace(' ')
       PsiElement(IDENTIFIER)('foo')
-      VALUE_PARAMETER_LIST
+    PsiElement(DOT)('.')
-        PsiElement(LPAR)('(')
+    PsiElement(IDENTIFIER)('bar')
-        PsiElement(RPAR)(')')
+    PsiElement(SEMICOLON)(';')
-      PsiWhiteSpace(' ')
+  PsiWhiteSpace('\n\n')
-      BLOCK
+  CLASS
-        PsiElement(LBRACE)('{')
+    PsiElement(class)('class')
-        PsiWhiteSpace('\n    ')
+    PsiWhiteSpace(' ')
-        DOT_QUALIFIED_EXPRESSION
+    PsiElement(IDENTIFIER)('X')
-          DOT_QUALIFIED_EXPRESSION
+    PsiWhiteSpace('\n\n')
-            DOT_QUALIFIED_EXPRESSION
+    TYPE_PARAMETER_LIST
-              ROOT_NAMESPACE
+      <empty list>
-                PsiElement(namespace)('package')
+  PsiErrorElement:Expecting namespace or top level declaration
-              PsiElement(DOT)('.')
+    PsiElement(namespace)('package')
+  PsiWhiteSpace(' ')
+  MODIFIER_LIST
+    ANNOTATION_ENTRY
+      CONSTRUCTOR_CALLEE
+        TYPE_REFERENCE
+          USER_TYPE
+            USER_TYPE
               REFERENCE_EXPRESSION
                 PsiElement(IDENTIFIER)('foo')
             PsiElement(DOT)('.')
             REFERENCE_EXPRESSION
               PsiElement(IDENTIFIER)('bar')
+  PsiWhiteSpace(' ')
+  PsiErrorElement:Expecting namespace or top level declaration
+    PsiElement(LBRACE)('{')
+  PsiWhiteSpace('\n  ')
+  FUN
+    PsiElement(fun)('fun')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('foo')
+    VALUE_PARAMETER_LIST
+      PsiElement(LPAR)('(')
+      PsiElement(RPAR)(')')
+    PsiWhiteSpace(' ')
+    BLOCK
+      PsiElement(LBRACE)('{')
+      PsiWhiteSpace('\n    ')
+      DOT_QUALIFIED_EXPRESSION
+        DOT_QUALIFIED_EXPRESSION
+          DOT_QUALIFIED_EXPRESSION
+            ROOT_NAMESPACE
+              PsiElement(namespace)('package')
+            PsiElement(DOT)('.')
+            REFERENCE_EXPRESSION
+              PsiElement(IDENTIFIER)('foo')
           PsiElement(DOT)('.')
+          REFERENCE_EXPRESSION
+            PsiElement(IDENTIFIER)('bar')
+        PsiElement(DOT)('.')
+        REFERENCE_EXPRESSION
+          PsiElement(IDENTIFIER)('X')
+      PsiWhiteSpace('\n    ')
+      DOT_QUALIFIED_EXPRESSION
+        DOT_QUALIFIED_EXPRESSION
+          DOT_QUALIFIED_EXPRESSION
+            ROOT_NAMESPACE
+              PsiElement(namespace)('package')
+            PsiElement(DOT)('.')
+            REFERENCE_EXPRESSION
+              PsiElement(IDENTIFIER)('foo')
+          PsiElement(DOT)('.')
+          REFERENCE_EXPRESSION
+            PsiElement(IDENTIFIER)('bar')
+        PsiElement(DOT)('.')
+        CALL_EXPRESSION
           REFERENCE_EXPRESSION
             PsiElement(IDENTIFIER)('X')
-        PsiWhiteSpace('\n    ')
+          VALUE_ARGUMENT_LIST
-        DOT_QUALIFIED_EXPRESSION
+            PsiElement(LPAR)('(')
-          DOT_QUALIFIED_EXPRESSION
+            PsiElement(RPAR)(')')
-            DOT_QUALIFIED_EXPRESSION
+      PsiWhiteSpace('\n    ')
-              ROOT_NAMESPACE
+      WHEN
-                PsiElement(namespace)('package')
+        PsiElement(when)('when')
-              PsiElement(DOT)('.')
+        PsiWhiteSpace(' ')
-              REFERENCE_EXPRESSION
+        PsiElement(LPAR)('(')
-                PsiElement(IDENTIFIER)('foo')
+        REFERENCE_EXPRESSION
-            PsiElement(DOT)('.')
+          PsiElement(IDENTIFIER)('e')
-            REFERENCE_EXPRESSION
+        PsiElement(RPAR)(')')
-              PsiElement(IDENTIFIER)('bar')
+        PsiWhiteSpace(' ')
-          PsiElement(DOT)('.')
+        PsiElement(LBRACE)('{')
-          CALL_EXPRESSION
+        PsiWhiteSpace('\n      ')
-            REFERENCE_EXPRESSION
+        WHEN_ENTRY
-              PsiElement(IDENTIFIER)('X')
+          WHEN_CONDITION_IS_PATTERN
-            VALUE_ARGUMENT_LIST
+            PsiElement(is)('is')
-              PsiElement(LPAR)('(')
+            PsiWhiteSpace(' ')
-              PsiElement(RPAR)(')')
+            DECOMPOSER_PATTERN
-        PsiWhiteSpace('\n    ')
+              DOT_QUALIFIED_EXPRESSION
-        WHEN
-          PsiElement(when)('when')
-          PsiWhiteSpace(' ')
-          PsiElement(LPAR)('(')
-          REFERENCE_EXPRESSION
-            PsiElement(IDENTIFIER)('e')
-          PsiElement(RPAR)(')')
-          PsiWhiteSpace(' ')
-          PsiElement(LBRACE)('{')
-          PsiWhiteSpace('\n      ')
-          WHEN_ENTRY
-            WHEN_CONDITION_IS_PATTERN
-              PsiElement(is)('is')
-              PsiWhiteSpace(' ')
-              DECOMPOSER_PATTERN
                 DOT_QUALIFIED_EXPRESSION
                   DOT_QUALIFIED_EXPRESSION
-                    DOT_QUALIFIED_EXPRESSION
+                    ROOT_NAMESPACE
-                      ROOT_NAMESPACE
+                      PsiElement(namespace)('package')
-                        PsiElement(namespace)('package')
-                      PsiElement(DOT)('.')
-                      REFERENCE_EXPRESSION
-                        PsiElement(IDENTIFIER)('foo')
                     PsiElement(DOT)('.')
                     REFERENCE_EXPRESSION
-                      PsiElement(IDENTIFIER)('bar')
+                      PsiElement(IDENTIFIER)('foo')
                   PsiElement(DOT)('.')
                   REFERENCE_EXPRESSION
-                    PsiElement(IDENTIFIER)('X')
+                    PsiElement(IDENTIFIER)('bar')
-                PsiWhiteSpace('  ')
+                PsiElement(DOT)('.')
-                DECOMPOSER_ARGUMENT_LIST
+                REFERENCE_EXPRESSION
-                  PsiElement(HASH)('#')
+                  PsiElement(IDENTIFIER)('X')
-                  PsiElement(LPAR)('(')
+              PsiWhiteSpace('  ')
-                  TUPLE_PATTERN_ENTRY
+              DECOMPOSER_ARGUMENT_LIST
-                    TYPE_PATTERN
+                PsiElement(HASH)('#')
-                      TYPE_REFERENCE
+                PsiElement(LPAR)('(')
-                        USER_TYPE
+                TUPLE_PATTERN_ENTRY
-                          REFERENCE_EXPRESSION
+                  TYPE_PATTERN
-                            PsiElement(IDENTIFIER)('x')
+                    TYPE_REFERENCE
-                  PsiElement(RPAR)(')')
+                      USER_TYPE
-            PsiWhiteSpace(' ')
+                        REFERENCE_EXPRESSION
-            PsiElement(ARROW)('->')
+                          PsiElement(IDENTIFIER)('x')
-            PsiWhiteSpace(' ')
+                PsiElement(RPAR)(')')
-            BLOCK
+          PsiWhiteSpace(' ')
-              PsiElement(LBRACE)('{')
+          PsiElement(ARROW)('->')
-              PsiElement(RBRACE)('}')
+          PsiWhiteSpace(' ')
-          PsiWhiteSpace('\n    ')
+          BLOCK
-          PsiElement(RBRACE)('}')
+            PsiElement(LBRACE)('{')
-        PsiWhiteSpace('\n  ')
+            PsiElement(RBRACE)('}')
+        PsiWhiteSpace('\n    ')
         PsiElement(RBRACE)('}')
-    PsiWhiteSpace('\n')
+      PsiWhiteSpace('\n  ')
-    PsiErrorElement:Expecting namespace or top level declaration
+      PsiElement(RBRACE)('}')
-      PsiElement(RBRACE)('}')
+  PsiWhiteSpace('\n')
+  PsiErrorElement:Expecting namespace or top level declaration
+    PsiElement(RBRACE)('}')

compiler/testData/psi/SemicolonAfterIf.txt

@@ -1,94 +1,93 @@
 JetFile: SemicolonAfterIf.jet
-  NAMESPACE
+  NAMESPACE_HEADER
-    NAMESPACE_HEADER
+    <empty list>
-      <empty list>
+  FUN
-    FUN
+    PsiElement(fun)('fun')
-      PsiElement(fun)('fun')
+    PsiWhiteSpace(' ')
-      PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('foo')
-      PsiElement(IDENTIFIER)('foo')
+    VALUE_PARAMETER_LIST
-      VALUE_PARAMETER_LIST
+      PsiElement(LPAR)('(')
-        PsiElement(LPAR)('(')
+      VALUE_PARAMETER
-        VALUE_PARAMETER
+        PsiElement(IDENTIFIER)('a')
-          PsiElement(IDENTIFIER)('a')
+        PsiElement(COLON)(':')
-          PsiElement(COLON)(':')
-          PsiWhiteSpace(' ')
-          TYPE_REFERENCE
-            USER_TYPE
-              REFERENCE_EXPRESSION
-                PsiElement(IDENTIFIER)('Int')
-        PsiElement(RPAR)(')')
-      PsiElement(COLON)(':')
-      PsiWhiteSpace(' ')
-      TYPE_REFERENCE
-        USER_TYPE
-          REFERENCE_EXPRESSION
-            PsiElement(IDENTIFIER)('Int')
-      PsiWhiteSpace(' ')
-      BLOCK
-        PsiElement(LBRACE)('{')
         PsiWhiteSpace(' ')
-        PROPERTY
+        TYPE_REFERENCE
-          PsiElement(var)('var')
+          USER_TYPE
-          PsiWhiteSpace(' ')
-          PsiElement(IDENTIFIER)('x')
-          PsiWhiteSpace(' ')
-          PsiElement(EQ)('=')
-          PsiWhiteSpace(' ')
-          REFERENCE_EXPRESSION
-            PsiElement(IDENTIFIER)('a')
-        PsiElement(SEMICOLON)(';')
-        PsiWhiteSpace(' ')
-        PROPERTY
-          PsiElement(var)('var')
-          PsiWhiteSpace(' ')
-          PsiElement(IDENTIFIER)('y')
-          PsiWhiteSpace(' ')
-          PsiElement(EQ)('=')
-          PsiWhiteSpace(' ')
-          POSTFIX_EXPRESSION
             REFERENCE_EXPRESSION
-              PsiElement(IDENTIFIER)('x')
+              PsiElement(IDENTIFIER)('Int')
-            OPERATION_REFERENCE
+      PsiElement(RPAR)(')')
-              PsiElement(PLUSPLUS)('++')
+    PsiElement(COLON)(':')
-        PsiElement(SEMICOLON)(';')
+    PsiWhiteSpace(' ')
+    TYPE_REFERENCE
+      USER_TYPE
+        REFERENCE_EXPRESSION
+          PsiElement(IDENTIFIER)('Int')
+    PsiWhiteSpace(' ')
+    BLOCK
+      PsiElement(LBRACE)('{')
+      PsiWhiteSpace(' ')
+      PROPERTY
+        PsiElement(var)('var')
         PsiWhiteSpace(' ')
-        IF
+        PsiElement(IDENTIFIER)('x')
-          PsiElement(if)('if')
-          PsiWhiteSpace(' ')
-          PsiElement(LPAR)('(')
-          CONDITION
-            BINARY_EXPRESSION
-              BINARY_EXPRESSION
-                REFERENCE_EXPRESSION
-                  PsiElement(IDENTIFIER)('y')
-                OPERATION_REFERENCE
-                  PsiElement(PLUS)('+')
-                INTEGER_CONSTANT
-                  PsiElement(INTEGER_LITERAL)('1')
-              PsiWhiteSpace(' ')
-              OPERATION_REFERENCE
-                PsiElement(EXCLEQ)('!=')
-              PsiWhiteSpace(' ')
-              REFERENCE_EXPRESSION
-                PsiElement(IDENTIFIER)('x')
-          PsiElement(RPAR)(')')
-          PsiWhiteSpace(' ')
-          THEN
-            RETURN
-              PsiElement(return)('return')
-              PsiWhiteSpace(' ')
-              PREFIX_EXPRESSION
-                OPERATION_REFERENCE
-                  PsiElement(MINUS)('-')
-                INTEGER_CONSTANT
-                  PsiElement(INTEGER_LITERAL)('1')
-        PsiElement(SEMICOLON)(';')
         PsiWhiteSpace(' ')
-        RETURN
+        PsiElement(EQ)('=')
-          PsiElement(return)('return')
+        PsiWhiteSpace(' ')
-          PsiWhiteSpace(' ')
+        REFERENCE_EXPRESSION
+          PsiElement(IDENTIFIER)('a')
+      PsiElement(SEMICOLON)(';')
+      PsiWhiteSpace(' ')
+      PROPERTY
+        PsiElement(var)('var')
+        PsiWhiteSpace(' ')
+        PsiElement(IDENTIFIER)('y')
+        PsiWhiteSpace(' ')
+        PsiElement(EQ)('=')
+        PsiWhiteSpace(' ')
+        POSTFIX_EXPRESSION
           REFERENCE_EXPRESSION
             PsiElement(IDENTIFIER)('x')
-        PsiElement(SEMICOLON)(';')
+          OPERATION_REFERENCE
+            PsiElement(PLUSPLUS)('++')
+      PsiElement(SEMICOLON)(';')
+      PsiWhiteSpace(' ')
+      IF
+        PsiElement(if)('if')
         PsiWhiteSpace(' ')
-        PsiElement(RBRACE)('}')
+        PsiElement(LPAR)('(')
+        CONDITION
+          BINARY_EXPRESSION
+            BINARY_EXPRESSION
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('y')
+              OPERATION_REFERENCE
+                PsiElement(PLUS)('+')
+              INTEGER_CONSTANT
+                PsiElement(INTEGER_LITERAL)('1')
+            PsiWhiteSpace(' ')
+            OPERATION_REFERENCE
+              PsiElement(EXCLEQ)('!=')
+            PsiWhiteSpace(' ')
+            REFERENCE_EXPRESSION
+              PsiElement(IDENTIFIER)('x')
+        PsiElement(RPAR)(')')
+        PsiWhiteSpace(' ')
+        THEN
+          RETURN
+            PsiElement(return)('return')
+            PsiWhiteSpace(' ')
+            PREFIX_EXPRESSION
+              OPERATION_REFERENCE
+                PsiElement(MINUS)('-')
+              INTEGER_CONSTANT
+                PsiElement(INTEGER_LITERAL)('1')
+      PsiElement(SEMICOLON)(';')
+      PsiWhiteSpace(' ')
+      RETURN
+        PsiElement(return)('return')
+        PsiWhiteSpace(' ')
+        REFERENCE_EXPRESSION
+          PsiElement(IDENTIFIER)('x')
+      PsiElement(SEMICOLON)(';')
+      PsiWhiteSpace(' ')
+      PsiElement(RBRACE)('}')

compiler/testData/psi/SimpleClassMembers_ERR.txt

@@ -1,209 +1,208 @@
 JetFile: SimpleClassMembers_ERR.jet
-  NAMESPACE
+  NAMESPACE_HEADER
-    NAMESPACE_HEADER
+    <empty list>
+  CLASS
+    PsiElement(class)('class')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('foo')
+    PsiWhiteSpace(' ')
+    TYPE_PARAMETER_LIST
       <empty list>
-    CLASS
+    CLASS_BODY
-      PsiElement(class)('class')
+      PsiElement(LBRACE)('{')
-      PsiWhiteSpace(' ')
+      PsiWhiteSpace('\n\n    ')
-      PsiElement(IDENTIFIER)('foo')
+      CLASS
-      PsiWhiteSpace(' ')
+        PsiElement(class)('class')
-      TYPE_PARAMETER_LIST
-        <empty list>
-      CLASS_BODY
-        PsiElement(LBRACE)('{')
-        PsiWhiteSpace('\n\n    ')
-        CLASS
-          PsiElement(class)('class')
-          PsiWhiteSpace(' ')
-          PsiElement(IDENTIFIER)('foo')
-          PsiWhiteSpace(' ')
-          TYPE_PARAMETER_LIST
-            <empty list>
-          CLASS_BODY
-            PsiElement(LBRACE)('{')
-            PsiElement(RBRACE)('}')
         PsiWhiteSpace(' ')
-        PsiErrorElement:Expecting member declaration
+        PsiElement(IDENTIFIER)('foo')
-          PsiElement(MINUS)('-')
+        PsiWhiteSpace(' ')
-        PsiWhiteSpace('\n\n    ')
+        TYPE_PARAMETER_LIST
-        CLASS
+          <empty list>
-          PsiElement(class)('class')
+        CLASS_BODY
-          PsiWhiteSpace(' ')
+          PsiElement(LBRACE)('{')
-          PsiElement(IDENTIFIER)('Bar')
+          PsiElement(RBRACE)('}')
-          PsiWhiteSpace(' ')
+      PsiWhiteSpace(' ')
-          TYPE_PARAMETER_LIST
+      PsiErrorElement:Expecting member declaration
-            <empty list>
+        PsiElement(MINUS)('-')
-          CLASS_BODY
+      PsiWhiteSpace('\n\n    ')
-            PsiElement(LBRACE)('{')
+      CLASS
-            PsiWhiteSpace('\n    ')
+        PsiElement(class)('class')
-            MODIFIER_LIST
+        PsiWhiteSpace(' ')
-              ANNOTATION_ENTRY
+        PsiElement(IDENTIFIER)('Bar')
+        PsiWhiteSpace(' ')
+        TYPE_PARAMETER_LIST
+          <empty list>
+        CLASS_BODY
+          PsiElement(LBRACE)('{')
+          PsiWhiteSpace('\n    ')
+          MODIFIER_LIST
+            ANNOTATION_ENTRY
+              CONSTRUCTOR_CALLEE
+                TYPE_REFERENCE
+                  USER_TYPE
+                    REFERENCE_EXPRESSION
+                      PsiElement(IDENTIFIER)('sdfsd')
+          PsiWhiteSpace('\n    ')
+          PsiErrorElement:Expecting member declaration
+            PsiElement(RBRACE)('}')
+          PsiWhiteSpace('\n\n    ')
+          FUN
+            PsiElement(fun)('fun')
+            PsiWhiteSpace(' ')
+            PsiElement(IDENTIFIER)('foo')
+            VALUE_PARAMETER_LIST
+              PsiElement(LPAR)('(')
+              PsiElement(RPAR)(')')
+          PsiWhiteSpace('\n\n    ')
+          PROPERTY
+            PsiElement(val)('val')
+            PsiWhiteSpace(' ')
+            PsiElement(IDENTIFIER)('x')
+          PsiWhiteSpace('\n\n    ')
+          PROPERTY
+            PsiElement(var)('var')
+            PsiWhiteSpace(' ')
+            PsiElement(IDENTIFIER)('f')
+          PsiWhiteSpace('\n\n    ')
+          TYPEDEF
+            PsiElement(type)('type')
+            PsiWhiteSpace(' ')
+            PsiElement(IDENTIFIER)('foo')
+            PsiWhiteSpace(' ')
+            TYPE_PARAMETER_LIST
+              <empty list>
+            PsiElement(EQ)('=')
+            PsiWhiteSpace(' ')
+            TYPE_REFERENCE
+              PsiErrorElement:Type expected
+                <empty list>
+            PsiElement(SEMICOLON)(';')
+          PsiWhiteSpace('\n\n    ')
+          CONSTRUCTOR
+            PsiElement(this)('this')
+            VALUE_PARAMETER_LIST
+              PsiElement(LPAR)('(')
+              PsiElement(RPAR)(')')
+            PsiWhiteSpace(' ')
+            PsiElement(COLON)(':')
+            PsiWhiteSpace(' ')
+            INITIALIZER_LIST
+              THIS_CALL
+                THIS_CONSTRUCTOR_REFERENCE
+                  PsiElement(this)('this')
+                VALUE_ARGUMENT_LIST
+                  PsiElement(LPAR)('(')
+                  VALUE_ARGUMENT
+                    REFERENCE_EXPRESSION
+                      PsiElement(IDENTIFIER)('a')
+                  PsiElement(COMMA)(',')
+                  PsiWhiteSpace(' ')
+                  VALUE_ARGUMENT
+                    REFERENCE_EXPRESSION
+                      PsiElement(IDENTIFIER)('b')
+                  PsiElement(COMMA)(',')
+                  PsiWhiteSpace(' ')
+                  VALUE_ARGUMENT
+                    REFERENCE_EXPRESSION
+                      PsiElement(IDENTIFIER)('c')
+                  PsiElement(RPAR)(')')
+              PsiElement(COMMA)(',')
+              PsiWhiteSpace(' ')
+              DELEGATOR_SUPER_CALL
                 CONSTRUCTOR_CALLEE
                   TYPE_REFERENCE
                     USER_TYPE
                       REFERENCE_EXPRESSION
-                        PsiElement(IDENTIFIER)('sdfsd')
+                        PsiElement(IDENTIFIER)('Foo')
-            PsiWhiteSpace('\n    ')
+                      TYPE_ARGUMENT_LIST
-            PsiErrorElement:Expecting member declaration
+                        PsiElement(LT)('<')
+                        TYPE_PROJECTION
+                          TYPE_REFERENCE
+                            USER_TYPE
+                              REFERENCE_EXPRESSION
+                                PsiElement(IDENTIFIER)('T')
+                        PsiErrorElement:Expecting a '>'
+                          <empty list>
+                VALUE_ARGUMENT_LIST
+                  PsiElement(LPAR)('(')
+                  VALUE_ARGUMENT
+                    REFERENCE_EXPRESSION
+                      PsiElement(IDENTIFIER)('bar')
+                  PsiElement(RPAR)(')')
+          PsiWhiteSpace('\n\n    ')
+          CONSTRUCTOR
+            PsiElement(this)('this')
+            VALUE_PARAMETER_LIST
+              PsiElement(LPAR)('(')
+              PsiElement(RPAR)(')')
+            PsiWhiteSpace(' ')
+            PsiElement(COLON)(':')
+            PsiWhiteSpace(' ')
+            INITIALIZER_LIST
+              THIS_CALL
+                THIS_CONSTRUCTOR_REFERENCE
+                  PsiElement(this)('this')
+                VALUE_ARGUMENT_LIST
+                  PsiElement(LPAR)('(')
+                  VALUE_ARGUMENT
+                    REFERENCE_EXPRESSION
+                      PsiElement(IDENTIFIER)('a')
+                  PsiElement(COMMA)(',')
+                  PsiWhiteSpace(' ')
+                  VALUE_ARGUMENT
+                    REFERENCE_EXPRESSION
+                      PsiElement(IDENTIFIER)('b')
+                  PsiElement(COMMA)(',')
+                  PsiWhiteSpace(' ')
+                  VALUE_ARGUMENT
+                    REFERENCE_EXPRESSION
+                      PsiElement(IDENTIFIER)('c')
+                  PsiElement(RPAR)(')')
+              PsiElement(COMMA)(',')
+              PsiWhiteSpace(' ')
+              DELEGATOR_SUPER_CALL
+                CONSTRUCTOR_CALLEE
+                  TYPE_REFERENCE
+                    USER_TYPE
+                      REFERENCE_EXPRESSION
+                        PsiElement(IDENTIFIER)('Foo')
+                      TYPE_ARGUMENT_LIST
+                        PsiElement(LT)('<')
+                        TYPE_PROJECTION
+                          TYPE_REFERENCE
+                            USER_TYPE
+                              REFERENCE_EXPRESSION
+                                PsiElement(IDENTIFIER)('T')
+                        PsiElement(GT)('>')
+                VALUE_ARGUMENT_LIST
+                  PsiElement(LPAR)('(')
+                  VALUE_ARGUMENT
+                    REFERENCE_EXPRESSION
+                      PsiElement(IDENTIFIER)('bar')
+                  PsiElement(RPAR)(')')
+            PsiWhiteSpace(' ')
+            BLOCK
+              PsiElement(LBRACE)('{')
+              PsiWhiteSpace('\n\n    ')
               PsiElement(RBRACE)('}')
-            PsiWhiteSpace('\n\n    ')
+          PsiWhiteSpace('\n\n    ')
-            FUN
+          CONSTRUCTOR
-              PsiElement(fun)('fun')
+            PsiElement(this)('this')
-              PsiWhiteSpace(' ')
+            VALUE_PARAMETER_LIST
-              PsiElement(IDENTIFIER)('foo')
+              PsiElement(LPAR)('(')
-              VALUE_PARAMETER_LIST
+              PsiElement(RPAR)(')')
-                PsiElement(LPAR)('(')
+            PsiWhiteSpace(' ')
-                PsiElement(RPAR)(')')
+            PsiElement(COLON)(':')
-            PsiWhiteSpace('\n\n    ')
+            PsiWhiteSpace(' ')
-            PROPERTY
+            INITIALIZER_LIST
-              PsiElement(val)('val')
+              PsiErrorElement:Expecting constructor call (this(...)) or supertype initializer
-              PsiWhiteSpace(' ')
+                PsiElement(MINUS)('-')
-              PsiElement(IDENTIFIER)('x')
+            PsiWhiteSpace(' ')
-            PsiWhiteSpace('\n\n    ')
+            BLOCK
-            PROPERTY
+              PsiElement(LBRACE)('{')
-              PsiElement(var)('var')
+              PsiWhiteSpace('\n\n    ')
-              PsiWhiteSpace(' ')
+              PsiElement(RBRACE)('}')
-              PsiElement(IDENTIFIER)('f')
+          PsiWhiteSpace('\n\n')
-            PsiWhiteSpace('\n\n    ')
+          PsiElement(RBRACE)('}')
-            TYPEDEF
+      PsiErrorElement:Missing '}
-              PsiElement(type)('type')
+        <empty list>
-              PsiWhiteSpace(' ')
-              PsiElement(IDENTIFIER)('foo')
-              PsiWhiteSpace(' ')
-              TYPE_PARAMETER_LIST
-                <empty list>
-              PsiElement(EQ)('=')
-              PsiWhiteSpace(' ')
-              TYPE_REFERENCE
-                PsiErrorElement:Type expected
-                  <empty list>
-              PsiElement(SEMICOLON)(';')
-            PsiWhiteSpace('\n\n    ')
-            CONSTRUCTOR
-              PsiElement(this)('this')
-              VALUE_PARAMETER_LIST
-                PsiElement(LPAR)('(')
-                PsiElement(RPAR)(')')
-              PsiWhiteSpace(' ')
-              PsiElement(COLON)(':')
-              PsiWhiteSpace(' ')
-              INITIALIZER_LIST
-                THIS_CALL
-                  THIS_CONSTRUCTOR_REFERENCE
-                    PsiElement(this)('this')
-                  VALUE_ARGUMENT_LIST
-                    PsiElement(LPAR)('(')
-                    VALUE_ARGUMENT
-                      REFERENCE_EXPRESSION
-                        PsiElement(IDENTIFIER)('a')
-                    PsiElement(COMMA)(',')
-                    PsiWhiteSpace(' ')
-                    VALUE_ARGUMENT
-                      REFERENCE_EXPRESSION
-                        PsiElement(IDENTIFIER)('b')
-                    PsiElement(COMMA)(',')
-                    PsiWhiteSpace(' ')
-                    VALUE_ARGUMENT
-                      REFERENCE_EXPRESSION
-                        PsiElement(IDENTIFIER)('c')
-                    PsiElement(RPAR)(')')
-                PsiElement(COMMA)(',')
-                PsiWhiteSpace(' ')
-                DELEGATOR_SUPER_CALL
-                  CONSTRUCTOR_CALLEE
-                    TYPE_REFERENCE
-                      USER_TYPE
-                        REFERENCE_EXPRESSION
-                          PsiElement(IDENTIFIER)('Foo')
-                        TYPE_ARGUMENT_LIST
-                          PsiElement(LT)('<')
-                          TYPE_PROJECTION
-                            TYPE_REFERENCE
-                              USER_TYPE
-                                REFERENCE_EXPRESSION
-                                  PsiElement(IDENTIFIER)('T')
-                          PsiErrorElement:Expecting a '>'
-                            <empty list>
-                  VALUE_ARGUMENT_LIST
-                    PsiElement(LPAR)('(')
-                    VALUE_ARGUMENT
-                      REFERENCE_EXPRESSION
-                        PsiElement(IDENTIFIER)('bar')
-                    PsiElement(RPAR)(')')
-            PsiWhiteSpace('\n\n    ')
-            CONSTRUCTOR
-              PsiElement(this)('this')
-              VALUE_PARAMETER_LIST
-                PsiElement(LPAR)('(')
-                PsiElement(RPAR)(')')
-              PsiWhiteSpace(' ')
-              PsiElement(COLON)(':')
-              PsiWhiteSpace(' ')
-              INITIALIZER_LIST
-                THIS_CALL
-                  THIS_CONSTRUCTOR_REFERENCE
-                    PsiElement(this)('this')
-                  VALUE_ARGUMENT_LIST
-                    PsiElement(LPAR)('(')
-                    VALUE_ARGUMENT
-                      REFERENCE_EXPRESSION
-                        PsiElement(IDENTIFIER)('a')
-                    PsiElement(COMMA)(',')
-                    PsiWhiteSpace(' ')
-                    VALUE_ARGUMENT
-                      REFERENCE_EXPRESSION
-                        PsiElement(IDENTIFIER)('b')
-                    PsiElement(COMMA)(',')
-                    PsiWhiteSpace(' ')
-                    VALUE_ARGUMENT
-                      REFERENCE_EXPRESSION
-                        PsiElement(IDENTIFIER)('c')
-                    PsiElement(RPAR)(')')
-                PsiElement(COMMA)(',')
-                PsiWhiteSpace(' ')
-                DELEGATOR_SUPER_CALL
-                  CONSTRUCTOR_CALLEE
-                    TYPE_REFERENCE
-                      USER_TYPE
-                        REFERENCE_EXPRESSION
-                          PsiElement(IDENTIFIER)('Foo')
-                        TYPE_ARGUMENT_LIST
-                          PsiElement(LT)('<')
-                          TYPE_PROJECTION
-                            TYPE_REFERENCE
-                              USER_TYPE
-                                REFERENCE_EXPRESSION
-                                  PsiElement(IDENTIFIER)('T')
-                          PsiElement(GT)('>')
-                  VALUE_ARGUMENT_LIST
-                    PsiElement(LPAR)('(')
-                    VALUE_ARGUMENT
-                      REFERENCE_EXPRESSION
-                        PsiElement(IDENTIFIER)('bar')
-                    PsiElement(RPAR)(')')
-              PsiWhiteSpace(' ')
-              BLOCK
-                PsiElement(LBRACE)('{')
-                PsiWhiteSpace('\n\n    ')
-                PsiElement(RBRACE)('}')
-            PsiWhiteSpace('\n\n    ')
-            CONSTRUCTOR
-              PsiElement(this)('this')
-              VALUE_PARAMETER_LIST
-                PsiElement(LPAR)('(')
-                PsiElement(RPAR)(')')
-              PsiWhiteSpace(' ')
-              PsiElement(COLON)(':')
-              PsiWhiteSpace(' ')
-              INITIALIZER_LIST
-                PsiErrorElement:Expecting constructor call (this(...)) or supertype initializer
-                  PsiElement(MINUS)('-')
-              PsiWhiteSpace(' ')
-              BLOCK
-                PsiElement(LBRACE)('{')
-                PsiWhiteSpace('\n\n    ')
-                PsiElement(RBRACE)('}')
-            PsiWhiteSpace('\n\n')
-            PsiElement(RBRACE)('}')
-        PsiErrorElement:Missing '}
-          <empty list>

compiler/testData/psi/SimpleModifiers.txt

@@ -1,154 +1,153 @@
 JetFile: SimpleModifiers.jet
-  NAMESPACE
+  NAMESPACE_HEADER
-    NAMESPACE_HEADER
+    PsiElement(namespace)('package')
-      PsiElement(namespace)('package')
+    PsiWhiteSpace(' ')
-      PsiWhiteSpace(' ')
+    REFERENCE_EXPRESSION
-      REFERENCE_EXPRESSION
+      PsiElement(IDENTIFIER)('foo')
-        PsiElement(IDENTIFIER)('foo')
+    PsiElement(DOT)('.')
-      PsiElement(DOT)('.')
+    REFERENCE_EXPRESSION
-      REFERENCE_EXPRESSION
+      PsiElement(IDENTIFIER)('bar')
-        PsiElement(IDENTIFIER)('bar')
+    PsiElement(DOT)('.')
-      PsiElement(DOT)('.')
+    PsiElement(IDENTIFIER)('goo')
-      PsiElement(IDENTIFIER)('goo')
+  PsiWhiteSpace('\n\n')
-    PsiWhiteSpace('\n\n')
+  CLASS
-    CLASS
+    MODIFIER_LIST
-      MODIFIER_LIST
+      PsiElement(abstract)('abstract')
-        PsiElement(abstract)('abstract')
+      PsiWhiteSpace('\n')
-        PsiWhiteSpace('\n')
+      PsiElement(open)('open')
-        PsiElement(open)('open')
+      PsiWhiteSpace('\n')
-        PsiWhiteSpace('\n')
+      PsiElement(enum)('enum')
-        PsiElement(enum)('enum')
+      PsiWhiteSpace('\n')
-        PsiWhiteSpace('\n')
+      PsiElement(open)('open')
-        PsiElement(open)('open')
+      PsiWhiteSpace('\n')
-        PsiWhiteSpace('\n')
+      PsiElement(annotation)('annotation')
-        PsiElement(annotation)('annotation')
+      PsiWhiteSpace('\n')
-        PsiWhiteSpace('\n')
+      PsiElement(override)('override')
-        PsiElement(override)('override')
+      PsiWhiteSpace('\n')
-        PsiWhiteSpace('\n')
+      PsiElement(open)('open')
-        PsiElement(open)('open')
+      PsiWhiteSpace('\n')
-        PsiWhiteSpace('\n')
+      PsiElement(abstract)('abstract')
-        PsiElement(abstract)('abstract')
+      PsiWhiteSpace('\n')
-        PsiWhiteSpace('\n')
+      PsiElement(private)('private')
-        PsiElement(private)('private')
+      PsiWhiteSpace('\n')
-        PsiWhiteSpace('\n')
+      PsiElement(protected)('protected')
-        PsiElement(protected)('protected')
+      PsiWhiteSpace('\n')
-        PsiWhiteSpace('\n')
+      PsiElement(public)('public')
-        PsiElement(public)('public')
+      PsiWhiteSpace('\n')
-        PsiWhiteSpace('\n')
+      PsiElement(internal)('internal')
-        PsiElement(internal)('internal')
+      PsiWhiteSpace('\n')
-        PsiWhiteSpace('\n')
+      PsiElement(in)('in')
-        PsiElement(in)('in')
+      PsiWhiteSpace('\n')
-        PsiWhiteSpace('\n')
+      PsiElement(out)('out')
-        PsiElement(out)('out')
+      PsiWhiteSpace('\n')
-        PsiWhiteSpace('\n')
+      PsiElement(ref)('ref')
-        PsiElement(ref)('ref')
+    PsiWhiteSpace('\n ')
-      PsiWhiteSpace('\n ')
+    PsiElement(class)('class')
-      PsiElement(class)('class')
+    PsiWhiteSpace(' ')
-      PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('Bar')
-      PsiElement(IDENTIFIER)('Bar')
+    TYPE_PARAMETER_LIST
-      TYPE_PARAMETER_LIST
+      PsiElement(LT)('<')
-        PsiElement(LT)('<')
+      TYPE_PARAMETER
-        TYPE_PARAMETER
+        MODIFIER_LIST
-          MODIFIER_LIST
+          PsiElement(abstract)('abstract')
-            PsiElement(abstract)('abstract')
+          PsiWhiteSpace('\n        ')
-            PsiWhiteSpace('\n        ')
+          PsiElement(open)('open')
-            PsiElement(open)('open')
+          PsiWhiteSpace('\n        ')
-            PsiWhiteSpace('\n        ')
+          PsiElement(enum)('enum')
-            PsiElement(enum)('enum')
+          PsiWhiteSpace('\n        ')
-            PsiWhiteSpace('\n        ')
+          PsiElement(open)('open')
-            PsiElement(open)('open')
+          PsiWhiteSpace('\n        ')
-            PsiWhiteSpace('\n        ')
+          PsiElement(annotation)('annotation')
-            PsiElement(annotation)('annotation')
+          PsiWhiteSpace('\n        ')
-            PsiWhiteSpace('\n        ')
+          PsiElement(override)('override')
-            PsiElement(override)('override')
+          PsiWhiteSpace('\n        ')
-            PsiWhiteSpace('\n        ')
+          PsiElement(open)('open')
-            PsiElement(open)('open')
+          PsiWhiteSpace('\n        ')
-            PsiWhiteSpace('\n        ')
+          PsiElement(abstract)('abstract')
-            PsiElement(abstract)('abstract')
+          PsiWhiteSpace('\n        ')
-            PsiWhiteSpace('\n        ')
+          PsiElement(private)('private')
-            PsiElement(private)('private')
+          PsiWhiteSpace('\n        ')
-            PsiWhiteSpace('\n        ')
+          PsiElement(protected)('protected')
-            PsiElement(protected)('protected')
+          PsiWhiteSpace('\n        ')
-            PsiWhiteSpace('\n        ')
+          PsiElement(public)('public')
-            PsiElement(public)('public')
+          PsiWhiteSpace('\n        ')
-            PsiWhiteSpace('\n        ')
+          PsiElement(internal)('internal')
-            PsiElement(internal)('internal')
+          PsiWhiteSpace('\n        ')
-            PsiWhiteSpace('\n        ')
+          PsiElement(in)('in')
-            PsiElement(in)('in')
+          PsiWhiteSpace('\n        ')
-            PsiWhiteSpace('\n        ')
+          PsiElement(out)('out')
-            PsiElement(out)('out')
+          PsiWhiteSpace('\n        ')
-            PsiWhiteSpace('\n        ')
+          PsiElement(ref)('ref')
-            PsiElement(ref)('ref')
+        PsiWhiteSpace(' ')
-          PsiWhiteSpace(' ')
+        PsiElement(IDENTIFIER)('T')
-          PsiElement(IDENTIFIER)('T')
+      PsiElement(GT)('>')
-        PsiElement(GT)('>')
+    PsiWhiteSpace(' ')
-      PsiWhiteSpace(' ')
+    CLASS_BODY
-      CLASS_BODY
+      PsiElement(LBRACE)('{')
-        PsiElement(LBRACE)('{')
+      PsiWhiteSpace('\n    ')
-        PsiWhiteSpace('\n    ')
+      PROPERTY
-        PROPERTY
+        PsiElement(val)('val')
-          PsiElement(val)('val')
+        PsiWhiteSpace(' ')
-          PsiWhiteSpace(' ')
+        PsiElement(IDENTIFIER)('abstract')
-          PsiElement(IDENTIFIER)('abstract')
+      PsiWhiteSpace('\n    ')
-        PsiWhiteSpace('\n    ')
+      PROPERTY
-        PROPERTY
+        PsiElement(val)('val')
-          PsiElement(val)('val')
+        PsiWhiteSpace(' ')
-          PsiWhiteSpace(' ')
+        PsiElement(IDENTIFIER)('open')
-          PsiElement(IDENTIFIER)('open')
+      PsiWhiteSpace('\n    ')
-        PsiWhiteSpace('\n    ')
+      PROPERTY
-        PROPERTY
+        PsiElement(val)('val')
-          PsiElement(val)('val')
+        PsiWhiteSpace(' ')
-          PsiWhiteSpace(' ')
+        PsiElement(IDENTIFIER)('enum')
-          PsiElement(IDENTIFIER)('enum')
+      PsiWhiteSpace('\n    ')
-        PsiWhiteSpace('\n    ')
+      PROPERTY
-        PROPERTY
+        PsiElement(val)('val')
-          PsiElement(val)('val')
+        PsiWhiteSpace(' ')
-          PsiWhiteSpace(' ')
+        PsiElement(IDENTIFIER)('open')
-          PsiElement(IDENTIFIER)('open')
+      PsiWhiteSpace('\n    ')
-        PsiWhiteSpace('\n    ')
+      PROPERTY
-        PROPERTY
+        PsiElement(val)('val')
-          PsiElement(val)('val')
+        PsiWhiteSpace(' ')
-          PsiWhiteSpace(' ')
+        PsiElement(IDENTIFIER)('annotation')
-          PsiElement(IDENTIFIER)('annotation')
+      PsiWhiteSpace('\n    ')
-        PsiWhiteSpace('\n    ')
+      PROPERTY
-        PROPERTY
+        PsiElement(val)('val')
-          PsiElement(val)('val')
+        PsiWhiteSpace(' ')
-          PsiWhiteSpace(' ')
+        PsiElement(IDENTIFIER)('override')
-          PsiElement(IDENTIFIER)('override')
+      PsiWhiteSpace('\n    ')
-        PsiWhiteSpace('\n    ')
+      PROPERTY
-        PROPERTY
+        PsiElement(val)('val')
-          PsiElement(val)('val')
+        PsiWhiteSpace(' ')
-          PsiWhiteSpace(' ')
+        PsiElement(IDENTIFIER)('open')
-          PsiElement(IDENTIFIER)('open')
+      PsiWhiteSpace('\n    ')
-        PsiWhiteSpace('\n    ')
+      PROPERTY
-        PROPERTY
+        PsiElement(val)('val')
-          PsiElement(val)('val')
+        PsiWhiteSpace(' ')
-          PsiWhiteSpace(' ')
+        PsiElement(IDENTIFIER)('abstract')
-          PsiElement(IDENTIFIER)('abstract')
+      PsiWhiteSpace('\n    ')
-        PsiWhiteSpace('\n    ')
+      PROPERTY
-        PROPERTY
+        PsiElement(val)('val')
-          PsiElement(val)('val')
+        PsiWhiteSpace(' ')
-          PsiWhiteSpace(' ')
+        PsiElement(IDENTIFIER)('private')
-          PsiElement(IDENTIFIER)('private')
+      PsiWhiteSpace('\n    ')
-        PsiWhiteSpace('\n    ')
+      PROPERTY
-        PROPERTY
+        PsiElement(val)('val')
-          PsiElement(val)('val')
+        PsiWhiteSpace(' ')
-          PsiWhiteSpace(' ')
+        PsiElement(IDENTIFIER)('protected')
-          PsiElement(IDENTIFIER)('protected')
+      PsiWhiteSpace('\n    ')
-        PsiWhiteSpace('\n    ')
+      PROPERTY
-        PROPERTY
+        PsiElement(val)('val')
-          PsiElement(val)('val')
+        PsiWhiteSpace(' ')
-          PsiWhiteSpace(' ')
+        PsiElement(IDENTIFIER)('public')
-          PsiElement(IDENTIFIER)('public')
+      PsiWhiteSpace('\n    ')
-        PsiWhiteSpace('\n    ')
+      PROPERTY
-        PROPERTY
+        PsiElement(val)('val')
-          PsiElement(val)('val')
+        PsiWhiteSpace(' ')
-          PsiWhiteSpace(' ')
+        PsiElement(IDENTIFIER)('internal')
-          PsiElement(IDENTIFIER)('internal')
+      PsiWhiteSpace('\n    ')
-        PsiWhiteSpace('\n    ')
+      PROPERTY
-        PROPERTY
+        PsiElement(val)('val')
-          PsiElement(val)('val')
+        PsiWhiteSpace(' ')
-          PsiWhiteSpace(' ')
+        PsiElement(IDENTIFIER)('lazy')
-          PsiElement(IDENTIFIER)('lazy')
+      PsiWhiteSpace('\n')
-        PsiWhiteSpace('\n')
+      PsiElement(RBRACE)('}')
-        PsiElement(RBRACE)('}')

compiler/testData/psi/SoftKeywordsInTypeArguments.txt

@@ -1,55 +1,54 @@
 JetFile: SoftKeywordsInTypeArguments.jet
-  NAMESPACE
+  NAMESPACE_HEADER
-    NAMESPACE_HEADER
+    <empty list>
-      <empty list>
+  CLASS
-    CLASS
+    PsiElement(class)('class')
-      PsiElement(class)('class')
+    PsiWhiteSpace(' ')
-      PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('Foo')
-      PsiElement(IDENTIFIER)('Foo')
+    TYPE_PARAMETER_LIST
-      TYPE_PARAMETER_LIST
+      PsiElement(LT)('<')
-        PsiElement(LT)('<')
+      TYPE_PARAMETER
-        TYPE_PARAMETER
+        MODIFIER_LIST
-          MODIFIER_LIST
+          PsiElement(out)('out')
-            PsiElement(out)('out')
-          PsiWhiteSpace(' ')
-          PsiElement(IDENTIFIER)('abstract')
-        PsiElement(COMMA)(',')
         PsiWhiteSpace(' ')
-        TYPE_PARAMETER
+        PsiElement(IDENTIFIER)('abstract')
-          MODIFIER_LIST
+      PsiElement(COMMA)(',')
-            PsiElement(out)('out')
-          PsiWhiteSpace(' ')
-          PsiElement(IDENTIFIER)('out')
-        PsiElement(GT)('>')
       PsiWhiteSpace(' ')
-      CLASS_BODY
+      TYPE_PARAMETER
-        PsiElement(LBRACE)('{')
+        MODIFIER_LIST
-        PsiElement(RBRACE)('}')
+          PsiElement(out)('out')
-    PsiWhiteSpace('\n\n')
+        PsiWhiteSpace(' ')
-    FUN
+        PsiElement(IDENTIFIER)('out')
-      PsiElement(fun)('fun')
+      PsiElement(GT)('>')
-      PsiWhiteSpace(' ')
+    PsiWhiteSpace(' ')
-      PsiElement(IDENTIFIER)('f')
+    CLASS_BODY
-      VALUE_PARAMETER_LIST
+      PsiElement(LBRACE)('{')
-        PsiElement(LPAR)('(')
+      PsiElement(RBRACE)('}')
-        PsiElement(RPAR)(')')
+  PsiWhiteSpace('\n\n')
-      PsiWhiteSpace(' ')
+  FUN
-      BLOCK
+    PsiElement(fun)('fun')
-        PsiElement(LBRACE)('{')
+    PsiWhiteSpace(' ')
-        PsiWhiteSpace('\n\n  ')
+    PsiElement(IDENTIFIER)('f')
-        CALL_EXPRESSION
+    VALUE_PARAMETER_LIST
-          REFERENCE_EXPRESSION
+      PsiElement(LPAR)('(')
-            PsiElement(IDENTIFIER)('Foo')
+      PsiElement(RPAR)(')')
-          TYPE_ARGUMENT_LIST
+    PsiWhiteSpace(' ')
-            PsiElement(LT)('<')
+    BLOCK
-            TYPE_PROJECTION
+      PsiElement(LBRACE)('{')
-              MODIFIER_LIST
+      PsiWhiteSpace('\n\n  ')
-                PsiElement(out)('out')
+      CALL_EXPRESSION
-              PsiWhiteSpace(' ')
+        REFERENCE_EXPRESSION
-              TYPE_REFERENCE
+          PsiElement(IDENTIFIER)('Foo')
-                USER_TYPE
+        TYPE_ARGUMENT_LIST
-                  REFERENCE_EXPRESSION
+          PsiElement(LT)('<')
-                    PsiElement(IDENTIFIER)('out')
+          TYPE_PROJECTION
-            PsiElement(GT)('>')
+            MODIFIER_LIST
-        PsiWhiteSpace('\n\n')
+              PsiElement(out)('out')
-        PsiElement(RBRACE)('}')
+            PsiWhiteSpace(' ')
+            TYPE_REFERENCE
+              USER_TYPE
+                REFERENCE_EXPRESSION
+                  PsiElement(IDENTIFIER)('out')
+          PsiElement(GT)('>')
+      PsiWhiteSpace('\n\n')
+      PsiElement(RBRACE)('}')

compiler/testData/psi/StringTemplates.txt

@@ -1,391 +1,390 @@
 JetFile: StringTemplates.jet
-  NAMESPACE
+  NAMESPACE_HEADER
-    NAMESPACE_HEADER
+    <empty list>
-      <empty list>
+  FUN
-    FUN
+    PsiElement(fun)('fun')
-      PsiElement(fun)('fun')
+    PsiWhiteSpace(' ')
-      PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('demo')
-      PsiElement(IDENTIFIER)('demo')
+    VALUE_PARAMETER_LIST
-      VALUE_PARAMETER_LIST
+      PsiElement(LPAR)('(')
-        PsiElement(LPAR)('(')
+      PsiElement(RPAR)(')')
-        PsiElement(RPAR)(')')
+    PsiWhiteSpace(' ')
-      PsiWhiteSpace(' ')
+    BLOCK
-      BLOCK
+      PsiElement(LBRACE)('{')
-        PsiElement(LBRACE)('{')
+      PsiWhiteSpace('\n  ')
-        PsiWhiteSpace('\n  ')
+      PROPERTY
-        PROPERTY
+        PsiElement(val)('val')
-          PsiElement(val)('val')
+        PsiWhiteSpace(' ')
-          PsiWhiteSpace(' ')
+        PsiElement(IDENTIFIER)('abc')
-          PsiElement(IDENTIFIER)('abc')
+        PsiWhiteSpace(' ')
-          PsiWhiteSpace(' ')
+        PsiElement(EQ)('=')
-          PsiElement(EQ)('=')
+        PsiWhiteSpace(' ')
-          PsiWhiteSpace(' ')
+        INTEGER_CONSTANT
-          INTEGER_CONSTANT
+          PsiElement(INTEGER_LITERAL)('1')
-            PsiElement(INTEGER_LITERAL)('1')
+      PsiWhiteSpace('\n  ')
-        PsiWhiteSpace('\n  ')
+      PROPERTY
-        PROPERTY
+        PsiElement(val)('val')
-          PsiElement(val)('val')
+        PsiWhiteSpace(' ')
-          PsiWhiteSpace(' ')
+        PsiElement(IDENTIFIER)('a')
-          PsiElement(IDENTIFIER)('a')
+        PsiWhiteSpace(' ')
-          PsiWhiteSpace(' ')
+        PsiElement(EQ)('=')
-          PsiElement(EQ)('=')
+        PsiWhiteSpace(' ')
-          PsiWhiteSpace(' ')
-          STRING_TEMPLATE
-            PsiElement(OPEN_QUOTE)('"')
-            PsiElement(CLOSING_QUOTE)('"')
-        PsiWhiteSpace('\n  ')
-        PROPERTY
-          PsiElement(val)('val')
-          PsiWhiteSpace(' ')
-          PsiElement(IDENTIFIER)('asd')
-          PsiWhiteSpace(' ')
-          PsiElement(EQ)('=')
-          PsiWhiteSpace(' ')
-          INTEGER_CONSTANT
-            PsiElement(INTEGER_LITERAL)('1')
-        PsiWhiteSpace('\n  ')
-        PROPERTY
-          PsiElement(val)('val')
-          PsiWhiteSpace(' ')
-          PsiElement(IDENTIFIER)('bar')
-          PsiWhiteSpace(' ')
-          PsiElement(EQ)('=')
-          PsiWhiteSpace(' ')
-          INTEGER_CONSTANT
-            PsiElement(INTEGER_LITERAL)('5')
-        PsiWhiteSpace('\n  ')
-        FUN
-          PsiElement(fun)('fun')
-          PsiWhiteSpace(' ')
-          PsiElement(IDENTIFIER)('map')
-          VALUE_PARAMETER_LIST
-            PsiElement(LPAR)('(')
-            VALUE_PARAMETER
-              PsiElement(IDENTIFIER)('f')
-              PsiWhiteSpace(' ')
-              PsiElement(COLON)(':')
-              PsiWhiteSpace('  ')
-              TYPE_REFERENCE
-                FUNCTION_TYPE
-                  VALUE_PARAMETER_LIST
-                    PsiElement(LPAR)('(')
-                    PsiElement(RPAR)(')')
-                  PsiWhiteSpace(' ')
-                  PsiElement(ARROW)('->')
-                  PsiWhiteSpace(' ')
-                  TYPE_REFERENCE
-                    NULLABLE_TYPE
-                      USER_TYPE
-                        REFERENCE_EXPRESSION
-                          PsiElement(IDENTIFIER)('Any')
-                      PsiElement(QUEST)('?')
-            PsiElement(RPAR)(')')
-          PsiWhiteSpace(' ')
-          PsiElement(COLON)(':')
-          PsiWhiteSpace(' ')
-          TYPE_REFERENCE
-            USER_TYPE
-              REFERENCE_EXPRESSION
-                PsiElement(IDENTIFIER)('Int')
-          PsiWhiteSpace('  ')
-          PsiElement(EQ)('=')
-          PsiWhiteSpace(' ')
-          INTEGER_CONSTANT
-            PsiElement(INTEGER_LITERAL)('1')
-        PsiWhiteSpace('\n  ')
-        FUN
-          PsiElement(fun)('fun')
-          PsiWhiteSpace(' ')
-          PsiElement(IDENTIFIER)('buzz')
-          VALUE_PARAMETER_LIST
-            PsiElement(LPAR)('(')
-            VALUE_PARAMETER
-              PsiElement(IDENTIFIER)('f')
-              PsiWhiteSpace(' ')
-              PsiElement(COLON)(':')
-              PsiWhiteSpace('  ')
-              TYPE_REFERENCE
-                FUNCTION_TYPE
-                  VALUE_PARAMETER_LIST
-                    PsiElement(LPAR)('(')
-                    PsiElement(RPAR)(')')
-                  PsiWhiteSpace(' ')
-                  PsiElement(ARROW)('->')
-                  PsiWhiteSpace(' ')
-                  TYPE_REFERENCE
-                    NULLABLE_TYPE
-                      USER_TYPE
-                        REFERENCE_EXPRESSION
-                          PsiElement(IDENTIFIER)('Any')
-                      PsiElement(QUEST)('?')
-            PsiElement(RPAR)(')')
-          PsiWhiteSpace(' ')
-          PsiElement(COLON)(':')
-          PsiWhiteSpace(' ')
-          TYPE_REFERENCE
-            USER_TYPE
-              REFERENCE_EXPRESSION
-                PsiElement(IDENTIFIER)('Int')
-          PsiWhiteSpace('  ')
-          PsiElement(EQ)('=')
-          PsiWhiteSpace(' ')
-          INTEGER_CONSTANT
-            PsiElement(INTEGER_LITERAL)('1')
-        PsiWhiteSpace('\n  ')
-        PROPERTY
-          PsiElement(val)('val')
-          PsiWhiteSpace(' ')
-          PsiElement(IDENTIFIER)('sdf')
-          PsiWhiteSpace(' ')
-          PsiElement(EQ)('=')
-          PsiWhiteSpace(' ')
-          INTEGER_CONSTANT
-            PsiElement(INTEGER_LITERAL)('1')
-        PsiWhiteSpace('\n  ')
-        PROPERTY
-          PsiElement(val)('val')
-          PsiWhiteSpace(' ')
-          PsiElement(IDENTIFIER)('foo')
-          PsiWhiteSpace(' ')
-          PsiElement(EQ)('=')
-          PsiWhiteSpace(' ')
-          INTEGER_CONSTANT
-            PsiElement(INTEGER_LITERAL)('3')
-        PsiElement(SEMICOLON)(';')
-        PsiWhiteSpace('\n    ')
         STRING_TEMPLATE
           PsiElement(OPEN_QUOTE)('"')
-          SHORT_STRING_TEMPLATE_ENTRY
-            PsiElement(SHORT_TEMPLATE_ENTRY_START)('$')
-            THIS_EXPRESSION
-              REFERENCE_EXPRESSION
-                PsiElement(this)('this')
-          LITERAL_STRING_TEMPLATE_ENTRY
-            PsiElement(REGULAR_STRING_PART)(' must be')
-          SHORT_STRING_TEMPLATE_ENTRY
-            PsiElement(SHORT_TEMPLATE_ENTRY_START)('$')
-            PsiErrorElement:Keyword cannot be used as a reference
-              PsiElement(as)('as')
-          SHORT_STRING_TEMPLATE_ENTRY
-            PsiElement(SHORT_TEMPLATE_ENTRY_START)('$')
-            REFERENCE_EXPRESSION
-              PsiElement(IDENTIFIER)('t')
           PsiElement(CLOSING_QUOTE)('"')
-        PsiWhiteSpace('\n    ')
+      PsiWhiteSpace('\n  ')
-        STRING_TEMPLATE
+      PROPERTY
-          PsiElement(OPEN_QUOTE)('"')
+        PsiElement(val)('val')
-          SHORT_STRING_TEMPLATE_ENTRY
+        PsiWhiteSpace(' ')
-            PsiElement(SHORT_TEMPLATE_ENTRY_START)('$')
+        PsiElement(IDENTIFIER)('asd')
-            REFERENCE_EXPRESSION
+        PsiWhiteSpace(' ')
-              PsiElement(IDENTIFIER)('abc')
+        PsiElement(EQ)('=')
-          PsiElement(CLOSING_QUOTE)('"')
+        PsiWhiteSpace(' ')
-        PsiWhiteSpace('\n    ')
+        INTEGER_CONSTANT
-        STRING_TEMPLATE
+          PsiElement(INTEGER_LITERAL)('1')
-          PsiElement(OPEN_QUOTE)('"')
+      PsiWhiteSpace('\n  ')
-          SHORT_STRING_TEMPLATE_ENTRY
+      PROPERTY
-            PsiElement(SHORT_TEMPLATE_ENTRY_START)('$')
+        PsiElement(val)('val')
-            REFERENCE_EXPRESSION
+        PsiWhiteSpace(' ')
-              PsiElement(IDENTIFIER)('abc')
+        PsiElement(IDENTIFIER)('bar')
-          ESCAPE_STRING_TEMPLATE_ENTRY
+        PsiWhiteSpace(' ')
-            PsiElement(ESCAPE_SEQUENCE)('\"')
+        PsiElement(EQ)('=')
-          PsiErrorElement:Expecting '"'
+        PsiWhiteSpace(' ')
-            <empty list>
+        INTEGER_CONSTANT
-        PsiWhiteSpace('\n    ')
+          PsiElement(INTEGER_LITERAL)('5')
-        STRING_TEMPLATE
+      PsiWhiteSpace('\n  ')
-          PsiElement(OPEN_QUOTE)('"')
+      FUN
-          LITERAL_STRING_TEMPLATE_ENTRY
+        PsiElement(fun)('fun')
-            PsiElement(REGULAR_STRING_PART)('$')
+        PsiWhiteSpace(' ')
-          PsiElement(CLOSING_QUOTE)('"')
+        PsiElement(IDENTIFIER)('map')
-        PsiWhiteSpace('\n    ')
+        VALUE_PARAMETER_LIST
-        STRING_TEMPLATE
+          PsiElement(LPAR)('(')
-          PsiElement(OPEN_QUOTE)('"')
+          VALUE_PARAMETER
-          LITERAL_STRING_TEMPLATE_ENTRY
+            PsiElement(IDENTIFIER)('f')
-            PsiElement(REGULAR_STRING_PART)('$')
+            PsiWhiteSpace(' ')
-          LITERAL_STRING_TEMPLATE_ENTRY
+            PsiElement(COLON)(':')
-            PsiElement(REGULAR_STRING_PART)('.')
+            PsiWhiteSpace('  ')
-          LITERAL_STRING_TEMPLATE_ENTRY
+            TYPE_REFERENCE
-            PsiElement(REGULAR_STRING_PART)('$')
+              FUNCTION_TYPE
-          LITERAL_STRING_TEMPLATE_ENTRY
+                VALUE_PARAMETER_LIST
-            PsiElement(REGULAR_STRING_PART)('.asdf')
+                  PsiElement(LPAR)('(')
-          LITERAL_STRING_TEMPLATE_ENTRY
+                  PsiElement(RPAR)(')')
-            PsiElement(REGULAR_STRING_PART)('$')
-          ESCAPE_STRING_TEMPLATE_ENTRY
-            PsiElement(ESCAPE_SEQUENCE)('\t')
-          PsiElement(CLOSING_QUOTE)('"')
-        PsiWhiteSpace('\n    ')
-        STRING_TEMPLATE
-          PsiElement(OPEN_QUOTE)('"')
-          LITERAL_STRING_TEMPLATE_ENTRY
-            PsiElement(REGULAR_STRING_PART)('asd')
-          ESCAPE_STRING_TEMPLATE_ENTRY
-            PsiElement(ESCAPE_SEQUENCE)('\$')
-          PsiElement(CLOSING_QUOTE)('"')
-        PsiWhiteSpace('\n    ')
-        STRING_TEMPLATE
-          PsiElement(OPEN_QUOTE)('"')
-          LITERAL_STRING_TEMPLATE_ENTRY
-            PsiElement(REGULAR_STRING_PART)('asd')
-          SHORT_STRING_TEMPLATE_ENTRY
-            PsiElement(SHORT_TEMPLATE_ENTRY_START)('$')
-            REFERENCE_EXPRESSION
-              PsiElement(IDENTIFIER)('a')
-          PsiElement(CLOSING_QUOTE)('"')
-        PsiWhiteSpace('\n    ')
-        STRING_TEMPLATE
-          PsiElement(OPEN_QUOTE)('"')
-          LITERAL_STRING_TEMPLATE_ENTRY
-            PsiElement(REGULAR_STRING_PART)('asd')
-          SHORT_STRING_TEMPLATE_ENTRY
-            PsiElement(SHORT_TEMPLATE_ENTRY_START)('$')
-            REFERENCE_EXPRESSION
-              PsiElement(IDENTIFIER)('a')
-          SHORT_STRING_TEMPLATE_ENTRY
-            PsiElement(SHORT_TEMPLATE_ENTRY_START)('$')
-            REFERENCE_EXPRESSION
-              PsiElement(IDENTIFIER)('asd')
-          LITERAL_STRING_TEMPLATE_ENTRY
-            PsiElement(REGULAR_STRING_PART)('$')
-          PsiElement(CLOSING_QUOTE)('"')
-        PsiWhiteSpace('\n    ')
-        STRING_TEMPLATE
-          PsiElement(OPEN_QUOTE)('"')
-          LITERAL_STRING_TEMPLATE_ENTRY
-            PsiElement(REGULAR_STRING_PART)('fosdfasdo')
-          LONG_STRING_TEMPLATE_ENTRY
-            PsiElement(LONG_TEMPLATE_ENTRY_START)('${')
-            BINARY_EXPRESSION
-              BINARY_EXPRESSION
-                INTEGER_CONSTANT
-                  PsiElement(INTEGER_LITERAL)('1')
                 PsiWhiteSpace(' ')
-                OPERATION_REFERENCE
+                PsiElement(ARROW)('->')
-                  PsiElement(PLUS)('+')
                 PsiWhiteSpace(' ')
-                REFERENCE_EXPRESSION
+                TYPE_REFERENCE
-                  PsiElement(IDENTIFIER)('bar')
+                  NULLABLE_TYPE
-              PsiWhiteSpace(' ')
+                    USER_TYPE
-              OPERATION_REFERENCE
-                PsiElement(PLUS)('+')
-              PsiWhiteSpace(' ')
-              INTEGER_CONSTANT
-                PsiElement(INTEGER_LITERAL)('100')
-            PsiElement(LONG_TEMPLATE_ENTRY_END)('}')
-          LITERAL_STRING_TEMPLATE_ENTRY
-            PsiElement(REGULAR_STRING_PART)('}sdsdfgdsfsdf')
-          PsiElement(CLOSING_QUOTE)('"')
-        PsiWhiteSpace('\n    ')
-        STRING_TEMPLATE
-          PsiElement(OPEN_QUOTE)('"')
-          LITERAL_STRING_TEMPLATE_ENTRY
-            PsiElement(REGULAR_STRING_PART)('foo')
-          LONG_STRING_TEMPLATE_ENTRY
-            PsiElement(LONG_TEMPLATE_ENTRY_START)('${')
-            BINARY_EXPRESSION
-              REFERENCE_EXPRESSION
-                PsiElement(IDENTIFIER)('bar')
-              PsiWhiteSpace(' ')
-              OPERATION_REFERENCE
-                PsiElement(PLUS)('+')
-              PsiWhiteSpace(' ')
-              CALL_EXPRESSION
-                REFERENCE_EXPRESSION
-                  PsiElement(IDENTIFIER)('map')
-                PsiWhiteSpace(' ')
-                FUNCTION_LITERAL_EXPRESSION
-                  FUNCTION_LITERAL
-                    PsiElement(LBRACE)('{')
-                    BLOCK
                       REFERENCE_EXPRESSION
-                        PsiElement(IDENTIFIER)('foo')
+                        PsiElement(IDENTIFIER)('Any')
-                    PsiElement(RBRACE)('}')
+                    PsiElement(QUEST)('?')
-            PsiElement(LONG_TEMPLATE_ENTRY_END)('}')
+          PsiElement(RPAR)(')')
-          LITERAL_STRING_TEMPLATE_ENTRY
+        PsiWhiteSpace(' ')
-            PsiElement(REGULAR_STRING_PART)('sdfsdf')
+        PsiElement(COLON)(':')
-          PsiElement(CLOSING_QUOTE)('"')
+        PsiWhiteSpace(' ')
-        PsiWhiteSpace('\n    ')
+        TYPE_REFERENCE
-        STRING_TEMPLATE
+          USER_TYPE
-          PsiElement(OPEN_QUOTE)('"')
+            REFERENCE_EXPRESSION
-          LITERAL_STRING_TEMPLATE_ENTRY
+              PsiElement(IDENTIFIER)('Int')
-            PsiElement(REGULAR_STRING_PART)('foo')
+        PsiWhiteSpace('  ')
-          LONG_STRING_TEMPLATE_ENTRY
+        PsiElement(EQ)('=')
-            PsiElement(LONG_TEMPLATE_ENTRY_START)('${')
+        PsiWhiteSpace(' ')
+        INTEGER_CONSTANT
+          PsiElement(INTEGER_LITERAL)('1')
+      PsiWhiteSpace('\n  ')
+      FUN
+        PsiElement(fun)('fun')
+        PsiWhiteSpace(' ')
+        PsiElement(IDENTIFIER)('buzz')
+        VALUE_PARAMETER_LIST
+          PsiElement(LPAR)('(')
+          VALUE_PARAMETER
+            PsiElement(IDENTIFIER)('f')
+            PsiWhiteSpace(' ')
+            PsiElement(COLON)(':')
+            PsiWhiteSpace('  ')
+            TYPE_REFERENCE
+              FUNCTION_TYPE
+                VALUE_PARAMETER_LIST
+                  PsiElement(LPAR)('(')
+                  PsiElement(RPAR)(')')
+                PsiWhiteSpace(' ')
+                PsiElement(ARROW)('->')
+                PsiWhiteSpace(' ')
+                TYPE_REFERENCE
+                  NULLABLE_TYPE
+                    USER_TYPE
+                      REFERENCE_EXPRESSION
+                        PsiElement(IDENTIFIER)('Any')
+                    PsiElement(QUEST)('?')
+          PsiElement(RPAR)(')')
+        PsiWhiteSpace(' ')
+        PsiElement(COLON)(':')
+        PsiWhiteSpace(' ')
+        TYPE_REFERENCE
+          USER_TYPE
+            REFERENCE_EXPRESSION
+              PsiElement(IDENTIFIER)('Int')
+        PsiWhiteSpace('  ')
+        PsiElement(EQ)('=')
+        PsiWhiteSpace(' ')
+        INTEGER_CONSTANT
+          PsiElement(INTEGER_LITERAL)('1')
+      PsiWhiteSpace('\n  ')
+      PROPERTY
+        PsiElement(val)('val')
+        PsiWhiteSpace(' ')
+        PsiElement(IDENTIFIER)('sdf')
+        PsiWhiteSpace(' ')
+        PsiElement(EQ)('=')
+        PsiWhiteSpace(' ')
+        INTEGER_CONSTANT
+          PsiElement(INTEGER_LITERAL)('1')
+      PsiWhiteSpace('\n  ')
+      PROPERTY
+        PsiElement(val)('val')
+        PsiWhiteSpace(' ')
+        PsiElement(IDENTIFIER)('foo')
+        PsiWhiteSpace(' ')
+        PsiElement(EQ)('=')
+        PsiWhiteSpace(' ')
+        INTEGER_CONSTANT
+          PsiElement(INTEGER_LITERAL)('3')
+      PsiElement(SEMICOLON)(';')
+      PsiWhiteSpace('\n    ')
+      STRING_TEMPLATE
+        PsiElement(OPEN_QUOTE)('"')
+        SHORT_STRING_TEMPLATE_ENTRY
+          PsiElement(SHORT_TEMPLATE_ENTRY_START)('$')
+          THIS_EXPRESSION
+            REFERENCE_EXPRESSION
+              PsiElement(this)('this')
+        LITERAL_STRING_TEMPLATE_ENTRY
+          PsiElement(REGULAR_STRING_PART)(' must be')
+        SHORT_STRING_TEMPLATE_ENTRY
+          PsiElement(SHORT_TEMPLATE_ENTRY_START)('$')
+          PsiErrorElement:Keyword cannot be used as a reference
+            PsiElement(as)('as')
+        SHORT_STRING_TEMPLATE_ENTRY
+          PsiElement(SHORT_TEMPLATE_ENTRY_START)('$')
+          REFERENCE_EXPRESSION
+            PsiElement(IDENTIFIER)('t')
+        PsiElement(CLOSING_QUOTE)('"')
+      PsiWhiteSpace('\n    ')
+      STRING_TEMPLATE
+        PsiElement(OPEN_QUOTE)('"')
+        SHORT_STRING_TEMPLATE_ENTRY
+          PsiElement(SHORT_TEMPLATE_ENTRY_START)('$')
+          REFERENCE_EXPRESSION
+            PsiElement(IDENTIFIER)('abc')
+        PsiElement(CLOSING_QUOTE)('"')
+      PsiWhiteSpace('\n    ')
+      STRING_TEMPLATE
+        PsiElement(OPEN_QUOTE)('"')
+        SHORT_STRING_TEMPLATE_ENTRY
+          PsiElement(SHORT_TEMPLATE_ENTRY_START)('$')
+          REFERENCE_EXPRESSION
+            PsiElement(IDENTIFIER)('abc')
+        ESCAPE_STRING_TEMPLATE_ENTRY
+          PsiElement(ESCAPE_SEQUENCE)('\"')
+        PsiErrorElement:Expecting '"'
+          <empty list>
+      PsiWhiteSpace('\n    ')
+      STRING_TEMPLATE
+        PsiElement(OPEN_QUOTE)('"')
+        LITERAL_STRING_TEMPLATE_ENTRY
+          PsiElement(REGULAR_STRING_PART)('$')
+        PsiElement(CLOSING_QUOTE)('"')
+      PsiWhiteSpace('\n    ')
+      STRING_TEMPLATE
+        PsiElement(OPEN_QUOTE)('"')
+        LITERAL_STRING_TEMPLATE_ENTRY
+          PsiElement(REGULAR_STRING_PART)('$')
+        LITERAL_STRING_TEMPLATE_ENTRY
+          PsiElement(REGULAR_STRING_PART)('.')
+        LITERAL_STRING_TEMPLATE_ENTRY
+          PsiElement(REGULAR_STRING_PART)('$')
+        LITERAL_STRING_TEMPLATE_ENTRY
+          PsiElement(REGULAR_STRING_PART)('.asdf')
+        LITERAL_STRING_TEMPLATE_ENTRY
+          PsiElement(REGULAR_STRING_PART)('$')
+        ESCAPE_STRING_TEMPLATE_ENTRY
+          PsiElement(ESCAPE_SEQUENCE)('\t')
+        PsiElement(CLOSING_QUOTE)('"')
+      PsiWhiteSpace('\n    ')
+      STRING_TEMPLATE
+        PsiElement(OPEN_QUOTE)('"')
+        LITERAL_STRING_TEMPLATE_ENTRY
+          PsiElement(REGULAR_STRING_PART)('asd')
+        ESCAPE_STRING_TEMPLATE_ENTRY
+          PsiElement(ESCAPE_SEQUENCE)('\$')
+        PsiElement(CLOSING_QUOTE)('"')
+      PsiWhiteSpace('\n    ')
+      STRING_TEMPLATE
+        PsiElement(OPEN_QUOTE)('"')
+        LITERAL_STRING_TEMPLATE_ENTRY
+          PsiElement(REGULAR_STRING_PART)('asd')
+        SHORT_STRING_TEMPLATE_ENTRY
+          PsiElement(SHORT_TEMPLATE_ENTRY_START)('$')
+          REFERENCE_EXPRESSION
+            PsiElement(IDENTIFIER)('a')
+        PsiElement(CLOSING_QUOTE)('"')
+      PsiWhiteSpace('\n    ')
+      STRING_TEMPLATE
+        PsiElement(OPEN_QUOTE)('"')
+        LITERAL_STRING_TEMPLATE_ENTRY
+          PsiElement(REGULAR_STRING_PART)('asd')
+        SHORT_STRING_TEMPLATE_ENTRY
+          PsiElement(SHORT_TEMPLATE_ENTRY_START)('$')
+          REFERENCE_EXPRESSION
+            PsiElement(IDENTIFIER)('a')
+        SHORT_STRING_TEMPLATE_ENTRY
+          PsiElement(SHORT_TEMPLATE_ENTRY_START)('$')
+          REFERENCE_EXPRESSION
+            PsiElement(IDENTIFIER)('asd')
+        LITERAL_STRING_TEMPLATE_ENTRY
+          PsiElement(REGULAR_STRING_PART)('$')
+        PsiElement(CLOSING_QUOTE)('"')
+      PsiWhiteSpace('\n    ')
+      STRING_TEMPLATE
+        PsiElement(OPEN_QUOTE)('"')
+        LITERAL_STRING_TEMPLATE_ENTRY
+          PsiElement(REGULAR_STRING_PART)('fosdfasdo')
+        LONG_STRING_TEMPLATE_ENTRY
+          PsiElement(LONG_TEMPLATE_ENTRY_START)('${')
+          BINARY_EXPRESSION
             BINARY_EXPRESSION
-              REFERENCE_EXPRESSION
+              INTEGER_CONSTANT
-                PsiElement(IDENTIFIER)('bar')
+                PsiElement(INTEGER_LITERAL)('1')
               PsiWhiteSpace(' ')
               OPERATION_REFERENCE
                 PsiElement(PLUS)('+')
               PsiWhiteSpace(' ')
-              CALL_EXPRESSION
-                REFERENCE_EXPRESSION
-                  PsiElement(IDENTIFIER)('map')
-                PsiWhiteSpace(' ')
-                FUNCTION_LITERAL_EXPRESSION
-                  FUNCTION_LITERAL
-                    PsiElement(LBRACE)('{')
-                    PsiWhiteSpace(' ')
-                    BLOCK
-                      STRING_TEMPLATE
-                        PsiElement(OPEN_QUOTE)('"')
-                        LITERAL_STRING_TEMPLATE_ENTRY
-                          PsiElement(REGULAR_STRING_PART)('foo')
-                        PsiElement(CLOSING_QUOTE)('"')
-                    PsiWhiteSpace(' ')
-                    PsiElement(RBRACE)('}')
-            PsiElement(LONG_TEMPLATE_ENTRY_END)('}')
-          LITERAL_STRING_TEMPLATE_ENTRY
-            PsiElement(REGULAR_STRING_PART)('sdfsdf')
-          PsiElement(CLOSING_QUOTE)('"')
-        PsiWhiteSpace('\n    ')
-        STRING_TEMPLATE
-          PsiElement(OPEN_QUOTE)('"')
-          LITERAL_STRING_TEMPLATE_ENTRY
-            PsiElement(REGULAR_STRING_PART)('foo')
-          LONG_STRING_TEMPLATE_ENTRY
-            PsiElement(LONG_TEMPLATE_ENTRY_START)('${')
-            BINARY_EXPRESSION
               REFERENCE_EXPRESSION
                 PsiElement(IDENTIFIER)('bar')
+            PsiWhiteSpace(' ')
+            OPERATION_REFERENCE
+              PsiElement(PLUS)('+')
+            PsiWhiteSpace(' ')
+            INTEGER_CONSTANT
+              PsiElement(INTEGER_LITERAL)('100')
+          PsiElement(LONG_TEMPLATE_ENTRY_END)('}')
+        LITERAL_STRING_TEMPLATE_ENTRY
+          PsiElement(REGULAR_STRING_PART)('}sdsdfgdsfsdf')
+        PsiElement(CLOSING_QUOTE)('"')
+      PsiWhiteSpace('\n    ')
+      STRING_TEMPLATE
+        PsiElement(OPEN_QUOTE)('"')
+        LITERAL_STRING_TEMPLATE_ENTRY
+          PsiElement(REGULAR_STRING_PART)('foo')
+        LONG_STRING_TEMPLATE_ENTRY
+          PsiElement(LONG_TEMPLATE_ENTRY_START)('${')
+          BINARY_EXPRESSION
+            REFERENCE_EXPRESSION
+              PsiElement(IDENTIFIER)('bar')
+            PsiWhiteSpace(' ')
+            OPERATION_REFERENCE
+              PsiElement(PLUS)('+')
+            PsiWhiteSpace(' ')
+            CALL_EXPRESSION
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('map')
               PsiWhiteSpace(' ')
-              OPERATION_REFERENCE
+              FUNCTION_LITERAL_EXPRESSION
-                PsiElement(PLUS)('+')
+                FUNCTION_LITERAL
+                  PsiElement(LBRACE)('{')
+                  BLOCK
+                    REFERENCE_EXPRESSION
+                      PsiElement(IDENTIFIER)('foo')
+                  PsiElement(RBRACE)('}')
+          PsiElement(LONG_TEMPLATE_ENTRY_END)('}')
+        LITERAL_STRING_TEMPLATE_ENTRY
+          PsiElement(REGULAR_STRING_PART)('sdfsdf')
+        PsiElement(CLOSING_QUOTE)('"')
+      PsiWhiteSpace('\n    ')
+      STRING_TEMPLATE
+        PsiElement(OPEN_QUOTE)('"')
+        LITERAL_STRING_TEMPLATE_ENTRY
+          PsiElement(REGULAR_STRING_PART)('foo')
+        LONG_STRING_TEMPLATE_ENTRY
+          PsiElement(LONG_TEMPLATE_ENTRY_START)('${')
+          BINARY_EXPRESSION
+            REFERENCE_EXPRESSION
+              PsiElement(IDENTIFIER)('bar')
+            PsiWhiteSpace(' ')
+            OPERATION_REFERENCE
+              PsiElement(PLUS)('+')
+            PsiWhiteSpace(' ')
+            CALL_EXPRESSION
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('map')
               PsiWhiteSpace(' ')
-              CALL_EXPRESSION
+              FUNCTION_LITERAL_EXPRESSION
-                REFERENCE_EXPRESSION
+                FUNCTION_LITERAL
-                  PsiElement(IDENTIFIER)('map')
+                  PsiElement(LBRACE)('{')
-                PsiWhiteSpace(' ')
+                  PsiWhiteSpace(' ')
-                FUNCTION_LITERAL_EXPRESSION
+                  BLOCK
-                  FUNCTION_LITERAL
+                    STRING_TEMPLATE
-                    PsiElement(LBRACE)('{')
+                      PsiElement(OPEN_QUOTE)('"')
-                    PsiWhiteSpace('\n      ')
+                      LITERAL_STRING_TEMPLATE_ENTRY
-                    BLOCK
+                        PsiElement(REGULAR_STRING_PART)('foo')
-                      STRING_TEMPLATE
+                      PsiElement(CLOSING_QUOTE)('"')
-                        PsiElement(OPEN_QUOTE)('"')
+                  PsiWhiteSpace(' ')
-                        LITERAL_STRING_TEMPLATE_ENTRY
+                  PsiElement(RBRACE)('}')
-                          PsiElement(REGULAR_STRING_PART)('foo')
+          PsiElement(LONG_TEMPLATE_ENTRY_END)('}')
-                        SHORT_STRING_TEMPLATE_ENTRY
+        LITERAL_STRING_TEMPLATE_ENTRY
-                          PsiElement(SHORT_TEMPLATE_ENTRY_START)('$')
+          PsiElement(REGULAR_STRING_PART)('sdfsdf')
+        PsiElement(CLOSING_QUOTE)('"')
+      PsiWhiteSpace('\n    ')
+      STRING_TEMPLATE
+        PsiElement(OPEN_QUOTE)('"')
+        LITERAL_STRING_TEMPLATE_ENTRY
+          PsiElement(REGULAR_STRING_PART)('foo')
+        LONG_STRING_TEMPLATE_ENTRY
+          PsiElement(LONG_TEMPLATE_ENTRY_START)('${')
+          BINARY_EXPRESSION
+            REFERENCE_EXPRESSION
+              PsiElement(IDENTIFIER)('bar')
+            PsiWhiteSpace(' ')
+            OPERATION_REFERENCE
+              PsiElement(PLUS)('+')
+            PsiWhiteSpace(' ')
+            CALL_EXPRESSION
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('map')
+              PsiWhiteSpace(' ')
+              FUNCTION_LITERAL_EXPRESSION
+                FUNCTION_LITERAL
+                  PsiElement(LBRACE)('{')
+                  PsiWhiteSpace('\n      ')
+                  BLOCK
+                    STRING_TEMPLATE
+                      PsiElement(OPEN_QUOTE)('"')
+                      LITERAL_STRING_TEMPLATE_ENTRY
+                        PsiElement(REGULAR_STRING_PART)('foo')
+                      SHORT_STRING_TEMPLATE_ENTRY
+                        PsiElement(SHORT_TEMPLATE_ENTRY_START)('$')
+                        REFERENCE_EXPRESSION
+                          PsiElement(IDENTIFIER)('sdf')
+                      LONG_STRING_TEMPLATE_ENTRY
+                        PsiElement(LONG_TEMPLATE_ENTRY_START)('${')
+                        PsiWhiteSpace(' ')
+                        CALL_EXPRESSION
                           REFERENCE_EXPRESSION
-                            PsiElement(IDENTIFIER)('sdf')
+                            PsiElement(IDENTIFIER)('buzz')
-                        LONG_STRING_TEMPLATE_ENTRY
+                          FUNCTION_LITERAL_EXPRESSION
-                          PsiElement(LONG_TEMPLATE_ENTRY_START)('${')
+                            FUNCTION_LITERAL
-                          PsiWhiteSpace(' ')
+                              PsiElement(LBRACE)('{')
-                          CALL_EXPRESSION
+                              BLOCK
-                            REFERENCE_EXPRESSION
+                                <empty list>
-                              PsiElement(IDENTIFIER)('buzz')
+                              PsiElement(RBRACE)('}')
-                            FUNCTION_LITERAL_EXPRESSION
+                        PsiElement(LONG_TEMPLATE_ENTRY_END)('}')
-                              FUNCTION_LITERAL
+                      PsiElement(CLOSING_QUOTE)('"')
-                                PsiElement(LBRACE)('{')
+                  PsiWhiteSpace(' ')
-                                BLOCK
+                  PsiElement(RBRACE)('}')
-                                  <empty list>
+          PsiElement(LONG_TEMPLATE_ENTRY_END)('}')
-                                PsiElement(RBRACE)('}')
+        LITERAL_STRING_TEMPLATE_ENTRY
-                          PsiElement(LONG_TEMPLATE_ENTRY_END)('}')
+          PsiElement(REGULAR_STRING_PART)('sdfsdf')
-                        PsiElement(CLOSING_QUOTE)('"')
+        PsiElement(CLOSING_QUOTE)('"')
-                    PsiWhiteSpace(' ')
+      PsiWhiteSpace('\n')
-                    PsiElement(RBRACE)('}')
+      PsiElement(RBRACE)('}')
-            PsiElement(LONG_TEMPLATE_ENTRY_END)('}')
-          LITERAL_STRING_TEMPLATE_ENTRY
-            PsiElement(REGULAR_STRING_PART)('sdfsdf')
-          PsiElement(CLOSING_QUOTE)('"')
-        PsiWhiteSpace('\n')
-        PsiElement(RBRACE)('}')

compiler/testData/psi/Super.txt

@@ -1,90 +1,89 @@
 JetFile: Super.jet
   PsiComment(EOL_COMMENT)('// KT-156 Fix the this<Super> syntax')
   PsiWhiteSpace('\n')
-  NAMESPACE
+  NAMESPACE_HEADER
-    NAMESPACE_HEADER
+    <empty list>
-      <empty list>
+  FUN
-    FUN
+    PsiElement(fun)('fun')
-      PsiElement(fun)('fun')
+    PsiWhiteSpace(' ')
-      PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('foo')
-      PsiElement(IDENTIFIER)('foo')
+    VALUE_PARAMETER_LIST
-      VALUE_PARAMETER_LIST
+      PsiElement(LPAR)('(')
-        PsiElement(LPAR)('(')
+      PsiElement(RPAR)(')')
-        PsiElement(RPAR)(')')
+    PsiWhiteSpace(' ')
-      PsiWhiteSpace(' ')
+    BLOCK
-      BLOCK
+      PsiElement(LBRACE)('{')
-        PsiElement(LBRACE)('{')
+      PsiWhiteSpace('\n    ')
-        PsiWhiteSpace('\n    ')
+      DOT_QUALIFIED_EXPRESSION
-        DOT_QUALIFIED_EXPRESSION
+        SUPER_EXPRESSION
-          SUPER_EXPRESSION
+          REFERENCE_EXPRESSION
-            REFERENCE_EXPRESSION
+            PsiElement(super)('super')
-              PsiElement(super)('super')
+        PsiElement(DOT)('.')
-          PsiElement(DOT)('.')
+        CALL_EXPRESSION
-          CALL_EXPRESSION
+          REFERENCE_EXPRESSION
-            REFERENCE_EXPRESSION
+            PsiElement(IDENTIFIER)('foo')
-              PsiElement(IDENTIFIER)('foo')
+          VALUE_ARGUMENT_LIST
-            VALUE_ARGUMENT_LIST
+            PsiElement(LPAR)('(')
-              PsiElement(LPAR)('(')
+            PsiElement(RPAR)(')')
-              PsiElement(RPAR)(')')
+      PsiElement(SEMICOLON)(';')
-        PsiElement(SEMICOLON)(';')
+      PsiWhiteSpace('\n    ')
-        PsiWhiteSpace('\n    ')
+      DOT_QUALIFIED_EXPRESSION
-        DOT_QUALIFIED_EXPRESSION
+        SUPER_EXPRESSION
-          SUPER_EXPRESSION
+          REFERENCE_EXPRESSION
-            REFERENCE_EXPRESSION
+            PsiElement(super)('super')
-              PsiElement(super)('super')
+          PsiElement(LT)('<')
-            PsiElement(LT)('<')
+          TYPE_REFERENCE
-            TYPE_REFERENCE
+            USER_TYPE
-              USER_TYPE
+              REFERENCE_EXPRESSION
-                REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('Int')
-                  PsiElement(IDENTIFIER)('Int')
+          PsiElement(GT)('>')
-            PsiElement(GT)('>')
+        PsiElement(DOT)('.')
-          PsiElement(DOT)('.')
+        CALL_EXPRESSION
-          CALL_EXPRESSION
+          REFERENCE_EXPRESSION
-            REFERENCE_EXPRESSION
+            PsiElement(IDENTIFIER)('foo')
-              PsiElement(IDENTIFIER)('foo')
+          VALUE_ARGUMENT_LIST
-            VALUE_ARGUMENT_LIST
+            PsiElement(LPAR)('(')
-              PsiElement(LPAR)('(')
+            PsiElement(RPAR)(')')
-              PsiElement(RPAR)(')')
+      PsiElement(SEMICOLON)(';')
-        PsiElement(SEMICOLON)(';')
+      PsiWhiteSpace('\n    ')
-        PsiWhiteSpace('\n    ')
+      DOT_QUALIFIED_EXPRESSION
-        DOT_QUALIFIED_EXPRESSION
+        SUPER_EXPRESSION
-          SUPER_EXPRESSION
+          REFERENCE_EXPRESSION
-            REFERENCE_EXPRESSION
+            PsiElement(super)('super')
-              PsiElement(super)('super')
+          PsiElement(LT)('<')
-            PsiElement(LT)('<')
+          TYPE_REFERENCE
-            TYPE_REFERENCE
+            PsiErrorElement:Type expected
-              PsiErrorElement:Type expected
+              <empty list>
-                <empty list>
+          PsiElement(GT)('>')
-            PsiElement(GT)('>')
+        PsiElement(DOT)('.')
-          PsiElement(DOT)('.')
+        CALL_EXPRESSION
-          CALL_EXPRESSION
+          REFERENCE_EXPRESSION
-            REFERENCE_EXPRESSION
+            PsiElement(IDENTIFIER)('foo')
-              PsiElement(IDENTIFIER)('foo')
+          VALUE_ARGUMENT_LIST
-            VALUE_ARGUMENT_LIST
+            PsiElement(LPAR)('(')
-              PsiElement(LPAR)('(')
+            PsiElement(RPAR)(')')
-              PsiElement(RPAR)(')')
+      PsiElement(SEMICOLON)(';')
-        PsiElement(SEMICOLON)(';')
+      PsiWhiteSpace('\n    ')
-        PsiWhiteSpace('\n    ')
+      DOT_QUALIFIED_EXPRESSION
-        DOT_QUALIFIED_EXPRESSION
+        SUPER_EXPRESSION
-          SUPER_EXPRESSION
+          REFERENCE_EXPRESSION
-            REFERENCE_EXPRESSION
+            PsiElement(super)('super')
-              PsiElement(super)('super')
+          PsiElement(LT)('<')
-            PsiElement(LT)('<')
+          TYPE_REFERENCE
-            TYPE_REFERENCE
+            USER_TYPE
-              USER_TYPE
+              REFERENCE_EXPRESSION
-                REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('Int')
-                  PsiElement(IDENTIFIER)('Int')
+          PsiElement(GT)('>')
-            PsiElement(GT)('>')
+          LABEL_QUALIFIER
-            LABEL_QUALIFIER
+            LABEL_REFERENCE
-              LABEL_REFERENCE
+              PsiElement(LABEL_IDENTIFIER)('@label')
-                PsiElement(LABEL_IDENTIFIER)('@label')
+        PsiElement(DOT)('.')
-          PsiElement(DOT)('.')
+        CALL_EXPRESSION
-          CALL_EXPRESSION
+          REFERENCE_EXPRESSION
-            REFERENCE_EXPRESSION
+            PsiElement(IDENTIFIER)('foo')
-              PsiElement(IDENTIFIER)('foo')
+          VALUE_ARGUMENT_LIST
-            VALUE_ARGUMENT_LIST
+            PsiElement(LPAR)('(')
-              PsiElement(LPAR)('(')
+            PsiElement(RPAR)(')')
-              PsiElement(RPAR)(')')
+      PsiElement(SEMICOLON)(';')
-        PsiElement(SEMICOLON)(';')
+      PsiWhiteSpace('\n')
-        PsiWhiteSpace('\n')
+      PsiElement(RBRACE)('}')
-        PsiElement(RBRACE)('}')

compiler/testData/psi/ThisType.txt

@@ -1,64 +1,84 @@
 JetFile: ThisType.jet
-  NAMESPACE
+  NAMESPACE_HEADER
-    NAMESPACE_HEADER
+    <empty list>
-      <empty list>
+  CLASS
-    CLASS
+    PsiElement(class)('class')
-      PsiElement(class)('class')
+    PsiWhiteSpace(' ')
-      PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('Foo')
-      PsiElement(IDENTIFIER)('Foo')
+    TYPE_PARAMETER_LIST
-      TYPE_PARAMETER_LIST
+      PsiElement(LT)('<')
-        PsiElement(LT)('<')
+      TYPE_PARAMETER
-        TYPE_PARAMETER
+        PsiElement(IDENTIFIER)('T')
-          PsiElement(IDENTIFIER)('T')
-          PsiWhiteSpace(' ')
-          PsiElement(COLON)(':')
-          PsiWhiteSpace(' ')
-          TYPE_REFERENCE
-            USER_TYPE
-              REFERENCE_EXPRESSION
-                PsiElement(IDENTIFIER)('List')
-              TYPE_ARGUMENT_LIST
-                PsiElement(LT)('<')
-                TYPE_PROJECTION
-                  TYPE_REFERENCE
-                    SELF_TYPE
-                      PsiElement(This)('This')
-                PsiElement(GT)('>')
-        PsiElement(GT)('>')
-      VALUE_PARAMETER_LIST
-        PsiElement(LPAR)('(')
-        VALUE_PARAMETER
-          PsiElement(IDENTIFIER)('a')
-          PsiWhiteSpace(' ')
-          PsiElement(COLON)(':')
-          PsiWhiteSpace(' ')
-          TYPE_REFERENCE
-            SELF_TYPE
-              PsiElement(This)('This')
-        PsiElement(COMMA)(',')
         PsiWhiteSpace(' ')
-        VALUE_PARAMETER
+        PsiElement(COLON)(':')
-          PsiElement(IDENTIFIER)('b')
+        PsiWhiteSpace(' ')
-          PsiWhiteSpace(' ')
+        TYPE_REFERENCE
-          PsiElement(COLON)(':')
+          USER_TYPE
-          PsiWhiteSpace(' ')
+            REFERENCE_EXPRESSION
-          TYPE_REFERENCE
+              PsiElement(IDENTIFIER)('List')
-            USER_TYPE
+            TYPE_ARGUMENT_LIST
-              REFERENCE_EXPRESSION
+              PsiElement(LT)('<')
-                PsiElement(IDENTIFIER)('bar')
+              TYPE_PROJECTION
-              TYPE_ARGUMENT_LIST
+                TYPE_REFERENCE
-                PsiElement(LT)('<')
+                  SELF_TYPE
-                TYPE_PROJECTION
+                    PsiElement(This)('This')
-                  TYPE_REFERENCE
+              PsiElement(GT)('>')
-                    SELF_TYPE
+      PsiElement(GT)('>')
-                      PsiElement(This)('This')
+    VALUE_PARAMETER_LIST
-                PsiElement(GT)('>')
+      PsiElement(LPAR)('(')
-        PsiElement(RPAR)(')')
+      VALUE_PARAMETER
+        PsiElement(IDENTIFIER)('a')
+        PsiWhiteSpace(' ')
+        PsiElement(COLON)(':')
+        PsiWhiteSpace(' ')
+        TYPE_REFERENCE
+          SELF_TYPE
+            PsiElement(This)('This')
+      PsiElement(COMMA)(',')
       PsiWhiteSpace(' ')
-      PsiElement(COLON)(':')
+      VALUE_PARAMETER
-      PsiWhiteSpace(' ')
+        PsiElement(IDENTIFIER)('b')
-      DELEGATION_SPECIFIER_LIST
+        PsiWhiteSpace(' ')
-        DELEGATOR_BY
+        PsiElement(COLON)(':')
+        PsiWhiteSpace(' ')
+        TYPE_REFERENCE
+          USER_TYPE
+            REFERENCE_EXPRESSION
+              PsiElement(IDENTIFIER)('bar')
+            TYPE_ARGUMENT_LIST
+              PsiElement(LT)('<')
+              TYPE_PROJECTION
+                TYPE_REFERENCE
+                  SELF_TYPE
+                    PsiElement(This)('This')
+              PsiElement(GT)('>')
+      PsiElement(RPAR)(')')
+    PsiWhiteSpace(' ')
+    PsiElement(COLON)(':')
+    PsiWhiteSpace(' ')
+    DELEGATION_SPECIFIER_LIST
+      DELEGATOR_BY
+        TYPE_REFERENCE
+          USER_TYPE
+            REFERENCE_EXPRESSION
+              PsiElement(IDENTIFIER)('List')
+            TYPE_ARGUMENT_LIST
+              PsiElement(LT)('<')
+              TYPE_PROJECTION
+                TYPE_REFERENCE
+                  SELF_TYPE
+                    PsiElement(This)('This')
+              PsiElement(GT)('>')
+        PsiWhiteSpace(' ')
+        PsiElement(by)('by')
+        PsiWhiteSpace(' ')
+        BINARY_WITH_TYPE
+          REFERENCE_EXPRESSION
+            PsiElement(IDENTIFIER)('foo')
+          PsiWhiteSpace(' ')
+          OPERATION_REFERENCE
+            PsiElement(as)('as')
+          PsiWhiteSpace(' ')
           TYPE_REFERENCE
             USER_TYPE
               REFERENCE_EXPRESSION
@@ -70,84 +90,63 @@ JetFile: ThisType.jet
                     SELF_TYPE
                       PsiElement(This)('This')
                 PsiElement(GT)('>')
-          PsiWhiteSpace(' ')
+    PsiWhiteSpace(' ')
-          PsiElement(by)('by')
+    CLASS_BODY
-          PsiWhiteSpace(' ')
+      PsiElement(LBRACE)('{')
-          BINARY_WITH_TYPE
+      PsiWhiteSpace('\n  ')
-            REFERENCE_EXPRESSION
+      FUN
-              PsiElement(IDENTIFIER)('foo')
+        PsiElement(fun)('fun')
+        PsiWhiteSpace(' ')
+        PsiElement(IDENTIFIER)('foo')
+        VALUE_PARAMETER_LIST
+          PsiElement(LPAR)('(')
+          VALUE_PARAMETER
+            PsiElement(IDENTIFIER)('a')
             PsiWhiteSpace(' ')
-            OPERATION_REFERENCE
+            PsiElement(COLON)(':')
-              PsiElement(as)('as')
             PsiWhiteSpace(' ')
             TYPE_REFERENCE
-              USER_TYPE
+              SELF_TYPE
-                REFERENCE_EXPRESSION
+                PsiElement(This)('This')
-                  PsiElement(IDENTIFIER)('List')
+          PsiElement(RPAR)(')')
-                TYPE_ARGUMENT_LIST
+        PsiWhiteSpace(' ')
-                  PsiElement(LT)('<')
+        PsiElement(COLON)(':')
-                  TYPE_PROJECTION
+        PsiWhiteSpace(' ')
-                    TYPE_REFERENCE
+        TYPE_REFERENCE
-                      SELF_TYPE
+          SELF_TYPE
-                        PsiElement(This)('This')
+            PsiElement(This)('This')
-                  PsiElement(GT)('>')
+        PsiWhiteSpace(' ')
-      PsiWhiteSpace(' ')
+        BLOCK
-      CLASS_BODY
+          PsiElement(LBRACE)('{')
-        PsiElement(LBRACE)('{')
+          PsiWhiteSpace('\n    ')
-        PsiWhiteSpace('\n  ')
+          PROPERTY
-        FUN
+            PsiElement(val)('val')
-          PsiElement(fun)('fun')
+            PsiWhiteSpace(' ')
-          PsiWhiteSpace(' ')
+            PsiElement(IDENTIFIER)('a')
-          PsiElement(IDENTIFIER)('foo')
+            PsiWhiteSpace(' ')
-          VALUE_PARAMETER_LIST
+            PsiElement(COLON)(':')
-            PsiElement(LPAR)('(')
+            PsiWhiteSpace(' ')
-            VALUE_PARAMETER
+            TYPE_REFERENCE
-              PsiElement(IDENTIFIER)('a')
+              SELF_TYPE
-              PsiWhiteSpace(' ')
+                PsiElement(This)('This')
-              PsiElement(COLON)(':')
+            PsiWhiteSpace(' ')
-              PsiWhiteSpace(' ')
+            PsiElement(EQ)('=')
-              TYPE_REFERENCE
+            PsiWhiteSpace(' ')
-                SELF_TYPE
+            CALL_EXPRESSION
-                  PsiElement(This)('This')
+              REFERENCE_EXPRESSION
-            PsiElement(RPAR)(')')
+                PsiElement(IDENTIFIER)('Foo')
-          PsiWhiteSpace(' ')
+              TYPE_ARGUMENT_LIST
-          PsiElement(COLON)(':')
+                PsiElement(LT)('<')
-          PsiWhiteSpace(' ')
+                TYPE_PROJECTION
-          TYPE_REFERENCE
+                  TYPE_REFERENCE
-            SELF_TYPE
+                    SELF_TYPE
-              PsiElement(This)('This')
+                      PsiElement(This)('This')
-          PsiWhiteSpace(' ')
+                PsiElement(GT)('>')
-          BLOCK
+              VALUE_ARGUMENT_LIST
-            PsiElement(LBRACE)('{')
+                PsiElement(LPAR)('(')
-            PsiWhiteSpace('\n    ')
+                PsiElement(RPAR)(')')
-            PROPERTY
+          PsiElement(SEMICOLON)(';')
-              PsiElement(val)('val')
+          PsiWhiteSpace('\n  ')
-              PsiWhiteSpace(' ')
+          PsiElement(RBRACE)('}')
-              PsiElement(IDENTIFIER)('a')
+      PsiWhiteSpace('\n')
-              PsiWhiteSpace(' ')
+      PsiElement(RBRACE)('}')
-              PsiElement(COLON)(':')
-              PsiWhiteSpace(' ')
-              TYPE_REFERENCE
-                SELF_TYPE
-                  PsiElement(This)('This')
-              PsiWhiteSpace(' ')
-              PsiElement(EQ)('=')
-              PsiWhiteSpace(' ')
-              CALL_EXPRESSION
-                REFERENCE_EXPRESSION
-                  PsiElement(IDENTIFIER)('Foo')
-                TYPE_ARGUMENT_LIST
-                  PsiElement(LT)('<')
-                  TYPE_PROJECTION
-                    TYPE_REFERENCE
-                      SELF_TYPE
-                        PsiElement(This)('This')
-                  PsiElement(GT)('>')
-                VALUE_ARGUMENT_LIST
-                  PsiElement(LPAR)('(')
-                  PsiElement(RPAR)(')')
-            PsiElement(SEMICOLON)(';')
-            PsiWhiteSpace('\n  ')
-            PsiElement(RBRACE)('}')
-        PsiWhiteSpace('\n')
-        PsiElement(RBRACE)('}')

compiler/testData/psi/TupleTypes.txt

@@ -1,138 +1,229 @@
 JetFile: TupleTypes.jet
-  NAMESPACE
+  NAMESPACE_HEADER
-    NAMESPACE_HEADER
+    <empty list>
+  CLASS
+    PsiElement(class)('class')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('F')
+    TYPE_PARAMETER_LIST
       <empty list>
-    CLASS
+    VALUE_PARAMETER_LIST
-      PsiElement(class)('class')
+      PsiElement(LPAR)('(')
-      PsiWhiteSpace(' ')
+      PsiWhiteSpace('\n    ')
-      PsiElement(IDENTIFIER)('F')
+      VALUE_PARAMETER
-      TYPE_PARAMETER_LIST
+        PsiElement(IDENTIFIER)('a')
-        <empty list>
+        PsiWhiteSpace(' ')
-      VALUE_PARAMETER_LIST
+        PsiElement(COLON)(':')
-        PsiElement(LPAR)('(')
+        PsiWhiteSpace(' ')
-        PsiWhiteSpace('\n    ')
+        TYPE_REFERENCE
-        VALUE_PARAMETER
+          TUPLE_TYPE
-          PsiElement(IDENTIFIER)('a')
+            PsiElement(HASH)('#')
-          PsiWhiteSpace(' ')
+            PsiElement(LPAR)('(')
-          PsiElement(COLON)(':')
+            PsiElement(RPAR)(')')
-          PsiWhiteSpace(' ')
+      PsiElement(COMMA)(',')
-          TYPE_REFERENCE
+      PsiWhiteSpace('\n    ')
-            TUPLE_TYPE
+      VALUE_PARAMETER
-              PsiElement(HASH)('#')
+        PsiElement(IDENTIFIER)('x')
-              PsiElement(LPAR)('(')
+        PsiWhiteSpace(' ')
-              PsiElement(RPAR)(')')
+        PsiElement(COLON)(':')
-        PsiElement(COMMA)(',')
+        PsiWhiteSpace(' ')
-        PsiWhiteSpace('\n    ')
+        TYPE_REFERENCE
-        VALUE_PARAMETER
+          TUPLE_TYPE
-          PsiElement(IDENTIFIER)('x')
+            PsiElement(HASH)('#')
-          PsiWhiteSpace(' ')
+            PsiElement(LPAR)('(')
-          PsiElement(COLON)(':')
+            TYPE_REFERENCE
-          PsiWhiteSpace(' ')
+              USER_TYPE
-          TYPE_REFERENCE
+                REFERENCE_EXPRESSION
-            TUPLE_TYPE
+                  PsiElement(IDENTIFIER)('X')
-              PsiElement(HASH)('#')
+            PsiElement(RPAR)(')')
-              PsiElement(LPAR)('(')
+      PsiElement(COMMA)(',')
-              TYPE_REFERENCE
+      PsiWhiteSpace('\n    ')
-                USER_TYPE
+      VALUE_PARAMETER
-                  REFERENCE_EXPRESSION
+        PsiElement(IDENTIFIER)('b')
-                    PsiElement(IDENTIFIER)('X')
+        PsiWhiteSpace(' ')
-              PsiElement(RPAR)(')')
+        PsiElement(COLON)(':')
-        PsiElement(COMMA)(',')
+        PsiWhiteSpace(' ')
-        PsiWhiteSpace('\n    ')
+        TYPE_REFERENCE
-        VALUE_PARAMETER
+          TUPLE_TYPE
-          PsiElement(IDENTIFIER)('b')
+            PsiElement(HASH)('#')
-          PsiWhiteSpace(' ')
+            PsiElement(LPAR)('(')
-          PsiElement(COLON)(':')
+            TYPE_REFERENCE
-          PsiWhiteSpace(' ')
+              USER_TYPE
-          TYPE_REFERENCE
+                REFERENCE_EXPRESSION
-            TUPLE_TYPE
+                  PsiElement(IDENTIFIER)('A')
-              PsiElement(HASH)('#')
+            PsiElement(COMMA)(',')
-              PsiElement(LPAR)('(')
-              TYPE_REFERENCE
-                USER_TYPE
-                  REFERENCE_EXPRESSION
-                    PsiElement(IDENTIFIER)('A')
-              PsiElement(COMMA)(',')
-              PsiWhiteSpace(' ')
-              TYPE_REFERENCE
-                USER_TYPE
-                  REFERENCE_EXPRESSION
-                    PsiElement(IDENTIFIER)('B')
-              PsiElement(RPAR)(')')
-        PsiElement(COMMA)(',')
-        PsiWhiteSpace('\n    ')
-        VALUE_PARAMETER
-          PsiElement(IDENTIFIER)('c')
-          PsiWhiteSpace(' ')
-          PsiElement(COLON)(':')
-          PsiWhiteSpace(' ')
-          TYPE_REFERENCE
-            TUPLE_TYPE
-              PsiElement(HASH)('#')
-              PsiElement(LPAR)('(')
-              LABELED_TUPLE_TYPE_ENTRY
-                PsiElement(IDENTIFIER)('x')
-                PsiWhiteSpace(' ')
-                PsiElement(COLON)(':')
-                PsiWhiteSpace(' ')
-                TYPE_REFERENCE
-                  USER_TYPE
-                    REFERENCE_EXPRESSION
-                      PsiElement(IDENTIFIER)('Int')
-              PsiElement(COMMA)(',')
-              PsiWhiteSpace(' ')
-              LABELED_TUPLE_TYPE_ENTRY
-                PsiElement(IDENTIFIER)('y')
-                PsiWhiteSpace(' ')
-                PsiElement(COLON)(':')
-                PsiWhiteSpace(' ')
-                TYPE_REFERENCE
-                  USER_TYPE
-                    REFERENCE_EXPRESSION
-                      PsiElement(IDENTIFIER)('Int')
-              PsiElement(RPAR)(')')
-        PsiElement(COMMA)(',')
-        PsiWhiteSpace('\n    ')
-        VALUE_PARAMETER
-          PsiElement(IDENTIFIER)('a')
-          PsiWhiteSpace(' ')
-          PsiElement(COLON)(':')
-          PsiWhiteSpace(' ')
-          TYPE_REFERENCE
-            ANNOTATION
-              PsiElement(LBRACKET)('[')
-              ANNOTATION_ENTRY
-                CONSTRUCTOR_CALLEE
-                  TYPE_REFERENCE
-                    USER_TYPE
-                      REFERENCE_EXPRESSION
-                        PsiElement(IDENTIFIER)('x')
-              PsiElement(RBRACKET)(']')
             PsiWhiteSpace(' ')
-            TUPLE_TYPE
+            TYPE_REFERENCE
-              PsiElement(HASH)('#')
+              USER_TYPE
-              PsiElement(LPAR)('(')
+                REFERENCE_EXPRESSION
-              PsiElement(RPAR)(')')
+                  PsiElement(IDENTIFIER)('B')
-        PsiElement(COMMA)(',')
+            PsiElement(RPAR)(')')
-        PsiWhiteSpace('\n    ')
+      PsiElement(COMMA)(',')
-        VALUE_PARAMETER
+      PsiWhiteSpace('\n    ')
-          PsiElement(IDENTIFIER)('x')
+      VALUE_PARAMETER
+        PsiElement(IDENTIFIER)('c')
+        PsiWhiteSpace(' ')
+        PsiElement(COLON)(':')
+        PsiWhiteSpace(' ')
+        TYPE_REFERENCE
+          TUPLE_TYPE
+            PsiElement(HASH)('#')
+            PsiElement(LPAR)('(')
+            LABELED_TUPLE_TYPE_ENTRY
+              PsiElement(IDENTIFIER)('x')
+              PsiWhiteSpace(' ')
+              PsiElement(COLON)(':')
+              PsiWhiteSpace(' ')
+              TYPE_REFERENCE
+                USER_TYPE
+                  REFERENCE_EXPRESSION
+                    PsiElement(IDENTIFIER)('Int')
+            PsiElement(COMMA)(',')
+            PsiWhiteSpace(' ')
+            LABELED_TUPLE_TYPE_ENTRY
+              PsiElement(IDENTIFIER)('y')
+              PsiWhiteSpace(' ')
+              PsiElement(COLON)(':')
+              PsiWhiteSpace(' ')
+              TYPE_REFERENCE
+                USER_TYPE
+                  REFERENCE_EXPRESSION
+                    PsiElement(IDENTIFIER)('Int')
+            PsiElement(RPAR)(')')
+      PsiElement(COMMA)(',')
+      PsiWhiteSpace('\n    ')
+      VALUE_PARAMETER
+        PsiElement(IDENTIFIER)('a')
+        PsiWhiteSpace(' ')
+        PsiElement(COLON)(':')
+        PsiWhiteSpace(' ')
+        TYPE_REFERENCE
+          ANNOTATION
+            PsiElement(LBRACKET)('[')
+            ANNOTATION_ENTRY
+              CONSTRUCTOR_CALLEE
+                TYPE_REFERENCE
+                  USER_TYPE
+                    REFERENCE_EXPRESSION
+                      PsiElement(IDENTIFIER)('x')
+            PsiElement(RBRACKET)(']')
           PsiWhiteSpace(' ')
-          PsiElement(COLON)(':')
+          TUPLE_TYPE
+            PsiElement(HASH)('#')
+            PsiElement(LPAR)('(')
+            PsiElement(RPAR)(')')
+      PsiElement(COMMA)(',')
+      PsiWhiteSpace('\n    ')
+      VALUE_PARAMETER
+        PsiElement(IDENTIFIER)('x')
+        PsiWhiteSpace(' ')
+        PsiElement(COLON)(':')
+        PsiWhiteSpace(' ')
+        TYPE_REFERENCE
+          ANNOTATION
+            PsiElement(LBRACKET)('[')
+            ANNOTATION_ENTRY
+              CONSTRUCTOR_CALLEE
+                TYPE_REFERENCE
+                  USER_TYPE
+                    REFERENCE_EXPRESSION
+                      PsiElement(IDENTIFIER)('x')
+            PsiElement(RBRACKET)(']')
+          TUPLE_TYPE
+            PsiElement(HASH)('#')
+            PsiElement(LPAR)('(')
+            TYPE_REFERENCE
+              ANNOTATION
+                PsiElement(LBRACKET)('[')
+                ANNOTATION_ENTRY
+                  CONSTRUCTOR_CALLEE
+                    TYPE_REFERENCE
+                      USER_TYPE
+                        REFERENCE_EXPRESSION
+                          PsiElement(IDENTIFIER)('x')
+                PsiElement(RBRACKET)(']')
+              PsiWhiteSpace(' ')
+              USER_TYPE
+                REFERENCE_EXPRESSION
+                  PsiElement(IDENTIFIER)('X')
+            PsiElement(RPAR)(')')
+      PsiElement(COMMA)(',')
+      PsiWhiteSpace('\n    ')
+      VALUE_PARAMETER
+        PsiElement(IDENTIFIER)('b')
+        PsiWhiteSpace(' ')
+        PsiElement(COLON)(':')
+        PsiWhiteSpace(' ')
+        TYPE_REFERENCE
+          ANNOTATION
+            PsiElement(LBRACKET)('[')
+            ANNOTATION_ENTRY
+              CONSTRUCTOR_CALLEE
+                TYPE_REFERENCE
+                  USER_TYPE
+                    REFERENCE_EXPRESSION
+                      PsiElement(IDENTIFIER)('x')
+            PsiElement(RBRACKET)(']')
           PsiWhiteSpace(' ')
-          TYPE_REFERENCE
+          TUPLE_TYPE
-            ANNOTATION
+            PsiElement(HASH)('#')
-              PsiElement(LBRACKET)('[')
+            PsiElement(LPAR)('(')
-              ANNOTATION_ENTRY
+            TYPE_REFERENCE
-                CONSTRUCTOR_CALLEE
+              ANNOTATION
-                  TYPE_REFERENCE
+                PsiElement(LBRACKET)('[')
-                    USER_TYPE
+                ANNOTATION_ENTRY
-                      REFERENCE_EXPRESSION
+                  CONSTRUCTOR_CALLEE
-                        PsiElement(IDENTIFIER)('x')
+                    TYPE_REFERENCE
-              PsiElement(RBRACKET)(']')
+                      USER_TYPE
-            TUPLE_TYPE
+                        REFERENCE_EXPRESSION
-              PsiElement(HASH)('#')
+                          PsiElement(IDENTIFIER)('x')
-              PsiElement(LPAR)('(')
+                PsiElement(RBRACKET)(']')
+              PsiWhiteSpace(' ')
+              USER_TYPE
+                REFERENCE_EXPRESSION
+                  PsiElement(IDENTIFIER)('A')
+            PsiElement(COMMA)(',')
+            PsiWhiteSpace(' ')
+            TYPE_REFERENCE
+              ANNOTATION
+                PsiElement(LBRACKET)('[')
+                ANNOTATION_ENTRY
+                  CONSTRUCTOR_CALLEE
+                    TYPE_REFERENCE
+                      USER_TYPE
+                        REFERENCE_EXPRESSION
+                          PsiElement(IDENTIFIER)('x')
+                PsiElement(RBRACKET)(']')
+              USER_TYPE
+                REFERENCE_EXPRESSION
+                  PsiElement(IDENTIFIER)('B')
+            PsiElement(RPAR)(')')
+      PsiElement(COMMA)(',')
+      PsiWhiteSpace('\n    ')
+      VALUE_PARAMETER
+        PsiElement(IDENTIFIER)('c')
+        PsiWhiteSpace(' ')
+        PsiElement(COLON)(':')
+        PsiWhiteSpace(' ')
+        TYPE_REFERENCE
+          ANNOTATION
+            PsiElement(LBRACKET)('[')
+            ANNOTATION_ENTRY
+              CONSTRUCTOR_CALLEE
+                TYPE_REFERENCE
+                  USER_TYPE
+                    REFERENCE_EXPRESSION
+                      PsiElement(IDENTIFIER)('x')
+            PsiElement(RBRACKET)(']')
+          PsiWhiteSpace(' ')
+          TUPLE_TYPE
+            PsiElement(HASH)('#')
+            PsiElement(LPAR)('(')
+            LABELED_TUPLE_TYPE_ENTRY
+              PsiElement(IDENTIFIER)('x')
+              PsiWhiteSpace(' ')
+              PsiElement(COLON)(':')
+              PsiWhiteSpace(' ')
               TYPE_REFERENCE
                 ANNOTATION
                   PsiElement(LBRACKET)('[')
@@ -146,29 +237,14 @@ JetFile: TupleTypes.jet
                 PsiWhiteSpace(' ')
                 USER_TYPE
                   REFERENCE_EXPRESSION
-                    PsiElement(IDENTIFIER)('X')
+                    PsiElement(IDENTIFIER)('Int')
-              PsiElement(RPAR)(')')
+            PsiElement(COMMA)(',')
-        PsiElement(COMMA)(',')
-        PsiWhiteSpace('\n    ')
-        VALUE_PARAMETER
-          PsiElement(IDENTIFIER)('b')
-          PsiWhiteSpace(' ')
-          PsiElement(COLON)(':')
-          PsiWhiteSpace(' ')
-          TYPE_REFERENCE
-            ANNOTATION
-              PsiElement(LBRACKET)('[')
-              ANNOTATION_ENTRY
-                CONSTRUCTOR_CALLEE
-                  TYPE_REFERENCE
-                    USER_TYPE
-                      REFERENCE_EXPRESSION
-                        PsiElement(IDENTIFIER)('x')
-              PsiElement(RBRACKET)(']')
             PsiWhiteSpace(' ')
-            TUPLE_TYPE
+            LABELED_TUPLE_TYPE_ENTRY
-              PsiElement(HASH)('#')
+              PsiElement(IDENTIFIER)('y')
-              PsiElement(LPAR)('(')
+              PsiWhiteSpace(' ')
+              PsiElement(COLON)(':')
+              PsiWhiteSpace(' ')
               TYPE_REFERENCE
                 ANNOTATION
                   PsiElement(LBRACKET)('[')
@@ -182,84 +258,7 @@ JetFile: TupleTypes.jet
                 PsiWhiteSpace(' ')
                 USER_TYPE
                   REFERENCE_EXPRESSION
-                    PsiElement(IDENTIFIER)('A')
+                    PsiElement(IDENTIFIER)('Int')
-              PsiElement(COMMA)(',')
+            PsiElement(RPAR)(')')
-              PsiWhiteSpace(' ')
+      PsiWhiteSpace('\n    ')
-              TYPE_REFERENCE
+      PsiElement(RPAR)(')')
-                ANNOTATION
-                  PsiElement(LBRACKET)('[')
-                  ANNOTATION_ENTRY
-                    CONSTRUCTOR_CALLEE
-                      TYPE_REFERENCE
-                        USER_TYPE
-                          REFERENCE_EXPRESSION
-                            PsiElement(IDENTIFIER)('x')
-                  PsiElement(RBRACKET)(']')
-                USER_TYPE
-                  REFERENCE_EXPRESSION
-                    PsiElement(IDENTIFIER)('B')
-              PsiElement(RPAR)(')')
-        PsiElement(COMMA)(',')
-        PsiWhiteSpace('\n    ')
-        VALUE_PARAMETER
-          PsiElement(IDENTIFIER)('c')
-          PsiWhiteSpace(' ')
-          PsiElement(COLON)(':')
-          PsiWhiteSpace(' ')
-          TYPE_REFERENCE
-            ANNOTATION
-              PsiElement(LBRACKET)('[')
-              ANNOTATION_ENTRY
-                CONSTRUCTOR_CALLEE
-                  TYPE_REFERENCE
-                    USER_TYPE
-                      REFERENCE_EXPRESSION
-                        PsiElement(IDENTIFIER)('x')
-              PsiElement(RBRACKET)(']')
-            PsiWhiteSpace(' ')
-            TUPLE_TYPE
-              PsiElement(HASH)('#')
-              PsiElement(LPAR)('(')
-              LABELED_TUPLE_TYPE_ENTRY
-                PsiElement(IDENTIFIER)('x')
-                PsiWhiteSpace(' ')
-                PsiElement(COLON)(':')
-                PsiWhiteSpace(' ')
-                TYPE_REFERENCE
-                  ANNOTATION
-                    PsiElement(LBRACKET)('[')
-                    ANNOTATION_ENTRY
-                      CONSTRUCTOR_CALLEE
-                        TYPE_REFERENCE
-                          USER_TYPE
-                            REFERENCE_EXPRESSION
-                              PsiElement(IDENTIFIER)('x')
-                    PsiElement(RBRACKET)(']')
-                  PsiWhiteSpace(' ')
-                  USER_TYPE
-                    REFERENCE_EXPRESSION
-                      PsiElement(IDENTIFIER)('Int')
-              PsiElement(COMMA)(',')
-              PsiWhiteSpace(' ')
-              LABELED_TUPLE_TYPE_ENTRY
-                PsiElement(IDENTIFIER)('y')
-                PsiWhiteSpace(' ')
-                PsiElement(COLON)(':')
-                PsiWhiteSpace(' ')
-                TYPE_REFERENCE
-                  ANNOTATION
-                    PsiElement(LBRACKET)('[')
-                    ANNOTATION_ENTRY
-                      CONSTRUCTOR_CALLEE
-                        TYPE_REFERENCE
-                          USER_TYPE
-                            REFERENCE_EXPRESSION
-                              PsiElement(IDENTIFIER)('x')
-                    PsiElement(RBRACKET)(']')
-                  PsiWhiteSpace(' ')
-                  USER_TYPE
-                    REFERENCE_EXPRESSION
-                      PsiElement(IDENTIFIER)('Int')
-              PsiElement(RPAR)(')')
-        PsiWhiteSpace('\n    ')
-        PsiElement(RPAR)(')')

compiler/testData/psi/TupleTypes_ERR.txt

@@ -1,173 +1,249 @@
 JetFile: TupleTypes_ERR.jet
-  NAMESPACE
+  NAMESPACE_HEADER
-    NAMESPACE_HEADER
+    <empty list>
+  CLASS
+    PsiElement(class)('class')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('F')
+    TYPE_PARAMETER_LIST
       <empty list>
-    CLASS
+    VALUE_PARAMETER_LIST
-      PsiElement(class)('class')
+      PsiElement(LPAR)('(')
-      PsiWhiteSpace(' ')
+      PsiWhiteSpace('\n    ')
-      PsiElement(IDENTIFIER)('F')
+      VALUE_PARAMETER
-      TYPE_PARAMETER_LIST
+        PsiElement(IDENTIFIER)('a')
-        <empty list>
+        PsiWhiteSpace(' ')
-      VALUE_PARAMETER_LIST
+        PsiElement(COLON)(':')
-        PsiElement(LPAR)('(')
+        PsiWhiteSpace(' ')
-        PsiWhiteSpace('\n    ')
+        TYPE_REFERENCE
-        VALUE_PARAMETER
+          TUPLE_TYPE
-          PsiElement(IDENTIFIER)('a')
+            PsiElement(HASH)('#')
-          PsiWhiteSpace(' ')
+            PsiElement(LPAR)('(')
-          PsiElement(COLON)(':')
+            PsiElement(RPAR)(')')
-          PsiWhiteSpace(' ')
+      PsiElement(COMMA)(',')
-          TYPE_REFERENCE
+      PsiWhiteSpace('\n    ')
-            TUPLE_TYPE
+      VALUE_PARAMETER
-              PsiElement(HASH)('#')
+        PsiElement(IDENTIFIER)('x')
-              PsiElement(LPAR)('(')
+        PsiWhiteSpace(' ')
-              PsiElement(RPAR)(')')
+        PsiElement(COLON)(':')
-        PsiElement(COMMA)(',')
+        PsiWhiteSpace(' ')
-        PsiWhiteSpace('\n    ')
+        TYPE_REFERENCE
-        VALUE_PARAMETER
+          TUPLE_TYPE
-          PsiElement(IDENTIFIER)('x')
+            PsiElement(HASH)('#')
-          PsiWhiteSpace(' ')
+            PsiElement(LPAR)('(')
-          PsiElement(COLON)(':')
+            TYPE_REFERENCE
-          PsiWhiteSpace(' ')
+              USER_TYPE
-          TYPE_REFERENCE
+                REFERENCE_EXPRESSION
-            TUPLE_TYPE
+                  PsiElement(IDENTIFIER)('X')
-              PsiElement(HASH)('#')
+            PsiElement(RPAR)(')')
-              PsiElement(LPAR)('(')
+      PsiElement(COMMA)(',')
-              TYPE_REFERENCE
+      PsiWhiteSpace('\n    ')
-                USER_TYPE
+      VALUE_PARAMETER
-                  REFERENCE_EXPRESSION
+        PsiElement(IDENTIFIER)('b')
-                    PsiElement(IDENTIFIER)('X')
+        PsiWhiteSpace(' ')
-              PsiElement(RPAR)(')')
+        PsiElement(COLON)(':')
-        PsiElement(COMMA)(',')
+        PsiWhiteSpace(' ')
-        PsiWhiteSpace('\n    ')
+        TYPE_REFERENCE
-        VALUE_PARAMETER
+          TUPLE_TYPE
-          PsiElement(IDENTIFIER)('b')
+            PsiElement(HASH)('#')
-          PsiWhiteSpace(' ')
+            PsiElement(LPAR)('(')
-          PsiElement(COLON)(':')
+            TYPE_REFERENCE
-          PsiWhiteSpace(' ')
+              USER_TYPE
-          TYPE_REFERENCE
+                REFERENCE_EXPRESSION
-            TUPLE_TYPE
+                  PsiElement(IDENTIFIER)('A')
-              PsiElement(HASH)('#')
+            PsiElement(COMMA)(',')
-              PsiElement(LPAR)('(')
+            PsiErrorElement:Type expected
-              TYPE_REFERENCE
+              <empty list>
-                USER_TYPE
+            PsiWhiteSpace(' ')
-                  REFERENCE_EXPRESSION
+            PsiElement(RPAR)(')')
-                    PsiElement(IDENTIFIER)('A')
+      PsiElement(COMMA)(',')
-              PsiElement(COMMA)(',')
+      PsiWhiteSpace('\n    ')
-              PsiErrorElement:Type expected
+      VALUE_PARAMETER
-                <empty list>
+        PsiElement(IDENTIFIER)('c')
+        PsiWhiteSpace(' ')
+        PsiElement(COLON)(':')
+        PsiWhiteSpace(' ')
+        TYPE_REFERENCE
+          TUPLE_TYPE
+            PsiElement(HASH)('#')
+            PsiElement(LPAR)('(')
+            LABELED_TUPLE_TYPE_ENTRY
+              PsiElement(IDENTIFIER)('x')
               PsiWhiteSpace(' ')
-              PsiElement(RPAR)(')')
+              PsiElement(COLON)(':')
-        PsiElement(COMMA)(',')
+              PsiWhiteSpace(' ')
-        PsiWhiteSpace('\n    ')
+              TYPE_REFERENCE
-        VALUE_PARAMETER
+                PsiErrorElement:Type expected
-          PsiElement(IDENTIFIER)('c')
+                  <empty list>
-          PsiWhiteSpace(' ')
+            PsiElement(COMMA)(',')
-          PsiElement(COLON)(':')
+            PsiWhiteSpace('  ')
-          PsiWhiteSpace(' ')
+            PsiErrorElement:Expecting a name for tuple entry
-          TYPE_REFERENCE
+              PsiElement(COLON)(':')
-            TUPLE_TYPE
+            PsiWhiteSpace(' ')
-              PsiElement(HASH)('#')
+            TYPE_REFERENCE
-              PsiElement(LPAR)('(')
+              USER_TYPE
-              LABELED_TUPLE_TYPE_ENTRY
+                REFERENCE_EXPRESSION
-                PsiElement(IDENTIFIER)('x')
+                  PsiElement(IDENTIFIER)('Int')
-                PsiWhiteSpace(' ')
+            PsiElement(RPAR)(')')
-                PsiElement(COLON)(':')
+      PsiElement(COMMA)(',')
-                PsiWhiteSpace(' ')
+      PsiWhiteSpace('\n    ')
+      VALUE_PARAMETER
+        PsiElement(IDENTIFIER)('a')
+        PsiWhiteSpace(' ')
+        PsiElement(COLON)(':')
+        PsiWhiteSpace(' ')
+        TYPE_REFERENCE
+          ANNOTATION
+            PsiElement(LBRACKET)('[')
+            ANNOTATION_ENTRY
+              CONSTRUCTOR_CALLEE
                 TYPE_REFERENCE
-                  PsiErrorElement:Type expected
+                  USER_TYPE
-                    <empty list>
+                    REFERENCE_EXPRESSION
-              PsiElement(COMMA)(',')
+                      PsiElement(IDENTIFIER)('x')
-              PsiWhiteSpace('  ')
+            PsiElement(RBRACKET)(']')
-              PsiErrorElement:Expecting a name for tuple entry
+          PsiWhiteSpace(' ')
-                PsiElement(COLON)(':')
+          TUPLE_TYPE
+            PsiElement(HASH)('#')
+            PsiElement(LPAR)('(')
+            PsiElement(RPAR)(')')
+      PsiElement(COMMA)(',')
+      PsiWhiteSpace('\n    ')
+      VALUE_PARAMETER
+        PsiElement(IDENTIFIER)('x')
+        PsiWhiteSpace(' ')
+        PsiElement(COLON)(':')
+        PsiWhiteSpace(' ')
+        TYPE_REFERENCE
+          ANNOTATION
+            PsiElement(LBRACKET)('[')
+            ANNOTATION_ENTRY
+              CONSTRUCTOR_CALLEE
+                TYPE_REFERENCE
+                  USER_TYPE
+                    REFERENCE_EXPRESSION
+                      PsiElement(IDENTIFIER)('x')
+            PsiElement(RBRACKET)(']')
+          TUPLE_TYPE
+            PsiElement(HASH)('#')
+            PsiElement(LPAR)('(')
+            TYPE_REFERENCE
+              ANNOTATION
+                PsiElement(LBRACKET)('[')
+                ANNOTATION_ENTRY
+                  CONSTRUCTOR_CALLEE
+                    TYPE_REFERENCE
+                      USER_TYPE
+                        REFERENCE_EXPRESSION
+                          PsiElement(IDENTIFIER)('x')
+                PsiWhiteSpace(' ')
+                ANNOTATION_ENTRY
+                  CONSTRUCTOR_CALLEE
+                    TYPE_REFERENCE
+                      USER_TYPE
+                        REFERENCE_EXPRESSION
+                          PsiElement(IDENTIFIER)('X')
+                PsiErrorElement:Expecting ']' to close an attribute annotation
+                  <empty list>
+            PsiElement(RPAR)(')')
+      PsiElement(COMMA)(',')
+      PsiWhiteSpace('\n    ')
+      VALUE_PARAMETER
+        PsiElement(IDENTIFIER)('b')
+        PsiWhiteSpace(' ')
+        PsiElement(COLON)(':')
+        PsiWhiteSpace(' ')
+        TYPE_REFERENCE
+          ANNOTATION
+            PsiElement(LBRACKET)('[')
+            ANNOTATION_ENTRY
+              CONSTRUCTOR_CALLEE
+                TYPE_REFERENCE
+                  USER_TYPE
+                    REFERENCE_EXPRESSION
+                      PsiElement(IDENTIFIER)('x')
+            PsiElement(RBRACKET)(']')
+          PsiWhiteSpace(' ')
+          TUPLE_TYPE
+            PsiElement(HASH)('#')
+            PsiElement(LPAR)('(')
+            TYPE_REFERENCE
+              ANNOTATION
+                PsiElement(LBRACKET)('[')
+                ANNOTATION_ENTRY
+                  CONSTRUCTOR_CALLEE
+                    TYPE_REFERENCE
+                      USER_TYPE
+                        REFERENCE_EXPRESSION
+                          PsiElement(IDENTIFIER)('x')
+                PsiElement(RBRACKET)(']')
+              PsiWhiteSpace(' ')
+              USER_TYPE
+                REFERENCE_EXPRESSION
+                  PsiElement(IDENTIFIER)('A')
+            PsiElement(COMMA)(',')
+            PsiWhiteSpace(' ')
+            TYPE_REFERENCE
+              ANNOTATION
+                PsiElement(LBRACKET)('[')
+                ANNOTATION_ENTRY
+                  CONSTRUCTOR_CALLEE
+                    TYPE_REFERENCE
+                      USER_TYPE
+                        REFERENCE_EXPRESSION
+                          PsiElement(IDENTIFIER)('x')
+                PsiElement(RBRACKET)(']')
+              USER_TYPE
+                REFERENCE_EXPRESSION
+                  PsiElement(IDENTIFIER)('B')
+            PsiElement(RPAR)(')')
+      PsiElement(COMMA)(',')
+      PsiWhiteSpace('\n    ')
+      VALUE_PARAMETER
+        PsiElement(IDENTIFIER)('c')
+        PsiWhiteSpace(' ')
+        PsiElement(COLON)(':')
+        PsiWhiteSpace(' ')
+        TYPE_REFERENCE
+          ANNOTATION
+            PsiElement(LBRACKET)('[')
+            ANNOTATION_ENTRY
+              CONSTRUCTOR_CALLEE
+                TYPE_REFERENCE
+                  USER_TYPE
+                    REFERENCE_EXPRESSION
+                      PsiElement(IDENTIFIER)('x')
+            PsiElement(RBRACKET)(']')
+          PsiWhiteSpace(' ')
+          TUPLE_TYPE
+            PsiElement(HASH)('#')
+            PsiElement(LPAR)('(')
+            LABELED_TUPLE_TYPE_ENTRY
+              PsiElement(IDENTIFIER)('x')
+              PsiWhiteSpace(' ')
+              PsiElement(COLON)(':')
               PsiWhiteSpace(' ')
               TYPE_REFERENCE
+                ANNOTATION
+                  PsiElement(LBRACKET)('[')
+                  ANNOTATION_ENTRY
+                    CONSTRUCTOR_CALLEE
+                      TYPE_REFERENCE
+                        USER_TYPE
+                          REFERENCE_EXPRESSION
+                            PsiElement(IDENTIFIER)('x')
+                  PsiElement(RBRACKET)(']')
+                PsiWhiteSpace(' ')
                 USER_TYPE
                   REFERENCE_EXPRESSION
                     PsiElement(IDENTIFIER)('Int')
-              PsiElement(RPAR)(')')
+            PsiElement(COMMA)(',')
-        PsiElement(COMMA)(',')
-        PsiWhiteSpace('\n    ')
-        VALUE_PARAMETER
-          PsiElement(IDENTIFIER)('a')
-          PsiWhiteSpace(' ')
-          PsiElement(COLON)(':')
-          PsiWhiteSpace(' ')
-          TYPE_REFERENCE
-            ANNOTATION
-              PsiElement(LBRACKET)('[')
-              ANNOTATION_ENTRY
-                CONSTRUCTOR_CALLEE
-                  TYPE_REFERENCE
-                    USER_TYPE
-                      REFERENCE_EXPRESSION
-                        PsiElement(IDENTIFIER)('x')
-              PsiElement(RBRACKET)(']')
             PsiWhiteSpace(' ')
-            TUPLE_TYPE
+            LABELED_TUPLE_TYPE_ENTRY
-              PsiElement(HASH)('#')
+              PsiElement(IDENTIFIER)('y')
-              PsiElement(LPAR)('(')
+              PsiWhiteSpace(' ')
-              PsiElement(RPAR)(')')
+              PsiElement(COLON)(':')
-        PsiElement(COMMA)(',')
+              PsiWhiteSpace(' ')
-        PsiWhiteSpace('\n    ')
-        VALUE_PARAMETER
-          PsiElement(IDENTIFIER)('x')
-          PsiWhiteSpace(' ')
-          PsiElement(COLON)(':')
-          PsiWhiteSpace(' ')
-          TYPE_REFERENCE
-            ANNOTATION
-              PsiElement(LBRACKET)('[')
-              ANNOTATION_ENTRY
-                CONSTRUCTOR_CALLEE
-                  TYPE_REFERENCE
-                    USER_TYPE
-                      REFERENCE_EXPRESSION
-                        PsiElement(IDENTIFIER)('x')
-              PsiElement(RBRACKET)(']')
-            TUPLE_TYPE
-              PsiElement(HASH)('#')
-              PsiElement(LPAR)('(')
-              TYPE_REFERENCE
-                ANNOTATION
-                  PsiElement(LBRACKET)('[')
-                  ANNOTATION_ENTRY
-                    CONSTRUCTOR_CALLEE
-                      TYPE_REFERENCE
-                        USER_TYPE
-                          REFERENCE_EXPRESSION
-                            PsiElement(IDENTIFIER)('x')
-                  PsiWhiteSpace(' ')
-                  ANNOTATION_ENTRY
-                    CONSTRUCTOR_CALLEE
-                      TYPE_REFERENCE
-                        USER_TYPE
-                          REFERENCE_EXPRESSION
-                            PsiElement(IDENTIFIER)('X')
-                  PsiErrorElement:Expecting ']' to close an attribute annotation
-                    <empty list>
-              PsiElement(RPAR)(')')
-        PsiElement(COMMA)(',')
-        PsiWhiteSpace('\n    ')
-        VALUE_PARAMETER
-          PsiElement(IDENTIFIER)('b')
-          PsiWhiteSpace(' ')
-          PsiElement(COLON)(':')
-          PsiWhiteSpace(' ')
-          TYPE_REFERENCE
-            ANNOTATION
-              PsiElement(LBRACKET)('[')
-              ANNOTATION_ENTRY
-                CONSTRUCTOR_CALLEE
-                  TYPE_REFERENCE
-                    USER_TYPE
-                      REFERENCE_EXPRESSION
-                        PsiElement(IDENTIFIER)('x')
-              PsiElement(RBRACKET)(']')
-            PsiWhiteSpace(' ')
-            TUPLE_TYPE
-              PsiElement(HASH)('#')
-              PsiElement(LPAR)('(')
               TYPE_REFERENCE
                 ANNOTATION
                   PsiElement(LBRACKET)('[')
@@ -181,84 +257,7 @@ JetFile: TupleTypes_ERR.jet
                 PsiWhiteSpace(' ')
                 USER_TYPE
                   REFERENCE_EXPRESSION
-                    PsiElement(IDENTIFIER)('A')
+                    PsiElement(IDENTIFIER)('Int')
-              PsiElement(COMMA)(',')
+            PsiElement(RPAR)(')')
-              PsiWhiteSpace(' ')
+      PsiWhiteSpace('\n    ')
-              TYPE_REFERENCE
+      PsiElement(RPAR)(')')
-                ANNOTATION
-                  PsiElement(LBRACKET)('[')
-                  ANNOTATION_ENTRY
-                    CONSTRUCTOR_CALLEE
-                      TYPE_REFERENCE
-                        USER_TYPE
-                          REFERENCE_EXPRESSION
-                            PsiElement(IDENTIFIER)('x')
-                  PsiElement(RBRACKET)(']')
-                USER_TYPE
-                  REFERENCE_EXPRESSION
-                    PsiElement(IDENTIFIER)('B')
-              PsiElement(RPAR)(')')
-        PsiElement(COMMA)(',')
-        PsiWhiteSpace('\n    ')
-        VALUE_PARAMETER
-          PsiElement(IDENTIFIER)('c')
-          PsiWhiteSpace(' ')
-          PsiElement(COLON)(':')
-          PsiWhiteSpace(' ')
-          TYPE_REFERENCE
-            ANNOTATION
-              PsiElement(LBRACKET)('[')
-              ANNOTATION_ENTRY
-                CONSTRUCTOR_CALLEE
-                  TYPE_REFERENCE
-                    USER_TYPE
-                      REFERENCE_EXPRESSION
-                        PsiElement(IDENTIFIER)('x')
-              PsiElement(RBRACKET)(']')
-            PsiWhiteSpace(' ')
-            TUPLE_TYPE
-              PsiElement(HASH)('#')
-              PsiElement(LPAR)('(')
-              LABELED_TUPLE_TYPE_ENTRY
-                PsiElement(IDENTIFIER)('x')
-                PsiWhiteSpace(' ')
-                PsiElement(COLON)(':')
-                PsiWhiteSpace(' ')
-                TYPE_REFERENCE
-                  ANNOTATION
-                    PsiElement(LBRACKET)('[')
-                    ANNOTATION_ENTRY
-                      CONSTRUCTOR_CALLEE
-                        TYPE_REFERENCE
-                          USER_TYPE
-                            REFERENCE_EXPRESSION
-                              PsiElement(IDENTIFIER)('x')
-                    PsiElement(RBRACKET)(']')
-                  PsiWhiteSpace(' ')
-                  USER_TYPE
-                    REFERENCE_EXPRESSION
-                      PsiElement(IDENTIFIER)('Int')
-              PsiElement(COMMA)(',')
-              PsiWhiteSpace(' ')
-              LABELED_TUPLE_TYPE_ENTRY
-                PsiElement(IDENTIFIER)('y')
-                PsiWhiteSpace(' ')
-                PsiElement(COLON)(':')
-                PsiWhiteSpace(' ')
-                TYPE_REFERENCE
-                  ANNOTATION
-                    PsiElement(LBRACKET)('[')
-                    ANNOTATION_ENTRY
-                      CONSTRUCTOR_CALLEE
-                        TYPE_REFERENCE
-                          USER_TYPE
-                            REFERENCE_EXPRESSION
-                              PsiElement(IDENTIFIER)('x')
-                    PsiElement(RBRACKET)(']')
-                  PsiWhiteSpace(' ')
-                  USER_TYPE
-                    REFERENCE_EXPRESSION
-                      PsiElement(IDENTIFIER)('Int')
-              PsiElement(RPAR)(')')
-        PsiWhiteSpace('\n    ')
-        PsiElement(RPAR)(')')

compiler/testData/psi/TuplesWithLabeledEntries.txt

@@ -1,45 +1,44 @@
 JetFile: TuplesWithLabeledEntries.jet
-  NAMESPACE
+  NAMESPACE_HEADER
-    NAMESPACE_HEADER
+    <empty list>
-      <empty list>
+  PROPERTY
-    PROPERTY
+    PsiElement(val)('val')
-      PsiElement(val)('val')
+    PsiWhiteSpace(' ')
-      PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('foo')
-      PsiElement(IDENTIFIER)('foo')
+    PsiWhiteSpace(' ')
-      PsiWhiteSpace(' ')
+    PsiElement(EQ)('=')
-      PsiElement(EQ)('=')
+    PsiWhiteSpace(' ')
-      PsiWhiteSpace(' ')
+    TUPLE
-      TUPLE
+      PsiElement(HASH)('#')
-        PsiElement(HASH)('#')
+      PsiElement(LPAR)('(')
-        PsiElement(LPAR)('(')
+      LABELED_TUPLE_ENTRY
-        LABELED_TUPLE_ENTRY
+        PsiElement(IDENTIFIER)('a')
-          PsiElement(IDENTIFIER)('a')
-          PsiWhiteSpace(' ')
-          PsiElement(EQ)('=')
-          PsiWhiteSpace(' ')
-          INTEGER_CONSTANT
-            PsiElement(INTEGER_LITERAL)('3')
-        PsiElement(RPAR)(')')
-    PsiWhiteSpace('\n')
-    PROPERTY
-      PsiElement(val)('val')
-      PsiWhiteSpace(' ')
-      PsiElement(IDENTIFIER)('foo')
-      PsiWhiteSpace(' ')
-      PsiElement(EQ)('=')
-      PsiWhiteSpace(' ')
-      TUPLE
-        PsiElement(HASH)('#')
-        PsiElement(LPAR)('(')
-        LABELED_TUPLE_ENTRY
-          PsiElement(IDENTIFIER)('a')
-          PsiWhiteSpace(' ')
-          PsiElement(EQ)('=')
-          PsiWhiteSpace(' ')
-          INTEGER_CONSTANT
-            PsiElement(INTEGER_LITERAL)('3')
-        PsiElement(COMMA)(',')
         PsiWhiteSpace(' ')
-        REFERENCE_EXPRESSION
+        PsiElement(EQ)('=')
-          PsiElement(IDENTIFIER)('a')
+        PsiWhiteSpace(' ')
-        PsiElement(RPAR)(')')
+        INTEGER_CONSTANT
+          PsiElement(INTEGER_LITERAL)('3')
+      PsiElement(RPAR)(')')
+  PsiWhiteSpace('\n')
+  PROPERTY
+    PsiElement(val)('val')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('foo')
+    PsiWhiteSpace(' ')
+    PsiElement(EQ)('=')
+    PsiWhiteSpace(' ')
+    TUPLE
+      PsiElement(HASH)('#')
+      PsiElement(LPAR)('(')
+      LABELED_TUPLE_ENTRY
+        PsiElement(IDENTIFIER)('a')
+        PsiWhiteSpace(' ')
+        PsiElement(EQ)('=')
+        PsiWhiteSpace(' ')
+        INTEGER_CONSTANT
+          PsiElement(INTEGER_LITERAL)('3')
+      PsiElement(COMMA)(',')
+      PsiWhiteSpace(' ')
+      REFERENCE_EXPRESSION
+        PsiElement(IDENTIFIER)('a')
+      PsiElement(RPAR)(')')