KT-691 Allow to create nested namespaces with dot delimiter

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

@@ -4,15 +4,13 @@ import com.intellij.psi.util.PsiTreeUtil;
 import gnu.trove.THashSet;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
-import org.jetbrains.jet.lang.psi.JetClass;
+import org.jetbrains.jet.lang.psi.*;
-import org.jetbrains.jet.lang.psi.JetNamedDeclaration;
-import org.jetbrains.jet.lang.psi.JetNamespace;
 import org.jetbrains.jet.lang.resolve.calls.ExpressionAsFunctionDescriptor;
-import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
 import org.jetbrains.jet.lang.types.JetStandardClasses;
 import org.jetbrains.jet.lang.types.JetType;
 
 import java.util.Collections;
+import java.util.Iterator;
 import java.util.List;
 import java.util.Set;
 
@@ -115,10 +113,22 @@ public class CodegenUtil {
         if (parent != null) {
             String parentFQName = getFQName(parent);
             if (parentFQName.length() > 0) {
-                return parentFQName + "." + jetNamespace.getName();
+                return parentFQName + "." + getFQName(jetNamespace.getHeader());
             }
         }
-        return jetNamespace.getName(); // TODO: Must include module root namespace
+        return getFQName(jetNamespace.getHeader()); // TODO: Must include module root namespace
+    }
+
+    private static String getFQName(JetNamespaceHeader header) {
+        StringBuilder builder = new StringBuilder();
+        for (Iterator<JetSimpleNameExpression> iterator = header.getParentNamespaceNames().iterator(); iterator.hasNext(); ) {
+            JetSimpleNameExpression nameExpression = iterator.next();
+            builder.append(nameExpression.getReferencedName());
+            builder.append(".");
+        }
+//        PsiElement nameIdentifier = header.getNameIdentifier();
+        builder.append(header.getName());
+        return builder.toString();
     }
 
     public static String getFQName(JetClass jetClass) {

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

@@ -142,5 +142,5 @@ public interface JetNodeTypes {
     JetNodeType WHEN_CONDITION_IN_RANGE   = new JetNodeType("WHEN_CONDITION_IN_RANGE", JetWhenConditionInRange.class);
     JetNodeType WHEN_CONDITION_IS_PATTERN = new JetNodeType("WHEN_CONDITION_IS_PATTERN", JetWhenConditionIsPattern.class);
 
-    JetNodeType NAMESPACE_NAME = new JetNodeType("NAMESPACE_NAME", JetContainerNode.class);
+    JetNodeType NAMESPACE_HEADER = new JetNodeType("NAMESPACE_HEADER", JetNamespaceHeader.class);
 }

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

@@ -115,17 +115,18 @@ public class JetParsing extends AbstractJetParsing {
          *   : modifiers "namespace" SimpleName{"."} SEMI?
          *   ;
          */
+        PsiBuilder.Marker namespaceHeader = mark();
         PsiBuilder.Marker firstEntry = mark();
         parseModifierList(MODIFIER_LIST, true);
 
         if (at(NAMESPACE_KEYWORD)) {
             advance(); // NAMESPACE_KEYWORD
-
             parseNamespaceName();
 
             if (at(LBRACE)) {
                 // Because it's blocked namespace and it will be parsed as one of top level objects
                 firstEntry.rollbackTo();
+                namespaceHeader.done(NAMESPACE_HEADER);
                 return;
             }
 
@@ -135,6 +136,7 @@ public class JetParsing extends AbstractJetParsing {
         } else {
             firstEntry.rollbackTo();
         }
+        namespaceHeader.done(NAMESPACE_HEADER);
 
         // TODO: Duplicate with parsing imports in parseToplevelDeclarations
         while (at(IMPORT_KEYWORD)) {
@@ -145,12 +147,18 @@ public class JetParsing extends AbstractJetParsing {
     /* SimpleName{"."} */
     private void parseNamespaceName() {
         PsiBuilder.Marker nsName = mark();
-        expect(IDENTIFIER, "Expecting qualified name", NAMESPACE_NAME_RECOVERY_SET);
+        while (true) {
-        while (!eol() && at(DOT)) {
-            advance(); // DOT
             expect(IDENTIFIER, "Namespace name must be a '.'-separated identifier list", NAMESPACE_NAME_RECOVERY_SET);
+            if (at(DOT)) {
+                nsName.done(REFERENCE_EXPRESSION);
+                advance(); // DOT
+                nsName = mark();
+            }
+            else {
+                nsName.drop();
+                break;
+            }
         }
-        nsName.done(NAMESPACE_NAME);
     }
 
     /*
@@ -378,6 +386,7 @@ public class JetParsing extends AbstractJetParsing {
      */
     private JetNodeType parseNamespaceBlock() {
         assert _at(NAMESPACE_KEYWORD);
+        PsiBuilder.Marker namespaceHeader = mark();
         advance(); // NAMESPACE_KEYWORD
 
         if (at(LBRACE)) {
@@ -386,6 +395,7 @@ public class JetParsing extends AbstractJetParsing {
         else {
             parseNamespaceName();
         }
+        namespaceHeader.done(NAMESPACE_HEADER);
 
         if (!at(LBRACE)) {
             error("A namespace block in '{...}' expected");

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

@@ -2,6 +2,7 @@ package org.jetbrains.jet.lang.psi;
 
 import com.intellij.lang.ASTNode;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.JetNodeTypes;
 
 import java.util.ArrayList;
@@ -26,6 +27,7 @@ public class JetAnnotatedExpression extends JetExpression {
         return visitor.visitAnnotatedExpression(this, data);
     }
 
+    @Nullable
     public JetExpression getBaseExpression() {
         return findChildByClass(JetExpression.class);
     }

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

@@ -39,18 +39,23 @@ public class JetNamespace extends JetNamedDeclaration {
     }
 
     public String getName() {
-        PsiElement nameIdentifier = getNameIdentifier();
+        String name = super.getName();
-        return nameIdentifier != null ? nameIdentifier.getText() : "";
+        return name == null ? "" : name;
+    }
+
+    @NotNull
+    public JetNamespaceHeader getHeader() {
+        return (JetNamespaceHeader) findChildByType(JetNodeTypes.NAMESPACE_HEADER);
     }
 
     @Override
     public PsiElement getNameIdentifier() {
-        return findChildByType(JetNodeTypes.NAMESPACE_NAME);
+        return getHeader().getNameIdentifier();
     }
 
     @Override
     public PsiElement setName(@NonNls @NotNull String name) throws IncorrectOperationException {
-        throw new UnsupportedOperationException(); // TODO
+        throw new UnsupportedOperationException();
     }
 
 }

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

@@ -0,0 +1,35 @@
+package org.jetbrains.jet.lang.psi;
+
+import com.intellij.lang.ASTNode;
+import com.intellij.psi.PsiElement;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.jetbrains.jet.JetNodeTypes;
+import org.jetbrains.jet.lexer.JetTokens;
+
+import java.util.List;
+
+/**
+ * @author abreslav
+ */
+public class JetNamespaceHeader extends JetElement {
+    public JetNamespaceHeader(@NotNull ASTNode node) {
+        super(node);
+    }
+
+    @NotNull
+    public List<JetSimpleNameExpression> getParentNamespaceNames() {
+        return findChildrenByType(JetNodeTypes.REFERENCE_EXPRESSION);
+    }
+
+    @Nullable
+    public PsiElement getNameIdentifier() {
+        return findChildByType(JetTokens.IDENTIFIER);
+    }
+
+    @Override
+    public String getName() {
+        PsiElement nameIdentifier = getNameIdentifier();
+        return nameIdentifier == null ? "" : nameIdentifier.getText();
+    }
+}

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

@@ -69,19 +69,7 @@ public class TypeHierarchyResolver {
             declaration.accept(new JetVisitorVoid() {
                 @Override
                 public void visitNamespace(JetNamespace namespace) {
-                    String name = JetPsiUtil.safeName(namespace.getName());
+                    NamespaceDescriptorImpl namespaceDescriptor = createNamespaceDescriptorPathIfNeeded(namespace, owner);
-
-                    NamespaceDescriptorImpl namespaceDescriptor = owner.getNamespace(name);
-                    if (namespaceDescriptor == null) {
-                        namespaceDescriptor = new NamespaceDescriptorImpl(
-                                owner.getOriginal(),
-                                Collections.<AnnotationDescriptor>emptyList(), // TODO: annotations
-                                name
-                        );
-                        namespaceDescriptor.initialize(new WritableScopeImpl(JetScope.EMPTY, namespaceDescriptor, new TraceBasedRedeclarationHandler(context.getTrace())).setDebugName("Namespace member scope"));
-                        owner.addNamespace(namespaceDescriptor);
-                        context.getTrace().record(BindingContext.NAMESPACE, namespace, namespaceDescriptor);
-                    }
                     context.getNamespaceDescriptors().put(namespace, namespaceDescriptor);
 
                     WriteThroughScope namespaceScope = new WriteThroughScope(outerScope, namespaceDescriptor.getMemberScope(), new TraceBasedRedeclarationHandler(context.getTrace()));
@@ -202,6 +190,35 @@ public class TypeHierarchyResolver {
         }
     }
 
+    private NamespaceDescriptorImpl createNamespaceDescriptorPathIfNeeded(JetNamespace namespace, NamespaceLike owner) {
+        NamespaceLike currentOwner = owner;
+        for (JetSimpleNameExpression nameExpression : namespace.getHeader().getParentNamespaceNames()) {
+            currentOwner = createNamespaceDescriptorIfNeeded(null, currentOwner, JetPsiUtil.safeName(nameExpression.getReferencedName()));
+            context.getTrace().record(REFERENCE_TARGET, nameExpression, currentOwner);
+        }
+
+        String name = JetPsiUtil.safeName(namespace.getName());
+        return createNamespaceDescriptorIfNeeded(namespace, currentOwner, name);
+    }
+
+    @NotNull
+    private NamespaceDescriptorImpl createNamespaceDescriptorIfNeeded(@Nullable JetNamespace namespace, @NotNull NamespaceLike owner, @NotNull String name) {
+        NamespaceDescriptorImpl namespaceDescriptor = owner.getNamespace(name);
+        if (namespaceDescriptor == null) {
+            namespaceDescriptor = new NamespaceDescriptorImpl(
+                    owner.getOriginal(),
+                    Collections.<AnnotationDescriptor>emptyList(), // TODO: annotations
+                    name
+            );
+            namespaceDescriptor.initialize(new WritableScopeImpl(JetScope.EMPTY, namespaceDescriptor, new TraceBasedRedeclarationHandler(context.getTrace())).setDebugName("Namespace member scope"));
+            owner.addNamespace(namespaceDescriptor);
+            if (namespace != null) {
+                context.getTrace().record(BindingContext.NAMESPACE, namespace, namespaceDescriptor);
+            }
+        }
+        return namespaceDescriptor;
+    }
+
     @NotNull
     private ClassKind getClassKind(@NotNull JetClass jetClass) {
         if (jetClass.isTrait()) return ClassKind.TRAIT;

compiler/testData/checkerWithErrorTypes/quick/regressions/kt691.jet

@@ -0,0 +1,2 @@
+// KT-691 Allow to create nested namespaces with dot delimiter
+namespace foo.bar.buz

compiler/testData/psi/AnnotatedExpressions.txt

@@ -1,5 +1,7 @@
 JetFile: AnnotatedExpressions.jet
   NAMESPACE
+    NAMESPACE_HEADER
+      <empty list>
     FUN
       PsiElement(fun)('fun')
       PsiWhiteSpace(' ')

compiler/testData/psi/AnonymousInitializer.txt

@@ -1,5 +1,7 @@
 JetFile: AnonymousInitializer.jet
   NAMESPACE
+    NAMESPACE_HEADER
+      <empty list>
     CLASS
       PsiElement(class)('class')
       PsiWhiteSpace(' ')

compiler/testData/psi/Attributes.txt

@@ -1,11 +1,13 @@
 JetFile: Attributes.jet
   NAMESPACE
-    PsiElement(namespace)('namespace')
+    NAMESPACE_HEADER
-    PsiWhiteSpace(' ')
+      PsiElement(namespace)('namespace')
-    NAMESPACE_NAME
+      PsiWhiteSpace(' ')
-      PsiElement(IDENTIFIER)('foo')
+      REFERENCE_EXPRESSION
+        PsiElement(IDENTIFIER)('foo')
       PsiElement(DOT)('.')
-      PsiElement(IDENTIFIER)('bar')
+      REFERENCE_EXPRESSION
+        PsiElement(IDENTIFIER)('bar')
       PsiElement(DOT)('.')
       PsiElement(IDENTIFIER)('goo')
     PsiWhiteSpace('\n\n')

compiler/testData/psi/AttributesOnPatterns.txt

@@ -1,5 +1,7 @@
 JetFile: AttributesOnPatterns.jet
   NAMESPACE
+    NAMESPACE_HEADER
+      <empty list>
     FUN
       PsiElement(fun)('fun')
       PsiWhiteSpace(' ')

compiler/testData/psi/Attributes_ERR.txt

@@ -1,11 +1,13 @@
 JetFile: Attributes_ERR.jet
   NAMESPACE
-    PsiElement(namespace)('namespace')
+    NAMESPACE_HEADER
-    PsiWhiteSpace(' ')
+      PsiElement(namespace)('namespace')
-    NAMESPACE_NAME
+      PsiWhiteSpace(' ')
-      PsiElement(IDENTIFIER)('foo')
+      REFERENCE_EXPRESSION
+        PsiElement(IDENTIFIER)('foo')
       PsiElement(DOT)('.')
-      PsiElement(IDENTIFIER)('bar')
+      REFERENCE_EXPRESSION
+        PsiElement(IDENTIFIER)('bar')
       PsiElement(DOT)('.')
       PsiElement(IDENTIFIER)('goo')
     PsiWhiteSpace('\n\n')

compiler/testData/psi/BabySteps.txt

@@ -1,8 +1,8 @@
 JetFile: BabySteps.jet
   NAMESPACE
-    PsiElement(namespace)('namespace')
+    NAMESPACE_HEADER
-    PsiWhiteSpace(' ')
+      PsiElement(namespace)('namespace')
-    NAMESPACE_NAME
+      PsiWhiteSpace(' ')
       PsiElement(IDENTIFIER)('foo')
     PsiWhiteSpace('\n\n')
     CLASS

compiler/testData/psi/BabySteps_ERR.txt

@@ -1,8 +1,8 @@
 JetFile: BabySteps_ERR.jet
   NAMESPACE
-    PsiElement(namespace)('namespace')
+    NAMESPACE_HEADER
-    PsiWhiteSpace(' ')
+      PsiElement(namespace)('namespace')
-    NAMESPACE_NAME
+      PsiWhiteSpace(' ')
       PsiElement(IDENTIFIER)('foo')
     PsiWhiteSpace('\n\n')
     CLASS

compiler/testData/psi/ByCaluses.txt

@@ -1,5 +1,7 @@
 JetFile: ByCaluses.jet
   NAMESPACE
+    NAMESPACE_HEADER
+      <empty list>
     CLASS
       PsiElement(class)('class')
       PsiWhiteSpace(' ')

compiler/testData/psi/CallWithManyClosures.txt

@@ -1,5 +1,7 @@
 JetFile: CallWithManyClosures.jet
   NAMESPACE
+    NAMESPACE_HEADER
+      <empty list>
     PROPERTY
       PsiElement(val)('val')
       PsiWhiteSpace(' ')

compiler/testData/psi/CallsInWhen.txt

@@ -1,5 +1,7 @@
 JetFile: CallsInWhen.jet
   NAMESPACE
+    NAMESPACE_HEADER
+      <empty list>
     FUN
       PsiElement(fun)('fun')
       PsiWhiteSpace(' ')

compiler/testData/psi/Constructors.txt

@@ -1,5 +1,7 @@
 JetFile: Constructors.jet
   NAMESPACE
+    NAMESPACE_HEADER
+      <empty list>
     CLASS
       PsiElement(class)('class')
       PsiWhiteSpace(' ')

compiler/testData/psi/ControlStructures.txt

@@ -1,5 +1,7 @@
 JetFile: ControlStructures.jet
   NAMESPACE
+    NAMESPACE_HEADER
+      <empty list>
     FUN
       PsiElement(fun)('fun')
       PsiWhiteSpace(' ')

compiler/testData/psi/EOLsInComments.txt

@@ -1,5 +1,7 @@
 JetFile: EOLsInComments.jet
   NAMESPACE
+    NAMESPACE_HEADER
+      <empty list>
     FUN
       PsiElement(fun)('fun')
       PsiWhiteSpace(' ')

compiler/testData/psi/EOLsOnRollback.txt

@@ -1,5 +1,7 @@
 JetFile: EOLsOnRollback.jet
   NAMESPACE
+    NAMESPACE_HEADER
+      <empty list>
     FUN
       PsiElement(fun)('fun')
       PsiWhiteSpace(' ')

compiler/testData/psi/EmptyFile.txt

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

compiler/testData/psi/Enums.txt

@@ -1,5 +1,7 @@
 JetFile: Enums.jet
   NAMESPACE
+    NAMESPACE_HEADER
+      <empty list>
     CLASS
       MODIFIER_LIST
         PsiElement(enum)('enum')

compiler/testData/psi/Expressions_ERR.txt

@@ -1,5 +1,7 @@
 JetFile: Expressions_ERR.jet
   NAMESPACE
+    NAMESPACE_HEADER
+      <empty list>
     PROPERTY
       PsiElement(val)('val')
       PsiWhiteSpace(' ')

compiler/testData/psi/FileStart_ERR.txt

@@ -1,12 +1,15 @@
 JetFile: FileStart_ERR.jet
   NAMESPACE
+    NAMESPACE_HEADER
+      <empty list>
     PsiErrorElement:Expecting namespace or top level declaration
       PsiElement(DIV)('/')
     NAMESPACE
-      PsiElement(namespace)('namespace')
+      NAMESPACE_HEADER
-      PsiWhiteSpace(' ')
+        PsiElement(namespace)('namespace')
-      NAMESPACE_NAME
+        PsiWhiteSpace(' ')
-        PsiElement(IDENTIFIER)('foo')
+        REFERENCE_EXPRESSION
+          PsiElement(IDENTIFIER)('foo')
         PsiElement(DOT)('.')
         PsiElement(IDENTIFIER)('bar')
       PsiErrorElement:A namespace block in '{...}' expected

compiler/testData/psi/FunctionCalls.txt

@@ -1,5 +1,7 @@
 JetFile: FunctionCalls.jet
   NAMESPACE
+    NAMESPACE_HEADER
+      <empty list>
     FUN
       PsiElement(fun)('fun')
       PsiWhiteSpace(' ')

compiler/testData/psi/FunctionLiterals.txt

@@ -1,5 +1,7 @@
 JetFile: FunctionLiterals.jet
   NAMESPACE
+    NAMESPACE_HEADER
+      <empty list>
     FUN
       PsiElement(fun)('fun')
       PsiWhiteSpace(' ')

compiler/testData/psi/FunctionLiterals_ERR.txt

@@ -1,5 +1,7 @@
 JetFile: FunctionLiterals_ERR.jet
   NAMESPACE
+    NAMESPACE_HEADER
+      <empty list>
     FUN
       PsiElement(fun)('fun')
       PsiWhiteSpace(' ')

compiler/testData/psi/FunctionTypes.txt

@@ -1,5 +1,7 @@
 JetFile: FunctionTypes.jet
   NAMESPACE
+    NAMESPACE_HEADER
+      <empty list>
     TYPEDEF
       PsiElement(type)('type')
       PsiWhiteSpace(' ')

compiler/testData/psi/FunctionTypes_ERR.txt

@@ -1,5 +1,7 @@
 JetFile: FunctionTypes_ERR.jet
   NAMESPACE
+    NAMESPACE_HEADER
+      <empty list>
     TYPEDEF
       PsiElement(type)('type')
       PsiWhiteSpace(' ')

compiler/testData/psi/Functions.txt

@@ -1,5 +1,7 @@
 JetFile: Functions.jet
   NAMESPACE
+    NAMESPACE_HEADER
+      <empty list>
     FUN
       PsiElement(fun)('fun')
       PsiWhiteSpace(' ')

compiler/testData/psi/Functions_ERR.txt

@@ -1,5 +1,7 @@
 JetFile: Functions_ERR.jet
   NAMESPACE
+    NAMESPACE_HEADER
+      <empty list>
     FUN
       PsiElement(fun)('fun')
       PsiWhiteSpace(' ')

compiler/testData/psi/HangOnLonelyModifier.txt

@@ -1,5 +1,7 @@
 JetFile: HangOnLonelyModifier.jet
   NAMESPACE
+    NAMESPACE_HEADER
+      <empty list>
     FUN
       PsiElement(fun)('fun')
       PsiWhiteSpace(' ')

compiler/testData/psi/IfWithPropery.txt

@@ -1,5 +1,7 @@
 JetFile: IfWithPropery.jet
   NAMESPACE
+    NAMESPACE_HEADER
+      <empty list>
     PROPERTY
       PsiElement(val)('val')
       PsiWhiteSpace(' ')

compiler/testData/psi/ImportSoftKW.txt

@@ -1,5 +1,7 @@
 JetFile: ImportSoftKW.jet
   NAMESPACE
+    NAMESPACE_HEADER
+      <empty list>
     IMPORT_DIRECTIVE
       PsiElement(import)('import')
       PsiWhiteSpace(' ')

compiler/testData/psi/Imports.txt

@@ -1,11 +1,13 @@
 JetFile: Imports.jet
   NAMESPACE
-    PsiElement(namespace)('namespace')
+    NAMESPACE_HEADER
-    PsiWhiteSpace(' ')
+      PsiElement(namespace)('namespace')
-    NAMESPACE_NAME
+      PsiWhiteSpace(' ')
-      PsiElement(IDENTIFIER)('foo')
+      REFERENCE_EXPRESSION
+        PsiElement(IDENTIFIER)('foo')
       PsiElement(DOT)('.')
-      PsiElement(IDENTIFIER)('bar')
+      REFERENCE_EXPRESSION
+        PsiElement(IDENTIFIER)('bar')
       PsiElement(DOT)('.')
       PsiElement(IDENTIFIER)('goo')
     PsiWhiteSpace('\n\n')

compiler/testData/psi/Imports_ERR.txt

@@ -1,11 +1,13 @@
 JetFile: Imports_ERR.jet
   NAMESPACE
-    PsiElement(namespace)('namespace')
+    NAMESPACE_HEADER
-    PsiWhiteSpace(' ')
+      PsiElement(namespace)('namespace')
-    NAMESPACE_NAME
+      PsiWhiteSpace(' ')
-      PsiElement(IDENTIFIER)('foo')
+      REFERENCE_EXPRESSION
+        PsiElement(IDENTIFIER)('foo')
       PsiElement(DOT)('.')
-      PsiElement(IDENTIFIER)('bar')
+      REFERENCE_EXPRESSION
+        PsiElement(IDENTIFIER)('bar')
       PsiElement(DOT)('.')
       PsiElement(IDENTIFIER)('goo')
     PsiWhiteSpace('\n\n')

compiler/testData/psi/Labels.txt

@@ -1,5 +1,7 @@
 JetFile: Labels.jet
   NAMESPACE
+    NAMESPACE_HEADER
+      <empty list>
     FUN
       PsiElement(fun)('fun')
       PsiWhiteSpace(' ')

compiler/testData/psi/LocalDeclarations.txt

@@ -1,5 +1,7 @@
 JetFile: LocalDeclarations.jet
   NAMESPACE
+    NAMESPACE_HEADER
+      <empty list>
     FUN
       PsiElement(fun)('fun')
       PsiWhiteSpace(' ')

compiler/testData/psi/ModifierAsSelector.txt

@@ -2,6 +2,8 @@ JetFile: ModifierAsSelector.jet
   PsiComment(EOL_COMMENT)('// JET-1')
   PsiWhiteSpace('\n\n')
   NAMESPACE
+    NAMESPACE_HEADER
+      <empty list>
     PROPERTY
       PsiElement(val)('val')
       PsiWhiteSpace(' ')

compiler/testData/psi/NamespaceBlock.txt

@@ -1,11 +1,13 @@
 JetFile: NamespaceBlock.jet
   NAMESPACE
-    PsiElement(namespace)('namespace')
+    NAMESPACE_HEADER
-    PsiWhiteSpace(' ')
+      PsiElement(namespace)('namespace')
-    NAMESPACE_NAME
+      PsiWhiteSpace(' ')
-      PsiElement(IDENTIFIER)('foo')
+      REFERENCE_EXPRESSION
+        PsiElement(IDENTIFIER)('foo')
       PsiElement(DOT)('.')
-      PsiElement(IDENTIFIER)('bar')
+      REFERENCE_EXPRESSION
+        PsiElement(IDENTIFIER)('bar')
       PsiElement(DOT)('.')
       PsiElement(IDENTIFIER)('goo')
     PsiWhiteSpace('\n\n')
@@ -20,9 +22,9 @@ JetFile: NamespaceBlock.jet
       PsiElement(IDENTIFIER)('bar')
     PsiWhiteSpace('\n\n')
     NAMESPACE
-      PsiElement(namespace)('namespace')
+      NAMESPACE_HEADER
-      PsiWhiteSpace(' ')
+        PsiElement(namespace)('namespace')
-      NAMESPACE_NAME
+        PsiWhiteSpace(' ')
         PsiElement(IDENTIFIER)('foof')
       PsiWhiteSpace(' ')
       PsiElement(LBRACE)('{')
@@ -53,9 +55,9 @@ JetFile: NamespaceBlock.jet
             PsiElement(RBRACE)('}')
         PsiWhiteSpace('\n\n    ')
         NAMESPACE
-          PsiElement(namespace)('namespace')
+          NAMESPACE_HEADER
-          PsiWhiteSpace(' ')
+            PsiElement(namespace)('namespace')
-          NAMESPACE_NAME
+            PsiWhiteSpace(' ')
             PsiElement(IDENTIFIER)('bar')
           PsiWhiteSpace(' ')
           PsiElement(LBRACE)('{')
@@ -73,9 +75,9 @@ JetFile: NamespaceBlock.jet
                 PsiElement(RBRACE)('}')
             PsiWhiteSpace('\n\n      ')
             NAMESPACE
-              PsiElement(namespace)('namespace')
+              NAMESPACE_HEADER
-              PsiWhiteSpace(' ')
+                PsiElement(namespace)('namespace')
-              NAMESPACE_NAME
+                PsiWhiteSpace(' ')
                 PsiElement(IDENTIFIER)('ns')
               PsiWhiteSpace(' ')
               PsiElement(LBRACE)('{')
@@ -116,9 +118,9 @@ JetFile: NamespaceBlock.jet
         PsiElement(RBRACE)('}')
     PsiWhiteSpace('\n\n')
     NAMESPACE
-      PsiElement(namespace)('namespace')
+      NAMESPACE_HEADER
-      PsiWhiteSpace(' ')
+        PsiElement(namespace)('namespace')
-      NAMESPACE_NAME
+        PsiWhiteSpace(' ')
         PsiElement(IDENTIFIER)('foo')
       PsiWhiteSpace(' ')
       PsiElement(LBRACE)('{')
@@ -127,9 +129,9 @@ JetFile: NamespaceBlock.jet
       PsiElement(RBRACE)('}')
     PsiWhiteSpace('\n\n')
     NAMESPACE
-      PsiElement(namespace)('namespace')
+      NAMESPACE_HEADER
-      PsiWhiteSpace(' ')
+        PsiElement(namespace)('namespace')
-      NAMESPACE_NAME
+        PsiWhiteSpace(' ')
         PsiElement(IDENTIFIER)('bar')
       PsiWhiteSpace(' ')
       PsiElement(LBRACE)('{')

compiler/testData/psi/NamespaceBlockFirst.txt

@@ -1,9 +1,11 @@
 JetFile: NamespaceBlockFirst.jet
   NAMESPACE
+    NAMESPACE_HEADER
+      <empty list>
     NAMESPACE
-      PsiElement(namespace)('namespace')
+      NAMESPACE_HEADER
-      PsiWhiteSpace(' ')
+        PsiElement(namespace)('namespace')
-      NAMESPACE_NAME
+        PsiWhiteSpace(' ')
         PsiElement(IDENTIFIER)('foobar')
       PsiWhiteSpace(' ')
       PsiElement(LBRACE)('{')

compiler/testData/psi/NamespaceBlock_ERR.txt

@@ -1,11 +1,13 @@
 JetFile: NamespaceBlock_ERR.jet
   NAMESPACE
-    PsiElement(namespace)('namespace')
+    NAMESPACE_HEADER
-    PsiWhiteSpace(' ')
+      PsiElement(namespace)('namespace')
-    NAMESPACE_NAME
+      PsiWhiteSpace(' ')
-      PsiElement(IDENTIFIER)('foo')
+      REFERENCE_EXPRESSION
+        PsiElement(IDENTIFIER)('foo')
       PsiElement(DOT)('.')
-      PsiElement(IDENTIFIER)('bar')
+      REFERENCE_EXPRESSION
+        PsiElement(IDENTIFIER)('bar')
       PsiElement(DOT)('.')
       PsiElement(IDENTIFIER)('goo')
     PsiWhiteSpace('\n\n')
@@ -69,9 +71,9 @@ JetFile: NamespaceBlock_ERR.jet
                 REFERENCE_EXPRESSION
                   PsiElement(IDENTIFIER)('bar')
       PsiWhiteSpace('\n\n')
-      PsiElement(namespace)('namespace')
+      NAMESPACE_HEADER
-      PsiWhiteSpace(' ')
+        PsiElement(namespace)('namespace')
-      NAMESPACE_NAME
+        PsiWhiteSpace(' ')
         PsiElement(IDENTIFIER)('foof')
       PsiWhiteSpace(' ')
       PsiElement(LBRACE)('{')
@@ -190,9 +192,9 @@ JetFile: NamespaceBlock_ERR.jet
           PsiElement(SEMICOLON)(';')
         PsiWhiteSpace('\n\n    ')
         NAMESPACE
-          PsiElement(namespace)('namespace')
+          NAMESPACE_HEADER
-          PsiWhiteSpace(' ')
+            PsiElement(namespace)('namespace')
-          NAMESPACE_NAME
+            PsiWhiteSpace(' ')
             PsiElement(IDENTIFIER)('foo')
           PsiErrorElement:A namespace block in '{...}' expected
             <empty list>
@@ -209,9 +211,10 @@ JetFile: NamespaceBlock_ERR.jet
             PsiElement(RBRACE)('}')
         PsiWhiteSpace('\n    ')
         NAMESPACE
-          PsiElement(namespace)('namespace')
+          NAMESPACE_HEADER
-          PsiErrorElement:Expecting namespace name
+            PsiElement(namespace)('namespace')
-            <empty list>
+            PsiErrorElement:Expecting namespace name
+              <empty list>
           PsiWhiteSpace('  ')
           PsiElement(LBRACE)('{')
           PsiWhiteSpace('\n      ')
@@ -228,9 +231,9 @@ JetFile: NamespaceBlock_ERR.jet
                 PsiElement(RBRACE)('}')
             PsiWhiteSpace('\n\n      ')
             NAMESPACE
-              PsiElement(namespace)('namespace')
+              NAMESPACE_HEADER
-              PsiWhiteSpace(' ')
+                PsiElement(namespace)('namespace')
-              NAMESPACE_NAME
+                PsiWhiteSpace(' ')
                 PsiElement(IDENTIFIER)('ns')
               PsiWhiteSpace(' ')
               PsiElement(LBRACE)('{')
@@ -279,17 +282,18 @@ JetFile: NamespaceBlock_ERR.jet
         PsiElement(RBRACE)('}')
     PsiWhiteSpace('\n\n')
     NAMESPACE
-      PsiElement(namespace)('namespace')
+      NAMESPACE_HEADER
-      PsiWhiteSpace(' ')
+        PsiElement(namespace)('namespace')
-      NAMESPACE_NAME
+        PsiWhiteSpace(' ')
         PsiElement(IDENTIFIER)('foo')
       PsiErrorElement:A namespace block in '{...}' expected
         <empty list>
     PsiWhiteSpace('\n\n')
     NAMESPACE
-      PsiElement(namespace)('namespace')
+      NAMESPACE_HEADER
-      PsiErrorElement:Expecting namespace name
+        PsiElement(namespace)('namespace')
-        <empty list>
+        PsiErrorElement:Expecting namespace name
+          <empty list>
       PsiWhiteSpace(' ')
       PsiElement(LBRACE)('{')
       NAMESPACE_BODY
@@ -297,9 +301,9 @@ JetFile: NamespaceBlock_ERR.jet
       PsiElement(RBRACE)('}')
     PsiWhiteSpace('\n\n')
     NAMESPACE
-      PsiElement(namespace)('namespace')
+      NAMESPACE_HEADER
-      PsiWhiteSpace(' ')
+        PsiElement(namespace)('namespace')
-      NAMESPACE_NAME
+        PsiWhiteSpace(' ')
         PsiElement(IDENTIFIER)('bar')
       PsiWhiteSpace(' ')
       PsiElement(LBRACE)('{')

compiler/testData/psi/NamespaceModifiers.txt

@@ -1,23 +1,23 @@
 JetFile: NamespaceModifiers.jet
   NAMESPACE
-    MODIFIER_LIST
+    NAMESPACE_HEADER
-      PsiElement(public)('public')
+      MODIFIER_LIST
+        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)('namespace')
       PsiWhiteSpace(' ')
-      ANNOTATION
-        PsiElement(LBRACKET)('[')
-        ANNOTATION_ENTRY
-          CONSTRUCTOR_CALLEE
-            TYPE_REFERENCE
-              USER_TYPE
-                REFERENCE_EXPRESSION
-                  PsiElement(IDENTIFIER)('a')
-        PsiElement(RBRACKET)(']')
-    PsiWhiteSpace(' ')
-    PsiElement(namespace)('namespace')
-    PsiWhiteSpace(' ')
-    NAMESPACE_NAME
       PsiElement(IDENTIFIER)('name')
-    PsiElement(SEMICOLON)(';')
+      PsiElement(SEMICOLON)(';')
     PsiWhiteSpace('\n\n')
     NAMESPACE
       MODIFIER_LIST
@@ -31,9 +31,9 @@ JetFile: NamespaceModifiers.jet
                     PsiElement(IDENTIFIER)('a')
           PsiElement(RBRACKET)(']')
       PsiWhiteSpace(' ')
-      PsiElement(namespace)('namespace')
+      NAMESPACE_HEADER
-      PsiWhiteSpace(' ')
+        PsiElement(namespace)('namespace')
-      NAMESPACE_NAME
+        PsiWhiteSpace(' ')
         PsiElement(IDENTIFIER)('a')
       PsiWhiteSpace(' ')
       PsiElement(LBRACE)('{')
@@ -48,9 +48,9 @@ JetFile: NamespaceModifiers.jet
           MODIFIER_LIST
             PsiElement(private)('private')
           PsiWhiteSpace(' ')
-          PsiElement(namespace)('namespace')
+          NAMESPACE_HEADER
-          PsiWhiteSpace(' ')
+            PsiElement(namespace)('namespace')
-          NAMESPACE_NAME
+            PsiWhiteSpace(' ')
             PsiElement(IDENTIFIER)('b')
           PsiWhiteSpace(' ')
           PsiElement(LBRACE)('{')

compiler/testData/psi/NewLinesValidOperations.txt

@@ -1,5 +1,7 @@
 JetFile: NewLinesValidOperations.jet
   NAMESPACE
+    NAMESPACE_HEADER
+      <empty list>
     FUN
       PsiElement(fun)('fun')
       PsiWhiteSpace(' ')

compiler/testData/psi/NewlinesInParentheses.txt

@@ -1,5 +1,7 @@
 JetFile: NewlinesInParentheses.jet
   NAMESPACE
+    NAMESPACE_HEADER
+      <empty list>
     FUN
       PsiElement(fun)('fun')
       PsiWhiteSpace(' ')

compiler/testData/psi/NotIsAndNotIn.txt

@@ -1,5 +1,7 @@
 JetFile: NotIsAndNotIn.jet
   NAMESPACE
+    NAMESPACE_HEADER
+      <empty list>
     FUN
       PsiElement(fun)('fun')
       PsiWhiteSpace(' ')

compiler/testData/psi/Precedence.txt

@@ -1,5 +1,7 @@
 JetFile: Precedence.jet
   NAMESPACE
+    NAMESPACE_HEADER
+      <empty list>
     FUN
       PsiElement(fun)('fun')
       PsiWhiteSpace(' ')

compiler/testData/psi/PredicateExpression.txt

@@ -1,5 +1,7 @@
 JetFile: PredicateExpression.jet
   NAMESPACE
+    NAMESPACE_HEADER
+      <empty list>
     FUN
       PsiElement(fun)('fun')
       PsiWhiteSpace(' ')

compiler/testData/psi/PrimaryConstructorModifiers_ERR.txt

@@ -1,5 +1,7 @@
 JetFile: PrimaryConstructorModifiers_ERR.jet
   NAMESPACE
+    NAMESPACE_HEADER
+      <empty list>
     CLASS
       MODIFIER_LIST
         PsiElement(open)('open')

compiler/testData/psi/Properties.txt

@@ -1,5 +1,7 @@
 JetFile: Properties.jet
   NAMESPACE
+    NAMESPACE_HEADER
+      <empty list>
     PROPERTY
       PsiElement(val)('val')
       PsiWhiteSpace(' ')

compiler/testData/psi/PropertiesFollowedByInitializers.txt

@@ -1,5 +1,7 @@
 JetFile: PropertiesFollowedByInitializers.jet
   NAMESPACE
+    NAMESPACE_HEADER
+      <empty list>
     CLASS
       PsiElement(class)('class')
       PsiWhiteSpace(' ')

compiler/testData/psi/Properties_ERR.txt

@@ -1,5 +1,7 @@
 JetFile: Properties_ERR.jet
   NAMESPACE
+    NAMESPACE_HEADER
+      <empty list>
     PROPERTY
       PsiElement(var)('var')
       PsiWhiteSpace(' ')

compiler/testData/psi/QuotedIdentifiers.txt

@@ -1,5 +1,7 @@
 JetFile: QuotedIdentifiers.jet
   NAMESPACE
+    NAMESPACE_HEADER
+      <empty list>
     FUN
       MODIFIER_LIST
         ANNOTATION
@@ -57,4 +59,4 @@ JetFile: QuotedIdentifiers.jet
       PsiWhiteSpace(' ')
       PsiElement(IDENTIFIER)('`1`')
       TYPE_PARAMETER_LIST
-        <empty list>
+        <empty list>

compiler/testData/psi/RootNamespace.txt

@@ -1,12 +1,13 @@
 JetFile: RootNamespace.jet
   NAMESPACE
-    PsiElement(namespace)('namespace')
+    NAMESPACE_HEADER
-    PsiWhiteSpace(' ')
+      PsiElement(namespace)('namespace')
-    NAMESPACE_NAME
+      PsiWhiteSpace(' ')
-      PsiElement(IDENTIFIER)('foo')
+      REFERENCE_EXPRESSION
+        PsiElement(IDENTIFIER)('foo')
       PsiElement(DOT)('.')
       PsiElement(IDENTIFIER)('bar')
-    PsiElement(SEMICOLON)(';')
+      PsiElement(SEMICOLON)(';')
     PsiWhiteSpace('\n\n')
     CLASS
       PsiElement(class)('class')
@@ -16,10 +17,11 @@ JetFile: RootNamespace.jet
       TYPE_PARAMETER_LIST
         <empty list>
     NAMESPACE
-      PsiElement(namespace)('namespace')
+      NAMESPACE_HEADER
-      PsiWhiteSpace(' ')
+        PsiElement(namespace)('namespace')
-      NAMESPACE_NAME
+        PsiWhiteSpace(' ')
-        PsiElement(IDENTIFIER)('foo')
+        REFERENCE_EXPRESSION
+          PsiElement(IDENTIFIER)('foo')
         PsiElement(DOT)('.')
         PsiElement(IDENTIFIER)('bar')
       PsiWhiteSpace(' ')

compiler/testData/psi/SemicolonAfterIf.txt

@@ -1,5 +1,7 @@
 JetFile: SemicolonAfterIf.jet
   NAMESPACE
+    NAMESPACE_HEADER
+      <empty list>
     FUN
       PsiElement(fun)('fun')
       PsiWhiteSpace(' ')

compiler/testData/psi/ShortAnnotations.txt

@@ -1,57 +1,57 @@
 JetFile: ShortAnnotations.jet
   NAMESPACE
-    MODIFIER_LIST
+    NAMESPACE_HEADER
-      ANNOTATION_ENTRY
+      MODIFIER_LIST
-        CONSTRUCTOR_CALLEE
+        ANNOTATION_ENTRY
-          TYPE_REFERENCE
+          CONSTRUCTOR_CALLEE
-            USER_TYPE
+            TYPE_REFERENCE
-              REFERENCE_EXPRESSION
+              USER_TYPE
-                PsiElement(IDENTIFIER)('foo')
+                REFERENCE_EXPRESSION
+                  PsiElement(IDENTIFIER)('foo')
+        PsiWhiteSpace(' ')
+        ANNOTATION_ENTRY
+          CONSTRUCTOR_CALLEE
+            TYPE_REFERENCE
+              USER_TYPE
+                REFERENCE_EXPRESSION
+                  PsiElement(IDENTIFIER)('bar')
+          VALUE_ARGUMENT_LIST
+            PsiElement(LPAR)('(')
+            VALUE_ARGUMENT
+              INTEGER_CONSTANT
+                PsiElement(INTEGER_LITERAL)('1')
+            PsiElement(RPAR)(')')
+        PsiWhiteSpace(' ')
+        ANNOTATION_ENTRY
+          CONSTRUCTOR_CALLEE
+            TYPE_REFERENCE
+              USER_TYPE
+                REFERENCE_EXPRESSION
+                  PsiElement(IDENTIFIER)('buzz')
+                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
+              INTEGER_CONSTANT
+                PsiElement(INTEGER_LITERAL)('1')
+            PsiElement(RPAR)(')')
+        PsiWhiteSpace(' ')
+        ANNOTATION_ENTRY
+          CONSTRUCTOR_CALLEE
+            TYPE_REFERENCE
+              USER_TYPE
+                REFERENCE_EXPRESSION
+                  PsiElement(IDENTIFIER)('zoo')
       PsiWhiteSpace(' ')
-      ANNOTATION_ENTRY
+      PsiElement(namespace)('namespace')
-        CONSTRUCTOR_CALLEE
-          TYPE_REFERENCE
-            USER_TYPE
-              REFERENCE_EXPRESSION
-                PsiElement(IDENTIFIER)('bar')
-        VALUE_ARGUMENT_LIST
-          PsiElement(LPAR)('(')
-          VALUE_ARGUMENT
-            INTEGER_CONSTANT
-              PsiElement(INTEGER_LITERAL)('1')
-          PsiElement(RPAR)(')')
       PsiWhiteSpace(' ')
-      ANNOTATION_ENTRY
-        CONSTRUCTOR_CALLEE
-          TYPE_REFERENCE
-            USER_TYPE
-              REFERENCE_EXPRESSION
-                PsiElement(IDENTIFIER)('buzz')
-              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
-            INTEGER_CONSTANT
-              PsiElement(INTEGER_LITERAL)('1')
-          PsiElement(RPAR)(')')
-      PsiWhiteSpace(' ')
-      ANNOTATION_ENTRY
-        CONSTRUCTOR_CALLEE
-          TYPE_REFERENCE
-            USER_TYPE
-              REFERENCE_EXPRESSION
-                PsiElement(IDENTIFIER)('zoo')
-    PsiWhiteSpace(' ')
-    PsiElement(namespace)('namespace')
-    PsiWhiteSpace(' ')
-    NAMESPACE_NAME
       PsiElement(IDENTIFIER)('aa')
     PsiWhiteSpace('\n\n')
     NAMESPACE
@@ -104,9 +104,9 @@ JetFile: ShortAnnotations.jet
                 REFERENCE_EXPRESSION
                   PsiElement(IDENTIFIER)('zoo')
       PsiWhiteSpace(' ')
-      PsiElement(namespace)('namespace')
+      NAMESPACE_HEADER
-      PsiWhiteSpace(' ')
+        PsiElement(namespace)('namespace')
-      NAMESPACE_NAME
+        PsiWhiteSpace(' ')
         PsiElement(IDENTIFIER)('a')
       PsiWhiteSpace(' ')
       PsiElement(LBRACE)('{')

compiler/testData/psi/SimpleClassMembers.txt

@@ -1,5 +1,7 @@
 JetFile: SimpleClassMembers.jet
   NAMESPACE
+    NAMESPACE_HEADER
+      <empty list>
     CLASS
       PsiElement(class)('class')
       PsiWhiteSpace(' ')

compiler/testData/psi/SimpleClassMembers_ERR.txt

@@ -1,5 +1,7 @@
 JetFile: SimpleClassMembers_ERR.jet
   NAMESPACE
+    NAMESPACE_HEADER
+      <empty list>
     CLASS
       PsiElement(class)('class')
       PsiWhiteSpace(' ')

compiler/testData/psi/SimpleExpressions.txt

@@ -1,5 +1,7 @@
 JetFile: SimpleExpressions.jet
   NAMESPACE
+    NAMESPACE_HEADER
+      <empty list>
     FUN
       PsiElement(fun)('fun')
       PsiWhiteSpace(' ')

compiler/testData/psi/SimpleModifiers.txt

@@ -1,11 +1,13 @@
 JetFile: SimpleModifiers.jet
   NAMESPACE
-    PsiElement(namespace)('namespace')
+    NAMESPACE_HEADER
-    PsiWhiteSpace(' ')
+      PsiElement(namespace)('namespace')
-    NAMESPACE_NAME
+      PsiWhiteSpace(' ')
-      PsiElement(IDENTIFIER)('foo')
+      REFERENCE_EXPRESSION
+        PsiElement(IDENTIFIER)('foo')
       PsiElement(DOT)('.')
-      PsiElement(IDENTIFIER)('bar')
+      REFERENCE_EXPRESSION
+        PsiElement(IDENTIFIER)('bar')
       PsiElement(DOT)('.')
       PsiElement(IDENTIFIER)('goo')
     PsiWhiteSpace('\n\n')

compiler/testData/psi/SoftKeywords.txt

@@ -1,11 +1,13 @@
 JetFile: SoftKeywords.jet
   NAMESPACE
-    PsiElement(namespace)('namespace')
+    NAMESPACE_HEADER
-    PsiWhiteSpace(' ')
+      PsiElement(namespace)('namespace')
-    NAMESPACE_NAME
+      PsiWhiteSpace(' ')
-      PsiElement(IDENTIFIER)('foo')
+      REFERENCE_EXPRESSION
+        PsiElement(IDENTIFIER)('foo')
       PsiElement(DOT)('.')
-      PsiElement(IDENTIFIER)('bar')
+      REFERENCE_EXPRESSION
+        PsiElement(IDENTIFIER)('bar')
       PsiElement(DOT)('.')
       PsiElement(IDENTIFIER)('goo')
     PsiWhiteSpace('\n\n')

compiler/testData/psi/SoftKeywordsInTypeArguments.txt

@@ -1,5 +1,7 @@
 JetFile: SoftKeywordsInTypeArguments.jet
   NAMESPACE
+    NAMESPACE_HEADER
+      <empty list>
     CLASS
       PsiElement(class)('class')
       PsiWhiteSpace(' ')

compiler/testData/psi/StringTemplates.txt

@@ -1,5 +1,7 @@
 JetFile: StringTemplates.jet
   NAMESPACE
+    NAMESPACE_HEADER
+      <empty list>
     FUN
       PsiElement(fun)('fun')
       PsiWhiteSpace(' ')

compiler/testData/psi/Super.txt

@@ -2,6 +2,8 @@ JetFile: Super.jet
   PsiComment(EOL_COMMENT)('// KT-156 Fix the this<Super> syntax')
   PsiWhiteSpace('\n')
   NAMESPACE
+    NAMESPACE_HEADER
+      <empty list>
     FUN
       PsiElement(fun)('fun')
       PsiWhiteSpace(' ')

compiler/testData/psi/ThisType.txt

@@ -1,5 +1,7 @@
 JetFile: ThisType.jet
   NAMESPACE
+    NAMESPACE_HEADER
+      <empty list>
     CLASS
       PsiElement(class)('class')
       PsiWhiteSpace(' ')

compiler/testData/psi/TupleTypes.txt

@@ -1,5 +1,7 @@
 JetFile: TupleTypes.jet
   NAMESPACE
+    NAMESPACE_HEADER
+      <empty list>
     CLASS
       PsiElement(class)('class')
       PsiWhiteSpace(' ')

compiler/testData/psi/TupleTypes_ERR.txt

@@ -1,5 +1,7 @@
 JetFile: TupleTypes_ERR.jet
   NAMESPACE
+    NAMESPACE_HEADER
+      <empty list>
     CLASS
       PsiElement(class)('class')
       PsiWhiteSpace(' ')

compiler/testData/psi/TuplesWithLabeledEntries.txt

@@ -1,5 +1,7 @@
 JetFile: TuplesWithLabeledEntries.jet
   NAMESPACE
+    NAMESPACE_HEADER
+      <empty list>
     PROPERTY
       PsiElement(val)('val')
       PsiWhiteSpace(' ')

compiler/testData/psi/TypeAnnotations.txt

@@ -1,5 +1,7 @@
 JetFile: TypeAnnotations.jet
   NAMESPACE
+    NAMESPACE_HEADER
+      <empty list>
     CLASS
       PsiElement(class)('class')
       PsiWhiteSpace(' ')

compiler/testData/psi/TypeConstraints.txt

@@ -1,5 +1,7 @@
 JetFile: TypeConstraints.jet
   NAMESPACE
+    NAMESPACE_HEADER
+      <empty list>
     CLASS
       PsiElement(class)('class')
       PsiWhiteSpace(' ')

compiler/testData/psi/TypeDef.txt

@@ -1,11 +1,13 @@
 JetFile: TypeDef.jet
   NAMESPACE
-    PsiElement(namespace)('namespace')
+    NAMESPACE_HEADER
-    PsiWhiteSpace(' ')
+      PsiElement(namespace)('namespace')
-    NAMESPACE_NAME
+      PsiWhiteSpace(' ')
-      PsiElement(IDENTIFIER)('foo')
+      REFERENCE_EXPRESSION
+        PsiElement(IDENTIFIER)('foo')
       PsiElement(DOT)('.')
-      PsiElement(IDENTIFIER)('bar')
+      REFERENCE_EXPRESSION
+        PsiElement(IDENTIFIER)('bar')
       PsiElement(DOT)('.')
       PsiElement(IDENTIFIER)('goo')
     PsiWhiteSpace('\n\n')

compiler/testData/psi/TypeDef_ERR.txt

@@ -1,5 +1,7 @@
 JetFile: TypeDef_ERR.jet
   NAMESPACE
+    NAMESPACE_HEADER
+      <empty list>
     TYPEDEF
       PsiElement(type)('type')
       PsiErrorElement:Type name expected

compiler/testData/psi/TypeExpressionAmbiguities_ERR.txt

@@ -1,5 +1,7 @@
 JetFile: TypeExpressionAmbiguities_ERR.jet
   NAMESPACE
+    NAMESPACE_HEADER
+      <empty list>
     FUN
       PsiElement(fun)('fun')
       PsiWhiteSpace(' ')

compiler/testData/psi/TypeParametersBeforeName.txt

@@ -1,5 +1,7 @@
 JetFile: TypeParametersBeforeName.jet
   NAMESPACE
+    NAMESPACE_HEADER
+      <empty list>
     FUN
       PsiElement(fun)('fun')
       PsiWhiteSpace(' ')

compiler/testData/psi/When.txt

@@ -1,5 +1,7 @@
 JetFile: When.jet
   NAMESPACE
+    NAMESPACE_HEADER
+      <empty list>
     FUN
       PsiElement(fun)('fun')
       PsiWhiteSpace(' ')

compiler/testData/psi/When_ERR.txt

@@ -1,5 +1,7 @@
 JetFile: When_ERR.jet
   NAMESPACE
+    NAMESPACE_HEADER
+      <empty list>
     FUN
       PsiElement(fun)('fun')
       PsiWhiteSpace(' ')

compiler/testData/psi/examples/AnonymousObjects.txt

@@ -1,5 +1,7 @@
 JetFile: AnonymousObjects.jet
   NAMESPACE
+    NAMESPACE_HEADER
+      <empty list>
     FUN
       PsiElement(fun)('fun')
       PsiWhiteSpace(' ')

compiler/testData/psi/examples/BinaryTree.txt

@@ -1,5 +1,7 @@
 JetFile: BinaryTree.jet
   NAMESPACE
+    NAMESPACE_HEADER
+      <empty list>
     CLASS
       PsiElement(class)('class')
       PsiWhiteSpace(' ')

compiler/testData/psi/examples/BitArith.txt

@@ -1,5 +1,7 @@
 JetFile: BitArith.jet
   NAMESPACE
+    NAMESPACE_HEADER
+      <empty list>
     FUN
       PsiElement(fun)('fun')
       PsiWhiteSpace(' ')

compiler/testData/psi/examples/Builder.txt

@@ -1,5 +1,7 @@
 JetFile: Builder.jet
   NAMESPACE
+    NAMESPACE_HEADER
+      <empty list>
     PROPERTY
       PsiElement(val)('val')
       PsiWhiteSpace(' ')

compiler/testData/psi/examples/Color.txt

@@ -1,5 +1,7 @@
 JetFile: Color.jet
   NAMESPACE
+    NAMESPACE_HEADER
+      <empty list>
     CLASS
       MODIFIER_LIST
         PsiElement(enum)('enum')

compiler/testData/psi/examples/FunctionsAndTypes.txt

@@ -1,5 +1,7 @@
 JetFile: FunctionsAndTypes.jet
   NAMESPACE
+    NAMESPACE_HEADER
+      <empty list>
     TYPEDEF
       PsiElement(type)('type')
       PsiWhiteSpace(' ')

compiler/testData/psi/examples/Graph.txt

@@ -1,5 +1,7 @@
 JetFile: Graph.jet
   NAMESPACE
+    NAMESPACE_HEADER
+      <empty list>
     CLASS
       PsiElement(class)('class')
       PsiWhiteSpace(' ')

compiler/testData/psi/examples/IPushPop.txt

@@ -1,5 +1,7 @@
 JetFile: IPushPop.jet
   NAMESPACE
+    NAMESPACE_HEADER
+      <empty list>
     CLASS
       MODIFIER_LIST
         PsiElement(open)('open')

compiler/testData/psi/examples/LINQ.txt

@@ -1,5 +1,7 @@
 JetFile: LINQ.jet
   NAMESPACE
+    NAMESPACE_HEADER
+      <empty list>
     FUN
       PsiElement(fun)('fun')
       PsiWhiteSpace(' ')

compiler/testData/psi/examples/PolymorphicClassObjects.txt

@@ -1,5 +1,7 @@
 JetFile: PolymorphicClassObjects.jet
   NAMESPACE
+    NAMESPACE_HEADER
+      <empty list>
     CLASS
       MODIFIER_LIST
         PsiElement(open)('open')

compiler/testData/psi/examples/Queue.txt

@@ -1,5 +1,7 @@
 JetFile: Queue.jet
   NAMESPACE
+    NAMESPACE_HEADER
+      <empty list>
     CLASS
       PsiElement(class)('class')
       PsiWhiteSpace(' ')

compiler/testData/psi/examples/Stack.txt

@@ -1,5 +1,7 @@
 JetFile: Stack.jet
   NAMESPACE
+    NAMESPACE_HEADER
+      <empty list>
     CLASS
       PsiElement(class)('class')
       PsiWhiteSpace(' ')

compiler/testData/psi/examples/UnionFind.txt

@@ -1,5 +1,7 @@
 JetFile: UnionFind.jet
   NAMESPACE
+    NAMESPACE_HEADER
+      <empty list>
     CLASS
       PsiElement(class)('class')
       PsiWhiteSpace(' ')

compiler/testData/psi/examples/UpdateOperation.txt

@@ -1,5 +1,7 @@
 JetFile: UpdateOperation.jet
   NAMESPACE
+    NAMESPACE_HEADER
+      <empty list>
     CLASS
       PsiElement(class)('class')
       PsiWhiteSpace(' ')

compiler/testData/psi/examples/With.txt

@@ -1,5 +1,7 @@
 JetFile: With.jet
   NAMESPACE
+    NAMESPACE_HEADER
+      <empty list>
     FUN
       MODIFIER_LIST
         ANNOTATION

compiler/testData/psi/examples/array/MutableArray.txt

@@ -2,6 +2,8 @@ JetFile: MutableArray.jet
   PsiComment(DOC_COMMENT)('/**\n  These declarations are "shallow" in the sense that they are not really compiled, only the type-checker uses them\n*/')
   PsiWhiteSpace('\n\n')
   NAMESPACE
+    NAMESPACE_HEADER
+      <empty list>
     CLASS
       MODIFIER_LIST
         PsiElement(open)('open')

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

@@ -1,5 +1,7 @@
 JetFile: ArrayList.jet
   NAMESPACE
+    NAMESPACE_HEADER
+      <empty list>
     CLASS
       PsiElement(class)('class')
       PsiWhiteSpace(' ')

compiler/testData/psi/examples/collections/HashMap.txt

@@ -1,5 +1,7 @@
 JetFile: HashMap.jet
   NAMESPACE
+    NAMESPACE_HEADER
+      <empty list>
     CLASS
       MODIFIER_LIST
         PsiElement(open)('open')

compiler/testData/psi/examples/collections/IIterable.txt

@@ -1,5 +1,7 @@
 JetFile: IIterable.jet
   NAMESPACE
+    NAMESPACE_HEADER
+      <empty list>
     CLASS
       MODIFIER_LIST
         PsiElement(open)('open')

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

@@ -1,5 +1,7 @@
 JetFile: IIterator.jet
   NAMESPACE
+    NAMESPACE_HEADER
+      <empty list>
     CLASS
       MODIFIER_LIST
         PsiElement(open)('open')

compiler/testData/psi/examples/collections/IList.txt

@@ -1,5 +1,7 @@
 JetFile: IList.jet
   NAMESPACE
+    NAMESPACE_HEADER
+      <empty list>
     CLASS
       MODIFIER_LIST
         PsiElement(open)('open')

compiler/testData/psi/examples/collections/IMutableIterable.txt

@@ -1,5 +1,7 @@
 JetFile: IMutableIterable.jet
   NAMESPACE
+    NAMESPACE_HEADER
+      <empty list>
     CLASS
       MODIFIER_LIST
         PsiElement(open)('open')