Create From Usage: Create class by reference expression

compiler/frontend/src/org/jetbrains/jet/lang/psi/psiUtil/jetPsiUtil.kt

@@ -376,3 +376,5 @@ public fun PsiElement.nextLeafSkipWhitespacesAndComments(): PsiElement? {
     return leaf
 }
 
+public fun JetExpression.isDotReceiver(): Boolean =
+        (getParent() as? JetDotQualifiedExpression)?.getReceiverExpression() == this

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

@@ -19,6 +19,7 @@ package org.jetbrains.jet.plugin.quickfix;
 import org.jetbrains.jet.lang.psi.JetClass;
 import org.jetbrains.jet.plugin.codeInsight.ImplementMethodsHandler;
 import org.jetbrains.jet.plugin.quickfix.createFromUsage.createClass.CreateClassFromTypeReferenceActionFactory;
+import org.jetbrains.jet.plugin.quickfix.createFromUsage.createClass.CreateClassFromReferenceExpressionActionFactory;
 import org.jetbrains.jet.plugin.quickfix.createFromUsage.createFunction.*;
 import org.jetbrains.jet.plugin.quickfix.createFromUsage.createVariable.*;
 
@@ -270,5 +271,6 @@ public class QuickFixRegistrar {
         QuickFixes.factories.put(DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE, CreatePropertyDelegateAccessorsActionFactory.INSTANCE$);
 
         QuickFixes.factories.put(UNRESOLVED_REFERENCE, CreateClassFromTypeReferenceActionFactory.INSTANCE$);
+        QuickFixes.factories.put(UNRESOLVED_REFERENCE, CreateClassFromReferenceExpressionActionFactory.INSTANCE$);
     }
 }

idea/src/org/jetbrains/jet/plugin/quickfix/createFromUsage/createClass/CreateClassFromReferenceExpressionActionFactory.kt

@@ -0,0 +1,104 @@
+package org.jetbrains.jet.plugin.quickfix.createFromUsage.createClass
+
+import org.jetbrains.jet.lang.diagnostics.Diagnostic
+import com.intellij.codeInsight.intention.IntentionAction
+import org.jetbrains.jet.lang.psi.JetSimpleNameExpression
+import org.jetbrains.jet.lang.psi.JetExpression
+import org.jetbrains.jet.lang.psi.psiUtil.getParentByType
+import org.jetbrains.jet.lang.psi.JetTypeReference
+import java.util.Collections
+import org.jetbrains.jet.plugin.quickfix.JetIntentionActionsFactory
+import org.jetbrains.jet.lang.psi.JetClass
+import org.jetbrains.jet.lang.psi.JetQualifiedExpression
+import org.jetbrains.jet.lang.psi.psiUtil.getAssignmentByLHS
+import org.jetbrains.jet.lang.psi.JetCallExpression
+import org.jetbrains.jet.lang.psi.JetImportDirective
+import org.jetbrains.jet.plugin.caches.resolve.getAnalysisResults
+import org.jetbrains.jet.lang.resolve.calls.callUtil.getCall
+import org.jetbrains.jet.lang.psi.JetFile
+import org.jetbrains.jet.lang.resolve.BindingContext
+import org.jetbrains.jet.lang.psi.psiUtil.getQualifiedElementSelector
+import org.jetbrains.jet.plugin.quickfix.createFromUsage.callableBuilder.TypeInfo
+import org.jetbrains.jet.lang.psi.JetReferenceExpression
+import java.util.Arrays
+import org.jetbrains.jet.lang.psi.JetDotQualifiedExpression
+import org.jetbrains.jet.lang.psi.psiUtil.isDotReceiver
+
+public object CreateClassFromReferenceExpressionActionFactory : JetIntentionActionsFactory() {
+    override fun doCreateActions(diagnostic: Diagnostic): List<IntentionAction> {
+        val refExpr = diagnostic.getPsiElement() as? JetSimpleNameExpression ?: return Collections.emptyList()
+        if (refExpr.getParentByType(javaClass<JetTypeReference>()) != null) return Collections.emptyList()
+
+        val file = refExpr.getContainingFile() as? JetFile ?: return Collections.emptyList()
+
+        val name = refExpr.getReferencedName()
+        if (!name.checkClassName()) return Collections.emptyList()
+
+        val exhaust = refExpr.getAnalysisResults()
+        val context = exhaust.getBindingContext()
+
+        val fullCallExpr = refExpr.getParent()?.let {
+            when {
+                it is JetCallExpression && it.getCalleeExpression() == refExpr -> return Collections.emptyList()
+                it is JetQualifiedExpression && it.getSelectorExpression() == refExpr -> it
+                else -> refExpr
+            }
+        } as? JetExpression ?: return Collections.emptyList()
+
+        val inImport = refExpr.getParentByType(javaClass<JetImportDirective>()) != null
+        val qualifierExpected = refExpr.isDotReceiver() || ((refExpr.getParent() as? JetDotQualifiedExpression)?.isDotReceiver() ?: false)
+
+        if (inImport || qualifierExpected) {
+            val receiverSelector = (fullCallExpr as? JetQualifiedExpression)?.getReceiverExpression()?.getQualifiedElementSelector() as? JetReferenceExpression
+            val qualifierDescriptor = receiverSelector?.let { context[BindingContext.REFERENCE_TARGET, it] }
+
+            val targetParent =
+                    getTargetParentByQualifier(refExpr.getContainingJetFile(), receiverSelector != null, qualifierDescriptor)
+                    ?: return Collections.emptyList()
+
+            return ClassKind.values()
+                    .filter {
+                        when (it) {
+                            ClassKind.ANNOTATION_CLASS -> inImport
+                            ClassKind.ENUM_ENTRY -> inImport && targetParent is JetClass && targetParent.isEnum()
+                            else -> true
+                        }
+                    }
+                    .map {
+                        val classInfo = ClassInfo(
+                                kind = it,
+                                name = name,
+                                targetParent = targetParent,
+                                expectedTypeInfo = TypeInfo.Empty
+                        )
+                        CreateClassFromUsageFix(refExpr, classInfo)
+                    }
+        }
+
+        if (fullCallExpr.getAssignmentByLHS() != null) return Collections.emptyList()
+
+        val call = refExpr.getCall(context) ?: return Collections.emptyList()
+        val targetParent = getTargetParentByCall(call, file) ?: return Collections.emptyList()
+        if (isInnerClassExpected(call)) return Collections.emptyList()
+
+        val (expectedTypeInfo, filter) = fullCallExpr.getInheritableTypeInfo(context, exhaust.getModuleDescriptor(), targetParent)
+
+        return Arrays.asList(ClassKind.OBJECT, ClassKind.ENUM_ENTRY)
+                .filter {
+                    filter(it) && when (it) {
+                        ClassKind.OBJECT -> true
+                        ClassKind.ENUM_ENTRY -> targetParent is JetClass && targetParent.isEnum()
+                        else -> false
+                    }
+                }
+                .map {
+                    val classInfo = ClassInfo(
+                            kind = it,
+                            name = name,
+                            targetParent = targetParent,
+                            expectedTypeInfo = expectedTypeInfo
+                    )
+                    CreateClassFromUsageFix(refExpr, classInfo)
+                }
+    }
+}

