KT-6628 Allow imports of classes from root package

#KT-6628 Fixed

compiler/frontend/src/org/jetbrains/kotlin/diagnostics/Errors.java

@@ -103,7 +103,6 @@ public interface Errors {
     DiagnosticFactory1<JetSimpleNameExpression, DeclarationDescriptor> CANNOT_BE_IMPORTED = DiagnosticFactory1.create(ERROR);
 
     DiagnosticFactory1<JetExpression, String> CONFLICTING_IMPORT = DiagnosticFactory1.create(ERROR);
-    DiagnosticFactory0<JetExpression> USELESS_SIMPLE_IMPORT = DiagnosticFactory0.create(WARNING);
 
     // Modifiers
 

compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DefaultErrorMessages.java

@@ -169,7 +169,6 @@ public class DefaultErrorMessages {
         MAP.put(CANNOT_IMPORT_FROM_ELEMENT, "Cannot import from ''{0}''", NAME);
         MAP.put(CANNOT_BE_IMPORTED, "Cannot import ''{0}'', functions and properties can be imported only from packages", NAME);
         MAP.put(CONFLICTING_IMPORT, "Conflicting import, imported name ''{0}'' is ambiguous", STRING);
-        MAP.put(USELESS_SIMPLE_IMPORT, "Useless import, does nothing");
         MAP.put(PLATFORM_CLASS_MAPPED_TO_KOTLIN, "This class shouldn''t be used in Kotlin. Use {0} instead.", CLASSES_OR_SEPARATED);
 
         MAP.put(CANNOT_INFER_PARAMETER_TYPE,

compiler/frontend/src/org/jetbrains/kotlin/resolve/ImportsResolver.java

@@ -133,7 +133,7 @@ public class ImportsResolver {
 
         if (lookupMode == LookupMode.EVERYTHING) {
             for (JetImportDirective importDirective : importDirectives) {
-                reportConflictingOrUselessImport(importDirective, fileScope, resolvedDirectives.get(importDirective), trace);
+                reportConflictingImport(importDirective, fileScope, resolvedDirectives.get(importDirective), trace);
             }
         }
     }
@@ -167,7 +167,7 @@ public class ImportsResolver {
         }
     }
 
-    public static void reportConflictingOrUselessImport(
+    public static void reportConflictingImport(
             @NotNull JetImportDirective importDirective,
             @NotNull JetScope fileScope,
             @Nullable Collection<? extends DeclarationDescriptor> resolvedTo,
@@ -180,26 +180,18 @@ public class ImportsResolver {
         Name aliasName = JetPsiUtil.getAliasName(importDirective);
         if (aliasName == null) return;
 
-        if (resolvedTo.size() == 1) {
-            DeclarationDescriptor target = resolvedTo.iterator().next();
-            if (target instanceof ClassDescriptor) {
-                if (fileScope.getClassifier(aliasName) == null) {
-                    trace.report(CONFLICTING_IMPORT.on(importedReference, aliasName.asString()));
-                    return;
-                }
-            }
-            else if (target instanceof PackageViewDescriptor) {
-                if (fileScope.getPackage(aliasName) == null) {
-                    trace.report(CONFLICTING_IMPORT.on(importedReference, aliasName.asString()));
-                    return;
-                }
+        if (resolvedTo.size() != 1) return;
+
+        DeclarationDescriptor target = resolvedTo.iterator().next();
+        if (target instanceof ClassDescriptor) {
+            if (fileScope.getClassifier(aliasName) == null) {
+                trace.report(CONFLICTING_IMPORT.on(importedReference, aliasName.asString()));
             }
         }
-
-        if (!importDirective.isAllUnder() &&
-            importedReference instanceof JetSimpleNameExpression &&
-            importDirective.getAliasName() == null) {
-            trace.report(USELESS_SIMPLE_IMPORT.on(importedReference));
+        else if (target instanceof PackageViewDescriptor) {
+            if (fileScope.getPackage(aliasName) == null) {
+                trace.report(CONFLICTING_IMPORT.on(importedReference, aliasName.asString()));
+            }
         }
     }
 }

compiler/frontend/src/org/jetbrains/kotlin/resolve/JetModuleUtil.java

@@ -28,8 +28,8 @@ public class JetModuleUtil {
         return getRootPackageScope(module, /* scopeIncludingMembers = */ false);
     }
 
-    public static JetScope getImportsResolutionScope(ModuleDescriptor module, boolean inRootPackage) {
-        return getRootPackageScope(module, /* scopeIncludingMembers = */ inRootPackage);
+    public static JetScope getImportsResolutionScope(ModuleDescriptor module, boolean includeRootPackageClasses) {
+        return getRootPackageScope(module, /* scopeIncludingMembers = */ includeRootPackageClasses);
     }
 
     private static JetScope getRootPackageScope(ModuleDescriptor module, boolean scopeIncludingMembers) {

compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/LazyFileScope.kt

@@ -71,7 +71,6 @@ class LazyFileScope private(
                 file.getImportDirectives()
 
             val packageView = getPackageViewDescriptor(file, resolveSession)
-            val inRootPackage = packageView.getFqName().isRoot()
             val rootPackageView = resolveSession.getModuleDescriptor().getPackage(FqName.ROOT)
                                   ?: throw IllegalStateException("Root package not found")
             val packageFragment = resolveSession.getPackageFragment(file.getPackageFqName())
@@ -79,8 +78,8 @@ class LazyFileScope private(
             val onlyVisibleFilter = VisibilityFilter(packageFragment, true)
             val onlyInvisibleFilter = VisibilityFilter(packageFragment, false)
 
-            val aliasImportResolver = LazyImportResolver(resolveSession, packageView, AliasImportsIndexed(imports), traceForImportResolve, inRootPackage)
-            val allUnderImportResolver = LazyImportResolver(resolveSession, packageView, AllUnderImportsIndexed(imports), traceForImportResolve, inRootPackage)
+            val aliasImportResolver = LazyImportResolver(resolveSession, packageView, AliasImportsIndexed(imports), traceForImportResolve, true)
+            val allUnderImportResolver = LazyImportResolver(resolveSession, packageView, AllUnderImportsIndexed(imports), traceForImportResolve, true)
             val defaultAliasImportResolver = LazyImportResolver(resolveSession, rootPackageView, AliasImportsIndexed(defaultImports), traceForDefaultImportResolve, false)
             val defaultAllUnderImportResolver = LazyImportResolver(resolveSession, rootPackageView, AllUnderImportsIndexed(defaultImports), traceForDefaultImportResolve, false)
 

compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/LazyImportScope.kt

@@ -68,12 +68,12 @@ class LazyImportResolver(
         val packageView: PackageViewDescriptor,
         val indexedImports: IndexedImports,
         private val traceForImportResolve: BindingTrace,
-        private val inRootPackage: Boolean
+        includeRootPackageClasses: Boolean
 ) {
     private val importedScopesProvider = resolveSession.getStorageManager().createMemoizedFunction {
         (directive: JetImportDirective) -> ImportDirectiveResolveCache(directive)
     }
-    private val rootScope = JetModuleUtil.getImportsResolutionScope(resolveSession.getModuleDescriptor(), inRootPackage)
+    private val rootScope = JetModuleUtil.getImportsResolutionScope(resolveSession.getModuleDescriptor(), includeRootPackageClasses)
 
     private var directiveUnderResolve: JetImportDirective? = null
 
@@ -135,7 +135,7 @@ class LazyImportResolver(
         val status = importedScopesProvider(importDirective).importResolveStatus
         if (status != null && !status.descriptors.isEmpty()) {
             val fileScope = resolveSession.getScopeProvider().getFileScope(importDirective.getContainingJetFile())
-            ImportsResolver.reportConflictingOrUselessImport(importDirective, fileScope, status.descriptors, traceForImportResolve)
+            ImportsResolver.reportConflictingImport(importDirective, fileScope, status.descriptors, traceForImportResolve)
         }
     }