Fixed resolving class name before dot and nothing else

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

@@ -87,9 +87,11 @@ public class QualifiedExpressionResolver {
         }
 
         JetSimpleNameExpression referenceExpression = userType.getReferenceExpression();
+        /*
         if (referenceExpression == null) {
             return Collections.emptyList();
         }
+        */
         JetUserType qualifier = userType.getQualifier();
 
         // We do not want to resolve the last segment of a user type to a package
@@ -97,11 +99,13 @@ public class QualifiedExpressionResolver {
 
         DeclarationDescriptor shouldBeVisibleFrom = outerScope.getContainingDeclaration();
         if (qualifier == null) {
+            if (referenceExpression == null) return Collections.emptyList();
             return lookupDescriptorsForSimpleNameReference(referenceExpression, filteredScope, shouldBeVisibleFrom, trace,
                                                            LookupMode.ONLY_CLASSES_AND_PACKAGES,
                                                            false, true);
         }
         Collection<DeclarationDescriptor> declarationDescriptors = lookupDescriptorsForUserType(qualifier, outerScope, trace, false);
+        if (referenceExpression == null) return Collections.emptyList();
         return lookupSelectorDescriptors(referenceExpression, declarationDescriptors, trace, shouldBeVisibleFrom,
                                          LookupMode.ONLY_CLASSES_AND_PACKAGES, true);
     }

compiler/frontend/src/org/jetbrains/kotlin/resolve/TypeResolver.kt

@@ -117,18 +117,6 @@ public class TypeResolver(
         var result: PossiblyBareType? = null
         typeElement?.accept(object : JetVisitorVoid() {
             override fun visitUserType(type: JetUserType) {
-                if (type.qualifier != null) { // we must resolve all type references in arguments of qualifier type
-                    for (typeArgument in type.qualifier!!.typeArguments) {
-                        typeArgument.typeReference?.let {
-                            ForceResolveUtil.forceResolveAllContents(resolveType(c, it))
-                        }
-                    }
-                }
-
-                val referenceExpression = type.getReferenceExpression()
-                val referencedName = type.getReferencedName()
-                if (referenceExpression == null || referencedName == null) return
-
                 val classifierDescriptor = resolveClass(c.scope, type, c.trace)
                 if (classifierDescriptor == null) {
                     val arguments = resolveTypeProjections(c, ErrorUtils.createErrorType("No type").getConstructor(), type.getTypeArguments())
@@ -136,6 +124,10 @@ public class TypeResolver(
                     return
                 }
 
+                val referenceExpression = type.getReferenceExpression()
+                val referencedName = type.getReferencedName()
+                if (referenceExpression == null || referencedName == null) return
+
                 c.trace.record(BindingContext.REFERENCE_TARGET, referenceExpression, classifierDescriptor)
 
                 when (classifierDescriptor) {
@@ -316,6 +308,14 @@ public class TypeResolver(
     }
 
     public fun resolveClass(scope: JetScope, userType: JetUserType, trace: BindingTrace): ClassifierDescriptor? {
+        if (userType.qualifier != null) { // we must resolve all type references in arguments of qualifier type
+            for (typeArgument in userType.qualifier!!.typeArguments) {
+                typeArgument.typeReference?.let {
+                    ForceResolveUtil.forceResolveAllContents(resolveType(scope, it, trace, true))
+                }
+            }
+        }
+
         val classifierDescriptor = qualifiedExpressionResolver.lookupDescriptorsForUserType(userType, scope, trace, true)
                                         .firstIsInstanceOrNull<ClassifierDescriptor>()
         if (classifierDescriptor != null) {

idea/testData/resolve/references/ClassNameBeforeDot.kt

@@ -0,0 +1,7 @@
+class Foo
+
+class C {
+    val prop: <caret>Foo.
+}
+
+// REF: (<root>).Foo

idea/testData/resolve/references/TypeArgumentBeforeDot2.kt

@@ -0,0 +1,9 @@
+class Generic<T>
+
+class C {
+    val prop: Generic<<caret>Foo>.
+}
+
+class Foo
+
+// REF: (<root>).Foo

idea/tests/org/jetbrains/kotlin/idea/resolve/ReferenceResolveTestGenerated.java

@@ -77,6 +77,12 @@ public class ReferenceResolveTestGenerated extends AbstractReferenceResolveTest
         doTest(fileName);
     }
 
+    @TestMetadata("ClassNameBeforeDot.kt")
+    public void testClassNameBeforeDot() throws Exception {
+        String fileName = JetTestUtils.navigationMetadata("idea/testData/resolve/references/ClassNameBeforeDot.kt");
+        doTest(fileName);
+    }
+
     @TestMetadata("ClassObjectClassLiteralReference.kt")
     public void testClassObjectClassLiteralReference() throws Exception {
         String fileName = JetTestUtils.navigationMetadata("idea/testData/resolve/references/ClassObjectClassLiteralReference.kt");
@@ -359,6 +365,12 @@ public class ReferenceResolveTestGenerated extends AbstractReferenceResolveTest
         doTest(fileName);
     }
 
+    @TestMetadata("TypeArgumentBeforeDot2.kt")
+    public void testTypeArgumentBeforeDot2() throws Exception {
+        String fileName = JetTestUtils.navigationMetadata("idea/testData/resolve/references/TypeArgumentBeforeDot2.kt");
+        doTest(fileName);
+    }
+
     @TestMetadata("TypeArgumentUnresolvedClass.kt")
     public void testTypeArgumentUnresolvedClass() throws Exception {
         String fileName = JetTestUtils.navigationMetadata("idea/testData/resolve/references/TypeArgumentUnresolvedClass.kt");