- KT-1232 Do not place import with default imports in scope after completion

- Don't activate not-in-scope completion on typing by default

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

@@ -4,14 +4,11 @@ import com.google.common.base.Predicate;
 import com.google.common.collect.Collections2;
 import com.google.common.collect.Lists;
 import com.google.common.collect.Sets;
-import com.intellij.util.containers.HashSet;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.jet.lang.descriptors.CallableDescriptor;
+import org.jetbrains.jet.lang.descriptors.*;
-import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
-import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor;
-import org.jetbrains.jet.lang.descriptors.TypeParameterDescriptor;
 import org.jetbrains.jet.lang.psi.JetExpression;
 import org.jetbrains.jet.lang.psi.JetImportDirective;
+import org.jetbrains.jet.lang.psi.JetNamespaceHeader;
 import org.jetbrains.jet.lang.psi.JetSimpleNameExpression;
 import org.jetbrains.jet.lang.resolve.BindingContext;
 import org.jetbrains.jet.lang.resolve.calls.inference.ConstraintResolutionListener;
@@ -57,17 +54,23 @@ public final class TipsManager {
         } else {
             JetScope resolutionScope = context.get(BindingContext.RESOLUTION_SCOPE, expression);
             if (resolutionScope != null) {
-                if (expression.getParent() instanceof JetImportDirective) {
+                if (expression.getParent() instanceof JetImportDirective || expression.getParent() instanceof JetNamespaceHeader) {
                     return excludeNonPackageDescriptors(resolutionScope.getAllDescriptors());
                 } else {
                     java.util.HashSet<DeclarationDescriptor> descriptorsSet = Sets.newHashSet();
+
                     ArrayList<ReceiverDescriptor> result = new ArrayList<ReceiverDescriptor>();
                     resolutionScope.getImplicitReceiversHierarchy(result);
+
                     for (ReceiverDescriptor receiverDescriptor : result) {
                         JetType receiverType = receiverDescriptor.getType();
                         descriptorsSet.addAll(receiverType.getMemberScope().getAllDescriptors());
                     }
+
                     descriptorsSet.addAll(resolutionScope.getAllDescriptors());
+
+                    ClassDescriptor anInt = context.get(BindingContext.FQNAME_TO_CLASS_DESCRIPTOR, "Int");
+
                     return excludeNotCallableExtensions(descriptorsSet, resolutionScope);
                 }
             }

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

@@ -10,6 +10,7 @@ import org.jetbrains.jet.lang.resolve.BindingTrace;
 import org.jetbrains.jet.lang.resolve.DescriptorUtils;
 import org.jetbrains.jet.lang.resolve.Importer;
 import org.jetbrains.jet.lang.resolve.scopes.WritableScope;
+import org.jetbrains.jet.util.QualifiedNamesUtil;
 
 import java.util.Collections;
 
@@ -18,6 +19,8 @@ import java.util.Collections;
  */
 public class JavaBridgeConfiguration implements Configuration {
 
+    public static final String[] DEFAULT_JAVA_IMPORTS = new String[] { "java.lang" };
+
     public static Configuration createJavaBridgeConfiguration(@NotNull Project project, @NotNull BindingTrace trace, Configuration delegateConfiguration) {
         return new JavaBridgeConfiguration(project, trace, delegateConfiguration);
     }
@@ -33,7 +36,10 @@ public class JavaBridgeConfiguration implements Configuration {
     @Override
     public void addDefaultImports(@NotNull BindingTrace trace, @NotNull WritableScope rootScope, @NotNull Importer importer) {
         rootScope.importScope(new JavaPackageScope("", createNamespaceDescriptor(JavaDescriptorResolver.JAVA_ROOT, ""), javaSemanticServices));
-        importer.addScopeImport(new JavaPackageScope("java.lang", createNamespaceDescriptor("lang", "java.lang"), javaSemanticServices));
+        for (String importFQN : DEFAULT_JAVA_IMPORTS) {
+            importer.addScopeImport(new JavaPackageScope(
+                importFQN, createNamespaceDescriptor(QualifiedNamesUtil.fqnToShortName(importFQN), importFQN), javaSemanticServices));
+        }
         delegateConfiguration.addDefaultImports(trace, rootScope, importer);
     }
 

compiler/frontend/src/org/jetbrains/jet/lang/StandardConfiguration.java

@@ -13,6 +13,8 @@ import org.jetbrains.jet.lang.resolve.scopes.WritableScope;
  * @author svtk
  */
 public class StandardConfiguration implements Configuration {
+    public static final String[] DEFAULT_JET_IMPORTS = new String[] { "std.*", "std.io.*" };
+
     private Project project;
 
     public static StandardConfiguration createStandardConfiguration(Project project) {
@@ -26,8 +28,9 @@ public class StandardConfiguration implements Configuration {
     @Override
     public void addDefaultImports(@NotNull BindingTrace trace, @NotNull WritableScope rootScope, @NotNull Importer importer) {
         ImportsResolver.ImportResolver importResolver = new ImportsResolver.ImportResolver(trace, true);
-        importResolver.processImportReference(JetPsiFactory.createImportDirective(project, "std.*"), rootScope, importer);
+        for (String defaultJetImport : DEFAULT_JET_IMPORTS) {
-        importResolver.processImportReference(JetPsiFactory.createImportDirective(project, "std.io.*"), rootScope, importer);
+            importResolver.processImportReference(JetPsiFactory.createImportDirective(project, defaultJetImport), rootScope, importer);
+        }
     }
 
     @Override

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

@@ -146,10 +146,8 @@ public class JetCompletionContributor extends CompletionContributor {
                 }
 
                 if (PsiTreeUtil.getParentOfType(nameExpression, JetUserType.class) != null) {
-                    return true;
+                    return parameters.getInvocationCount() == 1;
                 }
-
-                return parameters.getInvocationCount() == 1;
             }
         }
 

idea/src/org/jetbrains/jet/plugin/quickfix/ImportClassHelper.java

@@ -2,9 +2,11 @@ package org.jetbrains.jet.plugin.quickfix;
 
 import com.intellij.psi.PsiElement;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.lang.StandardConfiguration;
 import org.jetbrains.jet.lang.psi.*;
 import org.jetbrains.jet.lang.resolve.BindingContext;
 import org.jetbrains.jet.lang.resolve.java.AnalyzerFacade;
+import org.jetbrains.jet.lang.resolve.java.JavaBridgeConfiguration;
 import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver;
 import org.jetbrains.jet.lang.types.ErrorUtils;
 import org.jetbrains.jet.lang.types.JetType;
@@ -48,13 +50,10 @@ public class ImportClassHelper {
             importString = importString.substring((JavaDescriptorResolver.JAVA_ROOT + ".").length());
         }
 
-        // Check that import is useless
+        if (isImportedByDefault(importString, JetPsiUtil.getFQName(file))) {
-        if (QualifiedNamesUtil.isOneSegmentFQN(importString) ||
-                JetPsiUtil.getFQName(file).equals(QualifiedNamesUtil.withoutLastSegment(importString))) {
-
             return;
         }
-        
+
         List<JetImportDirective> importDirectives = file.getImportDirectives();
 
         JetImportDirective newDirective = JetPsiFactory.createImportDirective(file.getProject(), importString);
@@ -79,4 +78,26 @@ public class ImportClassHelper {
             firstDeclaration.getParent().addBefore(newDirective, firstDeclaration);
         }
     }
+
+    // Check that import is useless
+    private static boolean isImportedByDefault(@NotNull String importString, @NotNull String filePackageFqn) {
+        if (QualifiedNamesUtil.isOneSegmentFQN(importString) ||
+            filePackageFqn.equals(QualifiedNamesUtil.withoutLastSegment(importString))) {
+
+            return true;
+        }
+
+        for (String defaultJetImport : StandardConfiguration.DEFAULT_JET_IMPORTS) {
+            if (QualifiedNamesUtil.isImported(defaultJetImport, importString)) {
+                return true;
+            }
+        }
+
+        for (String defaultJavaImport : JavaBridgeConfiguration.DEFAULT_JAVA_IMPORTS) {
+            if (QualifiedNamesUtil.isImported(defaultJavaImport + ".*", importString)) {
+                return true;
+            }
+        }
+        return false;
+    }
 }

idea/testData/quickfix/importHelper/NoDefaultImport.kt

@@ -0,0 +1 @@
+class A {}

idea/testData/quickfix/importHelper/NoDefaultImport.kt.after

@@ -0,0 +1 @@
+class A {}

idea/tests/org/jetbrains/jet/completion/JetMultifileBasicCompletionTest.java

@@ -8,7 +8,7 @@ import org.jetbrains.jet.plugin.PluginTestCaseBase;
 public class JetMultifileBasicCompletionTest extends JetCompletionMultiTestBase {
 
     public void testTopLevelFunction() throws Exception {
-        doFileTest();
+        doFileTest(2);
     }
 
     public void testExtensionFunction() throws Exception {

idea/tests/org/jetbrains/jet/plugin/quickfix/ImportClassHelperTest.java

@@ -1,6 +1,7 @@
 package org.jetbrains.jet.plugin.quickfix;
 
 import com.intellij.codeInsight.daemon.LightDaemonAnalyzerTestCase;
+import com.intellij.openapi.application.ApplicationManager;
 import org.jetbrains.jet.lang.psi.JetFile;
 import org.jetbrains.jet.plugin.PluginTestCaseBase;
 
@@ -20,6 +21,17 @@ public class ImportClassHelperTest extends LightDaemonAnalyzerTestCase {
         checkResultByFile(getTestName(false) + ".kt.after");
     }
 
+    public void testNoDefaultImport() {
+        configureByFile(getTestName(false) + ".kt");
+        ApplicationManager.getApplication().runWriteAction(new Runnable() {
+            @Override
+            public void run() {
+                ImportClassHelper.addImportDirective("std.io.println", (JetFile) getFile());
+            }
+        });
+        checkResultByFile(getTestName(false) + ".kt.after");
+    }
+
     @Override
     protected String getTestDataPath() {
         return PluginTestCaseBase.getTestDataPathBase() + "/quickfix/importHelper/";