JetNamespace eliminated

.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>

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

@@ -753,11 +753,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

@@ -8,21 +8,18 @@ import com.intellij.openapi.util.text.StringUtil;
 import com.intellij.util.Function;
 import com.intellij.util.Processor;
 import jet.ExtensionFunction0;
-import jet.ExtensionFunction10;
-import jet.Function1;
 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;
 
 import java.io.*;
 import java.lang.reflect.Field;
-import java.lang.reflect.Method;
 import java.net.URL;
 import java.net.URLClassLoader;
 import java.util.Arrays;
@@ -337,9 +334,9 @@ public class CompileEnvironment {
         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;
             }
         }

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

@@ -10,7 +10,6 @@ import org.jetbrains.jet.codegen.ClassFileFactory;
 import org.jetbrains.jet.codegen.GenerationState;
 import org.jetbrains.jet.lang.cfg.pseudocode.JetControlFlowDataTraceFactory;
 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;
@@ -27,8 +26,8 @@ import java.util.List;
  */
 public class CompileSession {
     private final JetCoreEnvironment myEnvironment;
-    private final List<JetNamespace> mySourceFileNamespaces = new ArrayList<JetNamespace>();
+    private final List<JetFile> mySourceFiles = new ArrayList<JetFile>();
-    private final List<JetNamespace> myLibrarySourceFileNamespaces = new ArrayList<JetNamespace>();
+    private final List<JetFile> myLibrarySourceFiles = new ArrayList<JetFile>();
     private List<String> myErrors = new ArrayList<String>();
     private BindingContext myBindingContext;
 
@@ -63,7 +62,7 @@ public class CompileSession {
             VirtualFile fileByPath = myEnvironment.getLocalFileSystem().findFileByPath(file.getAbsolutePath());
             PsiFile psiFile = PsiManager.getInstance(myEnvironment.getProject()).findFile(fileByPath);
             if(psiFile instanceof JetFile) {
-                mySourceFileNamespaces.add(((JetFile) psiFile).getRootNamespace());
+                mySourceFiles.add((JetFile) psiFile);
             }
         }
     }
