From 1a0a92c11da77b8930f677c77c4b6e91d5ee3e50 Mon Sep 17 00:00:00 2001
From: Andrey Breslav <abreslav@abreslav-mac.labs.intellij.net>
Date: Wed, 12 Oct 2011 21:38:48 +0400
Subject: [PATCH] Imports with renaming supported for namespaces

---
 .../lang/resolve/TypeHierarchyResolver.java   | 18 +++++++++++---
 .../lang/resolve/scopes/WritableScope.java    |  2 ++
 .../resolve/scopes/WritableScopeImpl.java     | 24 +++++++++++++++----
 .../scopes/WritableScopeWithImports.java      | 13 ++++++++--
 .../resolve/scopes/WriteThroughScope.java     |  5 ++++
 5 files changed, 53 insertions(+), 9 deletions(-)

diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TypeHierarchyResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TypeHierarchyResolver.java
index 1a5d519e22c..698bdf32b65 100644
--- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TypeHierarchyResolver.java
+++ b/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();
-                    String importedClassifierName = aliasName != null ? aliasName : classifierDescriptor.getName();
-                    namespaceScope.importClassifierAlias(importedClassifierName, classifierDescriptor);
+                    if (aliasName != null) {
+                        namespaceScope.importClassifierAlias(aliasName, classifierDescriptor);
+                    }
+                }
+                if (namespaceDescriptor != null) {
+                    if (classifierDescriptor == null) {
+                        context.getTrace().record(BindingContext.REFERENCE_TARGET, referenceExpression, namespaceDescriptor);
+                    }
+                    if (aliasName != null) {
+                        namespaceScope.importNamespaceAlias(aliasName, namespaceDescriptor);
+                    }
                 }
             }
         }
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/WritableScope.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/WritableScope.java
index f37b8ae6b16..04ea11c3be4 100644
--- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/WritableScope.java
+++ b/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
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/WritableScopeImpl.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/WritableScopeImpl.java
index b63ee731480..ad719ac3305 100644
--- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/WritableScopeImpl.java
+++ b/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();
-        DeclarationDescriptor originalDescriptor = variableClassOrNamespaceDescriptors.get(name);
+        checkForRedeclaration(name, classifierDescriptor);
+        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
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/WritableScopeWithImports.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/WritableScopeWithImports.java
index b88a8d17be3..e3205c0d9ee 100644
--- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/WritableScopeWithImports.java
+++ b/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();
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/WriteThroughScope.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/WriteThroughScope.java
index fb5e6e6a8b5..941562949e4 100644
--- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/WriteThroughScope.java
+++ b/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);