diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/ClassFileFactory.java b/compiler/backend/src/org/jetbrains/jet/codegen/ClassFileFactory.java
index 0351dd3cd14..8b84717e21f 100644
--- a/compiler/backend/src/org/jetbrains/jet/codegen/ClassFileFactory.java
+++ b/compiler/backend/src/org/jetbrains/jet/codegen/ClassFileFactory.java
@@ -44,7 +44,7 @@ import static org.jetbrains.jet.lang.resolve.java.PackageClassUtils.getPackageCl
 public final class ClassFileFactory extends GenerationStateAware implements OutputFileCollection {
     @NotNull private ClassBuilderFactory builderFactory;
 
-    private final Map<FqName, NamespaceCodegen> ns2codegen = new HashMap<FqName, NamespaceCodegen>();
+    private final Map<FqName, PackageCodegen> package2codegen = new HashMap<FqName, PackageCodegen>();
     private final Map<String, ClassBuilderAndSourceFileList> generators = new LinkedHashMap<String, ClassBuilderAndSourceFileList>();
     private boolean isDone = false;
 
@@ -74,7 +74,7 @@ public final class ClassFileFactory extends GenerationStateAware implements Outp
     private void done() {
         if (!isDone) {
             isDone = true;
-            for (NamespaceCodegen codegen : ns2codegen.values()) {
+            for (PackageCodegen codegen : package2codegen.values()) {
                 codegen.done();
             }
         }
@@ -110,9 +110,9 @@ public final class ClassFileFactory extends GenerationStateAware implements Outp
         return answer.toString();
     }
 
-    public NamespaceCodegen forNamespace(final FqName fqName, final Collection<JetFile> files) {
+    public PackageCodegen forPackage(final FqName fqName, final Collection<JetFile> files) {
         assert !isDone : "Already done!";
-        NamespaceCodegen codegen = ns2codegen.get(fqName);
+        PackageCodegen codegen = package2codegen.get(fqName);
         if (codegen == null) {
             ClassBuilderOnDemand onDemand = new ClassBuilderOnDemand() {
                 @NotNull
@@ -121,8 +121,8 @@ public final class ClassFileFactory extends GenerationStateAware implements Outp
                     return newVisitor(asmTypeByFqNameWithoutInnerClasses(getPackageClassFqName(fqName)), files);
                 }
             };
-            codegen = new NamespaceCodegen(onDemand, fqName, state, files);
-            ns2codegen.put(fqName, codegen);
+            codegen = new PackageCodegen(onDemand, fqName, state, files);
+            package2codegen.put(fqName, codegen);
         }
 
         return codegen;
diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/ImplementationBodyCodegen.java b/compiler/backend/src/org/jetbrains/jet/codegen/ImplementationBodyCodegen.java
index 8dcd660c548..6bcbd0204ca 100644
--- a/compiler/backend/src/org/jetbrains/jet/codegen/ImplementationBodyCodegen.java
+++ b/compiler/backend/src/org/jetbrains/jet/codegen/ImplementationBodyCodegen.java
@@ -246,7 +246,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
             }
             else {
                 assert isObjectLiteral
-                        : "Function descriptor could be null only for object literal in package namespace: " + descriptor.getName();
+                        : "Function descriptor could be null only for object literal in package: " + descriptor.getName();
                 v.visitOuterClass(outerClassName, null, null);
             }
         }
@@ -261,7 +261,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
 
         JetFile containingFile = BindingContextUtils.getContainingFile(typeMapper.getBindingContext(), classDescriptor);
         assert containingFile != null : "Containing file should be present for " + classDescriptor;
-        return NamespaceCodegen.getNamespacePartInternalName(containingFile);
+        return PackageCodegen.getPackagePartInternalName(containingFile);
     }
 
     private void writeInnerClasses() {
diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/KotlinCodegenFacade.java b/compiler/backend/src/org/jetbrains/jet/codegen/KotlinCodegenFacade.java
index 3ba8907f39d..bf7b1c0ea0e 100644
--- a/compiler/backend/src/org/jetbrains/jet/codegen/KotlinCodegenFacade.java
+++ b/compiler/backend/src/org/jetbrains/jet/codegen/KotlinCodegenFacade.java
@@ -16,12 +16,10 @@
 
 package org.jetbrains.jet.codegen;
 
-import com.intellij.openapi.util.Pair;
 import com.intellij.util.containers.MultiMap;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.asm4.Type;
 import org.jetbrains.jet.codegen.state.GenerationState;
-import org.jetbrains.jet.lang.descriptors.ScriptDescriptor;
 import org.jetbrains.jet.lang.psi.JetFile;
 import org.jetbrains.jet.lang.psi.JetPsiUtil;
 import org.jetbrains.jet.lang.psi.JetScript;
@@ -29,7 +27,6 @@ import org.jetbrains.jet.lang.resolve.ScriptNameUtil;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 
 import java.util.Collection;
-import java.util.Collections;
 import java.util.Map;
 
 import static org.jetbrains.jet.codegen.binding.CodegenBinding.registerClassNameForScript;
@@ -50,25 +47,25 @@ public class KotlinCodegenFacade {
 
         state.beforeCompile();
 
-        MultiMap<FqName, JetFile> namespaceGrouping = new MultiMap<FqName, JetFile>();
+        MultiMap<FqName, JetFile> packageFqNameToFiles = new MultiMap<FqName, JetFile>();
         for (JetFile file : state.getFiles()) {
             if (file == null) throw new IllegalArgumentException("A null file given for compilation");
-            namespaceGrouping.putValue(JetPsiUtil.getFQName(file), file);
+            packageFqNameToFiles.putValue(JetPsiUtil.getFQName(file), file);
         }
 
-        for (Map.Entry<FqName, Collection<JetFile>> entry : namespaceGrouping.entrySet()) {
-            generateNamespace(state, entry.getKey(), entry.getValue(), errorHandler);
+        for (Map.Entry<FqName, Collection<JetFile>> entry : packageFqNameToFiles.entrySet()) {
+            generatePackage(state, entry.getKey(), entry.getValue(), errorHandler);
         }
     }
 
-    public static void generateNamespace(
+    public static void generatePackage(
             @NotNull GenerationState state,
             @NotNull FqName fqName,
             @NotNull Collection<JetFile> jetFiles,
             @NotNull CompilationErrorHandler errorHandler
     ) {
-            NamespaceCodegen codegen = state.getFactory().forNamespace(fqName, jetFiles);
-            codegen.generate(errorHandler);
+        PackageCodegen codegen = state.getFactory().forPackage(fqName, jetFiles);
+        codegen.generate(errorHandler);
     }
 
     private KotlinCodegenFacade() {}
diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/NamespaceCodegen.java b/compiler/backend/src/org/jetbrains/jet/codegen/PackageCodegen.java
similarity index 83%
rename from compiler/backend/src/org/jetbrains/jet/codegen/NamespaceCodegen.java
rename to compiler/backend/src/org/jetbrains/jet/codegen/PackageCodegen.java
index 34e3400fafc..27adbb5f730 100644
--- a/compiler/backend/src/org/jetbrains/jet/codegen/NamespaceCodegen.java
+++ b/compiler/backend/src/org/jetbrains/jet/codegen/PackageCodegen.java
@@ -53,7 +53,7 @@ import static org.jetbrains.jet.codegen.AsmUtil.asmTypeByFqNameWithoutInnerClass
 import static org.jetbrains.jet.descriptors.serialization.NameSerializationUtil.createNameResolver;
 import static org.jetbrains.jet.lang.resolve.java.PackageClassUtils.getPackageClassFqName;
 
-public class NamespaceCodegen extends MemberCodegen {
+public class PackageCodegen extends MemberCodegen {
     private final ClassBuilderOnDemand v;
 
     @NotNull
@@ -63,25 +63,25 @@ public class NamespaceCodegen extends MemberCodegen {
     private final Collection<JetFile> files;
     private final Set<PackageFragmentDescriptor> packageFragments;
 
-    public NamespaceCodegen(
+    public PackageCodegen(
             @NotNull ClassBuilderOnDemand v,
             @NotNull final FqName fqName,
             @NotNull GenerationState state,
-            @NotNull Collection<JetFile> namespaceFiles
+            @NotNull Collection<JetFile> packageFiles
     ) {
         super(state, null);
-        checkAllFilesHaveSameNamespace(namespaceFiles);
+        checkAllFilesHaveSamePackage(packageFiles);
 
         this.v = v;
         name = fqName;
-        this.files = namespaceFiles;
+        this.files = packageFiles;
 
         packageFragments = Sets.newHashSet();
-        for (JetFile file : namespaceFiles) {
+        for (JetFile file : packageFiles) {
             packageFragments.add(getPackageFragment(file));
         }
 
-        final PsiFile sourceFile = namespaceFiles.size() == 1 ? namespaceFiles.iterator().next().getContainingFile() : null;
+        final PsiFile sourceFile = packageFiles.size() == 1 ? packageFiles.iterator().next().getContainingFile() : null;
 
         v.addOptionalDeclaration(new ClassBuilderOnDemand.ClassBuilderCallback() {
             @Override
@@ -93,7 +93,7 @@ public class NamespaceCodegen extends MemberCodegen {
                               "java/lang/Object",
                               ArrayUtil.EMPTY_STRING_ARRAY
                 );
-                //We don't generate any source information for namespace with multiple files
+                //We don't generate any source information for package with multiple files
                 if (sourceFile != null) {
                     v.visitSource(sourceFile.getName(), null);
                 }
@@ -103,7 +103,7 @@ public class NamespaceCodegen extends MemberCodegen {
 
     public void generate(@NotNull CompilationErrorHandler errorHandler) {
         List<JvmSerializationBindings> bindings = new ArrayList<JvmSerializationBindings>(files.size() + 1);
-        boolean shouldGeneratePackageClass = shouldGenerateNSClass(files);
+        boolean shouldGeneratePackageClass = shouldGeneratePackageClass(files);
         if (shouldGeneratePackageClass) {
             bindings.add(v.getClassBuilder().getSerializationBindings());
         }
@@ -134,7 +134,7 @@ public class NamespaceCodegen extends MemberCodegen {
         }
 
         assert v.isActivated() == shouldGeneratePackageClass :
-                "Different algorithms for generating namespace class and for heuristics for: " + name.asString();
+                "Different algorithms for generating package class and for heuristics for: " + name.asString();
     }
 
     private void writeKotlinPackageAnnotationIfNeeded(@NotNull JvmSerializationBindings bindings) {
@@ -185,16 +185,16 @@ public class NamespaceCodegen extends MemberCodegen {
 
         if (!generateSrcClass) return null;
 
-        Type packagePartType = getNamespacePartType(getPackageClassFqName(name), file.getVirtualFile());
+        Type packagePartType = getPackagePartType(getPackageClassFqName(name), file.getVirtualFile());
         ClassBuilder builder = state.getFactory().forPackageFragment(packagePartType, file);
 
-        new NamespacePartCodegen(builder, file, packagePartType, packagePartContext, state).generate();
+        new PackagePartCodegen(builder, file, packagePartType, packagePartContext, state).generate();
 
-        FieldOwnerContext namespaceFacade = CodegenContext.STATIC.intoPackageFacade(packagePartType, getPackageFragment(file));
+        FieldOwnerContext packageFacade = CodegenContext.STATIC.intoPackageFacade(packagePartType, getPackageFragment(file));
 
         for (JetDeclaration declaration : file.getDeclarations()) {
             if (declaration instanceof JetNamedFunction || declaration instanceof JetProperty) {
-                genFunctionOrProperty(namespaceFacade, (JetTypeParameterListOwner) declaration, v.getClassBuilder());
+                genFunctionOrProperty(packageFacade, (JetTypeParameterListOwner) declaration, v.getClassBuilder());
             }
         }
 
@@ -214,13 +214,13 @@ public class NamespaceCodegen extends MemberCodegen {
     }
 
     /**
-     * @param namespaceFiles all files should have same package name
+     * @param packageFiles all files should have same package name
      * @return
      */
-    public static boolean shouldGenerateNSClass(@NotNull Collection<JetFile> namespaceFiles) {
-        checkAllFilesHaveSameNamespace(namespaceFiles);
+    public static boolean shouldGeneratePackageClass(@NotNull Collection<JetFile> packageFiles) {
+        checkAllFilesHaveSamePackage(packageFiles);
 
-        for (JetFile file : namespaceFiles) {
+        for (JetFile file : packageFiles) {
             for (JetDeclaration declaration : file.getDeclarations()) {
                 if (declaration instanceof JetProperty || declaration instanceof JetNamedFunction) {
                     return true;
@@ -231,9 +231,9 @@ public class NamespaceCodegen extends MemberCodegen {
         return false;
     }
 
-    private static void checkAllFilesHaveSameNamespace(Collection<JetFile> namespaceFiles) {
+    private static void checkAllFilesHaveSamePackage(Collection<JetFile> packageFiles) {
         FqName commonFqName = null;
-        for (JetFile file : namespaceFiles) {
+        for (JetFile file : packageFiles) {
             FqName fqName = JetPsiUtil.getFQName(file);
             if (commonFqName != null) {
                 if (!commonFqName.equals(fqName)) {
@@ -251,7 +251,7 @@ public class NamespaceCodegen extends MemberCodegen {
     }
 
     @NotNull
-    public static Type getNamespacePartType(@NotNull FqName facadeFqName, @NotNull VirtualFile file) {
+    public static Type getPackagePartType(@NotNull FqName facadeFqName, @NotNull VirtualFile file) {
         String fileName = FileUtil.getNameWithoutExtension(PathUtil.getFileName(file.getName()));
 
         // path hashCode to prevent same name / different path collision
@@ -269,8 +269,8 @@ public class NamespaceCodegen extends MemberCodegen {
     }
 
     @NotNull
-    public static String getNamespacePartInternalName(@NotNull JetFile file) {
+    public static String getPackagePartInternalName(@NotNull JetFile file) {
         FqName packageFqName = JetPsiUtil.getFQName(file);
-        return getNamespacePartType(getPackageClassFqName(packageFqName), file.getVirtualFile()).getInternalName();
+        return getPackagePartType(getPackageClassFqName(packageFqName), file.getVirtualFile()).getInternalName();
     }
 }
diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/NamespacePartCodegen.java b/compiler/backend/src/org/jetbrains/jet/codegen/PackagePartCodegen.java
similarity index 92%
rename from compiler/backend/src/org/jetbrains/jet/codegen/NamespacePartCodegen.java
rename to compiler/backend/src/org/jetbrains/jet/codegen/PackagePartCodegen.java
index bb1661ce63f..174fbb2091c 100644
--- a/compiler/backend/src/org/jetbrains/jet/codegen/NamespacePartCodegen.java
+++ b/compiler/backend/src/org/jetbrains/jet/codegen/PackagePartCodegen.java
@@ -39,7 +39,7 @@ import java.util.List;
 import static org.jetbrains.asm4.Opcodes.*;
 import static org.jetbrains.jet.codegen.AsmUtil.asmDescByFqNameWithoutInnerClasses;
 
-public class NamespacePartCodegen extends MemberCodegen {
+public class PackagePartCodegen extends MemberCodegen {
 
     private final ClassBuilder v;
 
@@ -47,30 +47,30 @@ public class NamespacePartCodegen extends MemberCodegen {
 
     private final JetFile jetFile;
 
-    private final Type namespacePartName;
+    private final Type packagePartName;
 
     private final FieldOwnerContext context;
 
-    public NamespacePartCodegen(
+    public PackagePartCodegen(
             @NotNull ClassBuilder v,
             @NotNull JetFile jetFile,
-            @NotNull Type namespacePartName,
+            @NotNull Type packagePartName,
             @NotNull FieldOwnerContext context,
             @NotNull GenerationState state
     ) {
         super(state, null);
         this.v = v;
         this.jetFile = jetFile;
-        this.namespacePartName = namespacePartName;
+        this.packagePartName = packagePartName;
         this.context = context;
         descriptor = state.getBindingContext().get(BindingContext.FILE_TO_PACKAGE_FRAGMENT, jetFile);
-        assert descriptor != null : "No namespace found for jetFile " + jetFile + " declared package: " + jetFile.getPackageName();
+        assert descriptor != null : "No package fragment found for jetFile " + jetFile + " declared package: " + jetFile.getPackageName();
     }
 
     public void generate() {
         v.defineClass(jetFile, V1_6,
                       ACC_PUBLIC | ACC_FINAL,
-                      namespacePartName.getInternalName(),
+                      packagePartName.getInternalName(),
                       null,
                       "java/lang/Object",
                       ArrayUtil.EMPTY_STRING_ARRAY
@@ -122,7 +122,7 @@ public class NamespacePartCodegen extends MemberCodegen {
             }
 
             mv.visitInsn(RETURN);
-            FunctionCodegen.endVisit(mv, "static initializer for namespace", jetFile);
+            FunctionCodegen.endVisit(mv, "static initializer for package", jetFile);
             mv.visitEnd();
         }
     }
diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/binding/CodegenAnnotatingVisitor.java b/compiler/backend/src/org/jetbrains/jet/codegen/binding/CodegenAnnotatingVisitor.java
index 1daac95ce1f..85aaaf21f17 100644
--- a/compiler/backend/src/org/jetbrains/jet/codegen/binding/CodegenAnnotatingVisitor.java
+++ b/compiler/backend/src/org/jetbrains/jet/codegen/binding/CodegenAnnotatingVisitor.java
@@ -333,9 +333,9 @@ class CodegenAnnotatingVisitor extends JetVisitorVoid {
         // working around a problem with shallow analysis
         if (propertyDescriptor == null) return;
 
-        String nameForClassOrNamespaceMember = getNameForClassOrNamespaceMember(propertyDescriptor);
-        if (nameForClassOrNamespaceMember != null) {
-            nameStack.push(nameForClassOrNamespaceMember);
+        String nameForClassOrPackageMember = getNameForClassOrPackageMember(propertyDescriptor);
+        if (nameForClassOrPackageMember != null) {
+            nameStack.push(nameForClassOrPackageMember);
         }
         else {
             nameStack.push(peekFromStack(nameStack) + '$' + property.getName());
@@ -350,9 +350,9 @@ class CodegenAnnotatingVisitor extends JetVisitorVoid {
         // working around a problem with shallow analysis
         if (functionDescriptor == null) return;
 
-        String nameForClassOrNamespaceMember = getNameForClassOrNamespaceMember(functionDescriptor);
-        if (nameForClassOrNamespaceMember != null) {
-            nameStack.push(nameForClassOrNamespaceMember);
+        String nameForClassOrPackageMember = getNameForClassOrPackageMember(functionDescriptor);
+        if (nameForClassOrPackageMember != null) {
+            nameStack.push(nameForClassOrPackageMember);
             super.visitNamedFunction(function);
             nameStack.pop();
         }
@@ -371,7 +371,7 @@ class CodegenAnnotatingVisitor extends JetVisitorVoid {
     }
 
     @Nullable
-    private String getNameForClassOrNamespaceMember(@NotNull DeclarationDescriptor descriptor) {
+    private String getNameForClassOrPackageMember(@NotNull DeclarationDescriptor descriptor) {
         DeclarationDescriptor containingDeclaration = descriptor.getContainingDeclaration();
 
         String peek = peekFromStack(nameStack);
diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/binding/CodegenBinding.java b/compiler/backend/src/org/jetbrains/jet/codegen/binding/CodegenBinding.java
index be90ce07448..60ef4d09c8d 100644
--- a/compiler/backend/src/org/jetbrains/jet/codegen/binding/CodegenBinding.java
+++ b/compiler/backend/src/org/jetbrains/jet/codegen/binding/CodegenBinding.java
@@ -61,7 +61,7 @@ public class CodegenBinding {
 
     public static void initTrace(BindingTrace bindingTrace, Collection<JetFile> files) {
         CodegenAnnotatingVisitor visitor = new CodegenAnnotatingVisitor(bindingTrace);
-        for (JetFile file : allFilesInNamespaces(bindingTrace.getBindingContext(), files)) {
+        for (JetFile file : allFilesInPackages(bindingTrace.getBindingContext(), files)) {
             file.accept(visitor);
         }
     }
@@ -223,7 +223,7 @@ public class CodegenBinding {
     }
 
     @NotNull
-    public static Collection<JetFile> allFilesInNamespaces(BindingContext bindingContext, Collection<JetFile> files) {
+    public static Collection<JetFile> allFilesInPackages(BindingContext bindingContext, Collection<JetFile> files) {
         // todo: we use Set and add given files but ignoring other scripts because something non-clear kept in binding
         // for scripts especially in case of REPL
 
diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/binding/PsiCodegenPredictor.java b/compiler/backend/src/org/jetbrains/jet/codegen/binding/PsiCodegenPredictor.java
index 13a995b6fa0..4ace893dbfd 100644
--- a/compiler/backend/src/org/jetbrains/jet/codegen/binding/PsiCodegenPredictor.java
+++ b/compiler/backend/src/org/jetbrains/jet/codegen/binding/PsiCodegenPredictor.java
@@ -22,7 +22,7 @@ import com.intellij.psi.util.PsiTreeUtil;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.asm4.Type;
-import org.jetbrains.jet.codegen.NamespaceCodegen;
+import org.jetbrains.jet.codegen.PackageCodegen;
 import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
 import org.jetbrains.jet.lang.psi.*;
 import org.jetbrains.jet.lang.resolve.BindingContext;
@@ -121,7 +121,7 @@ public final class PsiCodegenPredictor {
         }
 
         // NOTE: looks like a bug - for class in getter of top level property class name will be $propertyName$ClassName but not
-        // namespace$propertyName$ClassName
+        // PackageClassName$propertyName$ClassName
         if (declaration instanceof JetProperty) {
             return parentInternalName + "$" + name.asString();
         }
@@ -134,9 +134,9 @@ public final class PsiCodegenPredictor {
     }
 
     @Nullable
-    public static JetFile getFileForNamespacePartName(@NotNull Collection<JetFile> allNamespaceFiles, @NotNull JvmClassName className) {
-        for (JetFile file : allNamespaceFiles) {
-            String internalName = NamespaceCodegen.getNamespacePartInternalName(file);
+    public static JetFile getFileForPackagePartName(@NotNull Collection<JetFile> allPackageFiles, @NotNull JvmClassName className) {
+        for (JetFile file : allPackageFiles) {
+            String internalName = PackageCodegen.getPackagePartInternalName(file);
             JvmClassName jvmClassName = JvmClassName.byInternalName(internalName);
             if (jvmClassName.equals(className)) {
                 return file;
@@ -148,7 +148,7 @@ public final class PsiCodegenPredictor {
     @Nullable
     public static JetFile getFileForCodegenNamedClass(
             @NotNull BindingContext context,
-            @NotNull Collection<JetFile> allNamespaceFiles,
+            @NotNull Collection<JetFile> allPackageFiles,
             @NotNull final String classInternalName
     ) {
         final Ref<DeclarationDescriptor> resultingDescriptor = Ref.create();
@@ -165,7 +165,7 @@ public final class PsiCodegenPredictor {
             }
         };
 
-        CodegenBinding.initTrace(trace, allNamespaceFiles);
+        CodegenBinding.initTrace(trace, allPackageFiles);
 
         return resultingDescriptor.isNull() ? null
                : BindingContextUtils.getContainingFile(trace.getBindingContext(), resultingDescriptor.get());
diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/context/CodegenContext.java b/compiler/backend/src/org/jetbrains/jet/codegen/context/CodegenContext.java
index 99dd0a203b7..84e21d32698 100644
--- a/compiler/backend/src/org/jetbrains/jet/codegen/context/CodegenContext.java
+++ b/compiler/backend/src/org/jetbrains/jet/codegen/context/CodegenContext.java
@@ -101,7 +101,7 @@ public abstract class CodegenContext<T extends DeclarationDescriptor> {
         return thisDescriptor != null;
     }
 
-    public DeclarationDescriptor getClassOrNamespaceDescriptor() {
+    public DeclarationDescriptor getClassOrPackageDescriptor() {
         CodegenContext c = this;
         while (true) {
             assert c != null;
@@ -408,7 +408,7 @@ public abstract class CodegenContext<T extends DeclarationDescriptor> {
         }
 
         CodegenContext descriptorContext = null;
-        if (!fromOutsideContext || getClassOrNamespaceDescriptor() != descriptor.getContainingDeclaration()) {
+        if (!fromOutsideContext || getClassOrPackageDescriptor() != descriptor.getContainingDeclaration()) {
             DeclarationDescriptor enclosed = descriptor.getContainingDeclaration();
             boolean isClassObjectMember = DescriptorUtils.isClassObject(enclosed);
             //go upper
diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/context/PackageContext.java b/compiler/backend/src/org/jetbrains/jet/codegen/context/PackageContext.java
index 8db603b3b8f..5d3afc409f2 100644
--- a/compiler/backend/src/org/jetbrains/jet/codegen/context/PackageContext.java
+++ b/compiler/backend/src/org/jetbrains/jet/codegen/context/PackageContext.java
@@ -34,6 +34,6 @@ public class PackageContext extends FieldOwnerContext<PackageFragmentDescriptor>
 
     @Override
     public String toString() {
-        return "Namespace: " + getContextDescriptor().getName();
+        return "Package: " + getContextDescriptor().getName();
     }
 }
diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/state/JetTypeMapper.java b/compiler/backend/src/org/jetbrains/jet/codegen/state/JetTypeMapper.java
index 7e7b3fbc6b1..d30e9c690cb 100644
--- a/compiler/backend/src/org/jetbrains/jet/codegen/state/JetTypeMapper.java
+++ b/compiler/backend/src/org/jetbrains/jet/codegen/state/JetTypeMapper.java
@@ -135,7 +135,7 @@ public class JetTypeMapper extends BindingTraceAware {
         // It's not a package created for Java class statics
         JetFile file = BindingContextUtils.getContainingFile(bindingContext, descriptor);
         if (insideModule && file != null) {
-            return NamespaceCodegen.getNamespacePartInternalName(file);
+            return PackageCodegen.getPackagePartInternalName(file);
         }
         else {
             return PackageClassUtils.getPackageClassFqName(packageFragment.getFqName()).asString().replace('.', '/');
diff --git a/compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/CompileEnvironmentUtil.java b/compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/CompileEnvironmentUtil.java
index 3c78ae2ce9a..f7a2f1394ef 100644
--- a/compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/CompileEnvironmentUtil.java
+++ b/compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/CompileEnvironmentUtil.java
@@ -149,8 +149,8 @@ public class CompileEnvironmentUtil {
             loader = new GeneratedClassLoader(factory, KotlinToJVMBytecodeCompiler.class.getClassLoader());
         }
         try {
-            Class namespaceClass = loader.loadClass(PackageClassUtils.getPackageClassName(FqName.ROOT));
-            Method method = namespaceClass.getDeclaredMethod("project");
+            Class packageClass = loader.loadClass(PackageClassUtils.getPackageClassName(FqName.ROOT));
+            Method method = packageClass.getDeclaredMethod("project");
             if (method == null) {
                 throw new CompileEnvironmentException("Module script " + moduleFile + " must define project() function");
             }
diff --git a/compiler/cli/src/org/jetbrains/jet/cli/jvm/repl/ReplInterpreter.java b/compiler/cli/src/org/jetbrains/jet/cli/jvm/repl/ReplInterpreter.java
index d3acf1006a2..bcf7a8bb1b7 100644
--- a/compiler/cli/src/org/jetbrains/jet/cli/jvm/repl/ReplInterpreter.java
+++ b/compiler/cli/src/org/jetbrains/jet/cli/jvm/repl/ReplInterpreter.java
@@ -284,12 +284,12 @@ public class ReplInterpreter {
     private ScriptDescriptor doAnalyze(@NotNull JetFile psiFile, @NotNull MessageCollector messageCollector) {
         WritableScope scope = new WritableScopeImpl(
                 JetScope.EMPTY, module,
-                new TraceBasedRedeclarationHandler(trace), "Root scope in analyzeNamespace");
+                new TraceBasedRedeclarationHandler(trace), "Root scope in analyzePackage");
 
         scope.changeLockLevel(WritableScope.LockLevel.BOTH);
 
-        // Import a scope that contains all top-level namespaces that come from dependencies
-        // This makes the namespaces visible at all, does not import themselves
+        // Import a scope that contains all top-level packages that come from dependencies
+        // This makes the packages visible at all, does not import themselves
         scope.importScope(module.getPackage(FqName.ROOT).getMemberScope());
 
         if (lastLineScope != null) {
@@ -299,7 +299,7 @@ public class ReplInterpreter {
         scope.changeLockLevel(WritableScope.LockLevel.READING);
 
         // dummy builder is used because "root" is module descriptor,
-        // namespaces added to module explicitly in
+        // packages added to module explicitly in
         injector.getTopDownAnalyzer().doProcess(scope, new PackageLikeBuilderDummy(), Collections.singletonList(psiFile));
 
         boolean hasErrors = AnalyzerWithCompilerReport.reportDiagnostics(trace.getBindingContext(), messageCollector);
@@ -349,7 +349,7 @@ public class ReplInterpreter {
         registerClassNameForScript(state.getBindingTrace(), script, classType);
 
         state.beforeCompile();
-        KotlinCodegenFacade.generateNamespace(
+        KotlinCodegenFacade.generatePackage(
                 state,
                 JetPsiUtil.getFQName((JetFile) script.getContainingFile()),
                 Collections.singleton((JetFile) script.getContainingFile()),
diff --git a/compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/JavaElementFinder.java b/compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/JavaElementFinder.java
index f9f0538b787..0eba90d878d 100644
--- a/compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/JavaElementFinder.java
+++ b/compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/JavaElementFinder.java
@@ -34,7 +34,7 @@ import com.intellij.util.SmartList;
 import com.intellij.util.containers.SLRUCache;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.jet.codegen.NamespaceCodegen;
+import org.jetbrains.jet.codegen.PackageCodegen;
 import org.jetbrains.jet.lang.psi.JetClassOrObject;
 import org.jetbrains.jet.lang.psi.JetEnumEntry;
 import org.jetbrains.jet.lang.psi.JetFile;
@@ -145,7 +145,7 @@ public class JavaElementFinder extends PsiElementFinder implements JavaPsiFacade
     private void findPackageClass(FqName qualifiedName, GlobalSearchScope scope, List<PsiClass> answer) {
         Collection<JetFile> filesForPackage = lightClassGenerationSupport.findFilesForPackage(qualifiedName, scope);
 
-        if (!filesForPackage.isEmpty() && NamespaceCodegen.shouldGenerateNSClass(filesForPackage)) {
+        if (!filesForPackage.isEmpty() && PackageCodegen.shouldGeneratePackageClass(filesForPackage)) {
             KotlinLightClassForPackage lightClass = KotlinLightClassForPackage.create(psiManager, qualifiedName, scope, filesForPackage);
             if (lightClass != null) {
                 answer.add(lightClass);
diff --git a/compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/KotlinJavaFileStubProvider.java b/compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/KotlinJavaFileStubProvider.java
index e73c3eaf94d..d7f6b5acfbb 100644
--- a/compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/KotlinJavaFileStubProvider.java
+++ b/compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/KotlinJavaFileStubProvider.java
@@ -39,7 +39,7 @@ import com.intellij.util.containers.Stack;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.codegen.CompilationErrorHandler;
-import org.jetbrains.jet.codegen.NamespaceCodegen;
+import org.jetbrains.jet.codegen.PackageCodegen;
 import org.jetbrains.jet.codegen.binding.CodegenBinding;
 import org.jetbrains.jet.codegen.state.GenerationState;
 import org.jetbrains.jet.codegen.state.Progress;
@@ -96,7 +96,7 @@ public class KotlinJavaFileStubProvider implements CachedValueProvider<LightClas
 
                     @Override
                     public void generate(@NotNull GenerationState state, @NotNull Collection<JetFile> files) {
-                        NamespaceCodegen codegen = state.getFactory().forNamespace(packageFqName, files);
+                        PackageCodegen codegen = state.getFactory().forPackage(packageFqName, files);
                         codegen.generate(CompilationErrorHandler.THROW_EXCEPTION);
                         state.getFactory().asList();
                     }
@@ -169,8 +169,8 @@ public class KotlinJavaFileStubProvider implements CachedValueProvider<LightClas
 
                     @Override
                     public void generate(@NotNull GenerationState state, @NotNull Collection<JetFile> files) {
-                        NamespaceCodegen namespaceCodegen = state.getFactory().forNamespace(getPackageFqName(), files);
-                        namespaceCodegen.generateClassOrObject(classOrObject);
+                        PackageCodegen packageCodegen = state.getFactory().forPackage(getPackageFqName(), files);
+                        packageCodegen.generateClassOrObject(classOrObject);
                         state.getFactory().asList();
                     }
                 }
diff --git a/compiler/tests/org/jetbrains/jet/codegen/AnnotationGenTest.java b/compiler/tests/org/jetbrains/jet/codegen/AnnotationGenTest.java
index 888ffc8a971..3726611eee6 100644
--- a/compiler/tests/org/jetbrains/jet/codegen/AnnotationGenTest.java
+++ b/compiler/tests/org/jetbrains/jet/codegen/AnnotationGenTest.java
@@ -46,7 +46,7 @@ public class AnnotationGenTest extends CodegenTestCase {
     }
 
     private Class<?> getPackageSrcClass(@NotNull ClassLoader loader) throws ClassNotFoundException {
-        return loader.loadClass(NamespaceCodegen.getNamespacePartInternalName(myFiles.getPsiFile()));
+        return loader.loadClass(PackageCodegen.getPackagePartInternalName(myFiles.getPsiFile()));
     }
 
     public void testPropField() throws Exception {
diff --git a/compiler/tests/org/jetbrains/jet/codegen/CodegenTestCase.java b/compiler/tests/org/jetbrains/jet/codegen/CodegenTestCase.java
index 6b2e8bbb031..451711b18cf 100644
--- a/compiler/tests/org/jetbrains/jet/codegen/CodegenTestCase.java
+++ b/compiler/tests/org/jetbrains/jet/codegen/CodegenTestCase.java
@@ -167,14 +167,14 @@ public abstract class CodegenTestCase extends UsefulTestCase {
     }
 
     @NotNull
-    protected Class<?> generateNamespaceClass() {
+    protected Class<?> generatePackageClass() {
         FqName packageFqName = JetPsiUtil.getFQName(myFiles.getPsiFile());
         return generateClass(getPackageClassFqName(packageFqName).asString());
     }
 
     @NotNull
-    protected Class<?> generateNamespaceSrcClass() {
-        String name = NamespaceCodegen.getNamespacePartInternalName(myFiles.getPsiFile());
+    protected Class<?> generatePackagePartClass() {
+        String name = PackageCodegen.getPackagePartInternalName(myFiles.getPsiFile());
         return generateClass(name);
     }
 
@@ -263,7 +263,7 @@ public abstract class CodegenTestCase extends UsefulTestCase {
 
     @NotNull
     protected Method generateFunction() {
-        Class<?> aClass = generateNamespaceClass();
+        Class<?> aClass = generatePackageClass();
         try {
             return findTheOnlyMethod(aClass);
         } catch (Error e) {
@@ -274,7 +274,7 @@ public abstract class CodegenTestCase extends UsefulTestCase {
 
     @NotNull
     protected Method generateFunction(@NotNull String name) {
-        Class<?> aClass = generateNamespaceClass();
+        Class<?> aClass = generatePackageClass();
         Method method = findDeclaredMethodByName(aClass, name);
         if (method == null) {
             throw new IllegalArgumentException("Couldn't find method " + name + " in class " + aClass);
diff --git a/compiler/tests/org/jetbrains/jet/codegen/JUnitUsageGenTest.java b/compiler/tests/org/jetbrains/jet/codegen/JUnitUsageGenTest.java
index 2dfbee227c7..da8fea1a722 100644
--- a/compiler/tests/org/jetbrains/jet/codegen/JUnitUsageGenTest.java
+++ b/compiler/tests/org/jetbrains/jet/codegen/JUnitUsageGenTest.java
@@ -47,7 +47,7 @@ public class JUnitUsageGenTest extends CodegenTestCase {
 
     public void testKt1592() throws Exception {
         loadFile("junit/kt1592.kt");
-        Class<?> namespaceClass = generateNamespaceClass();
+        Class<?> namespaceClass = generatePackageClass();
         Method method = namespaceClass.getMethod("foo", Method.class);
         method.setAccessible(true);
         Annotation annotation = method.getAnnotation(getCorrespondingAnnotationClass(Test.class));
diff --git a/compiler/tests/org/jetbrains/jet/codegen/PrimitiveTypesTest.java b/compiler/tests/org/jetbrains/jet/codegen/PrimitiveTypesTest.java
index b1125ff1e39..b3429699a98 100644
--- a/compiler/tests/org/jetbrains/jet/codegen/PrimitiveTypesTest.java
+++ b/compiler/tests/org/jetbrains/jet/codegen/PrimitiveTypesTest.java
@@ -159,7 +159,7 @@ public class PrimitiveTypesTest extends CodegenTestCase {
 
     public void testCastOnStack() throws Exception {
         loadText("fun foo(): Double = System.currentTimeMillis().toDouble()");
-        Class<?> mainClass = generateNamespaceSrcClass();
+        Class<?> mainClass = generatePackagePartClass();
         Method main = mainClass.getDeclaredMethod("foo");
         double currentTimeMillis = (double) System.currentTimeMillis();
         double result = (Double) main.invoke(null);
diff --git a/compiler/tests/org/jetbrains/jet/codegen/PropertyGenTest.java b/compiler/tests/org/jetbrains/jet/codegen/PropertyGenTest.java
index bc4b5bc329c..f42ab5cdcb0 100644
--- a/compiler/tests/org/jetbrains/jet/codegen/PropertyGenTest.java
+++ b/compiler/tests/org/jetbrains/jet/codegen/PropertyGenTest.java
@@ -76,7 +76,7 @@ public class PropertyGenTest extends CodegenTestCase {
 
     public void testPrivatePropertyInNamespace() throws Exception {
         loadText("private val x = 239");
-        Class nsClass = generateNamespaceSrcClass();
+        Class nsClass = generatePackagePartClass();
         Field[] fields = nsClass.getDeclaredFields();
         assertEquals(1, fields.length);
         Field field = fields[0];
diff --git a/idea/src/org/jetbrains/jet/plugin/debugger/JetPositionManager.java b/idea/src/org/jetbrains/jet/plugin/debugger/JetPositionManager.java
index 48549acac86..6994ba9a9da 100644
--- a/idea/src/org/jetbrains/jet/plugin/debugger/JetPositionManager.java
+++ b/idea/src/org/jetbrains/jet/plugin/debugger/JetPositionManager.java
@@ -37,7 +37,7 @@ import org.jetbrains.annotations.TestOnly;
 import org.jetbrains.asm4.Type;
 import org.jetbrains.jet.analyzer.AnalyzeExhaust;
 import org.jetbrains.jet.codegen.ClassBuilderMode;
-import org.jetbrains.jet.codegen.NamespaceCodegen;
+import org.jetbrains.jet.codegen.PackageCodegen;
 import org.jetbrains.jet.codegen.binding.CodegenBinding;
 import org.jetbrains.jet.codegen.state.JetTypeMapper;
 import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
@@ -154,7 +154,7 @@ public class JetPositionManager implements PositionManager {
                 }
 
                 if (result.isNull()) {
-                    result.set(NamespaceCodegen.getNamespacePartInternalName(namespace));
+                    result.set(PackageCodegen.getPackagePartInternalName(namespace));
                 }
             }
         });
diff --git a/idea/src/org/jetbrains/jet/plugin/util/DebuggerUtils.java b/idea/src/org/jetbrains/jet/plugin/util/DebuggerUtils.java
index c3cb66bdf15..9fdfae58b6d 100644
--- a/idea/src/org/jetbrains/jet/plugin/util/DebuggerUtils.java
+++ b/idea/src/org/jetbrains/jet/plugin/util/DebuggerUtils.java
@@ -65,7 +65,7 @@ public class DebuggerUtils {
         }
 
         Collection<JetFile> allNamespaceFiles = filesProvider.allNamespaceFiles().fun(anyFile);
-        JetFile file = PsiCodegenPredictor.getFileForNamespacePartName(allNamespaceFiles, className);
+        JetFile file = PsiCodegenPredictor.getFileForPackagePartName(allNamespaceFiles, className);
         if (file != null) {
             return file;
         }
diff --git a/jps-plugin/test/org/jetbrains/jet/jps/build/KotlinJpsBuildTest.java b/jps-plugin/test/org/jetbrains/jet/jps/build/KotlinJpsBuildTest.java
index 96943f6127f..3d065cb8dfd 100644
--- a/jps-plugin/test/org/jetbrains/jet/jps/build/KotlinJpsBuildTest.java
+++ b/jps-plugin/test/org/jetbrains/jet/jps/build/KotlinJpsBuildTest.java
@@ -21,7 +21,7 @@ import com.intellij.openapi.util.io.FileUtil;
 import com.intellij.testFramework.LightVirtualFile;
 import com.intellij.util.Function;
 import com.intellij.util.containers.ContainerUtil;
-import org.jetbrains.jet.codegen.NamespaceCodegen;
+import org.jetbrains.jet.codegen.PackageCodegen;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jps.builders.BuildResult;
 import org.jetbrains.jps.model.java.JpsJavaDependencyScope;
@@ -323,7 +323,7 @@ public class KotlinJpsBuildTest extends AbstractKotlinJpsBuildTestCase {
                 return super.getPath().substring(1);
             }
         };
-        return NamespaceCodegen.getNamespacePartType(new FqName(packageClassFqName), fakeVirtualFile).getInternalName();
+        return PackageCodegen.getPackagePartType(new FqName(packageClassFqName), fakeVirtualFile).getInternalName();
     }
 
     private static enum Operation {