idea/src/org/jetbrains/jet/plugin/quickfix/createFromUsage/createClass/CreateClassFromTypeReferenceActionFactory.kt

@@ -8,28 +8,21 @@ import java.util.Collections
 import org.jetbrains.jet.lang.psi.JetUserType
 import org.jetbrains.jet.lang.psi.JetFile
 import org.jetbrains.jet.lang.resolve.BindingContext
-import org.jetbrains.jet.lang.descriptors.ClassDescriptor
-import org.jetbrains.jet.lang.descriptors.PackageViewDescriptor
 import org.jetbrains.jet.plugin.caches.resolve.getAnalysisResults
-import org.jetbrains.jet.plugin.codeInsight.DescriptorToDeclarationUtil
-import com.intellij.psi.JavaPsiFacade
-import com.intellij.openapi.module.ModuleUtilCore
-import com.intellij.psi.PsiDirectory
-import org.jetbrains.jet.lang.psi.JetElement
 import org.jetbrains.jet.plugin.quickfix.createFromUsage.callableBuilder.TypeInfo
 import org.jetbrains.jet.lang.types.Variance
+import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor
+import com.intellij.psi.PsiElement
 import org.jetbrains.jet.lang.psi.JetDelegatorToSuperClass
+import org.jetbrains.jet.lang.psi.JetDelegatorToSuperCall
 import org.jetbrains.jet.lang.psi.JetConstructorCalleeExpression
 import org.jetbrains.jet.plugin.project.AnalyzerFacadeWithCache