@@ -78,14 +77,14 @@ public class CompileSession {
             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 List<JetNamespace> getSourceFileNamespaces() {
+    public List<JetFile> getSourceFileNamespaces() {
-        return mySourceFileNamespaces;
+        return mySourceFiles;
     }
 
     public boolean analyze(final PrintStream out) {
@@ -95,9 +94,9 @@ public class CompileSession {
             }
             return false;
         }
-        List<JetNamespace> allNamespaces = new ArrayList<JetNamespace>(mySourceFileNamespaces);
+        List<JetFile> allNamespaces = new ArrayList<JetFile>(mySourceFiles);
-        allNamespaces.addAll(myLibrarySourceFileNamespaces);
+        allNamespaces.addAll(myLibrarySourceFiles);
-        myBindingContext = AnalyzerFacade.analyzeNamespacesWithJavaIntegration(
+        myBindingContext = AnalyzerFacade.analyzeFilesWithJavaIntegration(
                 myEnvironment.getProject(), allNamespaces, Predicates.<PsiFile>alwaysTrue(), JetControlFlowDataTraceFactory.EMPTY);
         ErrorCollector errorCollector = new ErrorCollector(myBindingContext);
         errorCollector.report(out);
@@ -106,13 +105,13 @@ public class CompileSession {
 
     public ClassFileFactory generate() {
         GenerationState generationState = new GenerationState(myEnvironment.getProject(), ClassBuilderFactory.BINARIES);
-        generationState.compileCorrectNamespaces(myBindingContext, mySourceFileNamespaces);
+        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();
     }
 

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/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
  */

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/psi/AnnotatedExpressions.txt

@@ -1,5 +1,4 @@
 JetFile: AnnotatedExpressions.jet
-  NAMESPACE
   NAMESPACE_HEADER
     <empty list>
   FUN

compiler/testData/psi/AnonymousInitializer.txt

@@ -1,5 +1,4 @@
 JetFile: AnonymousInitializer.jet
-  NAMESPACE
   NAMESPACE_HEADER
     <empty list>
   CLASS

compiler/testData/psi/Attributes.txt

@@ -1,5 +1,4 @@
 JetFile: Attributes.jet
-  NAMESPACE
   NAMESPACE_HEADER
     PsiElement(namespace)('package')
     PsiWhiteSpace(' ')

compiler/testData/psi/AttributesOnPatterns.txt

@@ -1,5 +1,4 @@
 JetFile: AttributesOnPatterns.jet
-  NAMESPACE
   NAMESPACE_HEADER
     <empty list>
   FUN

compiler/testData/psi/Attributes_ERR.txt

@@ -1,5 +1,4 @@
 JetFile: Attributes_ERR.jet
-  NAMESPACE
   NAMESPACE_HEADER
     PsiElement(namespace)('package')
     PsiWhiteSpace(' ')

compiler/testData/psi/BabySteps.txt

@@ -1,5 +1,4 @@
 JetFile: BabySteps.jet
-  NAMESPACE
   NAMESPACE_HEADER
     PsiElement(namespace)('package')
     PsiWhiteSpace(' ')

compiler/testData/psi/BabySteps_ERR.txt

@@ -1,5 +1,4 @@
 JetFile: BabySteps_ERR.jet
-  NAMESPACE
   NAMESPACE_HEADER
     PsiElement(namespace)('package')
     PsiWhiteSpace(' ')

compiler/testData/psi/ByCaluses.txt

@@ -1,5 +1,4 @@
 JetFile: ByCaluses.jet
-  NAMESPACE
   NAMESPACE_HEADER
     <empty list>
   CLASS

compiler/testData/psi/CallWithManyClosures.txt

@@ -1,5 +1,4 @@
 JetFile: CallWithManyClosures.jet
-  NAMESPACE
   NAMESPACE_HEADER
     <empty list>
   PROPERTY

compiler/testData/psi/CallsInWhen.txt

@@ -1,5 +1,4 @@
 JetFile: CallsInWhen.jet
-  NAMESPACE
   NAMESPACE_HEADER
     <empty list>
   FUN

compiler/testData/psi/Constructors.txt

@@ -1,5 +1,4 @@
 JetFile: Constructors.jet
-  NAMESPACE
   NAMESPACE_HEADER
     <empty list>
   CLASS

compiler/testData/psi/ControlStructures.txt

@@ -1,5 +1,4 @@
 JetFile: ControlStructures.jet
-  NAMESPACE
   NAMESPACE_HEADER
     <empty list>
   FUN

compiler/testData/psi/EOLsInComments.txt

@@ -1,5 +1,4 @@
 JetFile: EOLsInComments.jet
-  NAMESPACE
   NAMESPACE_HEADER
     <empty list>
   FUN

compiler/testData/psi/EOLsOnRollback.txt

@@ -1,5 +1,4 @@
 JetFile: EOLsOnRollback.jet
-  NAMESPACE
   NAMESPACE_HEADER
     <empty list>
   FUN

compiler/testData/psi/EmptyFile.txt

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

compiler/testData/psi/Enums.txt

@@ -1,5 +1,4 @@
 JetFile: Enums.jet
-  NAMESPACE
   NAMESPACE_HEADER
     <empty list>
   CLASS

compiler/testData/psi/Expressions_ERR.txt

@@ -1,5 +1,4 @@
 JetFile: Expressions_ERR.jet
-  NAMESPACE
   NAMESPACE_HEADER
     <empty list>
   PROPERTY

compiler/testData/psi/ExtensionsWithQNReceiver.txt

@@ -1,5 +1,4 @@
 JetFile: ExtensionsWithQNReceiver.jet
-  NAMESPACE
   NAMESPACE_HEADER
     <empty list>
   PROPERTY

compiler/testData/psi/FileStart_ERR.txt

@@ -1,5 +1,4 @@
 JetFile: FileStart_ERR.jet
-  NAMESPACE
   NAMESPACE_HEADER
     <empty list>
   PsiErrorElement:Expecting namespace or top level declaration

compiler/testData/psi/FunctionCalls.txt

@@ -1,5 +1,4 @@
 JetFile: FunctionCalls.jet
-  NAMESPACE
   NAMESPACE_HEADER
     <empty list>
   FUN

compiler/testData/psi/FunctionLiterals.txt

@@ -1,5 +1,4 @@
 JetFile: FunctionLiterals.jet
-  NAMESPACE
   NAMESPACE_HEADER
     <empty list>
   FUN

compiler/testData/psi/FunctionLiterals_ERR.txt

@@ -1,5 +1,4 @@
 JetFile: FunctionLiterals_ERR.jet
-  NAMESPACE
   NAMESPACE_HEADER
     <empty list>
   FUN

compiler/testData/psi/FunctionTypes.txt

@@ -1,5 +1,4 @@
 JetFile: FunctionTypes.jet
-  NAMESPACE
   NAMESPACE_HEADER
     <empty list>
   TYPEDEF

compiler/testData/psi/FunctionTypes_ERR.txt

@@ -1,5 +1,4 @@
 JetFile: FunctionTypes_ERR.jet
-  NAMESPACE
   NAMESPACE_HEADER
     <empty list>
   TYPEDEF

compiler/testData/psi/Functions.txt

@@ -1,5 +1,4 @@
 JetFile: Functions.jet
-  NAMESPACE
   NAMESPACE_HEADER
     <empty list>
   FUN

compiler/testData/psi/Functions_ERR.txt

@@ -1,5 +1,4 @@
 JetFile: Functions_ERR.jet
-  NAMESPACE
   NAMESPACE_HEADER
     <empty list>
   FUN

compiler/testData/psi/HangOnLonelyModifier.txt

@@ -1,5 +1,4 @@
 JetFile: HangOnLonelyModifier.jet
-  NAMESPACE
   NAMESPACE_HEADER
     <empty list>
   FUN

compiler/testData/psi/IfWithPropery.txt

@@ -1,5 +1,4 @@
 JetFile: IfWithPropery.jet
-  NAMESPACE
   NAMESPACE_HEADER
     <empty list>
   PROPERTY

compiler/testData/psi/ImportSoftKW.txt

@@ -1,5 +1,4 @@
 JetFile: ImportSoftKW.jet
-  NAMESPACE
   NAMESPACE_HEADER
     <empty list>
   IMPORT_DIRECTIVE

compiler/testData/psi/Imports.txt

@@ -1,5 +1,4 @@
 JetFile: Imports.jet
-  NAMESPACE
   NAMESPACE_HEADER
     PsiElement(namespace)('package')
     PsiWhiteSpace(' ')

compiler/testData/psi/Imports_ERR.txt

@@ -1,5 +1,4 @@
 JetFile: Imports_ERR.jet
-  NAMESPACE
   NAMESPACE_HEADER
     PsiElement(namespace)('package')
     PsiWhiteSpace(' ')

compiler/testData/psi/Labels.txt

@@ -1,5 +1,4 @@
 JetFile: Labels.jet
-  NAMESPACE
   NAMESPACE_HEADER
     <empty list>
   FUN

compiler/testData/psi/LocalDeclarations.txt

@@ -1,5 +1,4 @@
 JetFile: LocalDeclarations.jet
-  NAMESPACE
   NAMESPACE_HEADER
     <empty list>
   FUN

compiler/testData/psi/ModifierAsSelector.txt

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

compiler/testData/psi/NamespaceBlockFirst.txt

@@ -1,5 +1,4 @@
 JetFile: NamespaceBlockFirst.jet
-  NAMESPACE
   NAMESPACE_HEADER
     <empty list>
   PsiErrorElement:Expecting namespace or top level declaration

compiler/testData/psi/NamespaceModifiers.txt

@@ -1,5 +1,4 @@
 JetFile: NamespaceModifiers.jet
-  NAMESPACE
   NAMESPACE_HEADER
     MODIFIER_LIST
       PsiElement(public)('public')

compiler/testData/psi/NewLinesValidOperations.txt

@@ -1,5 +1,4 @@
 JetFile: NewLinesValidOperations.jet
-  NAMESPACE
   NAMESPACE_HEADER
     <empty list>
   FUN

compiler/testData/psi/NewlinesInParentheses.txt

@@ -1,5 +1,4 @@
 JetFile: NewlinesInParentheses.jet
-  NAMESPACE
   NAMESPACE_HEADER
     <empty list>
   FUN

compiler/testData/psi/NotIsAndNotIn.txt

@@ -1,5 +1,4 @@
 JetFile: NotIsAndNotIn.jet
-  NAMESPACE
   NAMESPACE_HEADER
     <empty list>
   FUN

compiler/testData/psi/Precedence.txt

@@ -1,5 +1,4 @@
 JetFile: Precedence.jet
-  NAMESPACE
   NAMESPACE_HEADER
     <empty list>
   FUN

compiler/testData/psi/PredicateExpression.txt

@@ -1,5 +1,4 @@
 JetFile: PredicateExpression.jet
-  NAMESPACE
   NAMESPACE_HEADER
     <empty list>
   FUN

compiler/testData/psi/PrimaryConstructorModifiers_ERR.txt

@@ -1,5 +1,4 @@
 JetFile: PrimaryConstructorModifiers_ERR.jet
-  NAMESPACE
   NAMESPACE_HEADER
     <empty list>
   CLASS

compiler/testData/psi/Properties.txt

@@ -1,5 +1,4 @@
 JetFile: Properties.jet
-  NAMESPACE
   NAMESPACE_HEADER
     <empty list>
   PROPERTY

compiler/testData/psi/PropertiesFollowedByInitializers.txt

@@ -1,5 +1,4 @@
 JetFile: PropertiesFollowedByInitializers.jet
-  NAMESPACE
   NAMESPACE_HEADER
     <empty list>
   CLASS

compiler/testData/psi/Properties_ERR.txt

@@ -1,5 +1,4 @@
 JetFile: Properties_ERR.jet
-  NAMESPACE
   NAMESPACE_HEADER
     <empty list>
   PROPERTY

compiler/testData/psi/QuotedIdentifiers.txt

@@ -1,5 +1,4 @@
 JetFile: QuotedIdentifiers.jet
-  NAMESPACE
   NAMESPACE_HEADER
     <empty list>
   FUN

compiler/testData/psi/RootNamespace.txt

@@ -1,5 +1,4 @@
 JetFile: RootNamespace.jet
-  NAMESPACE
   NAMESPACE_HEADER
     PsiElement(namespace)('package')
     PsiWhiteSpace(' ')

compiler/testData/psi/SemicolonAfterIf.txt

@@ -1,5 +1,4 @@
 JetFile: SemicolonAfterIf.jet
-  NAMESPACE
   NAMESPACE_HEADER
     <empty list>
   FUN

compiler/testData/psi/ShortAnnotations.txt

@@ -1,5 +1,4 @@
 JetFile: ShortAnnotations.jet
-  NAMESPACE
   NAMESPACE_HEADER
     MODIFIER_LIST
       ANNOTATION_ENTRY

compiler/testData/psi/SimpleClassMembers.txt

@@ -1,5 +1,4 @@
 JetFile: SimpleClassMembers.jet
-  NAMESPACE
   NAMESPACE_HEADER
     <empty list>
   CLASS

compiler/testData/psi/SimpleClassMembers_ERR.txt

@@ -1,5 +1,4 @@
 JetFile: SimpleClassMembers_ERR.jet
-  NAMESPACE
   NAMESPACE_HEADER
     <empty list>
   CLASS

compiler/testData/psi/SimpleExpressions.txt

@@ -1,5 +1,4 @@
 JetFile: SimpleExpressions.jet
-  NAMESPACE
   NAMESPACE_HEADER
     <empty list>
   FUN

compiler/testData/psi/SimpleModifiers.txt

@@ -1,5 +1,4 @@
 JetFile: SimpleModifiers.jet
-  NAMESPACE
   NAMESPACE_HEADER
     PsiElement(namespace)('package')
     PsiWhiteSpace(' ')

compiler/testData/psi/SoftKeywords.txt

@@ -1,5 +1,4 @@
 JetFile: SoftKeywords.jet
-  NAMESPACE
   NAMESPACE_HEADER
     PsiElement(namespace)('package')
     PsiWhiteSpace(' ')

compiler/testData/psi/SoftKeywordsInTypeArguments.txt

@@ -1,5 +1,4 @@
 JetFile: SoftKeywordsInTypeArguments.jet
-  NAMESPACE
   NAMESPACE_HEADER
     <empty list>
   CLASS

compiler/testData/psi/StringTemplates.txt

@@ -1,5 +1,4 @@
 JetFile: StringTemplates.jet
-  NAMESPACE
   NAMESPACE_HEADER
     <empty list>
   FUN

compiler/testData/psi/Super.txt

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

compiler/testData/psi/ThisType.txt

@@ -1,5 +1,4 @@
 JetFile: ThisType.jet
-  NAMESPACE
   NAMESPACE_HEADER
     <empty list>
   CLASS

compiler/testData/psi/TupleTypes.txt

@@ -1,5 +1,4 @@
 JetFile: TupleTypes.jet
-  NAMESPACE
   NAMESPACE_HEADER
     <empty list>
   CLASS

compiler/testData/psi/TupleTypes_ERR.txt

@@ -1,5 +1,4 @@
 JetFile: TupleTypes_ERR.jet
-  NAMESPACE
   NAMESPACE_HEADER
     <empty list>
   CLASS

compiler/testData/psi/TuplesWithLabeledEntries.txt

@@ -1,5 +1,4 @@
 JetFile: TuplesWithLabeledEntries.jet
-  NAMESPACE
   NAMESPACE_HEADER
     <empty list>
   PROPERTY

compiler/testData/psi/TypeAnnotations.txt

@@ -1,5 +1,4 @@
 JetFile: TypeAnnotations.jet
-  NAMESPACE
   NAMESPACE_HEADER
     <empty list>
   CLASS

compiler/testData/psi/TypeConstraints.txt

@@ -1,5 +1,4 @@
 JetFile: TypeConstraints.jet
-  NAMESPACE
   NAMESPACE_HEADER
     <empty list>
   CLASS

compiler/testData/psi/TypeDef.txt

@@ -1,5 +1,4 @@
 JetFile: TypeDef.jet
-  NAMESPACE
   NAMESPACE_HEADER
     PsiElement(namespace)('package')
     PsiWhiteSpace(' ')

compiler/testData/psi/TypeDef_ERR.txt

@@ -1,5 +1,4 @@
 JetFile: TypeDef_ERR.jet
-  NAMESPACE
   NAMESPACE_HEADER
     <empty list>
   TYPEDEF

compiler/testData/psi/TypeExpressionAmbiguities_ERR.txt

@@ -1,5 +1,4 @@
 JetFile: TypeExpressionAmbiguities_ERR.jet
-  NAMESPACE
   NAMESPACE_HEADER
     <empty list>
   FUN

compiler/testData/psi/TypeParametersBeforeName.txt

@@ -1,5 +1,4 @@
 JetFile: TypeParametersBeforeName.jet
-  NAMESPACE
   NAMESPACE_HEADER
     <empty list>
   FUN

compiler/testData/psi/When.txt

@@ -1,5 +1,4 @@
 JetFile: When.jet
-  NAMESPACE
   NAMESPACE_HEADER
     <empty list>
   FUN

compiler/testData/psi/When_ERR.txt

@@ -1,5 +1,4 @@
 JetFile: When_ERR.jet
-  NAMESPACE
   NAMESPACE_HEADER
     <empty list>
   FUN

compiler/testData/psi/examples/AnonymousObjects.txt

@@ -1,5 +1,4 @@
 JetFile: AnonymousObjects.jet
-  NAMESPACE
   NAMESPACE_HEADER
     <empty list>
   FUN

compiler/testData/psi/examples/BinaryTree.txt

@@ -1,5 +1,4 @@
 JetFile: BinaryTree.jet
-  NAMESPACE
   NAMESPACE_HEADER
     <empty list>
   CLASS

compiler/testData/psi/examples/BitArith.txt

@@ -1,5 +1,4 @@
 JetFile: BitArith.jet
-  NAMESPACE
   NAMESPACE_HEADER
     <empty list>
   FUN