From 3556f9751e640d387f74b017e66b7a89786e5548 Mon Sep 17 00:00:00 2001 From: Dmitry Petrov Date: Thu, 5 Nov 2015 18:55:52 +0300 Subject: [PATCH] Reuse package/class qualifier prefix resolution for qualified expression resolution. --- .../resolve/QualifiedExpressionResolver.kt | 210 +++++++++++++++--- .../resolve/calls/CallExpressionResolver.java | 13 +- .../resolve/calls/CallExpressionUnroller.kt | 2 +- .../resolve/calls/tasks/TaskPrioritizer.kt | 3 +- .../resolve/scopes/receivers/Qualifier.kt | 7 +- .../kotlin/resolve/scopes/utils/ScopeUtils.kt | 11 + .../classObjects/invisibleClassObjects.kt | 6 +- .../nestedClassInPrivateClassObject.kt | 4 +- .../tests/deprecated/nestedTypesUsage.kt | 8 +- .../tests/deprecated/objectUsage.kt | 6 +- .../tests/j+k/packageVisibility.kt | 12 +- .../j+k/privateNestedClassStaticMember.kt | 4 +- .../inspectionData/expected.xml | 19 -- .../lookupTracker/classifierMembers/foo.kt | 8 +- 14 files changed, 220 insertions(+), 93 deletions(-) diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/QualifiedExpressionResolver.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/QualifiedExpressionResolver.kt index 07b453ca7a8..ef2da026227 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/QualifiedExpressionResolver.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/QualifiedExpressionResolver.kt @@ -20,21 +20,27 @@ import com.intellij.util.SmartList import org.jetbrains.kotlin.descriptors.* import org.jetbrains.kotlin.diagnostics.Errors import org.jetbrains.kotlin.incremental.KotlinLookupLocation +import org.jetbrains.kotlin.lexer.KtTokens import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.psi.* +import org.jetbrains.kotlin.resolve.calls.CallExpressionElement import org.jetbrains.kotlin.resolve.descriptorUtil.classObjectType import org.jetbrains.kotlin.resolve.descriptorUtil.hasClassObjectType import org.jetbrains.kotlin.resolve.descriptorUtil.module import org.jetbrains.kotlin.resolve.scopes.ImportingScope import org.jetbrains.kotlin.resolve.scopes.LexicalScope import org.jetbrains.kotlin.resolve.scopes.receivers.* +import org.jetbrains.kotlin.resolve.scopes.utils.containsFunctionOrVariable import org.jetbrains.kotlin.resolve.scopes.utils.findClassifier +import org.jetbrains.kotlin.resolve.scopes.utils.findFunction +import org.jetbrains.kotlin.resolve.scopes.utils.findVariable import org.jetbrains.kotlin.resolve.source.KotlinSourceElement import org.jetbrains.kotlin.resolve.validation.SymbolUsageValidator import org.jetbrains.kotlin.types.expressions.ExpressionTypingContext import org.jetbrains.kotlin.utils.addIfNotNull import org.jetbrains.kotlin.utils.addToStdlib.check +import java.util.* public class QualifiedExpressionResolver(val symbolUsageValidator: SymbolUsageValidator) { @@ -78,7 +84,8 @@ public class QualifiedExpressionResolver(val symbolUsageValidator: SymbolUsageVa val (qualifierPartList, hasError) = userType.asQualifierPartList() if (hasError) { val descriptor = resolveToPackageOrClass( - qualifierPartList, module, trace, scope.ownerDescriptor, scope, inImport = false) as? ClassifierDescriptor + qualifierPartList, module, trace, scope.ownerDescriptor, scope, position = QualifierPosition.TYPE + ) as? ClassifierDescriptor return TypeQualifierResolutionResult(qualifierPartList, descriptor) } assert(qualifierPartList.size() >= 1) { @@ -87,7 +94,7 @@ public class QualifiedExpressionResolver(val symbolUsageValidator: SymbolUsageVa val qualifier = resolveToPackageOrClass( qualifierPartList.subList(0, qualifierPartList.size() - 1), module, - trace, scope.ownerDescriptor, scope.check { !userType.startWithPackage }, inImport = false + trace, scope.ownerDescriptor, scope.check { !userType.startWithPackage }, position = QualifierPosition.TYPE ) ?: return TypeQualifierResolutionResult(qualifierPartList, null) val lastPart = qualifierPartList.last() @@ -150,7 +157,7 @@ public class QualifiedExpressionResolver(val symbolUsageValidator: SymbolUsageVa return processSingleImport(moduleDescriptor, trace, importDirective, path, lastPart, packageFragmentForCheck) } val packageOrClassDescriptor = resolveToPackageOrClass(path, moduleDescriptor, trace, packageFragmentForCheck, - scopeForFirstPart = null, inImport = true) ?: return null + scopeForFirstPart = null, position = QualifierPosition.IMPORT) ?: return null if (packageOrClassDescriptor is ClassDescriptor && packageOrClassDescriptor.kind.isSingleton) { trace.report(Errors.CANNOT_ALL_UNDER_IMPORT_FROM_SINGLETON.on(lastPart.expression, packageOrClassDescriptor)) // todo report on star } @@ -164,13 +171,13 @@ public class QualifiedExpressionResolver(val symbolUsageValidator: SymbolUsageVa val aliasName = KtPsiUtil.getAliasName(importDirective) if (aliasName == null) { // import kotlin. - resolveToPackageOrClass(path, moduleDescriptor, trace, packageFragmentForVisibilityCheck, scopeForFirstPart = null, inImport = true) + resolveToPackageOrClass(path, moduleDescriptor, trace, packageFragmentForVisibilityCheck, scopeForFirstPart = null, position = QualifierPosition.IMPORT) return null } val packageOrClassDescriptor = resolveToPackageOrClass( path.subList(0, path.size() - 1), moduleDescriptor, trace, - packageFragmentForVisibilityCheck, scopeForFirstPart = null, inImport = true + packageFragmentForVisibilityCheck, scopeForFirstPart = null, position = QualifierPosition.IMPORT ) ?: return null val candidates = collectCandidateDescriptors(lastPart, packageOrClassDescriptor) @@ -284,57 +291,184 @@ public class QualifiedExpressionResolver(val symbolUsageValidator: SymbolUsageVa val expression: KtSimpleNameExpression, val typeArguments: KtTypeArgumentList? = null ) { + constructor (expression: KtSimpleNameExpression) : this(expression.getReferencedNameAsName(), expression) + val location = KotlinLookupLocation(expression) } + private enum class QualifierPosition { + IMPORT, TYPE, EXPRESSION + } + private fun resolveToPackageOrClass( path: List, moduleDescriptor: ModuleDescriptor, trace: BindingTrace, shouldBeVisibleFrom: DeclarationDescriptor?, scopeForFirstPart: LexicalScope?, - inImport: Boolean + position: QualifierPosition ): DeclarationDescriptor? { + val (packageOrClassDescriptor, endIndex) = + resolveToPackageOrClassPrefix(path, moduleDescriptor, trace, shouldBeVisibleFrom, scopeForFirstPart, position) + + if (endIndex != path.size) { + return null + } + + return packageOrClassDescriptor + } + + private fun resolveToPackageOrClassPrefix( + path: List, + moduleDescriptor: ModuleDescriptor, + trace: BindingTrace, + shouldBeVisibleFrom: DeclarationDescriptor?, + scopeForFirstPart: LexicalScope?, + position: QualifierPosition + ): Pair { if (path.isEmpty()) { - return moduleDescriptor.getPackage(FqName.ROOT) + return Pair(moduleDescriptor.getPackage(FqName.ROOT), 0) } - val firstDescriptor = scopeForFirstPart?.let { - val firstPart = path.first() - it.findClassifier(firstPart.name, firstPart.location)?.apply { - storeResult(trace, firstPart.expression, this, shouldBeVisibleFrom, inImport) - } + val inImport = position == QualifierPosition.IMPORT + + val firstPart = path.first() + + if (position == QualifierPosition.EXPRESSION) { + // In expression position, value wins against classifier (and package). + // If we see a function or variable (possibly ambiguous), + // tell resolver we have no qualifier and let it perform the context-dependent resolution. + if (scopeForFirstPart != null && scopeForFirstPart.containsFunctionOrVariable(firstPart.name, firstPart.location)) { + return Pair(null, 0) } + } + val classifierDescriptor = scopeForFirstPart?.let { + it.findClassifier(firstPart.name, firstPart.location) + } - val (currentDescriptor, currentIndex) = firstDescriptor?.let { Pair(it, 1) } ?: moduleDescriptor.quickResolveToPackage(path, trace, inImport) + if (classifierDescriptor != null) { + storeResult(trace, firstPart.expression, classifierDescriptor, shouldBeVisibleFrom, inImport) + } - return path.subList(currentIndex, path.size()).fold(currentDescriptor) { - descriptor, qualifierPart -> - // report unresolved reference only for first unresolved qualifier - if (descriptor == null) return@fold null + val (prefixDescriptor, nextIndexAfterPrefix) = + if (classifierDescriptor != null) + Pair(classifierDescriptor, 1) + else + moduleDescriptor.quickResolveToPackage(path, trace, inImport) - val nextDescriptor = when (descriptor) { - // TODO: support inner classes which captured type parameter from outer class - is ClassDescriptor -> - descriptor.unsubstitutedInnerClassesScope.getContributedClassifier(qualifierPart.name, qualifierPart.location) - is PackageViewDescriptor -> { - val packageView = if (qualifierPart.typeArguments == null) { - moduleDescriptor.getPackage(descriptor.fqName.child(qualifierPart.name)) - } else null + var currentDescriptor: DeclarationDescriptor? = prefixDescriptor + for (qualifierPartIndex in nextIndexAfterPrefix .. path.size - 1) { + val qualifierPart = path[qualifierPartIndex] - - if (packageView != null && !packageView.isEmpty()) { - packageView - } else { - descriptor.memberScope.getContributedClassifier(qualifierPart.name, qualifierPart.location) + val nextPackageOrClassDescriptor = + when (currentDescriptor) { + is ClassDescriptor -> + currentDescriptor.unsubstitutedInnerClassesScope.getContributedClassifier(qualifierPart.name, qualifierPart.location) + is PackageViewDescriptor -> { + val packageView = + if (qualifierPart.typeArguments == null) { + moduleDescriptor.getPackage(currentDescriptor.fqName.child(qualifierPart.name)) + } + else null + if (packageView != null && !packageView.isEmpty()) { + packageView + } + else { + currentDescriptor.memberScope.getContributedClassifier(qualifierPart.name, qualifierPart.location) + } + } + else -> + null } - } - else -> null + + // If we are in expression, this name can denote a value (not a package or class). + if (!(position == QualifierPosition.EXPRESSION && nextPackageOrClassDescriptor == null)) { + storeResult(trace, qualifierPart.expression, nextPackageOrClassDescriptor, shouldBeVisibleFrom, inImport) } - storeResult(trace, qualifierPart.expression, nextDescriptor, shouldBeVisibleFrom, inImport) - nextDescriptor + + if (nextPackageOrClassDescriptor == null) { + return Pair(currentDescriptor, qualifierPartIndex) + } + + currentDescriptor = nextPackageOrClassDescriptor } + + return Pair(currentDescriptor, path.size) + } + + + public fun resolveQualifierInExpressionAndUnroll( + expression: KtQualifiedExpression, + context: ExpressionTypingContext + ): List { + val qualifiedExpressions = unrollToLeftMostQualifiedExpression(expression) + val maxPossibleQualifierPrefix = getMaxPossibleQualifierPrefix(qualifiedExpressions) + + val (packageOrClassDescriptor, nextIndexAfterPrefix) = resolveToPackageOrClassPrefix( + path = maxPossibleQualifierPrefix, + moduleDescriptor = context.scope.ownerDescriptor.module, + trace = context.trace, + shouldBeVisibleFrom = context.scope.ownerDescriptor, + scopeForFirstPart = context.scope, + position = QualifierPosition.EXPRESSION + ) + + if (nextIndexAfterPrefix > 0) { + val qualifierReferenceExpression = maxPossibleQualifierPrefix[nextIndexAfterPrefix - 1].expression + val qualifier = + when (packageOrClassDescriptor) { + is PackageViewDescriptor -> + PackageQualifier(qualifierReferenceExpression, packageOrClassDescriptor) + is ClassDescriptor -> + ClassQualifier(qualifierReferenceExpression, packageOrClassDescriptor) + else -> + null + } + if (qualifier != null) { + context.trace.record(BindingContext.QUALIFIER, qualifier.expression, qualifier) + } + } + + return qualifiedExpressions.map { CallExpressionElement(it) } + } + + private fun unrollToLeftMostQualifiedExpression(expression: KtQualifiedExpression): List { + val unrolled = arrayListOf() + + var finger = expression + while (true) { + unrolled.add(finger) + val receiver = finger.receiverExpression + if (receiver !is KtQualifiedExpression) { + break + } + finger = receiver + } + + Collections.reverse(unrolled) + return unrolled + } + + private fun getMaxPossibleQualifierPrefix(qualifiedExpressions: List) : List { + if (qualifiedExpressions.isEmpty()) return emptyList() + + val first = qualifiedExpressions.first() + if (first.operationSign != KtTokens.DOT) return emptyList() + val firstReceiver = first.receiverExpression + if (firstReceiver !is KtSimpleNameExpression) return emptyList() + + val qualifierParts = arrayListOf() + qualifierParts.add(QualifierPart(firstReceiver)) + + for (qualifiedExpression in qualifiedExpressions.dropLast(1)) { + if (qualifiedExpression.operationSign != KtTokens.DOT) break + val selector = qualifiedExpression.selectorExpression + if (selector !is KtSimpleNameExpression) break + qualifierParts.add(QualifierPart(selector)) + } + + return qualifierParts } private fun ModuleDescriptor.quickResolveToPackage( @@ -516,13 +650,15 @@ public class QualifiedExpressionResolver(val symbolUsageValidator: SymbolUsageVa context: ExpressionTypingContext, selector: DeclarationDescriptor? ): DeclarationDescriptor { - if (qualifier is ClassQualifier && qualifier.classifier is TypeParameterDescriptor) { + if (qualifier is ClassifierQualifier && qualifier.classifier is TypeParameterDescriptor) { return qualifier.classifier } val selectorContainer = when (selector) { - is ConstructorDescriptor -> selector.containingDeclaration.containingDeclaration - else -> selector?.containingDeclaration + is ConstructorDescriptor -> + selector.containingDeclaration.containingDeclaration + else -> + selector?.containingDeclaration } if (qualifier is PackageQualifier && diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallExpressionResolver.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallExpressionResolver.java index 40ab7639a1f..5ec3b14ce41 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallExpressionResolver.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallExpressionResolver.java @@ -57,7 +57,6 @@ import org.jetbrains.kotlin.types.expressions.typeInfoFactory.TypeInfoFactoryKt; import javax.inject.Inject; import java.util.Collections; -import java.util.Deque; import java.util.List; import static org.jetbrains.kotlin.diagnostics.Errors.*; @@ -332,9 +331,12 @@ public class CallExpressionResolver { @NotNull KtQualifiedExpression expression, @NotNull ExpressionTypingContext context ) { ExpressionTypingContext currentContext = context.replaceExpectedType(NO_EXPECTED_TYPE).replaceContextDependency(INDEPENDENT); - Deque elementChain = CallExpressionUnrollerKt.unroll(expression); - KotlinTypeInfo receiverTypeInfo = expressionTypingServices.getTypeInfo(elementChain.getFirst().getReceiver(), currentContext); + List elementChain = + qualifiedExpressionResolver.resolveQualifierInExpressionAndUnroll(expression, context); + + CallExpressionElement firstElement = elementChain.iterator().next(); + KotlinTypeInfo receiverTypeInfo = expressionTypingServices.getTypeInfo(firstElement.getReceiver(), currentContext); KotlinType receiverType = receiverTypeInfo.getType(); DataFlowInfo receiverDataFlowInfo = receiverTypeInfo.getDataFlowInfo(); KotlinTypeInfo resultTypeInfo = receiverTypeInfo; @@ -353,15 +355,14 @@ public class CallExpressionResolver { : qualifierReceiver; boolean lastStage = element.getQualified() == expression; - assert lastStage == (element == elementChain.getLast()); // Drop NO_EXPECTED_TYPE / INDEPENDENT at last stage // But receiver data flow info changes should be always applied, while we are inside call chain ExpressionTypingContext baseContext = lastStage ? context : currentContext; currentContext = baseContext.replaceDataFlowInfo(receiverDataFlowInfo); KtExpression selectorExpression = element.getSelector(); - KotlinTypeInfo selectorReturnTypeInfo = getSelectorReturnTypeInfo( - receiver, element.getNode(), selectorExpression, currentContext); + KotlinTypeInfo selectorReturnTypeInfo = + getSelectorReturnTypeInfo(receiver, element.getNode(), selectorExpression, currentContext); KotlinType selectorReturnType = selectorReturnTypeInfo.getType(); resolveDeferredReceiverInQualifiedExpression(qualifierReceiver, element.getQualified(), currentContext); diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallExpressionUnroller.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallExpressionUnroller.kt index 4f992e04034..9d2059677a7 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallExpressionUnroller.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallExpressionUnroller.kt @@ -32,7 +32,7 @@ internal fun unroll(root: KtQualifiedExpression): Deque { return result } -internal data class CallExpressionElement(val qualified: KtQualifiedExpression) { +public data class CallExpressionElement internal constructor (val qualified: KtQualifiedExpression) { val receiver: KtExpression get() = qualified.receiverExpression diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/TaskPrioritizer.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/TaskPrioritizer.kt index d0098c012b6..69d47069b7c 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/TaskPrioritizer.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/TaskPrioritizer.kt @@ -69,7 +69,8 @@ public class TaskPrioritizer( when (explicitReceiver) { is QualifierReceiver -> { val qualifierReceiver: QualifierReceiver = explicitReceiver - val receiverScope = qualifierReceiver.getNestedClassesAndPackageMembersScope().memberScopeAsImportingScope() + val receiverScope = LexicalScope.empty(qualifierReceiver.getNestedClassesAndPackageMembersScope().memberScopeAsImportingScope(), + qualifierReceiver.descriptor) doComputeTasks(NO_RECEIVER, taskPrioritizerContext.replaceScope(receiverScope)) computeTasksForClassObjectReceiver(qualifierReceiver, taskPrioritizerContext) } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/scopes/receivers/Qualifier.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/scopes/receivers/Qualifier.kt index e81435358e9..e8c47910811 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/scopes/receivers/Qualifier.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/scopes/receivers/Qualifier.kt @@ -17,7 +17,6 @@ package org.jetbrains.kotlin.resolve.scopes.receivers import org.jetbrains.kotlin.descriptors.* -import org.jetbrains.kotlin.diagnostics.Errors.* import org.jetbrains.kotlin.incremental.KotlinLookupLocation import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.psi.KtExpression @@ -36,8 +35,6 @@ import org.jetbrains.kotlin.resolve.scopes.MemberScope import org.jetbrains.kotlin.resolve.scopes.utils.findClassifier import org.jetbrains.kotlin.resolve.scopes.utils.findPackage import org.jetbrains.kotlin.resolve.scopes.utils.memberScopeAsImportingScope -import org.jetbrains.kotlin.resolve.validation.SymbolUsageValidator -import org.jetbrains.kotlin.types.KotlinType import org.jetbrains.kotlin.types.expressions.ExpressionTypingContext import org.jetbrains.kotlin.utils.addIfNotNull import java.util.* @@ -102,9 +99,9 @@ class ClassifierQualifierWithEmptyScope( override val classifier: ClassifierDescriptor ) : ClassifierQualifier(referenceExpression) { - override fun getNestedClassesAndPackageMembersScope(): MemberScope = scope + override fun getNestedClassesAndPackageMembersScope(): MemberScope = MemberScope.Empty - override val scope: MemberScope = MemberScope.empty(classifier) + override val scope: MemberScope = MemberScope.Empty } class ClassQualifier( diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/scopes/utils/ScopeUtils.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/scopes/utils/ScopeUtils.kt index 565f2c71cfb..96a1f6ac9dc 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/scopes/utils/ScopeUtils.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/scopes/utils/ScopeUtils.kt @@ -98,6 +98,17 @@ public fun HierarchicalScope.findFunction(name: Name, location: LookupLocation, return null } +public fun HierarchicalScope.containsFunctionOrVariable(name: Name, location: LookupLocation): Boolean { + processForMeAndParent { + if (it.getContributedFunctions(name, location).isNotEmpty() || + it.getContributedVariables(name, location).isNotEmpty() + ) { + return true + } + } + return false +} + public fun HierarchicalScope.collectSyntheticExtensionProperties(receiverTypes: Collection, name: Name, location: LookupLocation) = collectAllFromImportingScopes { it.getContributedSyntheticExtensionProperties(receiverTypes, name, location) } diff --git a/compiler/testData/diagnostics/tests/classObjects/invisibleClassObjects.kt b/compiler/testData/diagnostics/tests/classObjects/invisibleClassObjects.kt index 0f9078d0057..045e0d7934c 100644 --- a/compiler/testData/diagnostics/tests/classObjects/invisibleClassObjects.kt +++ b/compiler/testData/diagnostics/tests/classObjects/invisibleClassObjects.kt @@ -40,12 +40,12 @@ fun test() { f(D) A.foo() - B.bar() + B.bar() C.baz() - D.quux() + D.quux() a.A.foo() a.C.baz() } -fun f(unused: Any) {} +fun f(unused: Any) {} \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/classObjects/nestedClassInPrivateClassObject.kt b/compiler/testData/diagnostics/tests/classObjects/nestedClassInPrivateClassObject.kt index cfc98fc83d2..95de9ebe69f 100644 --- a/compiler/testData/diagnostics/tests/classObjects/nestedClassInPrivateClassObject.kt +++ b/compiler/testData/diagnostics/tests/classObjects/nestedClassInPrivateClassObject.kt @@ -10,6 +10,6 @@ class A { } } -fun f1() = A.Companion.B.C +fun f1() = A.Companion.B.C -fun f2() = A.Companion.B.C.foo() \ No newline at end of file +fun f2() = A.Companion.B.C.foo() \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/deprecated/nestedTypesUsage.kt b/compiler/testData/diagnostics/tests/deprecated/nestedTypesUsage.kt index e961047cb8f..210f7b5ed08 100644 --- a/compiler/testData/diagnostics/tests/deprecated/nestedTypesUsage.kt +++ b/compiler/testData/diagnostics/tests/deprecated/nestedTypesUsage.kt @@ -12,7 +12,7 @@ class TopLevel { } fun useNested() { - val d = TopLevel.Nested.use() - TopLevel.Nested.Nested2() - TopLevel.Nested.CompanionNested2() -} + val d = TopLevel.Nested.use() + TopLevel.Nested.Nested2() + TopLevel.Nested.CompanionNested2() +} \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/deprecated/objectUsage.kt b/compiler/testData/diagnostics/tests/deprecated/objectUsage.kt index 6f6cccb9cb5..da074c35159 100644 --- a/compiler/testData/diagnostics/tests/deprecated/objectUsage.kt +++ b/compiler/testData/diagnostics/tests/deprecated/objectUsage.kt @@ -15,13 +15,13 @@ fun first() { } fun useObject() { - Obsolete.use() + Obsolete.use() val x = Obsolete } fun useCompanion() { val d = Another val x = Another.Companion - Another.Companion.use() + Another.Companion.use() Another.use() -} +} \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/j+k/packageVisibility.kt b/compiler/testData/diagnostics/tests/j+k/packageVisibility.kt index f9c9689a978..06b89d9879c 100644 --- a/compiler/testData/diagnostics/tests/j+k/packageVisibility.kt +++ b/compiler/testData/diagnostics/tests/j+k/packageVisibility.kt @@ -28,9 +28,9 @@ import a.MyJavaClass val mc1 = MyJavaClass() -val x = MyJavaClass.staticMethod() -val y = MyJavaClass.NestedClass.staticMethodOfNested() -val z = MyJavaClass.NestedClass() +val x = MyJavaClass.staticMethod() +val y = MyJavaClass.NestedClass.staticMethodOfNested() +val z = MyJavaClass.NestedClass() //FILE: c.kt package a.c @@ -39,6 +39,6 @@ import a.MyJavaClass val mc1 = MyJavaClass() -val x = MyJavaClass.staticMethod() -val y = MyJavaClass.NestedClass.staticMethodOfNested() -val z = MyJavaClass.NestedClass() \ No newline at end of file +val x = MyJavaClass.staticMethod() +val y = MyJavaClass.NestedClass.staticMethodOfNested() +val z = MyJavaClass.NestedClass() \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/j+k/privateNestedClassStaticMember.kt b/compiler/testData/diagnostics/tests/j+k/privateNestedClassStaticMember.kt index 1abe80f449d..11215de4728 100644 --- a/compiler/testData/diagnostics/tests/j+k/privateNestedClassStaticMember.kt +++ b/compiler/testData/diagnostics/tests/j+k/privateNestedClassStaticMember.kt @@ -14,5 +14,5 @@ public class Foo { // FILE: 1.kt fun main(args: Array) { - javaPackage.Foo.Bar.doSmth() -} + javaPackage.Foo.Bar.doSmth() +} \ No newline at end of file diff --git a/idea/testData/intentions/removeExplicitTypeArguments/inspectionData/expected.xml b/idea/testData/intentions/removeExplicitTypeArguments/inspectionData/expected.xml index cb120d91ca0..7e7b130bde5 100644 --- a/idea/testData/intentions/removeExplicitTypeArguments/inspectionData/expected.xml +++ b/idea/testData/intentions/removeExplicitTypeArguments/inspectionData/expected.xml @@ -133,23 +133,4 @@ Type arguments are unnecessary Remove explicit type arguments - - - platforrmType2.kt - 5 - light_idea_test_case - - Type arguments are unnecessary - Remove explicit type arguments - - - - - platforrmType1.kt - 5 - light_idea_test_case - - Type arguments are unnecessary - Remove explicit type arguments - \ No newline at end of file diff --git a/jps-plugin/testData/incremental/lookupTracker/classifierMembers/foo.kt b/jps-plugin/testData/incremental/lookupTracker/classifierMembers/foo.kt index 34f67fad97a..0d9e9e31416 100644 --- a/jps-plugin/testData/incremental/lookupTracker/classifierMembers/foo.kt +++ b/jps-plugin/testData/incremental/lookupTracker/classifierMembers/foo.kt @@ -19,8 +19,8 @@ import bar.* this./*c:foo.A*/a this./*c:foo.A*/foo() /*c:foo.A c:foo.A.Companion p:foo p:bar p:java.lang p:kotlin p:kotlin.annotation p:kotlin.jvm p:kotlin.io c:foo.A(getBaz) c:foo.A(getBAZ)*/baz() - /*c:foo.A c:foo.A.Companion p:foo p:bar p:java.lang p:kotlin p:kotlin.annotation p:kotlin.jvm p:kotlin.io*/Companion./*c:foo.A.Companion*/a - /*c:foo.A c:foo.A.Companion p:foo p:bar p:java.lang p:kotlin p:kotlin.annotation p:kotlin.jvm p:kotlin.io*/O./*c:foo.A.O*/v = "OK" + /*p:foo p:bar p:java.lang p:kotlin p:kotlin.annotation p:kotlin.jvm p:kotlin.io c:foo.A c:foo.A.Companion*/Companion./*c:foo.A.Companion*/a + /*p:foo p:bar p:java.lang p:kotlin p:kotlin.annotation p:kotlin.jvm p:kotlin.io c:foo.A c:foo.A.Companion*/O./*c:foo.A.O*/v = "OK" } class B { @@ -64,8 +64,8 @@ import bar.* val a = 1 fun foo() { /*c:foo.E*/a - /*c:foo.E p:foo p:bar p:java.lang p:kotlin p:kotlin.annotation p:kotlin.jvm p:kotlin.io*/Y./*c:foo.E*/a + /*p:foo p:bar p:java.lang p:kotlin p:kotlin.annotation p:kotlin.jvm p:kotlin.io c:foo.E*/Y./*c:foo.E*/a /*c:foo.E*/foo() - /*c:foo.E p:foo p:bar p:java.lang p:kotlin p:kotlin.annotation p:kotlin.jvm p:kotlin.io*/X./*c:foo.E*/foo() + /*p:foo p:bar p:java.lang p:kotlin p:kotlin.annotation p:kotlin.jvm p:kotlin.io c:foo.E*/X./*c:foo.E*/foo() } }