KT-1702 Renaming file causes "Operation not supported" and invalid imports

(Rename problem was caused because of invalid reference to file from package. Fix contains:
 - Change structure of references in package expression - last part is also a reference now
 - Resolve packages to expression but not to files)

  #KT-1702 fixed

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

@@ -162,23 +162,24 @@ public class JetParsing extends AbstractJetParsing {
 
     /* SimpleName{"."} */
     private void parseNamespaceName() {
-        PsiBuilder.Marker nsName = mark();
         while (true) {
             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);
+            PsiBuilder.Marker nsName = mark();
+            if (expect(IDENTIFIER, "Package name must be a '.'-separated identifier list", NAMESPACE_NAME_RECOVERY_SET)) {
+                nsName.done(REFERENCE_EXPRESSION);
+            }
+            else {
+                nsName.drop();
+            }
 
             if (at(DOT)) {
-                nsName.done(REFERENCE_EXPRESSION);
                 advance(); // DOT
-                nsName = mark();
             }
             else {
-                nsName.drop();
                 break;
             }
         }

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

@@ -24,7 +24,6 @@ import com.intellij.psi.impl.source.resolve.reference.ReferenceProvidersRegistry
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.JetNodeTypes;
-import org.jetbrains.jet.lexer.JetTokens;
 
 import java.util.List;
 
@@ -38,7 +37,15 @@ public class JetNamespaceHeader extends JetReferenceExpression {
 
     @NotNull
     public List<JetSimpleNameExpression> getParentNamespaceNames() {
-        return findChildrenByType(JetNodeTypes.REFERENCE_EXPRESSION);
+        List<JetSimpleNameExpression> parentParts = findChildrenByType(JetNodeTypes.REFERENCE_EXPRESSION);
+        JetSimpleNameExpression lastPart = (JetSimpleNameExpression)findLastChildByType(JetNodeTypes.REFERENCE_EXPRESSION);
+        parentParts.remove(lastPart);
+        return parentParts;
+    }
+
+    @Nullable
+    public JetSimpleNameExpression getLastPartExpression() {
+        return (JetSimpleNameExpression)findLastChildByType(JetNodeTypes.REFERENCE_EXPRESSION);
     }
 
     @NotNull
@@ -56,7 +63,12 @@ public class JetNamespaceHeader extends JetReferenceExpression {
 
     @Nullable
     public PsiElement getNameIdentifier() {
-        return findChildByType(JetTokens.IDENTIFIER);
+        JetSimpleNameExpression lastPart = (JetSimpleNameExpression)findLastChildByType(JetNodeTypes.REFERENCE_EXPRESSION);
+        if (lastPart == null) {
+            return null;
+        }
+
+        return lastPart.getIdentifier();
     }
 
     @Override

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

@@ -26,6 +26,7 @@ import com.intellij.psi.tree.TokenSet;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.parsing.JetExpressionParsing;
+import org.jetbrains.jet.lexer.JetTokens;
 
 import static org.jetbrains.jet.lexer.JetTokens.*;
 
@@ -99,6 +100,11 @@ public class JetSimpleNameExpression extends JetReferenceExpression {
         return this;
     }
 
+    @Nullable
+    public PsiElement getIdentifier() {
+        return findChildByType(JetTokens.IDENTIFIER);
+    }
+
     @Nullable @IfNotParsed
     public IElementType getReferencedNameElementType() {
         return getReferencedNameElement().getNode().getElementType();

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

@@ -24,10 +24,7 @@ import org.jetbrains.jet.lang.descriptors.ModuleDescriptor;
 import org.jetbrains.jet.lang.descriptors.NamespaceDescriptorImpl;
 import org.jetbrains.jet.lang.descriptors.NamespaceDescriptorParent;
 import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
-import org.jetbrains.jet.lang.psi.JetFile;
-import org.jetbrains.jet.lang.psi.JetNamespaceHeader;
-import org.jetbrains.jet.lang.psi.JetPsiUtil;
-import org.jetbrains.jet.lang.psi.JetSimpleNameExpression;
+import org.jetbrains.jet.lang.psi.*;
 import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 import org.jetbrains.jet.lang.resolve.scopes.RedeclarationHandler;
 import org.jetbrains.jet.lang.resolve.scopes.WritableScope;
@@ -63,13 +60,11 @@ public class NamespaceFactoryImpl implements NamespaceFactory {
         this.configuration = configuration;
     }
 
-
-
     public NamespaceDescriptorImpl createNamespaceDescriptorPathIfNeeded(JetFile file, JetScope outerScope) {
         JetNamespaceHeader namespaceHeader = file.getNamespaceHeader();
 
         if (moduleDescriptor.getRootNs() == null) {
-            createNamespaceDescriptorIfNeeded(null, moduleDescriptor, "<root>", true);
+            createNamespaceDescriptorIfNeeded(null, moduleDescriptor, "<root>", true, null);
         }
 
         NamespaceDescriptorParent currentOwner = moduleDescriptor.getRootNs();
@@ -80,22 +75,22 @@ public class NamespaceFactoryImpl implements NamespaceFactory {
         for (JetSimpleNameExpression nameExpression : namespaceHeader.getParentNamespaceNames()) {
             String namespaceName = JetPsiUtil.safeName(nameExpression.getReferencedName());
 
-            NamespaceDescriptorImpl namespaceDescriptor = createNamespaceDescriptorIfNeeded(null, currentOwner, namespaceName, false);
-            trace.record(BindingContext.NAMESPACE_IS_SRC, namespaceDescriptor, true);
-
-            currentOwner = namespaceDescriptor;
+            NamespaceDescriptorImpl namespaceDescriptor = createNamespaceDescriptorIfNeeded(
+                    null, currentOwner, namespaceName, false, nameExpression);
 
-            trace.record(REFERENCE_TARGET, nameExpression, currentOwner);
+            trace.record(BindingContext.NAMESPACE_IS_SRC, namespaceDescriptor, true);
             trace.record(RESOLUTION_SCOPE, nameExpression, outerScope);
 
             outerScope = namespaceDescriptor.getMemberScope();
+            currentOwner = namespaceDescriptor;
         }
 
         String name = JetPsiUtil.safeName(namespaceHeader.getName());
-        trace.record(RESOLUTION_SCOPE, namespaceHeader, outerScope);
+        NamespaceDescriptorImpl namespaceDescriptor = createNamespaceDescriptorIfNeeded(file, currentOwner, name, false,
+                                                                                        namespaceHeader.getLastPartExpression());
 
-        NamespaceDescriptorImpl namespaceDescriptor = createNamespaceDescriptorIfNeeded(file, currentOwner, name, false);
         trace.record(BindingContext.NAMESPACE_IS_SRC, namespaceDescriptor, true);
+        trace.record(RESOLUTION_SCOPE, namespaceHeader, outerScope);
 
         return namespaceDescriptor;
     }
@@ -106,13 +101,14 @@ public class NamespaceFactoryImpl implements NamespaceFactory {
         NamespaceDescriptorParent owner = moduleDescriptor;
         for (FqName pathElement : fqName.path()) {
             owner = createNamespaceDescriptorIfNeeded(null,
-                    owner, pathElement.isRoot() ? "<root>" : pathElement.shortName(), pathElement.isRoot());
+                    owner, pathElement.isRoot() ? "<root>" : pathElement.shortName(), pathElement.isRoot(), null);
         }
         return (NamespaceDescriptorImpl) owner;
     }
 
     @NotNull
-    public NamespaceDescriptorImpl createNamespaceDescriptorIfNeeded(@Nullable JetFile file, @NotNull NamespaceDescriptorParent owner, @NotNull String name, boolean root) {
+    public NamespaceDescriptorImpl createNamespaceDescriptorIfNeeded(@Nullable JetFile file,
+            @NotNull NamespaceDescriptorParent owner, @NotNull String name, boolean root, @Nullable JetReferenceExpression expression) {
         FqName fqName;
         NamespaceDescriptorImpl namespaceDescriptor;
         if (root) {
@@ -140,11 +136,15 @@ public class NamespaceFactoryImpl implements NamespaceFactory {
             namespaceDescriptor.initialize(scope);
             configuration.extendNamespaceScope(trace, namespaceDescriptor, scope);
             owner.addNamespace(namespaceDescriptor);
-            if (file != null) {
-                trace.record(BindingContext.NAMESPACE, file, namespaceDescriptor);
+            if (expression != null) {
+                trace.record(BindingContext.NAMESPACE, expression, namespaceDescriptor);
             }
         }
 
+        if (expression != null) {
+            trace.record(REFERENCE_TARGET, expression, namespaceDescriptor);
+        }
+
         if (file != null) {
             trace.record(BindingContext.FILE_TO_NAMESPACE, file, namespaceDescriptor);
 

compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/ValueArgumentsToParametersMapper.java

@@ -187,8 +187,9 @@ import static org.jetbrains.jet.lang.resolve.BindingContext.REFERENCE_TARGET;
             error = true;
         }
 
-        assert candidateCall.getThisObject().exists() == candidateCall.getResultingDescriptor().getExpectedThisObject().exists() :
-                "Shouldn't happen because of TaskPrioritizer: " + candidateCall.getCandidateDescriptor();
+        if (candidateCall.getThisObject().exists() != candidateCall.getResultingDescriptor().getExpectedThisObject().exists()) {
+            assert false : "Shouldn't happen because of TaskPrioritizer: " + candidateCall.getCandidateDescriptor();
+        }
 
         return error;
     }

compiler/testData/psi/Attributes.txt

@@ -8,7 +8,8 @@ JetFile: Attributes.jet
     REFERENCE_EXPRESSION
       PsiElement(IDENTIFIER)('bar')
     PsiElement(DOT)('.')
-    PsiElement(IDENTIFIER)('goo')
+    REFERENCE_EXPRESSION
+      PsiElement(IDENTIFIER)('goo')
   PsiWhiteSpace('\n\n')
   CLASS
     MODIFIER_LIST

compiler/testData/psi/Attributes_ERR.txt

@@ -8,7 +8,8 @@ JetFile: Attributes_ERR.jet
     REFERENCE_EXPRESSION
       PsiElement(IDENTIFIER)('bar')
     PsiElement(DOT)('.')
-    PsiElement(IDENTIFIER)('goo')
+    REFERENCE_EXPRESSION
+      PsiElement(IDENTIFIER)('goo')
   PsiWhiteSpace('\n\n')
   CLASS
     MODIFIER_LIST

compiler/testData/psi/BabySteps.txt

@@ -2,7 +2,8 @@ JetFile: BabySteps.jet
   NAMESPACE_HEADER
     PsiElement(package)('package')
     PsiWhiteSpace(' ')
-    PsiElement(IDENTIFIER)('foo')
+    REFERENCE_EXPRESSION
+      PsiElement(IDENTIFIER)('foo')
   PsiWhiteSpace('\n\n')
   CLASS
     PsiElement(class)('class')

compiler/testData/psi/BabySteps_ERR.txt

@@ -2,7 +2,8 @@ JetFile: BabySteps_ERR.jet
   NAMESPACE_HEADER
     PsiElement(package)('package')
     PsiWhiteSpace(' ')
-    PsiElement(IDENTIFIER)('foo')
+    REFERENCE_EXPRESSION
+      PsiElement(IDENTIFIER)('foo')
   PsiWhiteSpace('\n\n')
   CLASS
     PsiElement(class)('class')

compiler/testData/psi/Imports.txt

@@ -8,7 +8,8 @@ JetFile: Imports.jet
     REFERENCE_EXPRESSION
       PsiElement(IDENTIFIER)('bar')
     PsiElement(DOT)('.')
-    PsiElement(IDENTIFIER)('goo')
+    REFERENCE_EXPRESSION
+      PsiElement(IDENTIFIER)('goo')
   PsiWhiteSpace('\n\n')
   IMPORT_DIRECTIVE
     PsiElement(import)('import')

compiler/testData/psi/Imports_ERR.txt

@@ -8,7 +8,8 @@ JetFile: Imports_ERR.jet
     REFERENCE_EXPRESSION
       PsiElement(IDENTIFIER)('bar')
     PsiElement(DOT)('.')
-    PsiElement(IDENTIFIER)('goo')
+    REFERENCE_EXPRESSION
+      PsiElement(IDENTIFIER)('goo')
   PsiWhiteSpace('\n\n')
   IMPORT_DIRECTIVE
     PsiElement(import)('import')

compiler/testData/psi/NamespaceModifiers.txt

@@ -15,4 +15,5 @@ JetFile: NamespaceModifiers.jet
     PsiWhiteSpace(' ')
     PsiElement(package)('package')
     PsiWhiteSpace(' ')
-    PsiElement(IDENTIFIER)('name')
\ No newline at end of file
+    REFERENCE_EXPRESSION
+      PsiElement(IDENTIFIER)('name')
\ No newline at end of file

compiler/testData/psi/RootNamespace.txt

@@ -5,7 +5,8 @@ JetFile: RootNamespace.jet
     REFERENCE_EXPRESSION
       PsiElement(IDENTIFIER)('foo')
     PsiElement(DOT)('.')
-    PsiElement(IDENTIFIER)('bar')
+    REFERENCE_EXPRESSION
+      PsiElement(IDENTIFIER)('bar')
     PsiElement(SEMICOLON)(';')
   PsiWhiteSpace('\n\n')
   CLASS

compiler/testData/psi/ShortAnnotations.txt

@@ -51,7 +51,8 @@ JetFile: ShortAnnotations.jet
     PsiWhiteSpace(' ')
     PsiElement(package)('package')
     PsiWhiteSpace(' ')
-    PsiElement(IDENTIFIER)('aa')
+    REFERENCE_EXPRESSION
+      PsiElement(IDENTIFIER)('aa')
   PsiWhiteSpace('\n\n')
   CLASS
     MODIFIER_LIST

compiler/testData/psi/SimpleModifiers.txt

@@ -8,7 +8,8 @@ JetFile: SimpleModifiers.jet
     REFERENCE_EXPRESSION
       PsiElement(IDENTIFIER)('bar')
     PsiElement(DOT)('.')
-    PsiElement(IDENTIFIER)('goo')
+    REFERENCE_EXPRESSION
+      PsiElement(IDENTIFIER)('goo')
   PsiWhiteSpace('\n\n')
   CLASS
     MODIFIER_LIST

compiler/testData/psi/SoftKeywords.txt

@@ -8,7 +8,8 @@ JetFile: SoftKeywords.jet
     REFERENCE_EXPRESSION
       PsiElement(IDENTIFIER)('bar')
     PsiElement(DOT)('.')
-    PsiElement(IDENTIFIER)('goo')
+    REFERENCE_EXPRESSION
+      PsiElement(IDENTIFIER)('goo')
   PsiWhiteSpace('\n\n')
   IMPORT_DIRECTIVE
     PsiElement(import)('import')

compiler/testData/psi/TypeDef.txt

@@ -8,7 +8,8 @@ JetFile: TypeDef.jet
     REFERENCE_EXPRESSION
       PsiElement(IDENTIFIER)('bar')
     PsiElement(DOT)('.')
-    PsiElement(IDENTIFIER)('goo')
+    REFERENCE_EXPRESSION
+      PsiElement(IDENTIFIER)('goo')
   PsiWhiteSpace('\n\n')
   TYPEDEF
     PsiElement(type)('type')

compiler/testData/resolve/Namespaces.jet

 // FILE: f.kt
-~a~package a
+package ~a~a
     import java.*
 
     ~a.a~val a : util.List<Int>? = null

compiler/testData/resolve/NestedObjects.jet

-~ns~package nestedObjects
+package ~ns~nestedObjects
   object ~A~A {
     val b = `A.B`B
     val d = `A`A.`A.B`B.`A.B.A`A

compiler/tests/org/jetbrains/jet/compiler/ReadKotlinBinaryClassTest.java

@@ -22,11 +22,14 @@ import com.intellij.openapi.vfs.CharsetToolkit;
 import com.intellij.psi.PsiFileFactory;
 import com.intellij.psi.impl.PsiFileFactoryImpl;
 import com.intellij.testFramework.LightVirtualFile;
+import junit.framework.Assert;
 import junit.framework.Test;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.JetTestCaseBuilder;
 import org.jetbrains.jet.JetTestUtils;
-import org.jetbrains.jet.codegen.*;
+import org.jetbrains.jet.codegen.ClassFileFactory;
+import org.jetbrains.jet.codegen.GenerationState;
+import org.jetbrains.jet.codegen.GenerationUtils;
 import org.jetbrains.jet.di.InjectorForJavaSemanticServices;
 import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor;
 import org.jetbrains.jet.lang.psi.JetFile;
@@ -35,7 +38,6 @@ import org.jetbrains.jet.lang.resolve.FqName;
 import org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule;
 import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver;
 import org.jetbrains.jet.plugin.JetLanguage;
-import org.junit.Assert;
 
 import java.io.File;
 
@@ -73,7 +75,7 @@ public class ReadKotlinBinaryClassTest extends TestCaseWithTmpdir {
 
         CompileEnvironment.writeToOutputDirectory(classFileFactory, tmpdir.getPath());
         
-        NamespaceDescriptor namespaceFromSource = (NamespaceDescriptor) state.getBindingContext().get(BindingContext.DECLARATION_TO_DESCRIPTOR, psiFile);
+        NamespaceDescriptor namespaceFromSource = state.getBindingContext().get(BindingContext.FILE_TO_NAMESPACE, psiFile);
 
         Assert.assertEquals("test", namespaceFromSource.getName());
 

compiler/tests/org/jetbrains/jet/resolve/ExpectedResolveData.java

@@ -35,9 +35,9 @@ import org.jetbrains.jet.lang.resolve.java.AnalyzeExhaust;
 import org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM;
 import org.jetbrains.jet.lang.resolve.java.CompilerSpecialMode;
 import org.jetbrains.jet.lang.types.ErrorUtils;
-import org.jetbrains.jet.lang.types.lang.JetStandardLibrary;
 import org.jetbrains.jet.lang.types.JetType;
 import org.jetbrains.jet.lang.types.TypeConstructor;
+import org.jetbrains.jet.lang.types.lang.JetStandardLibrary;
 
 import java.util.List;
 import java.util.Map;
@@ -160,7 +160,7 @@ public abstract class ExpectedResolveData {
             if (ancestorOfType == null) {
                 JetNamespaceHeader header = getAncestorOfType(JetNamespaceHeader.class, element);
                 assert header != null : "Not a declaration: " + name;
-                ancestorOfType = header.getContainingFile();
+                ancestorOfType = element;
             }
             nameToDeclaration.put(name, ancestorOfType);
             declarationToName.put(ancestorOfType, name);
@@ -237,6 +237,9 @@ public abstract class ExpectedResolveData {
             assert expected != null : "No declaration for " + name;
 
             PsiElement actual = BindingContextUtils.resolveToDeclarationPsiElement(bindingContext, reference);
+            if (actual instanceof JetSimpleNameExpression) {
+                actual = ((JetSimpleNameExpression)actual).getIdentifier();
+            }
 
             String actualName = null;
             if (actual != null) {

idea/src/org/jetbrains/jet/plugin/completion/JetPackagesContributor.java

@@ -24,9 +24,11 @@ import com.intellij.psi.PsiReference;
 import com.intellij.psi.util.PsiTreeUtil;
 import com.intellij.util.ProcessingContext;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.compiler.TipsManager;
 import org.jetbrains.jet.lang.psi.JetFile;
 import org.jetbrains.jet.lang.psi.JetNamespaceHeader;
-import org.jetbrains.jet.plugin.references.JetPackageReference;
+import org.jetbrains.jet.lang.resolve.BindingContext;
+import org.jetbrains.jet.plugin.project.WholeProjectAnalyzerFacade;
 
 /**
  * Performs completion in package directive. Should suggest only packages and avoid showing fake package produced by
@@ -60,28 +62,26 @@ public class JetPackagesContributor extends CompletionContributor {
                        if (ref != null) {
 
                            // For package there will be a wrong prefix matcher with the whole package directive as prefix
-                           if (ref instanceof JetPackageReference) {
-                               JetPackageReference packageRef = (JetPackageReference) ref;
-                               PsiElement nameIdentifier = packageRef.getExpression().getNameIdentifier();
-                               if (nameIdentifier == null) {
-                                   return;
-                               }
-
-                               if (!(nameIdentifier.getTextOffset() <= parameters.getOffset())) {
-                                   return;
-                               }
+                           PsiElement nameIdentifier = namespaceHeader.getNameIdentifier();
+                           if (nameIdentifier == null) {
+                               return;
+                           }
 
-                               int prefixLength = parameters.getOffset() - nameIdentifier.getTextOffset();
-                               result = result.withPrefixMatcher(new PlainPrefixMatcher(nameIdentifier.getText().substring(0, prefixLength)));
+                           if (!(nameIdentifier.getTextOffset() <= parameters.getOffset())) {
+                               return;
                            }
 
-                           Object[] variants = ref.getVariants();
-                           for (Object variant : variants) {
-                               if (variant instanceof LookupElement) {
-                                   LookupElement lookupElement = (LookupElement) variant;
-                                   if (!lookupElement.getLookupString().contains(DUMMY_IDENTIFIER)) {
-                                       result.addElement((LookupElement) variant);
-                                   }
+                           int prefixLength = parameters.getOffset() - nameIdentifier.getTextOffset();
+                           result = result.withPrefixMatcher(new PlainPrefixMatcher(nameIdentifier.getText().substring(0, prefixLength)));
+
+                           BindingContext bindingContext = WholeProjectAnalyzerFacade.analyzeProjectWithCacheOnAFile(
+                                   (JetFile)namespaceHeader.getContainingFile())
+                                   .getBindingContext();
+
+                           for (LookupElement variant : DescriptorLookupConverter.collectLookupElements(
+                                   bindingContext, TipsManager.getReferenceVariants(namespaceHeader, bindingContext))) {
+                               if (!variant.getLookupString().contains(DUMMY_IDENTIFIER)) {
+                                   result.addElement(variant);
                                }
                            }
 

idea/src/org/jetbrains/jet/plugin/references/JetPackageReference.java

-/*
- * Copyright 2010-2012 JetBrains s.r.o.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.jetbrains.jet.plugin.references;
-
-import com.intellij.openapi.util.TextRange;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.jet.compiler.TipsManager;
-import org.jetbrains.jet.lang.psi.JetFile;
-import org.jetbrains.jet.lang.psi.JetNamespaceHeader;
-import org.jetbrains.jet.lang.resolve.BindingContext;
-import org.jetbrains.jet.plugin.completion.DescriptorLookupConverter;
-import org.jetbrains.jet.plugin.project.WholeProjectAnalyzerFacade;
-
-/**
- * @author Nikolay Krasko
- */
-public class JetPackageReference extends JetPsiReference {
-
-    private JetNamespaceHeader packageExpression;
-
-    public JetPackageReference(@NotNull JetNamespaceHeader expression) {
-        super(expression);
-        packageExpression = expression;
-    }
-
-    @NotNull
-    @Override
-    public Object[] getVariants() {
-        BindingContext bindingContext = WholeProjectAnalyzerFacade.analyzeProjectWithCacheOnAFile(
-                (JetFile) myExpression.getContainingFile())
-                    .getBindingContext();
-
-        return DescriptorLookupConverter.collectLookupElements(
-                bindingContext, TipsManager.getReferenceVariants(packageExpression, bindingContext));
-    }
-
-    @NotNull
-    @Override
-    public TextRange getRangeInElement() {
-        return new TextRange(0, getElement().getTextLength());
-    }
-
-    @NotNull
-    public JetNamespaceHeader getExpression() {
-        return packageExpression;
-    }
-}

idea/src/org/jetbrains/jet/plugin/references/JetPsiReference.java

@@ -16,6 +16,8 @@
 
 package org.jetbrains.jet.plugin.references;
 
+import com.intellij.openapi.diagnostic.Logger;
+import com.intellij.openapi.vfs.VirtualFile;
 import com.intellij.psi.PsiElement;
 import com.intellij.psi.PsiElementResolveResult;
 import com.intellij.psi.PsiPolyVariantReference;
@@ -38,6 +40,8 @@ import static org.jetbrains.jet.lang.resolve.BindingContext.DESCRIPTOR_TO_DECLAR
 
 public abstract class JetPsiReference implements PsiPolyVariantReference {
 
+    private static final Logger LOG = Logger.getInstance("#org.jetbrains.jet.plugin.references.JetPsiReference");
+
     @NotNull
     protected final JetReferenceExpression myExpression;
 
@@ -99,8 +103,7 @@ public abstract class JetPsiReference implements PsiPolyVariantReference {
     @Nullable
     protected PsiElement doResolve() {
         JetFile file = (JetFile) getElement().getContainingFile();
-        BindingContext bindingContext = WholeProjectAnalyzerFacade.analyzeProjectWithCacheOnAFile(file)
-                .getBindingContext();
+        BindingContext bindingContext = WholeProjectAnalyzerFacade.analyzeProjectWithCacheOnAFile(file).getBindingContext();
         PsiElement psiElement = BindingContextUtils.resolveToDeclarationPsiElement(bindingContext, myExpression);
         if (psiElement != null) {
             return psiElement;
@@ -108,6 +111,13 @@ public abstract class JetPsiReference implements PsiPolyVariantReference {
         Collection<? extends DeclarationDescriptor> declarationDescriptors = bindingContext.get(AMBIGUOUS_REFERENCE_TARGET, myExpression);
         if (declarationDescriptors != null) return null;
 
+
+        VirtualFile elementFile = file.getVirtualFile();
+        if (elementFile != null && elementFile.getNameWithoutExtension().equals(getElement().getText())) {
+            LOG.warn("Possible problem with file rename: " + elementFile.getNameWithoutExtension() +
+                     ", element: " + getElement());
+        }
+
         // TODO: Need a better resolution for Intrinsic function (KT-975)
         return file;
     }

idea/src/org/jetbrains/jet/plugin/references/JetReferenceContributor.java

@@ -20,7 +20,6 @@ import com.intellij.psi.*;
 import com.intellij.util.ProcessingContext;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.psi.JetArrayAccessExpression;
-import org.jetbrains.jet.lang.psi.JetNamespaceHeader;
 import org.jetbrains.jet.lang.psi.JetSimpleNameExpression;
 import org.jetbrains.jet.lang.psi.JetThisReferenceExpression;
 
@@ -41,15 +40,6 @@ public class JetReferenceContributor extends PsiReferenceContributor {
                                                 }
                                             });
 
-        registrar.registerReferenceProvider(psiElement(JetNamespaceHeader.class),
-                                            new PsiReferenceProvider() {
-                                                @NotNull
-                                                @Override
-                                                public PsiReference[] getReferencesByElement(@NotNull PsiElement element, @NotNull ProcessingContext context) {
-                                                    return new PsiReference[] { new JetPackageReference((JetNamespaceHeader) element) };
-                                                }
-                                            });
-
         registrar.registerReferenceProvider(psiElement(JetThisReferenceExpression.class),
                                             new PsiReferenceProvider() {
                                                 @NotNull