Merge remote branch 'origin/master'

.idea/compiler.xml

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

.idea/modules.xml

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

build.xml

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -10,7 +10,6 @@ import org.jetbrains.jet.lang.psi.*;
 public interface JetNodeTypes {
     IFileElementType JET_FILE = new IFileElementType(JetLanguage.INSTANCE);
 
-    JetNodeType NAMESPACE  = new JetNodeType("NAMESPACE", JetNamespace.class);
     JetNodeType CLASS      = new JetNodeType("CLASS", JetClass.class);
     JetNodeType PROPERTY   = new JetNodeType("PROPERTY", JetProperty.class);
     JetNodeType FUN        = new JetNodeType("FUN", JetNamedFunction.class);
@@ -35,7 +34,6 @@ public interface JetNodeTypes {
 
     JetNodeType CLASS_BODY                          = new JetNodeType("CLASS_BODY", JetClassBody.class);
     JetNodeType IMPORT_DIRECTIVE                    = new JetNodeType("IMPORT_DIRECTIVE", JetImportDirective.class);
-    JetNodeType NAMESPACE_BODY                      = new JetNodeType("NAMESPACE_BODY", JetNamespaceBody.class);
     JetNodeType MODIFIER_LIST                       = new JetNodeType("MODIFIER_LIST", JetModifierList.class);
     JetNodeType PRIMARY_CONSTRUCTOR_MODIFIER_LIST   = new JetNodeType("PRIMARY_CONSTRUCTOR_MODIFIER_LIST", JetModifierList.class);
     JetNodeType ANNOTATION = new JetNodeType("ANNOTATION", JetAnnotation.class);

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

@@ -7,8 +7,6 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
 import org.jetbrains.jet.lang.resolve.BindingContext;
 
-import static org.jetbrains.jet.lang.diagnostics.Severity.ERROR;
-
 /**
  * @author abreslav
  */

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

compiler/testData/compiler/smoke/Smoke.kts

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

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

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

compiler/testData/psi/AnnotatedExpressions.txt

@@ -1,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