-import org.jetbrains.jet.plugin.util.ProjectRootsUtil
 
 public object CreateClassFromTypeReferenceActionFactory: JetIntentionActionsFactory() {
     override fun doCreateActions(diagnostic: Diagnostic): List<IntentionAction> {
         val userType = QuickFixUtil.getParentElementOfType(diagnostic, javaClass<JetUserType>()) ?: return Collections.emptyList()
         val typeArguments = userType.getTypeArgumentsAsTypes()
 
-        val project = userType.getProject()
-
         val name = userType.getReferencedName() ?: return Collections.emptyList()
 
         val typeRefParent = userType.getParent()?.getParent()
@@ -45,31 +38,7 @@ public object CreateClassFromTypeReferenceActionFactory: JetIntentionActionsFact
         val qualifier = userType.getQualifier()?.getReferenceExpression()
         val qualifierDescriptor = qualifier?.let { context[BindingContext.REFERENCE_TARGET, it] }
 
-        val targetParent =
+        val targetParent = getTargetParentByQualifier(file, qualifier != null, qualifierDescriptor) ?: return Collections.emptyList()
-                when {
-                    qualifier == null -> file
-
-                    qualifierDescriptor is ClassDescriptor -> {
-                        DescriptorToDeclarationUtil.getDeclaration(project, qualifierDescriptor)
-                    }
-
-                    qualifierDescriptor is PackageViewDescriptor -> {
-                        val currentModule = ModuleUtilCore.findModuleForPsiElement(file)
-                        val targetFqName = qualifierDescriptor.getFqName()
-                        if (targetFqName != file.getPackageFqName()) {
-                            JavaPsiFacade.getInstance(project)
-                                    .findPackage(targetFqName.asString())
-                                    ?.getDirectories()
-                                    ?.firstOrNull { ModuleUtilCore.findModuleForPsiElement(it) == currentModule }
-                        }
-                        else file
-                    }
-
-                    else -> null
-                } ?: return Collections.emptyList()
-
-        if (!ProjectRootsUtil.isInProjectOrLibSource(targetParent)) return Collections.emptyList()
-        if (!(targetParent.isWritable() && (targetParent is PsiDirectory || targetParent is JetElement))) return Collections.emptyList()
 
         val possibleKinds = when {
             traitExpected -> Collections.singletonList(ClassKind.TRAIT)

idea/src/org/jetbrains/jet/plugin/quickfix/createFromUsage/createClass/createClassUtils.kt

@@ -0,0 +1,99 @@
+package org.jetbrains.jet.plugin.quickfix.createFromUsage.createClass
+
+import org.jetbrains.jet.lang.psi.JetFile
+import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor
+import com.intellij.psi.PsiElement
+import org.jetbrains.jet.lang.descriptors.ClassDescriptor
+import org.jetbrains.jet.lang.descriptors.PackageViewDescriptor
+import org.jetbrains.jet.plugin.codeInsight.DescriptorToDeclarationUtil
+import com.intellij.openapi.module.ModuleUtilCore
+import com.intellij.psi.JavaPsiFacade
+import com.intellij.psi.PsiDirectory
+import org.jetbrains.jet.lang.psi.JetElement
+import org.jetbrains.jet.lang.psi.JetExpression
+import org.jetbrains.jet.plugin.quickfix.createFromUsage.callableBuilder.guessTypes
+import org.jetbrains.jet.lang.resolve.BindingContext
+import org.jetbrains.jet.lang.descriptors.ModuleDescriptor
+import org.jetbrains.jet.lang.types.TypeUtils
+import org.jetbrains.jet.lang.types.checker.JetTypeChecker
+import org.jetbrains.jet.lang.descriptors.TypeParameterDescriptor
+import org.jetbrains.jet.plugin.quickfix.createFromUsage.callableBuilder.TypeInfo
+import org.jetbrains.jet.lang.types.Variance
+import org.jetbrains.jet.lang.psi.Call
+import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverValue
+import org.jetbrains.jet.lang.resolve.scopes.receivers.Qualifier
+import org.jetbrains.jet.plugin.util.ProjectRootsUtil
+import org.jetbrains.jet.lang.resolve.DescriptorUtils
+import org.jetbrains.jet.lang.resolve.DescriptorToSourceUtils
+
+private fun String.checkClassName(): Boolean = isNotEmpty() && Character.isUpperCase(first())
+
+private fun getTargetParentByQualifier(
+        file: JetFile,
+        isQualified: Boolean,
+        qualifierDescriptor: DeclarationDescriptor?): PsiElement? {
+    val project = file.getProject()
+
+    val targetParent = when {
+        !isQualified -> file
+
+        qualifierDescriptor is ClassDescriptor -> {
+            DescriptorToDeclarationUtil.getDeclaration(project, qualifierDescriptor)
+        }
+
+        qualifierDescriptor is PackageViewDescriptor -> {
+            val currentModule = ModuleUtilCore.findModuleForPsiElement(file)
+            val targetFqName = qualifierDescriptor.getFqName()
+            if (targetFqName != file.getPackageFqName()) {
+                JavaPsiFacade.getInstance(project)
+                        .findPackage(targetFqName.asString())
+                        ?.getDirectories()
+                        ?.firstOrNull { ModuleUtilCore.findModuleForPsiElement(it) == currentModule }
+            }
+            else file
+        }
+
+        else -> null
+    } ?: return null
+    return if (targetParent.isWritable()
+               && ProjectRootsUtil.isInProjectOrLibSource(targetParent)
+               && (targetParent is PsiDirectory || targetParent is JetElement)) return targetParent else null
+}
+
+private fun getTargetParentByCall(call: Call, file: JetFile): PsiElement? {
+    val receiver = call.getExplicitReceiver()
+    return when (receiver) {
+        ReceiverValue.NO_RECEIVER -> getTargetParentByQualifier(file, false, null)
+        is Qualifier -> getTargetParentByQualifier(file, true, receiver.resultingDescriptor)
+        else -> getTargetParentByQualifier(file, true, receiver.getType().getConstructor().getDeclarationDescriptor())
+    }
+}
+
+private fun isInnerClassExpected(call: Call): Boolean {
+    val receiver = call.getExplicitReceiver()
+    return receiver != ReceiverValue.NO_RECEIVER && receiver !is Qualifier
+}
+
+private fun JetExpression.getInheritableTypeInfo(
+        context: BindingContext,
+        moduleDescriptor: ModuleDescriptor,
+        containingDeclaration: PsiElement): Pair<TypeInfo, (ClassKind) -> Boolean> {
+    val types = guessTypes(context, moduleDescriptor, false)
+    if (types.size != 1) return TypeInfo.Empty to { classKind -> true }
+
+    val type = types.first()
+    val descriptor = type.getConstructor().getDeclarationDescriptor()
+
+    val canHaveSubtypes = TypeUtils.canHaveSubtypes(JetTypeChecker.DEFAULT, type)
+    val isEnum = DescriptorUtils.isEnumClass(descriptor)
+
+    if (!(canHaveSubtypes || isEnum)
+        || descriptor is TypeParameterDescriptor) return TypeInfo.Empty to { classKind -> false }
+
+    return TypeInfo.ByType(type, Variance.OUT_VARIANCE) to { classKind ->
+        when (classKind) {
+            ClassKind.ENUM_ENTRY -> isEnum && containingDeclaration == DescriptorToSourceUtils.descriptorToDeclaration(descriptor)
+            else -> canHaveSubtypes
+        }
+    }
+}

idea/testData/quickfix/autoImports/noImportForPrivateClass.before.Main.kt

@@ -1,5 +1,6 @@
 // "class com.intellij.codeInsight.daemon.impl.quickfix.ImportClassFixBase" "false"
 // ACTION: Create local variable 'PrivateClass'
+// ACTION: Create object 'PrivateClass'
 // ACTION: Create parameter 'PrivateClass'
 // ACTION: Create property 'PrivateClass'
 // ERROR: Unresolved reference: PrivateClass

idea/testData/quickfix/autoImports/noImportInImports.before.Main.kt

@@ -1,4 +1,9 @@
 // "class com.intellij.codeInsight.daemon.impl.quickfix.ImportClassFixBase" "false"
+// ACTION: Create annotation 'SomeTest'
+// ACTION: Create class 'SomeTest'
+// ACTION: Create enum 'SomeTest'
+// ACTION: Create object 'SomeTest'
+// ACTION: Create trait 'SomeTest'
 // ERROR: Unresolved reference: SomeTest
 
 package testing

idea/testData/quickfix/createFromUsage/createClass/importDirective/afterAnnotationInPackage.kt

@@ -0,0 +1,6 @@
+// "Create annotation 'A'" "true"
+package p
+
+import p.A
+
+annotation class A

idea/testData/quickfix/createFromUsage/createClass/importDirective/afterAnnotationWithQualifier.kt

@@ -0,0 +1,10 @@
+// "Create annotation 'A'" "true"
+package p
+
+import p.X.A
+
+class X {
+
+    annotation class A
+
+}

idea/testData/quickfix/createFromUsage/createClass/importDirective/afterClassInPackage.kt

@@ -0,0 +1,8 @@
+// "Create class 'A'" "true"
+package p
+
+import p.A
+
+class A {
+
+}

idea/testData/quickfix/createFromUsage/createClass/importDirective/afterClassWithQualifier.kt

@@ -0,0 +1,12 @@
+// "Create class 'A'" "true"
+package p
+
+import p.X.A
+
+class X {
+
+    class A {
+
+    }
+
+}

idea/testData/quickfix/createFromUsage/createClass/importDirective/afterEnumEntryInEnum.kt

@@ -0,0 +1,10 @@
+// "Create enum constant 'A'" "true"
+package p
+
+import p.E.A
+
+enum class E {
+
+    A
+
+}

idea/testData/quickfix/createFromUsage/createClass/importDirective/afterEnumInPackage.kt

@@ -0,0 +1,8 @@
+// "Create enum 'A'" "true"
+package p
+
+import p.A
+
+enum class A {
+
+}

idea/testData/quickfix/createFromUsage/createClass/importDirective/afterEnumWithQualifier.kt

@@ -0,0 +1,12 @@
+// "Create enum 'A'" "true"
+package p
+
+import p.X.A
+
+class X {
+
+    enum class A {
+
+    }
+
+}

idea/testData/quickfix/createFromUsage/createClass/importDirective/afterObjectInPackage.kt

@@ -0,0 +1,8 @@
+// "Create object 'A'" "true"
+package p
+
+import p.A
+
+object A {
+
+}

idea/testData/quickfix/createFromUsage/createClass/importDirective/afterObjectWithQualifier.kt

@@ -0,0 +1,12 @@
+// "Create object 'A'" "true"
+package p
+
+import p.X.A
+
+class X {
+
+    object A {
+
+    }
+
+}

idea/testData/quickfix/createFromUsage/createClass/importDirective/afterTraitInPackage.kt

@@ -0,0 +1,8 @@
+// "Create trait 'A'" "true"
+package p
+
+import p.A
+
+trait A {
+
+}

idea/testData/quickfix/createFromUsage/createClass/importDirective/afterTraitWithQualifier.kt

@@ -0,0 +1,12 @@
+// "Create trait 'A'" "true"
+package p
+
+import p.X.A
+
+class X {
+
+    trait A {
+
+    }
+
+}

idea/testData/quickfix/createFromUsage/createClass/importDirective/beforeAnnotationInPackage.kt

@@ -0,0 +1,4 @@
+// "Create annotation 'A'" "true"
+package p
+
+import p.<caret>A

idea/testData/quickfix/createFromUsage/createClass/importDirective/beforeAnnotationWithQualifier.kt

@@ -0,0 +1,8 @@
+// "Create annotation 'A'" "true"
+package p
+
+import p.X.<caret>A
+
+class X {
+
+}

idea/testData/quickfix/createFromUsage/createClass/importDirective/beforeClassInPackage.kt

@@ -0,0 +1,4 @@
+// "Create class 'A'" "true"
+package p
+
+import p.<caret>A

idea/testData/quickfix/createFromUsage/createClass/importDirective/beforeClassWithQualifier.kt

@@ -0,0 +1,8 @@
+// "Create class 'A'" "true"
+package p
+
+import p.X.<caret>A
+
+class X {
+
+}

idea/testData/quickfix/createFromUsage/createClass/importDirective/beforeEnumEntryInEnum.kt

@@ -0,0 +1,8 @@
+// "Create enum constant 'A'" "true"
+package p
+
+import p.E.<caret>A
+
+enum class E {
+
+}

idea/testData/quickfix/createFromUsage/createClass/importDirective/beforeEnumEntryInPackage.kt

@@ -0,0 +1,10 @@
+// "Create enum constant 'A'" "false"
+// ACTION: Create class 'A'
+// ACTION: Create trait 'A'
+// ACTION: Create object 'A'
+// ACTION: Create enum 'A'
+// ACTION: Create annotation 'A'
+// ERROR: Unresolved reference: A
+package p
+
+import p.<caret>A

idea/testData/quickfix/createFromUsage/createClass/importDirective/beforeEnumEntryWithQualifier.kt

@@ -0,0 +1,14 @@
+// "Create enum constant 'A'" "false"
+// ACTION: Create class 'A'
+// ACTION: Create trait 'A'
+// ACTION: Create object 'A'
+// ACTION: Create enum 'A'
+// ACTION: Create annotation 'A'
+// ERROR: Unresolved reference: A
+package p
+
+import p.X.<caret>A
+
+class X {
+
+}

idea/testData/quickfix/createFromUsage/createClass/importDirective/beforeEnumInPackage.kt

@@ -0,0 +1,4 @@
+// "Create enum 'A'" "true"
+package p
+
+import p.<caret>A

idea/testData/quickfix/createFromUsage/createClass/importDirective/beforeEnumWithQualifier.kt

@@ -0,0 +1,8 @@
+// "Create enum 'A'" "true"
+package p
+
+import p.X.<caret>A
+
+class X {
+
+}

idea/testData/quickfix/createFromUsage/createClass/importDirective/beforeObjectInPackage.kt

@@ -0,0 +1,4 @@
+// "Create object 'A'" "true"
+package p
+
+import p.<caret>A

idea/testData/quickfix/createFromUsage/createClass/importDirective/beforeObjectWithQualifier.kt

@@ -0,0 +1,8 @@
+// "Create object 'A'" "true"
+package p
+
+import p.X.<caret>A
+
+class X {
+
+}

idea/testData/quickfix/createFromUsage/createClass/importDirective/beforeTraitInPackage.kt

@@ -0,0 +1,4 @@
+// "Create trait 'A'" "true"
+package p
+
+import p.<caret>A

idea/testData/quickfix/createFromUsage/createClass/importDirective/beforeTraitWithQualifier.kt

@@ -0,0 +1,8 @@
+// "Create trait 'A'" "true"
+package p
+
+import p.X.<caret>A
+
+class X {
+
+}

idea/testData/quickfix/createFromUsage/createClass/referenceExpression/afterClassByNestedQualifier.kt

@@ -0,0 +1,13 @@
+// "Create class 'B'" "true"
+// ERROR: Unresolved reference: C
+package p
+
+fun foo() = A.B.C
+
+class A {
+
+    class B {
+
+    }
+
+}

idea/testData/quickfix/createFromUsage/createClass/referenceExpression/afterClassByQualifier.kt

@@ -0,0 +1,9 @@
+// "Create class 'A'" "true"
+// ERROR: Unresolved reference: B
+package p
+
+fun foo() = A.B
+
+class A {
+
+}

idea/testData/quickfix/createFromUsage/createClass/referenceExpression/afterEnumByQualifier.kt

@@ -0,0 +1,9 @@
+// "Create enum 'A'" "true"
+// ERROR: Unresolved reference: B
+package p
+
+fun foo() = A.B
+
+enum class A {
+
+}

idea/testData/quickfix/createFromUsage/createClass/referenceExpression/afterEnumEntryWithEnumQualifier.kt

@@ -0,0 +1,10 @@
+// "Create enum constant 'A'" "true"
+package p
+
+fun foo() = X.A
+
+enum class X {
+
+    A
+
+}

idea/testData/quickfix/createFromUsage/createClass/referenceExpression/afterEnumEntryWithEnumQualifierAndParams.kt

@@ -0,0 +1,11 @@
+// "Create enum constant 'A'" "true"
+// ERROR: No value passed for parameter n
+package p
+
+fun foo() = X.A
+
+enum class X(n: Int) {
+
+    A : X()
+
+}

idea/testData/quickfix/createFromUsage/createClass/referenceExpression/afterEnumEntryWithEnumSuperclass.kt

@@ -0,0 +1,10 @@
+// "Create enum constant 'A'" "true"
+package p
+
+fun foo(): E = E.A
+
+enum class E {
+
+    A
+
+}

idea/testData/quickfix/createFromUsage/createClass/referenceExpression/afterObjectByQualifier.kt

@@ -0,0 +1,9 @@
+// "Create object 'A'" "true"
+// ERROR: Unresolved reference: B
+package p
+
+fun foo() = A.B
+
+object A {
+
+}

idea/testData/quickfix/createFromUsage/createClass/referenceExpression/afterObjectInPackage.kt

@@ -0,0 +1,8 @@
+// "Create object 'A'" "true"
+package p
+
+fun foo() = p.A
+
+object A {
+
+}

idea/testData/quickfix/createFromUsage/createClass/referenceExpression/afterObjectNoReceiver.kt

@@ -0,0 +1,8 @@
+// "Create object 'A'" "true"
+package p
+
+fun foo() = A
+
+object A {
+
+}

idea/testData/quickfix/createFromUsage/createClass/referenceExpression/afterObjectWithQualifier.kt

@@ -0,0 +1,12 @@
+// "Create object 'A'" "true"
+package p
+
+fun foo() = X.A
+
+class X {
+
+    object A {
+
+    }
+
+}

idea/testData/quickfix/createFromUsage/createClass/referenceExpression/afterObjectWithSuperclass.kt

@@ -0,0 +1,12 @@
+// "Create object 'A'" "true"
+package p
+
+fun foo(): X = A
+
+open class X {
+
+}
+
+object A : X() {
+
+}

idea/testData/quickfix/createFromUsage/createClass/referenceExpression/afterObjectWithSupertrait.kt

@@ -0,0 +1,12 @@
+// "Create object 'A'" "true"
+package p
+
+fun foo(): X = A
+
+trait X {
+
+}
+
+object A : X {
+
+}

idea/testData/quickfix/createFromUsage/createClass/referenceExpression/afterTraitByQualifier.kt

@@ -0,0 +1,9 @@
+// "Create trait 'A'" "true"
+// ERROR: Unresolved reference: B
+package p
+
+fun foo() = A.B
+
+trait A {
+
+}

idea/testData/quickfix/createFromUsage/createClass/referenceExpression/afterUnusedReference.kt

@@ -0,0 +1,9 @@
+// "Create object 'Foo'" "true"
+
+fun test() {
+    Foo
+}
+
+object Foo {
+
+}

idea/testData/quickfix/createFromUsage/createClass/referenceExpression/afterValDelegateExpressionRuntime.kt

@@ -0,0 +1,14 @@
+// "Create object 'Foo'" "true"
+// DISABLE-ERRORS
+
+import kotlin.properties.ReadOnlyProperty
+
+open class B
+
+class A {
+    val x: B by Foo
+}
+
+object Foo : ReadOnlyProperty<A, B> {
+
+}

idea/testData/quickfix/createFromUsage/createClass/referenceExpression/afterVarDelegateExpressionRuntime.kt

@@ -0,0 +1,14 @@
+// "Create object 'Foo'" "true"
+// DISABLE-ERRORS
+
+import kotlin.properties.ReadWriteProperty
+
+open class B
+
+class A {
+    var x: B by Foo
+}
+
+object Foo : ReadWriteProperty<A, B> {
+
+}

idea/testData/quickfix/createFromUsage/createClass/referenceExpression/beforeAnnotationNoReceiver.kt

@@ -0,0 +1,9 @@
+// "Create annotation 'A'" "false"
+// ACTION: Create object 'A'
+// ACTION: Create local variable 'A'
+// ACTION: Create parameter 'A'
+// ACTION: Create property 'A'
+// ERROR: Unresolved reference: A
+package p
+
+fun foo() = <caret>A

idea/testData/quickfix/createFromUsage/createClass/referenceExpression/beforeClassByNestedQualifier.kt

@@ -0,0 +1,9 @@
+// "Create class 'B'" "true"
+// ERROR: Unresolved reference: C
+package p
+
+fun foo() = A.<caret>B.C
+
+class A {
+
+}

idea/testData/quickfix/createFromUsage/createClass/referenceExpression/beforeClassByQualifier.kt

@@ -0,0 +1,5 @@
+// "Create class 'A'" "true"
+// ERROR: Unresolved reference: B
+package p
+
+fun foo() = <caret>A.B

idea/testData/quickfix/createFromUsage/createClass/referenceExpression/beforeClassInPackage.kt

@@ -0,0 +1,6 @@
+// "Create class 'A'" "false"
+// ACTION: Create object 'A'
+// ERROR: Unresolved reference: A
+package p
+
+fun foo() = p.<caret>A

idea/testData/quickfix/createFromUsage/createClass/referenceExpression/beforeClassNoReceiver.kt

@@ -0,0 +1,9 @@
+// "Create class 'A'" "false"
+// ACTION: Create object 'A'
+// ACTION: Create local variable 'A'
+// ACTION: Create parameter 'A'
+// ACTION: Create property 'A'
+// ERROR: Unresolved reference: A
+package p
+
+fun foo() = <caret>A

idea/testData/quickfix/createFromUsage/createClass/referenceExpression/beforeClassWithQualifier.kt

@@ -0,0 +1,10 @@
+// "Create class 'A'" "false"
+// ACTION: Create object 'A'
+// ERROR: Unresolved reference: A
+package p
+
+fun foo() = X.<caret>A
+
+class X {
+
+}

idea/testData/quickfix/createFromUsage/createClass/referenceExpression/beforeClassWithReceiver.kt

@@ -0,0 +1,10 @@
+// "Create class 'A'" "false"
+// ACTION: Create property 'A'
+// ERROR: Unresolved reference: A
+package p
+
+fun foo() = X().<caret>A
+
+class X {
+
+}

idea/testData/quickfix/createFromUsage/createClass/referenceExpression/beforeEnumByQualifier.kt

@@ -0,0 +1,5 @@
+// "Create enum 'A'" "true"
+// ERROR: Unresolved reference: B
+package p
+
+fun foo() = <caret>A.B

idea/testData/quickfix/createFromUsage/createClass/referenceExpression/beforeEnumEntryNoReceiver.kt

@@ -0,0 +1,9 @@
+// "Create enum constant 'A'" "false"
+// ACTION: Create object 'A'
+// ACTION: Create local variable 'A'
+// ACTION: Create parameter 'A'
+// ACTION: Create property 'A'
+// ERROR: Unresolved reference: A
+package p
+
+fun foo() = <caret>A

idea/testData/quickfix/createFromUsage/createClass/referenceExpression/beforeEnumEntryWithEnumQualifier.kt

@@ -0,0 +1,8 @@
+// "Create enum constant 'A'" "true"
+package p
+
+fun foo() = X.<caret>A
+
+enum class X {
+
+}

idea/testData/quickfix/createFromUsage/createClass/referenceExpression/beforeEnumEntryWithEnumQualifierAndParams.kt

@@ -0,0 +1,9 @@
+// "Create enum constant 'A'" "true"
+// ERROR: No value passed for parameter n
+package p
+
+fun foo() = X.<caret>A
+
+enum class X(n: Int) {
+
+}

idea/testData/quickfix/createFromUsage/createClass/referenceExpression/beforeEnumEntryWithEnumSuperclass.kt

@@ -0,0 +1,8 @@
+// "Create enum constant 'A'" "true"
+package p
+
+fun foo(): E = E.<caret>A
+
+enum class E {
+
+}

idea/testData/quickfix/createFromUsage/createClass/referenceExpression/beforeEnumEntryWithQualifier.kt

@@ -0,0 +1,10 @@
+// "Create enum constant 'A'" "false"
+// ACTION: Create object 'A'
+// ERROR: Unresolved reference: A
+package p
+
+fun foo() = X.<caret>A
+
+class X {
+
+}

idea/testData/quickfix/createFromUsage/createClass/referenceExpression/beforeEnumEntryWithReceiver.kt

@@ -0,0 +1,10 @@
+// "Create enum constant 'A'" "false"
+// ACTION: Create property 'A'
+// ERROR: Unresolved reference: A
+package p
+
+fun foo() = X().<caret>A
+
+class X {
+
+}

idea/testData/quickfix/createFromUsage/createClass/referenceExpression/beforeEnumEntryWithSuperclass.kt

@@ -0,0 +1,15 @@
+// "Create enum constant 'A'" "false"
+// ACTION: Convert to block body
+// ACTION: Create object 'A'
+// ERROR: Unresolved reference: A
+package p
+
+fun foo(): X = E.<caret>A
+
+enum class E {
+
+}
+
+open class X {
+
+}

idea/testData/quickfix/createFromUsage/createClass/referenceExpression/beforeEnumNoReceiver.kt

@@ -0,0 +1,9 @@
+// "Create enum 'A'" "false"
+// ACTION: Create object 'A'
+// ACTION: Create local variable 'A'
+// ACTION: Create parameter 'A'
+// ACTION: Create property 'A'
+// ERROR: Unresolved reference: A
+package p
+
+fun foo() = <caret>A

idea/testData/quickfix/createFromUsage/createClass/referenceExpression/beforeObjectByQualifier.kt

@@ -0,0 +1,5 @@
+// "Create object 'A'" "true"
+// ERROR: Unresolved reference: B
+package p
+
+fun foo() = <caret>A.B

idea/testData/quickfix/createFromUsage/createClass/referenceExpression/beforeObjectInPackage.kt

@@ -0,0 +1,4 @@
+// "Create object 'A'" "true"
+package p
+
+fun foo() = p.<caret>A

idea/testData/quickfix/createFromUsage/createClass/referenceExpression/beforeObjectNoReceiver.kt

@@ -0,0 +1,4 @@
+// "Create object 'A'" "true"
+package p
+
+fun foo() = <caret>A

idea/testData/quickfix/createFromUsage/createClass/referenceExpression/beforeObjectWithQualifier.kt

@@ -0,0 +1,8 @@
+// "Create object 'A'" "true"
+package p
+
+fun foo() = X.<caret>A
+
+class X {
+
+}

idea/testData/quickfix/createFromUsage/createClass/referenceExpression/beforeObjectWithReceiver.kt

@@ -0,0 +1,10 @@
+// "Create object 'A'" "false"
+// ACTION: Create property 'A'
+// ERROR: Unresolved reference: A
+package p
+
+fun foo() = X().<caret>A
+
+class X {
+
+}

idea/testData/quickfix/createFromUsage/createClass/referenceExpression/beforeObjectWithSuperclass.kt

@@ -0,0 +1,8 @@
+// "Create object 'A'" "true"
+package p
+
+fun foo(): X = <caret>A
+
+open class X {
+
+}

idea/testData/quickfix/createFromUsage/createClass/referenceExpression/beforeObjectWithSupertrait.kt

@@ -0,0 +1,8 @@
+// "Create object 'A'" "true"
+package p
+
+fun foo(): X = <caret>A
+
+trait X {
+
+}

idea/testData/quickfix/createFromUsage/createClass/referenceExpression/beforeTraitByQualifier.kt

@@ -0,0 +1,5 @@
+// "Create trait 'A'" "true"
+// ERROR: Unresolved reference: B
+package p
+
+fun foo() = <caret>A.B

idea/testData/quickfix/createFromUsage/createClass/referenceExpression/beforeTraitNoReceiver.kt

@@ -0,0 +1,9 @@
+// "Create trait 'A'" "false"
+// ACTION: Create object 'A'
+// ACTION: Create local variable 'A'
+// ACTION: Create parameter 'A'
+// ACTION: Create property 'A'
+// ERROR: Unresolved reference: A
+package p
+
+fun foo() = <caret>A

idea/testData/quickfix/createFromUsage/createClass/referenceExpression/beforeUnusedReference.kt

@@ -0,0 +1,5 @@
+// "Create object 'Foo'" "true"
+
+fun test() {
+    <caret>Foo
+}

idea/testData/quickfix/createFromUsage/createClass/referenceExpression/beforeValDelegateExpressionRuntime.kt

@@ -0,0 +1,8 @@
+// "Create object 'Foo'" "true"
+// DISABLE-ERRORS
+
+open class B
+
+class A {
+    val x: B by <caret>Foo
+}

idea/testData/quickfix/createFromUsage/createClass/referenceExpression/beforeVarDelegateExpressionRuntime.kt

@@ -0,0 +1,8 @@
+// "Create object 'Foo'" "true"
+// DISABLE-ERRORS
+
+open class B
+
+class A {
+    var x: B by <caret>Foo
+}

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

@@ -628,7 +628,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest {
 
         @TestMetadata("idea/testData/quickfix/createFromUsage/createClass")
         @TestDataPath("$PROJECT_ROOT")
-        @InnerTestClasses({CreateClass.DelegationSpecifier.class, CreateClass.TypeReference.class})
+        @InnerTestClasses({CreateClass.DelegationSpecifier.class, CreateClass.ImportDirective.class, CreateClass.ReferenceExpression.class, CreateClass.TypeReference.class})
         @RunWith(JUnit3RunnerWithInners.class)
         public static class CreateClass extends AbstractQuickFixTest {
             public void testAllFilesPresentInCreateClass() throws Exception {
@@ -656,6 +656,270 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest {
                 }
             }
 
+            @TestMetadata("idea/testData/quickfix/createFromUsage/createClass/importDirective")
+            @TestDataPath("$PROJECT_ROOT")
+            @RunWith(JUnit3RunnerWithInners.class)
+            public static class ImportDirective extends AbstractQuickFixTest {
+                public void testAllFilesPresentInImportDirective() throws Exception {
+                    JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createClass/importDirective"), Pattern.compile("^before(\\w+)\\.kt$"), true);
+                }
+
+                @TestMetadata("beforeAnnotationInPackage.kt")
+                public void testAnnotationInPackage() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("idea/testData/quickfix/createFromUsage/createClass/importDirective/beforeAnnotationInPackage.kt");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("beforeAnnotationWithQualifier.kt")
+                public void testAnnotationWithQualifier() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("idea/testData/quickfix/createFromUsage/createClass/importDirective/beforeAnnotationWithQualifier.kt");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("beforeClassInPackage.kt")
+                public void testClassInPackage() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("idea/testData/quickfix/createFromUsage/createClass/importDirective/beforeClassInPackage.kt");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("beforeClassWithQualifier.kt")
+                public void testClassWithQualifier() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("idea/testData/quickfix/createFromUsage/createClass/importDirective/beforeClassWithQualifier.kt");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("beforeEnumEntryInEnum.kt")
+                public void testEnumEntryInEnum() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("idea/testData/quickfix/createFromUsage/createClass/importDirective/beforeEnumEntryInEnum.kt");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("beforeEnumEntryInPackage.kt")
+                public void testEnumEntryInPackage() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("idea/testData/quickfix/createFromUsage/createClass/importDirective/beforeEnumEntryInPackage.kt");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("beforeEnumEntryWithQualifier.kt")
+                public void testEnumEntryWithQualifier() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("idea/testData/quickfix/createFromUsage/createClass/importDirective/beforeEnumEntryWithQualifier.kt");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("beforeEnumInPackage.kt")
+                public void testEnumInPackage() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("idea/testData/quickfix/createFromUsage/createClass/importDirective/beforeEnumInPackage.kt");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("beforeEnumWithQualifier.kt")
+                public void testEnumWithQualifier() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("idea/testData/quickfix/createFromUsage/createClass/importDirective/beforeEnumWithQualifier.kt");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("beforeObjectInPackage.kt")
+                public void testObjectInPackage() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("idea/testData/quickfix/createFromUsage/createClass/importDirective/beforeObjectInPackage.kt");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("beforeObjectWithQualifier.kt")
+                public void testObjectWithQualifier() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("idea/testData/quickfix/createFromUsage/createClass/importDirective/beforeObjectWithQualifier.kt");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("beforeTraitInPackage.kt")
+                public void testTraitInPackage() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("idea/testData/quickfix/createFromUsage/createClass/importDirective/beforeTraitInPackage.kt");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("beforeTraitWithQualifier.kt")
+                public void testTraitWithQualifier() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("idea/testData/quickfix/createFromUsage/createClass/importDirective/beforeTraitWithQualifier.kt");
+                    doTest(fileName);
+                }
+            }
+
+            @TestMetadata("idea/testData/quickfix/createFromUsage/createClass/referenceExpression")
+            @TestDataPath("$PROJECT_ROOT")
+            @RunWith(JUnit3RunnerWithInners.class)
+            public static class ReferenceExpression extends AbstractQuickFixTest {
+                public void testAllFilesPresentInReferenceExpression() throws Exception {
+                    JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createClass/referenceExpression"), Pattern.compile("^before(\\w+)\\.kt$"), true);
+                }
+
+                @TestMetadata("beforeAnnotationNoReceiver.kt")
+                public void testAnnotationNoReceiver() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("idea/testData/quickfix/createFromUsage/createClass/referenceExpression/beforeAnnotationNoReceiver.kt");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("beforeClassByNestedQualifier.kt")
+                public void testClassByNestedQualifier() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("idea/testData/quickfix/createFromUsage/createClass/referenceExpression/beforeClassByNestedQualifier.kt");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("beforeClassByQualifier.kt")
+                public void testClassByQualifier() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("idea/testData/quickfix/createFromUsage/createClass/referenceExpression/beforeClassByQualifier.kt");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("beforeClassInPackage.kt")
+                public void testClassInPackage() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("idea/testData/quickfix/createFromUsage/createClass/referenceExpression/beforeClassInPackage.kt");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("beforeClassNoReceiver.kt")
+                public void testClassNoReceiver() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("idea/testData/quickfix/createFromUsage/createClass/referenceExpression/beforeClassNoReceiver.kt");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("beforeClassWithQualifier.kt")
+                public void testClassWithQualifier() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("idea/testData/quickfix/createFromUsage/createClass/referenceExpression/beforeClassWithQualifier.kt");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("beforeClassWithReceiver.kt")
+                public void testClassWithReceiver() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("idea/testData/quickfix/createFromUsage/createClass/referenceExpression/beforeClassWithReceiver.kt");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("beforeEnumByQualifier.kt")
+                public void testEnumByQualifier() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("idea/testData/quickfix/createFromUsage/createClass/referenceExpression/beforeEnumByQualifier.kt");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("beforeEnumEntryNoReceiver.kt")
+                public void testEnumEntryNoReceiver() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("idea/testData/quickfix/createFromUsage/createClass/referenceExpression/beforeEnumEntryNoReceiver.kt");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("beforeEnumEntryWithEnumQualifier.kt")
+                public void testEnumEntryWithEnumQualifier() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("idea/testData/quickfix/createFromUsage/createClass/referenceExpression/beforeEnumEntryWithEnumQualifier.kt");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("beforeEnumEntryWithEnumQualifierAndParams.kt")
+                public void testEnumEntryWithEnumQualifierAndParams() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("idea/testData/quickfix/createFromUsage/createClass/referenceExpression/beforeEnumEntryWithEnumQualifierAndParams.kt");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("beforeEnumEntryWithEnumSuperclass.kt")
+                public void testEnumEntryWithEnumSuperclass() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("idea/testData/quickfix/createFromUsage/createClass/referenceExpression/beforeEnumEntryWithEnumSuperclass.kt");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("beforeEnumEntryWithQualifier.kt")
+                public void testEnumEntryWithQualifier() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("idea/testData/quickfix/createFromUsage/createClass/referenceExpression/beforeEnumEntryWithQualifier.kt");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("beforeEnumEntryWithReceiver.kt")
+                public void testEnumEntryWithReceiver() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("idea/testData/quickfix/createFromUsage/createClass/referenceExpression/beforeEnumEntryWithReceiver.kt");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("beforeEnumEntryWithSuperclass.kt")
+                public void testEnumEntryWithSuperclass() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("idea/testData/quickfix/createFromUsage/createClass/referenceExpression/beforeEnumEntryWithSuperclass.kt");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("beforeEnumNoReceiver.kt")
+                public void testEnumNoReceiver() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("idea/testData/quickfix/createFromUsage/createClass/referenceExpression/beforeEnumNoReceiver.kt");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("beforeObjectByQualifier.kt")
+                public void testObjectByQualifier() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("idea/testData/quickfix/createFromUsage/createClass/referenceExpression/beforeObjectByQualifier.kt");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("beforeObjectInPackage.kt")
+                public void testObjectInPackage() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("idea/testData/quickfix/createFromUsage/createClass/referenceExpression/beforeObjectInPackage.kt");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("beforeObjectNoReceiver.kt")
+                public void testObjectNoReceiver() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("idea/testData/quickfix/createFromUsage/createClass/referenceExpression/beforeObjectNoReceiver.kt");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("beforeObjectWithQualifier.kt")
+                public void testObjectWithQualifier() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("idea/testData/quickfix/createFromUsage/createClass/referenceExpression/beforeObjectWithQualifier.kt");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("beforeObjectWithReceiver.kt")
+                public void testObjectWithReceiver() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("idea/testData/quickfix/createFromUsage/createClass/referenceExpression/beforeObjectWithReceiver.kt");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("beforeObjectWithSuperclass.kt")
+                public void testObjectWithSuperclass() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("idea/testData/quickfix/createFromUsage/createClass/referenceExpression/beforeObjectWithSuperclass.kt");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("beforeObjectWithSupertrait.kt")
+                public void testObjectWithSupertrait() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("idea/testData/quickfix/createFromUsage/createClass/referenceExpression/beforeObjectWithSupertrait.kt");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("beforeTraitByQualifier.kt")
+                public void testTraitByQualifier() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("idea/testData/quickfix/createFromUsage/createClass/referenceExpression/beforeTraitByQualifier.kt");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("beforeTraitNoReceiver.kt")
+                public void testTraitNoReceiver() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("idea/testData/quickfix/createFromUsage/createClass/referenceExpression/beforeTraitNoReceiver.kt");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("beforeUnusedReference.kt")
+                public void testUnusedReference() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("idea/testData/quickfix/createFromUsage/createClass/referenceExpression/beforeUnusedReference.kt");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("beforeValDelegateExpressionRuntime.kt")
+                public void testValDelegateExpressionRuntime() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("idea/testData/quickfix/createFromUsage/createClass/referenceExpression/beforeValDelegateExpressionRuntime.kt");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("beforeVarDelegateExpressionRuntime.kt")
+                public void testVarDelegateExpressionRuntime() throws Exception {
+                    String fileName = JetTestUtils.navigationMetadata("idea/testData/quickfix/createFromUsage/createClass/referenceExpression/beforeVarDelegateExpressionRuntime.kt");
+                    doTest(fileName);
+                }
+            }
+
             @TestMetadata("idea/testData/quickfix/createFromUsage/createClass/typeReference")
             @TestDataPath("$PROJECT_ROOT")
             @RunWith(JUnit3RunnerWithInners.class)