Imports with renaming supported for namespaces

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

@@ -227,6 +227,7 @@ public class TypeHierarchyResolver {
             }
             else {
                 ClassifierDescriptor classifierDescriptor = null;
+                NamespaceDescriptor namespaceDescriptor = null;
                 JetSimpleNameExpression referenceExpression = null;
 
                 JetExpression importedReference = importDirective.getImportedReference();
@@ -239,6 +240,7 @@ public class TypeHierarchyResolver {
                         String referencedName = referenceExpression.getReferencedName();
                         if (type != null && referencedName != null) {
                             classifierDescriptor = type.getMemberScope().getClassifier(referencedName);
+                            namespaceDescriptor = type.getMemberScope().getNamespace(referencedName);
                         }
                     }
                 }
@@ -249,15 +251,25 @@ public class TypeHierarchyResolver {
                     String referencedName = referenceExpression.getReferencedName();
                     if (referencedName != null) {
                         classifierDescriptor = outerScope.getClassifier(referencedName);
+                        namespaceDescriptor = outerScope.getNamespace(referencedName);
                     }
                 }
 
+                String aliasName = importDirective.getAliasName();
                 if (classifierDescriptor != null) {
                     context.getTrace().record(BindingContext.REFERENCE_TARGET, referenceExpression, classifierDescriptor);
 
-                    String aliasName = importDirective.getAliasName();
+                    if (aliasName != null) {
-                    String importedClassifierName = aliasName != null ? aliasName : classifierDescriptor.getName();
+                        namespaceScope.importClassifierAlias(aliasName, classifierDescriptor);
-                    namespaceScope.importClassifierAlias(importedClassifierName, classifierDescriptor);
+                    }
+                }
+                if (namespaceDescriptor != null) {
+                    if (classifierDescriptor == null) {
+                        context.getTrace().record(BindingContext.REFERENCE_TARGET, referenceExpression, namespaceDescriptor);
+                    }
+                    if (aliasName != null) {
+                        namespaceScope.importNamespaceAlias(aliasName, namespaceDescriptor);
+                    }
                 }
             }
         }

compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/WritableScope.java

@@ -21,6 +21,8 @@ public interface WritableScope extends JetScope {
 
     void addClassifierAlias(@NotNull String name, @NotNull ClassifierDescriptor classifierDescriptor);
 
+    void addNamespaceAlias(@NotNull String name, @NotNull NamespaceDescriptor namespaceDescriptor);
+
     void addNamespace(@NotNull NamespaceDescriptor namespaceDescriptor);
 
     @Nullable

compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/WritableScopeImpl.java

@@ -66,6 +66,12 @@ public class WritableScopeImpl extends WritableScopeWithImports {
         super.importClassifierAlias(importedClassifierName, classifierDescriptor);
     }
 
+    @Override
+    public void importNamespaceAlias(String aliasName, NamespaceDescriptor namespaceDescriptor) {
+        allDescriptors.add(namespaceDescriptor);
+        super.importNamespaceAlias(aliasName, namespaceDescriptor);
+    }
+
     @NotNull
     @Override
     public Collection<DeclarationDescriptor> getAllDescriptors() {
@@ -189,13 +195,23 @@ public class WritableScopeImpl extends WritableScopeWithImports {
 
     @Override
     public void addClassifierAlias(@NotNull String name, @NotNull ClassifierDescriptor classifierDescriptor) {
-        Map<String, DeclarationDescriptor> variableClassOrNamespaceDescriptors = getVariableClassOrNamespaceDescriptors();
+        checkForRedeclaration(name, classifierDescriptor);
-        DeclarationDescriptor originalDescriptor = variableClassOrNamespaceDescriptors.get(name);
+        getVariableClassOrNamespaceDescriptors().put(name, classifierDescriptor);
+        allDescriptors.add(classifierDescriptor);
+    }
+
+    @Override
+    public void addNamespaceAlias(@NotNull String name, @NotNull NamespaceDescriptor namespaceDescriptor) {
+        checkForRedeclaration(name, namespaceDescriptor);
+        getVariableClassOrNamespaceDescriptors().put(name, namespaceDescriptor);
+        allDescriptors.add(namespaceDescriptor);
+    }
+
+    private void checkForRedeclaration(String name, DeclarationDescriptor classifierDescriptor) {
+        DeclarationDescriptor originalDescriptor = getVariableClassOrNamespaceDescriptors().get(name);
         if (originalDescriptor != null) {
             redeclarationHandler.handleRedeclaration(originalDescriptor, classifierDescriptor);
         }
-        variableClassOrNamespaceDescriptors.put(name, classifierDescriptor);
-        allDescriptors.add(classifierDescriptor);
     }
 
     @Override

compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/WritableScopeWithImports.java

@@ -97,15 +97,24 @@ public abstract class WritableScopeWithImports extends JetScopeAdapter implement
         return null;
     }
 
-    public void importClassifierAlias(@NotNull String importedClassifierName, @NotNull ClassifierDescriptor classifierDescriptor) {
+    private WritableScope getCurrentIndividualImportScope() {
         if (currentIndividualImportScope == null) {
             WritableScopeImpl writableScope = new WritableScopeImpl(EMPTY, getContainingDeclaration(), RedeclarationHandler.DO_NOTHING).setDebugName("Individual import scope");
             importScope(writableScope);
             currentIndividualImportScope = writableScope;
         }
-        currentIndividualImportScope.addClassifierAlias(importedClassifierName, classifierDescriptor);
+        return currentIndividualImportScope;
     }
 
+    public void importClassifierAlias(@NotNull String importedClassifierName, @NotNull ClassifierDescriptor classifierDescriptor) {
+        getCurrentIndividualImportScope().addClassifierAlias(importedClassifierName, classifierDescriptor);
+    }
+    
+    
+    public void importNamespaceAlias(String aliasName, NamespaceDescriptor namespaceDescriptor) {
+        getCurrentIndividualImportScope().addNamespaceAlias(aliasName, namespaceDescriptor);
+    }
+    
     @Override
     public String toString() {
         return getClass().getSimpleName() + "@" + Integer.toHexString(System.identityHashCode(this)) + " " + debugName + " for " + getContainingDeclaration();

compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/WriteThroughScope.java

@@ -126,6 +126,11 @@ public class WriteThroughScope extends WritableScopeWithImports {
         writableWorker.addClassifierAlias(name, classifierDescriptor);
     }
 
+    @Override
+    public void addNamespaceAlias(@NotNull String name, @NotNull NamespaceDescriptor namespaceDescriptor) {
+        writableWorker.addNamespaceAlias(name, namespaceDescriptor);
+    }
+
     @Override
     public void addNamespace(@NotNull NamespaceDescriptor namespaceDescriptor) {
         writableWorker.addNamespace(namespaceDescriptor);