KT-1229 Packages should be showed in package derictive

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

@@ -97,6 +97,16 @@ public final class TipsManager {
         return Collections.emptyList();
     }
 
+    @NotNull
+    public static Collection<DeclarationDescriptor> getReferenceVariants(JetNamespaceHeader expression, BindingContext context) {
+        JetScope resolutionScope = context.get(BindingContext.RESOLUTION_SCOPE, expression);
+        if (resolutionScope != null) {
+            return excludeNonPackageDescriptors(resolutionScope.getAllDescriptors());
+        }
+
+        return Collections.emptyList();
+    }
+
     public static Collection<DeclarationDescriptor> excludePrivateDescriptors(
             @NotNull Collection<DeclarationDescriptor> descriptors) {
 

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

@@ -135,6 +135,8 @@ public class JetParsing extends AbstractJetParsing {
 
         if (at(PACKAGE_KEYWORD)) {
             advance(); // PACKAGE_KEYWORD
+
+
             parseNamespaceName();
 
             if (at(LBRACE)) {
@@ -162,7 +164,14 @@ public class JetParsing extends AbstractJetParsing {
     private void parseNamespaceName() {
         PsiBuilder.Marker nsName = mark();
         while (true) {
-            expect(IDENTIFIER, "Namespace name must be a '.'-separated identifier list", NAMESPACE_NAME_RECOVERY_SET);
+            if (myBuilder.newlineBeforeCurrentToken()) {
+                errorWithRecovery("Package name must be a '.'-separated identifier list placed on a single line", NAMESPACE_NAME_RECOVERY_SET);
+                nsName.drop();
+                break;
+            }
+
+            expect(IDENTIFIER, "Package name must be a '.'-separated identifier list", NAMESPACE_NAME_RECOVERY_SET);
+
             if (at(DOT)) {
                 nsName.done(REFERENCE_EXPRESSION);
                 advance(); // DOT

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

@@ -18,6 +18,9 @@ package org.jetbrains.jet.lang.psi;
 
 import com.intellij.lang.ASTNode;
 import com.intellij.psi.PsiElement;
+import com.intellij.psi.PsiReference;
+import com.intellij.psi.PsiReferenceService;
+import com.intellij.psi.impl.source.resolve.reference.ReferenceProvidersRegistry;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.JetNodeTypes;
@@ -28,7 +31,7 @@ import java.util.List;
 /**
  * @author abreslav
  */
-public class JetNamespaceHeader extends JetElement {
+public class JetNamespaceHeader extends JetReferenceExpression {
     public JetNamespaceHeader(@NotNull ASTNode node) {
         super(node);
     }
@@ -38,6 +41,19 @@ public class JetNamespaceHeader extends JetElement {
         return findChildrenByType(JetNodeTypes.REFERENCE_EXPRESSION);
     }
 
+    @NotNull
+    @Override
+    public PsiReference[] getReferences() {
+        return ReferenceProvidersRegistry.getReferencesFromProviders(this, PsiReferenceService.Hints.NO_HINTS);
+    }
+
+    @Nullable
+    @Override
+    public PsiReference getReference() {
+        PsiReference[] references = getReferences();
+        return references.length == 1 ? references[0] : null;
+    }
+
     @Nullable
     public PsiElement getNameIdentifier() {
         return findChildByType(JetTokens.IDENTIFIER);
@@ -49,3 +65,4 @@ public class JetNamespaceHeader extends JetElement {
         return nameIdentifier == null ? "" : nameIdentifier.getText();
     }
 }
+

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

@@ -85,7 +85,7 @@ public class TypeHierarchyResolver {
             declaration.accept(new JetVisitorVoid() {
                 @Override
                 public void visitJetFile(JetFile file) {
-                    NamespaceDescriptorImpl namespaceDescriptor = createNamespaceDescriptorPathIfNeeded(file, owner);
+                    NamespaceDescriptorImpl namespaceDescriptor = createNamespaceDescriptorPathIfNeeded(file, owner, outerScope);
                     context.getNamespaceDescriptors().put(file, namespaceDescriptor);
 
                     WriteThroughScope namespaceScope = new WriteThroughScope(outerScope, namespaceDescriptor.getMemberScope(), new TraceBasedRedeclarationHandler(context.getTrace()));
@@ -199,19 +199,34 @@ public class TypeHierarchyResolver {
         }
     }
 
-    private NamespaceDescriptorImpl createNamespaceDescriptorPathIfNeeded(JetFile file, NamespaceLike owner) {
+    private NamespaceDescriptorImpl createNamespaceDescriptorPathIfNeeded(JetFile file, NamespaceLike owner, JetScope outerScope) {
+
         NamespaceLike currentOwner = owner;
+
         for (JetSimpleNameExpression nameExpression : file.getNamespaceHeader().getParentNamespaceNames()) {
-            currentOwner = createNamespaceDescriptorIfNeeded(null, currentOwner, JetPsiUtil.safeName(nameExpression.getReferencedName()));
+            String namespaceName = JetPsiUtil.safeName(nameExpression.getReferencedName());
+
+            NamespaceDescriptorImpl namespaceDescriptor = createNamespaceDescriptorIfNeeded(null, currentOwner, namespaceName);
+
+            currentOwner = namespaceDescriptor;
+
             context.getTrace().record(REFERENCE_TARGET, nameExpression, currentOwner);
+            context.getTrace().record(RESOLUTION_SCOPE, nameExpression, outerScope);
+
+            outerScope = namespaceDescriptor.getMemberScope();
         }
 
         String name = JetPsiUtil.safeName(file.getNamespaceHeader().getName());
+        context.getTrace().record(RESOLUTION_SCOPE, file.getNamespaceHeader(), outerScope);
+
         return createNamespaceDescriptorIfNeeded(file, currentOwner, name);
+
+
     }
 
     @NotNull
-    private NamespaceDescriptorImpl createNamespaceDescriptorIfNeeded(@Nullable JetFile file, @NotNull NamespaceLike owner, @NotNull String name) {
+    private NamespaceDescriptorImpl createNamespaceDescriptorIfNeeded(@Nullable JetFile file, @NotNull NamespaceLike owner, String name) {
+
         NamespaceDescriptorImpl namespaceDescriptor = owner.getNamespace(name);
         if (namespaceDescriptor == null) {
             namespaceDescriptor = new NamespaceDescriptorImpl(
@@ -229,6 +244,7 @@ public class TypeHierarchyResolver {
                 context.getTrace().record(BindingContext.NAMESPACE, file, namespaceDescriptor);
             }
         }
+
         return namespaceDescriptor;
     }
 
@@ -406,7 +422,7 @@ public class TypeHierarchyResolver {
                             Filter.REMOVE_IF_SUBTYPE_IN_THE_SET.proceed(conflictingTypes);
                             break;
                     }
-                    
+
                     if (conflictingTypes.size() > 1) {
                         DeclarationDescriptor containingDeclaration = typeParameterDescriptor.getContainingDeclaration();
                         assert containingDeclaration instanceof ClassDescriptor : containingDeclaration;
@@ -436,7 +452,7 @@ public class TypeHierarchyResolver {
                 return JetTypeChecker.INSTANCE.isSubtypeOf(subject, other);
             }
         };
-        
+
         private void proceed(Set<JetType> conflictingTypes) {
             for (Iterator<JetType> iterator = conflictingTypes.iterator(); iterator.hasNext(); ) {
                 JetType type = iterator.next();
@@ -452,7 +468,7 @@ public class TypeHierarchyResolver {
 
         public abstract boolean removeNeeded(JetType subject, JetType other);
     }
-    
+
     private void checkTypesInClassHeaders() {
         for (Map.Entry<JetClass, MutableClassDescriptor> entry : context.getClasses().entrySet()) {
             JetClass jetClass = entry.getKey();