From 2637bf608ab22cb3261586c852b41151ef0030d9 Mon Sep 17 00:00:00 2001 From: Valentin Kipyatkov Date: Wed, 25 Mar 2015 17:14:47 +0300 Subject: [PATCH] Converting ElementResolver to Kotlin (step 1) --- .../kotlin/resolve/lazy/ElementResolver.java | 701 +++++++----------- 1 file changed, 275 insertions(+), 426 deletions(-) diff --git a/idea/ide-common/src/org/jetbrains/kotlin/resolve/lazy/ElementResolver.java b/idea/ide-common/src/org/jetbrains/kotlin/resolve/lazy/ElementResolver.java index 0540b60adec..ef495d2a719 100644 --- a/idea/ide-common/src/org/jetbrains/kotlin/resolve/lazy/ElementResolver.java +++ b/idea/ide-common/src/org/jetbrains/kotlin/resolve/lazy/ElementResolver.java @@ -14,645 +14,494 @@ * limitations under the License. */ -package org.jetbrains.kotlin.resolve.lazy; +package org.jetbrains.kotlin.resolve.lazy -import com.google.common.base.Function; -import com.google.common.base.Functions; -import com.intellij.psi.PsiElement; -import com.intellij.psi.util.PsiTreeUtil; -import kotlin.KotlinPackage; -import org.jetbrains.annotations.NotNull; -import org.jetbrains.kotlin.analyzer.AnalyzerPackage; -import org.jetbrains.kotlin.cfg.JetFlowInformationProvider; -import org.jetbrains.kotlin.descriptors.*; -import org.jetbrains.kotlin.descriptors.annotations.Annotated; -import org.jetbrains.kotlin.descriptors.annotations.Annotations; -import org.jetbrains.kotlin.di.InjectorForBodyResolve; -import org.jetbrains.kotlin.name.FqName; -import org.jetbrains.kotlin.name.Name; -import org.jetbrains.kotlin.psi.*; -import org.jetbrains.kotlin.resolve.*; -import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo; -import org.jetbrains.kotlin.resolve.lazy.descriptors.LazyClassDescriptor; -import org.jetbrains.kotlin.resolve.lazy.descriptors.LazyPackageDescriptor; -import org.jetbrains.kotlin.resolve.scopes.ChainedScope; -import org.jetbrains.kotlin.resolve.scopes.JetScope; -import org.jetbrains.kotlin.storage.ExceptionTracker; -import org.jetbrains.kotlin.storage.StorageManager; -import org.jetbrains.kotlin.types.TypeConstructor; -import org.jetbrains.kotlin.types.TypeUtils; +import com.google.common.base.Function +import com.google.common.base.Functions +import com.intellij.psi.PsiElement +import com.intellij.psi.util.PsiTreeUtil +import kotlin.KotlinPackage +import org.jetbrains.kotlin.analyzer.* +import org.jetbrains.kotlin.cfg.JetFlowInformationProvider +import org.jetbrains.kotlin.descriptors.* +import org.jetbrains.kotlin.descriptors.annotations.Annotated +import org.jetbrains.kotlin.descriptors.annotations.Annotations +import org.jetbrains.kotlin.di.InjectorForBodyResolve +import org.jetbrains.kotlin.name.FqName +import org.jetbrains.kotlin.name.Name +import org.jetbrains.kotlin.psi.* +import org.jetbrains.kotlin.resolve.* +import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo +import org.jetbrains.kotlin.resolve.lazy.descriptors.LazyClassDescriptor +import org.jetbrains.kotlin.resolve.lazy.descriptors.LazyPackageDescriptor +import org.jetbrains.kotlin.resolve.scopes.ChainedScope +import org.jetbrains.kotlin.resolve.scopes.JetScope +import org.jetbrains.kotlin.storage.ExceptionTracker +import org.jetbrains.kotlin.storage.StorageManager +import org.jetbrains.kotlin.types.TypeConstructor +import org.jetbrains.kotlin.types.TypeUtils +import java.util.Collections -import java.util.Collection; -import java.util.Collections; -import java.util.Map; +import org.jetbrains.kotlin.resolve.bindingContextUtil.BindingContextUtilPackage.getDataFlowInfo -import static org.jetbrains.kotlin.resolve.bindingContextUtil.BindingContextUtilPackage.getDataFlowInfo; +public abstract class ElementResolver protected(protected val resolveSession: ResolveSession) { -public abstract class ElementResolver { - - protected final ResolveSession resolveSession; - - protected ElementResolver(@NotNull ResolveSession session) { - resolveSession = session; + public open fun getElementAdditionalResolve(jetElement: JetElement): BindingContext { + return elementAdditionalResolve(jetElement, jetElement, BodyResolveMode.FULL) } - @NotNull - public BindingContext getElementAdditionalResolve(@NotNull JetElement jetElement) { - return elementAdditionalResolve(jetElement, jetElement, BodyResolveMode.FULL); + public open fun hasElementAdditionalResolveCached(jetElement: JetElement): Boolean { + return false } - public boolean hasElementAdditionalResolveCached(@NotNull JetElement jetElement) { - return false; + public fun resolveToElement(jetElement: JetElement): BindingContext { + return resolveToElement(jetElement, BodyResolveMode.FULL) } - @NotNull - public BindingContext resolveToElement(@NotNull JetElement jetElement) { - return resolveToElement(jetElement, BodyResolveMode.FULL); + protected open fun probablyNothingCallableNames(): ProbablyNothingCallableNames { + return DefaultNothingCallableNames } - @NotNull - protected ProbablyNothingCallableNames probablyNothingCallableNames() { - return DefaultNothingCallableNames.INSTANCE$; - } + public fun resolveToElement(jetElement: JetElement, bodyResolveMode: BodyResolveMode): BindingContext { + var jetElement = jetElement + [SuppressWarnings("unchecked")] var elementOfAdditionalResolve: JetElement? = JetPsiUtil.getTopmostParentOfTypes(jetElement, javaClass(), javaClass(), javaClass(), javaClass(), javaClass(), javaClass(), javaClass(), javaClass(), javaClass(), javaClass(), javaClass(), javaClass(), javaClass()) as JetElement - @NotNull - public BindingContext resolveToElement(@NotNull JetElement jetElement, BodyResolveMode bodyResolveMode) { - @SuppressWarnings("unchecked") JetElement elementOfAdditionalResolve = (JetElement) JetPsiUtil.getTopmostParentOfTypes( - jetElement, - JetNamedFunction.class, - JetClassInitializer.class, - JetSecondaryConstructor.class, - JetProperty.class, - JetParameter.class, - JetDelegationSpecifierList.class, - JetInitializerList.class, - JetImportDirective.class, - JetAnnotationEntry.class, - JetTypeParameter.class, - JetTypeConstraint.class, - JetPackageDirective.class, - JetCodeFragment.class - ); - - if (elementOfAdditionalResolve != null && !(elementOfAdditionalResolve instanceof JetParameter)) { - if (elementOfAdditionalResolve instanceof JetPackageDirective) { - elementOfAdditionalResolve = jetElement; + if (elementOfAdditionalResolve != null && !(elementOfAdditionalResolve is JetParameter)) { + if (elementOfAdditionalResolve is JetPackageDirective) { + elementOfAdditionalResolve = jetElement } if (bodyResolveMode != BodyResolveMode.FULL && !hasElementAdditionalResolveCached(jetElement)) { - return elementAdditionalResolve(elementOfAdditionalResolve, jetElement, bodyResolveMode); + return elementAdditionalResolve(elementOfAdditionalResolve, jetElement, bodyResolveMode) } - return getElementAdditionalResolve(elementOfAdditionalResolve); + return getElementAdditionalResolve(elementOfAdditionalResolve) } - JetParameter parameter = (JetParameter) elementOfAdditionalResolve; + val parameter = elementOfAdditionalResolve as JetParameter if (parameter != null) { - JetClass klass = PsiTreeUtil.getParentOfType(parameter, JetClass.class); + val klass = PsiTreeUtil.getParentOfType(parameter, javaClass()) if (klass != null && parameter.getParent() == klass.getPrimaryConstructorParameterList()) { - return getElementAdditionalResolve(klass); + return getElementAdditionalResolve(klass) } // Parameters for function literal could be met inside other parameters. We can't make resolveToDescriptors for internal elements. - jetElement = parameter; + jetElement = parameter } - JetDeclaration declaration = PsiTreeUtil.getParentOfType(jetElement, JetDeclaration.class, false); - if (declaration != null && !(declaration instanceof JetClassInitializer)) { + val declaration = PsiTreeUtil.getParentOfType(jetElement, javaClass(), false) + if (declaration != null && !(declaration is JetClassInitializer)) { // Activate descriptor resolution - resolveSession.resolveToDescriptor(declaration); + resolveSession.resolveToDescriptor(declaration) } - return resolveSession.getBindingContext(); + return resolveSession.getBindingContext() } - @NotNull - protected BindingContext elementAdditionalResolve( - @NotNull JetElement resolveElement, - @NotNull JetElement contextElement, - @NotNull BodyResolveMode bodyResolveMode - ) { + protected fun elementAdditionalResolve(resolveElement: JetElement, contextElement: JetElement, bodyResolveMode: BodyResolveMode): BindingContext { // All additional resolve should be done to separate trace - BindingTrace trace = resolveSession.getStorageManager().createSafeTrace( - new DelegatingBindingTrace(resolveSession.getBindingContext(), "trace to resolve element", resolveElement)); + val trace = resolveSession.getStorageManager().createSafeTrace(DelegatingBindingTrace(resolveSession.getBindingContext(), "trace to resolve element", resolveElement)) - JetFile file = resolveElement.getContainingJetFile(); + val file = resolveElement.getContainingJetFile() - StatementFilter statementFilter; - if (bodyResolveMode != BodyResolveMode.FULL && resolveElement instanceof JetDeclaration) { - statementFilter = new PartialBodyResolveFilter( - contextElement, - (JetDeclaration) resolveElement, - probablyNothingCallableNames(), - bodyResolveMode == BodyResolveMode.PARTIAL_FOR_COMPLETION); + val statementFilter: StatementFilter + if (bodyResolveMode != BodyResolveMode.FULL && resolveElement is JetDeclaration) { + statementFilter = PartialBodyResolveFilter(contextElement, resolveElement as JetDeclaration, probablyNothingCallableNames(), bodyResolveMode == BodyResolveMode.PARTIAL_FOR_COMPLETION) } else { - statementFilter = StatementFilter.NONE; + statementFilter = StatementFilter.NONE } - if (resolveElement instanceof JetNamedFunction) { - functionAdditionalResolve(resolveSession, (JetNamedFunction) resolveElement, trace, file, statementFilter); + if (resolveElement is JetNamedFunction) { + functionAdditionalResolve(resolveSession, resolveElement as JetNamedFunction, trace, file, statementFilter) } - else if (resolveElement instanceof JetClassInitializer) { - initializerAdditionalResolve(resolveSession, (JetClassInitializer) resolveElement, trace, file, statementFilter); + else if (resolveElement is JetClassInitializer) { + initializerAdditionalResolve(resolveSession, resolveElement as JetClassInitializer, trace, file, statementFilter) } - else if (resolveElement instanceof JetSecondaryConstructor) { - secondaryConstructorAdditionalResolve(resolveSession, (JetSecondaryConstructor) resolveElement, trace, file, statementFilter); + else if (resolveElement is JetSecondaryConstructor) { + secondaryConstructorAdditionalResolve(resolveSession, resolveElement as JetSecondaryConstructor, trace, file, statementFilter) } - else if (resolveElement instanceof JetProperty) { - propertyAdditionalResolve(resolveSession, (JetProperty) resolveElement, trace, file, statementFilter); + else if (resolveElement is JetProperty) { + propertyAdditionalResolve(resolveSession, resolveElement as JetProperty, trace, file, statementFilter) } - else if (resolveElement instanceof JetDelegationSpecifierList) { - delegationSpecifierAdditionalResolve(resolveSession, (JetClassOrObject) resolveElement.getParent(), trace, file); + else if (resolveElement is JetDelegationSpecifierList) { + delegationSpecifierAdditionalResolve(resolveSession, resolveElement.getParent() as JetClassOrObject, trace, file) } - else if (resolveElement instanceof JetInitializerList) { - delegationSpecifierAdditionalResolve(resolveSession, (JetEnumEntry) resolveElement.getParent(), trace, file); + else if (resolveElement is JetInitializerList) { + delegationSpecifierAdditionalResolve(resolveSession, resolveElement.getParent() as JetEnumEntry, trace, file) } - else if (resolveElement instanceof JetImportDirective) { - JetImportDirective importDirective = (JetImportDirective) resolveElement; - LazyFileScope scope = resolveSession.getScopeProvider().getFileScope(importDirective.getContainingJetFile()); - scope.forceResolveAllImports(); + else if (resolveElement is JetImportDirective) { + val importDirective = resolveElement as JetImportDirective + val scope = resolveSession.getScopeProvider().getFileScope(importDirective.getContainingJetFile()) + scope.forceResolveAllImports() } - else if (resolveElement instanceof JetAnnotationEntry) { - annotationAdditionalResolve(resolveSession, (JetAnnotationEntry) resolveElement); + else if (resolveElement is JetAnnotationEntry) { + annotationAdditionalResolve(resolveSession, resolveElement as JetAnnotationEntry) } - else if (resolveElement instanceof JetClass) { - constructorAdditionalResolve(resolveSession, (JetClass) resolveElement, trace, file, statementFilter); + else if (resolveElement is JetClass) { + constructorAdditionalResolve(resolveSession, resolveElement as JetClass, trace, file, statementFilter) } - else if (resolveElement instanceof JetTypeParameter) { - typeParameterAdditionalResolve(resolveSession, (JetTypeParameter) resolveElement); + else if (resolveElement is JetTypeParameter) { + typeParameterAdditionalResolve(resolveSession, resolveElement as JetTypeParameter) } - else if (resolveElement instanceof JetTypeConstraint) { - typeConstraintAdditionalResolve(resolveSession, (JetTypeConstraint) resolveElement); + else if (resolveElement is JetTypeConstraint) { + typeConstraintAdditionalResolve(resolveSession, resolveElement as JetTypeConstraint) } - else if (resolveElement instanceof JetCodeFragment) { - codeFragmentAdditionalResolve(resolveSession, (JetCodeFragment) resolveElement, trace, bodyResolveMode); + else if (resolveElement is JetCodeFragment) { + codeFragmentAdditionalResolve(resolveSession, resolveElement as JetCodeFragment, trace, bodyResolveMode) } - else if (PsiTreeUtil.getParentOfType(resolveElement, JetPackageDirective.class) != null) { - packageRefAdditionalResolve(resolveSession, trace, resolveElement); + else if (PsiTreeUtil.getParentOfType(resolveElement, javaClass()) != null) { + packageRefAdditionalResolve(resolveSession, trace, resolveElement) } else { - assert false : String.format("Invalid type of the topmost parent: %s\n%s", - resolveElement.toString(), - JetPsiUtil.getElementTextWithContext(resolveElement)); + assert(false) { String.format("Invalid type of the topmost parent: %s\n%s", resolveElement.toString(), JetPsiUtil.getElementTextWithContext(resolveElement)) } } - new JetFlowInformationProvider(resolveElement, trace).checkDeclaration(); + JetFlowInformationProvider(resolveElement, trace).checkDeclaration() - return trace.getBindingContext(); + return trace.getBindingContext() } - private static void packageRefAdditionalResolve(ResolveSession resolveSession, BindingTrace trace, JetElement jetElement) { - if (jetElement instanceof JetSimpleNameExpression) { - JetPackageDirective header = PsiTreeUtil.getParentOfType(jetElement, JetPackageDirective.class); - assert header != null; + private fun packageRefAdditionalResolve(resolveSession: ResolveSession, trace: BindingTrace, jetElement: JetElement) { + if (jetElement is JetSimpleNameExpression) { + val header = PsiTreeUtil.getParentOfType(jetElement, javaClass()) + assert(header != null) - JetSimpleNameExpression packageNameExpression = (JetSimpleNameExpression) jetElement; - if (trace.getBindingContext().get(BindingContext.RESOLUTION_SCOPE, packageNameExpression) == null) { - JetScope scope = getExpressionMemberScope(resolveSession, packageNameExpression); + val packageNameExpression = jetElement as JetSimpleNameExpression + if (trace.getBindingContext().get(BindingContext.RESOLUTION_SCOPE, packageNameExpression) == null) { + val scope = getExpressionMemberScope(resolveSession, packageNameExpression) if (scope != null) { - trace.record(BindingContext.RESOLUTION_SCOPE, packageNameExpression, scope); + trace.record(BindingContext.RESOLUTION_SCOPE, packageNameExpression, scope) } } if (Name.isValidIdentifier(packageNameExpression.getReferencedName())) { - if (trace.getBindingContext().get(BindingContext.REFERENCE_TARGET, packageNameExpression) == null) { - FqName fqName = header.getFqName(packageNameExpression); - PackageViewDescriptor packageDescriptor = resolveSession.getModuleDescriptor().getPackage(fqName); - assert packageDescriptor != null: "Package descriptor should be present in session for " + fqName; - trace.record(BindingContext.REFERENCE_TARGET, packageNameExpression, packageDescriptor); + if (trace.getBindingContext().get(BindingContext.REFERENCE_TARGET, packageNameExpression) == null) { + val fqName = header!!.getFqName(packageNameExpression) + val packageDescriptor = resolveSession.getModuleDescriptor().getPackage(fqName) + assert(packageDescriptor != null) { "Package descriptor should be present in session for " + fqName } + trace.record(BindingContext.REFERENCE_TARGET, packageNameExpression, packageDescriptor) } } } } - private static void typeConstraintAdditionalResolve(KotlinCodeAnalyzer analyzer, JetTypeConstraint jetTypeConstraint) { - JetDeclaration declaration = PsiTreeUtil.getParentOfType(jetTypeConstraint, JetDeclaration.class); - DeclarationDescriptor descriptor = analyzer.resolveToDescriptor(declaration); + private fun typeConstraintAdditionalResolve(analyzer: KotlinCodeAnalyzer, jetTypeConstraint: JetTypeConstraint) { + val declaration = PsiTreeUtil.getParentOfType(jetTypeConstraint, javaClass()) + val descriptor = analyzer.resolveToDescriptor(declaration) - assert (descriptor instanceof ClassDescriptor); + assert((descriptor is ClassDescriptor)) - TypeConstructor constructor = ((ClassDescriptor) descriptor).getTypeConstructor(); - for (TypeParameterDescriptor parameterDescriptor : constructor.getParameters()) { - ForceResolveUtil.forceResolveAllContents(parameterDescriptor); + val constructor = (descriptor as ClassDescriptor).getTypeConstructor() + for (parameterDescriptor in constructor.getParameters()) { + ForceResolveUtil.forceResolveAllContents(parameterDescriptor) } } - private void codeFragmentAdditionalResolve( - ResolveSession resolveSession, - JetCodeFragment codeFragment, - BindingTrace trace, - BodyResolveMode bodyResolveMode - ) { - JetElement codeFragmentExpression = codeFragment.getContentElement(); - if (!(codeFragmentExpression instanceof JetExpression)) return; + private fun codeFragmentAdditionalResolve(resolveSession: ResolveSession, codeFragment: JetCodeFragment, trace: BindingTrace, bodyResolveMode: BodyResolveMode) { + val codeFragmentExpression = codeFragment.getContentElement() + if (!(codeFragmentExpression is JetExpression)) return - PsiElement contextElement = codeFragment.getContext(); + val contextElement = codeFragment.getContext() - JetScope scopeForContextElement; - DataFlowInfo dataFlowInfoForContextElement; + val scopeForContextElement: JetScope? + val dataFlowInfoForContextElement: DataFlowInfo - if (contextElement instanceof JetClassOrObject) { - LazyClassDescriptor descriptor = (LazyClassDescriptor) resolveSession.resolveToDescriptor((JetClassOrObject) contextElement); + if (contextElement is JetClassOrObject) { + val descriptor = resolveSession.resolveToDescriptor(contextElement as JetClassOrObject) as LazyClassDescriptor - scopeForContextElement = descriptor.getScopeForMemberDeclarationResolution(); - dataFlowInfoForContextElement = DataFlowInfo.EMPTY; + scopeForContextElement = descriptor.getScopeForMemberDeclarationResolution() + dataFlowInfoForContextElement = DataFlowInfo.EMPTY } - else if (contextElement instanceof JetBlockExpression) { - JetElement newContextElement = KotlinPackage.lastOrNull(((JetBlockExpression) contextElement).getStatements()); + else if (contextElement is JetBlockExpression) { + val newContextElement = KotlinPackage.lastOrNull((contextElement as JetBlockExpression).getStatements()) - if (!(newContextElement instanceof JetExpression)) return; + if (!(newContextElement is JetExpression)) return - BindingContext contextForElement = resolveToElement((JetElement) contextElement, BodyResolveMode.FULL); + val contextForElement = resolveToElement(contextElement as JetElement, BodyResolveMode.FULL) - scopeForContextElement = contextForElement.get(BindingContext.RESOLUTION_SCOPE, ((JetExpression) newContextElement)); - dataFlowInfoForContextElement = getDataFlowInfo(contextForElement, (JetExpression) newContextElement); + scopeForContextElement = contextForElement.get(BindingContext.RESOLUTION_SCOPE, (newContextElement as JetExpression)) + dataFlowInfoForContextElement = contextForElement.getDataFlowInfo(newContextElement as JetExpression) } else { - if (!(contextElement instanceof JetExpression)) return; + if (!(contextElement is JetExpression)) return - JetExpression contextExpression = (JetExpression) contextElement; - BindingContext contextForElement = resolveToElement((JetElement) contextElement, bodyResolveMode); + val contextExpression = contextElement as JetExpression + val contextForElement = resolveToElement(contextElement as JetElement, bodyResolveMode) - scopeForContextElement = contextForElement.get(BindingContext.RESOLUTION_SCOPE, contextExpression); - dataFlowInfoForContextElement = getDataFlowInfo(contextForElement, contextExpression); + scopeForContextElement = contextForElement.get(BindingContext.RESOLUTION_SCOPE, contextExpression) + dataFlowInfoForContextElement = contextForElement.getDataFlowInfo(contextExpression) } - if (scopeForContextElement == null) return; + if (scopeForContextElement == null) return - JetScope codeFragmentScope = resolveSession.getScopeProvider().getFileScope(codeFragment); - ChainedScope chainedScope = new ChainedScope( - scopeForContextElement.getContainingDeclaration(), - "Scope for resolve code fragment", - scopeForContextElement, - codeFragmentScope - ); + val codeFragmentScope = resolveSession.getScopeProvider().getFileScope(codeFragment) + val chainedScope = ChainedScope(scopeForContextElement.getContainingDeclaration(), "Scope for resolve code fragment", scopeForContextElement, codeFragmentScope) - AnalyzerPackage.computeTypeInContext( - (JetExpression) codeFragmentExpression, - chainedScope, - trace, - dataFlowInfoForContextElement, - TypeUtils.NO_EXPECTED_TYPE, - resolveSession.getModuleDescriptor() - ); + (codeFragmentExpression as JetExpression).computeTypeInContext(chainedScope, trace, dataFlowInfoForContextElement, TypeUtils.NO_EXPECTED_TYPE, resolveSession.getModuleDescriptor()) } - private static void annotationAdditionalResolve(ResolveSession resolveSession, JetAnnotationEntry jetAnnotationEntry) { - JetModifierList modifierList = PsiTreeUtil.getParentOfType(jetAnnotationEntry, JetModifierList.class); - JetDeclaration declaration = PsiTreeUtil.getParentOfType(modifierList, JetDeclaration.class); + private fun annotationAdditionalResolve(resolveSession: ResolveSession, jetAnnotationEntry: JetAnnotationEntry) { + val modifierList = PsiTreeUtil.getParentOfType(jetAnnotationEntry, javaClass()) + val declaration = PsiTreeUtil.getParentOfType(modifierList, javaClass()) if (declaration != null) { - doResolveAnnotations(resolveSession, getAnnotationsByDeclaration(resolveSession, modifierList, declaration)); + doResolveAnnotations(resolveSession, getAnnotationsByDeclaration(resolveSession, modifierList, declaration)) } else { - JetFileAnnotationList fileAnnotationList = PsiTreeUtil.getParentOfType(jetAnnotationEntry, JetFileAnnotationList.class); + val fileAnnotationList = PsiTreeUtil.getParentOfType(jetAnnotationEntry, javaClass()) if (fileAnnotationList != null) { - doResolveAnnotations(resolveSession, resolveSession.getFileAnnotations(fileAnnotationList.getContainingJetFile())); + doResolveAnnotations(resolveSession, resolveSession.getFileAnnotations(fileAnnotationList.getContainingJetFile())) } - if (modifierList != null && modifierList.getParent() instanceof JetFile) { - doResolveAnnotations(resolveSession, resolveSession.getDanglingAnnotations(modifierList.getContainingJetFile())); + if (modifierList != null && modifierList.getParent() is JetFile) { + doResolveAnnotations(resolveSession, resolveSession.getDanglingAnnotations(modifierList.getContainingJetFile())) } } } - private static void doResolveAnnotations(ResolveSession resolveSession, Annotations annotations) { - AnnotationResolver.resolveAnnotationsArguments(annotations, resolveSession.getTrace()); - ForceResolveUtil.forceResolveAllContents(annotations); + private fun doResolveAnnotations(resolveSession: ResolveSession, annotations: Annotations) { + AnnotationResolver.resolveAnnotationsArguments(annotations, resolveSession.getTrace()) + ForceResolveUtil.forceResolveAllContents(annotations) } - private static Annotations getAnnotationsByDeclaration( - ResolveSession resolveSession, - JetModifierList modifierList, - JetDeclaration declaration - ) { - Annotated descriptor = resolveSession.resolveToDescriptor(declaration); - if (declaration instanceof JetClass) { - JetClass jetClass = (JetClass) declaration; - ClassDescriptor classDescriptor = (ClassDescriptor) descriptor; + private fun getAnnotationsByDeclaration(resolveSession: ResolveSession, modifierList: JetModifierList, declaration: JetDeclaration): Annotations { + var descriptor: Annotated? = resolveSession.resolveToDescriptor(declaration) + if (declaration is JetClass) { + val jetClass = declaration as JetClass + val classDescriptor = descriptor as ClassDescriptor if (modifierList == jetClass.getPrimaryConstructorModifierList()) { - descriptor = classDescriptor.getUnsubstitutedPrimaryConstructor(); - assert descriptor != null : "No constructor found: " + declaration.getText(); + descriptor = classDescriptor.getUnsubstitutedPrimaryConstructor() + assert(descriptor != null) { "No constructor found: " + declaration.getText() } } else if (modifierList.getParent() == jetClass.getBody()) { - if (classDescriptor instanceof LazyClassDescriptor) { - return ((LazyClassDescriptor) classDescriptor).getDanglingAnnotations(); + if (classDescriptor is LazyClassDescriptor) { + return (classDescriptor as LazyClassDescriptor).getDanglingAnnotations() } } } - return descriptor.getAnnotations(); + return descriptor!!.getAnnotations() } - private static void typeParameterAdditionalResolve(KotlinCodeAnalyzer analyzer, JetTypeParameter typeParameter) { - DeclarationDescriptor descriptor = analyzer.resolveToDescriptor(typeParameter); - ForceResolveUtil.forceResolveAllContents(descriptor); + private fun typeParameterAdditionalResolve(analyzer: KotlinCodeAnalyzer, typeParameter: JetTypeParameter) { + val descriptor = analyzer.resolveToDescriptor(typeParameter) + ForceResolveUtil.forceResolveAllContents(descriptor) } - private void delegationSpecifierAdditionalResolve( - ResolveSession resolveSession, - JetClassOrObject classOrObject, - BindingTrace trace, - JetFile file - ) { - LazyClassDescriptor descriptor = (LazyClassDescriptor) resolveSession.resolveToDescriptor(classOrObject); + private fun delegationSpecifierAdditionalResolve(resolveSession: ResolveSession, classOrObject: JetClassOrObject, trace: BindingTrace, file: JetFile) { + val descriptor = resolveSession.resolveToDescriptor(classOrObject) as LazyClassDescriptor // Activate resolving of supertypes - ForceResolveUtil.forceResolveAllContents(descriptor.getTypeConstructor().getSupertypes()); + ForceResolveUtil.forceResolveAllContents(descriptor.getTypeConstructor().getSupertypes()) - BodyResolver bodyResolver = createBodyResolver(resolveSession, trace, file, StatementFilter.NONE); - bodyResolver.resolveDelegationSpecifierList(createEmptyContext(resolveSession), classOrObject, descriptor, - descriptor.getUnsubstitutedPrimaryConstructor(), - descriptor.getScopeForClassHeaderResolution(), - descriptor.getScopeForMemberDeclarationResolution()); + val bodyResolver = createBodyResolver(resolveSession, trace, file, StatementFilter.NONE) + bodyResolver.resolveDelegationSpecifierList(createEmptyContext(resolveSession), classOrObject, descriptor, descriptor.getUnsubstitutedPrimaryConstructor(), descriptor.getScopeForClassHeaderResolution(), descriptor.getScopeForMemberDeclarationResolution()) } - private void propertyAdditionalResolve( - final ResolveSession resolveSession, - final JetProperty jetProperty, - BindingTrace trace, - JetFile file, - @NotNull StatementFilter statementFilter - ) { - JetScope propertyResolutionScope = resolveSession.getScopeProvider().getResolutionScopeForDeclaration(jetProperty); + private fun propertyAdditionalResolve(resolveSession: ResolveSession, jetProperty: JetProperty, trace: BindingTrace, file: JetFile, statementFilter: StatementFilter) { + val propertyResolutionScope = resolveSession.getScopeProvider().getResolutionScopeForDeclaration(jetProperty) - BodyResolveContextForLazy bodyResolveContext = new BodyResolveContextForLazy( - createParameters(resolveSession), - new Function() { - @Override - public JetScope apply(JetDeclaration declaration) { - assert declaration.getParent() == jetProperty : "Must be called only for property accessors, but called for " + - declaration; - return resolveSession.getScopeProvider().getResolutionScopeForDeclaration(declaration); - } - }); - BodyResolver bodyResolver = createBodyResolver(resolveSession, trace, file, statementFilter); - PropertyDescriptor descriptor = (PropertyDescriptor) resolveSession.resolveToDescriptor(jetProperty); - ForceResolveUtil.forceResolveAllContents(descriptor); + val bodyResolveContext = BodyResolveContextForLazy(createParameters(resolveSession), object : Function { + override fun apply(declaration: JetDeclaration?): JetScope? { + assert(declaration!!.getParent() == jetProperty) { "Must be called only for property accessors, but called for " + declaration } + return resolveSession.getScopeProvider().getResolutionScopeForDeclaration(declaration) + } + }) + val bodyResolver = createBodyResolver(resolveSession, trace, file, statementFilter) + val descriptor = resolveSession.resolveToDescriptor(jetProperty) as PropertyDescriptor + ForceResolveUtil.forceResolveAllContents(descriptor) - JetExpression propertyInitializer = jetProperty.getInitializer(); + val propertyInitializer = jetProperty.getInitializer() if (propertyInitializer != null) { - bodyResolver.resolvePropertyInitializer(bodyResolveContext, jetProperty, descriptor, propertyInitializer, propertyResolutionScope); + bodyResolver.resolvePropertyInitializer(bodyResolveContext, jetProperty, descriptor, propertyInitializer, propertyResolutionScope) } - JetExpression propertyDelegate = jetProperty.getDelegateExpression(); + val propertyDelegate = jetProperty.getDelegateExpression() if (propertyDelegate != null) { - bodyResolver.resolvePropertyDelegate(bodyResolveContext, jetProperty, descriptor, propertyDelegate, propertyResolutionScope, propertyResolutionScope); + bodyResolver.resolvePropertyDelegate(bodyResolveContext, jetProperty, descriptor, propertyDelegate, propertyResolutionScope, propertyResolutionScope) } - bodyResolver.resolvePropertyAccessors(bodyResolveContext, jetProperty, descriptor); + bodyResolver.resolvePropertyAccessors(bodyResolveContext, jetProperty, descriptor) - for (JetPropertyAccessor accessor : jetProperty.getAccessors()) { - new JetFlowInformationProvider(accessor, trace).checkDeclaration(); + for (accessor in jetProperty.getAccessors()) { + JetFlowInformationProvider(accessor, trace).checkDeclaration() } } - private void functionAdditionalResolve( - ResolveSession resolveSession, - JetNamedFunction namedFunction, - BindingTrace trace, - JetFile file, - @NotNull StatementFilter statementFilter - ) { - JetScope scope = resolveSession.getScopeProvider().getResolutionScopeForDeclaration(namedFunction); - FunctionDescriptor functionDescriptor = (FunctionDescriptor) resolveSession.resolveToDescriptor(namedFunction); - ForceResolveUtil.forceResolveAllContents(functionDescriptor); + private fun functionAdditionalResolve(resolveSession: ResolveSession, namedFunction: JetNamedFunction, trace: BindingTrace, file: JetFile, statementFilter: StatementFilter) { + val scope = resolveSession.getScopeProvider().getResolutionScopeForDeclaration(namedFunction) + val functionDescriptor = resolveSession.resolveToDescriptor(namedFunction) as FunctionDescriptor + ForceResolveUtil.forceResolveAllContents(functionDescriptor) - BodyResolver bodyResolver = createBodyResolver(resolveSession, trace, file, statementFilter); - bodyResolver.resolveFunctionBody(createEmptyContext(resolveSession), trace, namedFunction, functionDescriptor, scope); + val bodyResolver = createBodyResolver(resolveSession, trace, file, statementFilter) + bodyResolver.resolveFunctionBody(createEmptyContext(resolveSession), trace, namedFunction, functionDescriptor, scope) } - private void secondaryConstructorAdditionalResolve( - ResolveSession resolveSession, - JetSecondaryConstructor constructor, - BindingTrace trace, - JetFile file, - @NotNull StatementFilter statementFilter - ) { - JetScope scope = resolveSession.getScopeProvider().getResolutionScopeForDeclaration(constructor); - ConstructorDescriptor constructorDescriptor = (ConstructorDescriptor) resolveSession.resolveToDescriptor(constructor); - ForceResolveUtil.forceResolveAllContents(constructorDescriptor); + private fun secondaryConstructorAdditionalResolve(resolveSession: ResolveSession, constructor: JetSecondaryConstructor, trace: BindingTrace, file: JetFile, statementFilter: StatementFilter) { + val scope = resolveSession.getScopeProvider().getResolutionScopeForDeclaration(constructor) + val constructorDescriptor = resolveSession.resolveToDescriptor(constructor) as ConstructorDescriptor + ForceResolveUtil.forceResolveAllContents(constructorDescriptor) - BodyResolver bodyResolver = createBodyResolver(resolveSession, trace, file, statementFilter); - bodyResolver.resolveSecondaryConstructorBody(createEmptyContext(resolveSession), trace, constructor, constructorDescriptor, scope); + val bodyResolver = createBodyResolver(resolveSession, trace, file, statementFilter) + bodyResolver.resolveSecondaryConstructorBody(createEmptyContext(resolveSession), trace, constructor, constructorDescriptor, scope) } - private void constructorAdditionalResolve( - ResolveSession resolveSession, - JetClass klass, - BindingTrace trace, - JetFile file, - @NotNull StatementFilter statementFilter - ) { - JetScope scope = resolveSession.getScopeProvider().getResolutionScopeForDeclaration(klass); + private fun constructorAdditionalResolve(resolveSession: ResolveSession, klass: JetClass, trace: BindingTrace, file: JetFile, statementFilter: StatementFilter) { + val scope = resolveSession.getScopeProvider().getResolutionScopeForDeclaration(klass) - ClassDescriptor classDescriptor = (ClassDescriptor) resolveSession.resolveToDescriptor(klass); - ConstructorDescriptor constructorDescriptor = classDescriptor.getUnsubstitutedPrimaryConstructor(); - assert constructorDescriptor != null : - String.format("Can't get primary constructor for descriptor '%s' in from class '%s'", - classDescriptor, - JetPsiUtil.getElementTextWithContext(klass)); + val classDescriptor = resolveSession.resolveToDescriptor(klass) as ClassDescriptor + val constructorDescriptor = classDescriptor.getUnsubstitutedPrimaryConstructor() + assert(constructorDescriptor != null) { String.format("Can't get primary constructor for descriptor '%s' in from class '%s'", classDescriptor, JetPsiUtil.getElementTextWithContext(klass)) } - BodyResolver bodyResolver = createBodyResolver(resolveSession, trace, file, statementFilter); - bodyResolver.resolveConstructorParameterDefaultValuesAndAnnotations(createEmptyContext(resolveSession), trace, klass, - constructorDescriptor, scope); + val bodyResolver = createBodyResolver(resolveSession, trace, file, statementFilter) + bodyResolver.resolveConstructorParameterDefaultValuesAndAnnotations(createEmptyContext(resolveSession), trace, klass, constructorDescriptor, scope) } - private void initializerAdditionalResolve( - ResolveSession resolveSession, - JetClassInitializer classInitializer, - BindingTrace trace, - JetFile file, - @NotNull StatementFilter statementFilter - ) { - JetClassOrObject classOrObject = PsiTreeUtil.getParentOfType(classInitializer, JetClassOrObject.class); - LazyClassDescriptor classOrObjectDescriptor = (LazyClassDescriptor) resolveSession.resolveToDescriptor(classOrObject); + private fun initializerAdditionalResolve(resolveSession: ResolveSession, classInitializer: JetClassInitializer, trace: BindingTrace, file: JetFile, statementFilter: StatementFilter) { + val classOrObject = PsiTreeUtil.getParentOfType(classInitializer, javaClass()) + val classOrObjectDescriptor = resolveSession.resolveToDescriptor(classOrObject) as LazyClassDescriptor - BodyResolver bodyResolver = createBodyResolver(resolveSession, trace, file, statementFilter); - bodyResolver.resolveAnonymousInitializer(createEmptyContext(resolveSession), classInitializer, classOrObjectDescriptor); + val bodyResolver = createBodyResolver(resolveSession, trace, file, statementFilter) + bodyResolver.resolveAnonymousInitializer(createEmptyContext(resolveSession), classInitializer, classOrObjectDescriptor) } - private BodyResolver createBodyResolver(ResolveSession resolveSession, BindingTrace trace, JetFile file, @NotNull StatementFilter statementFilter) { - InjectorForBodyResolve bodyResolve = new InjectorForBodyResolve( - file.getProject(), - createParameters(resolveSession), - trace, - resolveSession.getModuleDescriptor(), - getAdditionalCheckerProvider(file), - statementFilter - ); - return bodyResolve.getBodyResolver(); + private fun createBodyResolver(resolveSession: ResolveSession, trace: BindingTrace, file: JetFile, statementFilter: StatementFilter): BodyResolver { + val bodyResolve = InjectorForBodyResolve(file.getProject(), createParameters(resolveSession), trace, resolveSession.getModuleDescriptor(), getAdditionalCheckerProvider(file), statementFilter) + return bodyResolve.getBodyResolver() } - private static TopDownAnalysisParameters createParameters(@NotNull ResolveSession resolveSession) { - return TopDownAnalysisParameters.createForLocalDeclarations( - resolveSession.getStorageManager(), resolveSession.getExceptionTracker() - ); + private fun createParameters(resolveSession: ResolveSession): TopDownAnalysisParameters { + return TopDownAnalysisParameters.createForLocalDeclarations(resolveSession.getStorageManager(), resolveSession.getExceptionTracker()) } - @NotNull - private static BodyResolveContextForLazy createEmptyContext(@NotNull ResolveSession resolveSession) { - return new BodyResolveContextForLazy(createParameters(resolveSession), Functions.constant(null)); + private fun createEmptyContext(resolveSession: ResolveSession): BodyResolveContextForLazy { + return BodyResolveContextForLazy(createParameters(resolveSession), Functions.constant(null)) } - private static JetScope getExpressionResolutionScope(@NotNull ResolveSession resolveSession, @NotNull JetExpression expression) { - ScopeProvider provider = resolveSession.getScopeProvider(); - JetDeclaration parentDeclaration = PsiTreeUtil.getParentOfType(expression, JetDeclaration.class); + private fun getExpressionResolutionScope(resolveSession: ResolveSession, expression: JetExpression): JetScope { + val provider = resolveSession.getScopeProvider() + val parentDeclaration = PsiTreeUtil.getParentOfType(expression, javaClass()) if (parentDeclaration == null) { - return provider.getFileScope(expression.getContainingJetFile()); + return provider.getFileScope(expression.getContainingJetFile()) } - return provider.getResolutionScopeForDeclaration(parentDeclaration); + return provider.getResolutionScopeForDeclaration(parentDeclaration) } - private static JetScope getExpressionMemberScope(@NotNull ResolveSession resolveSession, @NotNull JetExpression expression) { - BindingTrace trace = resolveSession.getStorageManager().createSafeTrace(new DelegatingBindingTrace( - resolveSession.getBindingContext(), "trace to resolve a member scope of expression", expression)); + private fun getExpressionMemberScope(resolveSession: ResolveSession, expression: JetExpression): JetScope? { + val trace = resolveSession.getStorageManager().createSafeTrace(DelegatingBindingTrace(resolveSession.getBindingContext(), "trace to resolve a member scope of expression", expression)) if (BindingContextUtils.isExpressionWithValidReference(expression, resolveSession.getBindingContext())) { - QualifiedExpressionResolver qualifiedExpressionResolver = resolveSession.getQualifiedExpressionResolver(); + val qualifiedExpressionResolver = resolveSession.getQualifiedExpressionResolver() // In some type declaration - if (expression.getParent() instanceof JetUserType) { - JetUserType qualifier = ((JetUserType) expression.getParent()).getQualifier(); + if (expression.getParent() is JetUserType) { + val qualifier = (expression.getParent() as JetUserType).getQualifier() if (qualifier != null) { - JetScope resolutionScope = getExpressionResolutionScope(resolveSession, expression); - Collection descriptors = - qualifiedExpressionResolver.lookupDescriptorsForUserType(qualifier, resolutionScope, trace, false); - for (DeclarationDescriptor descriptor : descriptors) { - if (descriptor instanceof LazyPackageDescriptor) { - return ((LazyPackageDescriptor) descriptor).getMemberScope(); + val resolutionScope = getExpressionResolutionScope(resolveSession, expression) + val descriptors = qualifiedExpressionResolver.lookupDescriptorsForUserType(qualifier, resolutionScope, trace, false) + for (descriptor in descriptors) { + if (descriptor is LazyPackageDescriptor) { + return (descriptor as LazyPackageDescriptor).getMemberScope() } } } } // Inside import - if (PsiTreeUtil.getParentOfType(expression, JetImportDirective.class, false) != null) { - PackageViewDescriptor rootPackage = resolveSession.getModuleDescriptor().getPackage(FqName.ROOT); - assert rootPackage != null; + if (PsiTreeUtil.getParentOfType(expression, javaClass(), false) != null) { + val rootPackage = resolveSession.getModuleDescriptor().getPackage(FqName.ROOT) + assert(rootPackage != null) - if (expression.getParent() instanceof JetDotQualifiedExpression) { - JetExpression element = ((JetDotQualifiedExpression) expression.getParent()).getReceiverExpression(); - FqName fqName = expression.getContainingJetFile().getPackageFqName(); + if (expression.getParent() is JetDotQualifiedExpression) { + val element = (expression.getParent() as JetDotQualifiedExpression).getReceiverExpression() + val fqName = expression.getContainingJetFile().getPackageFqName() - PackageViewDescriptor filePackage = resolveSession.getModuleDescriptor().getPackage(fqName); - assert filePackage != null : "File package should be already resolved and be found"; + val filePackage = resolveSession.getModuleDescriptor().getPackage(fqName) + assert(filePackage != null, "File package should be already resolved and be found") - JetScope scope = filePackage.getMemberScope(); - Collection descriptors; + val scope = filePackage!!.getMemberScope() + val descriptors: Collection - if (element instanceof JetDotQualifiedExpression) { - descriptors = qualifiedExpressionResolver.lookupDescriptorsForQualifiedExpression( - (JetDotQualifiedExpression) element, rootPackage.getMemberScope(), scope, trace, - QualifiedExpressionResolver.LookupMode.EVERYTHING, false); + if (element is JetDotQualifiedExpression) { + descriptors = qualifiedExpressionResolver.lookupDescriptorsForQualifiedExpression(element as JetDotQualifiedExpression, rootPackage!!.getMemberScope(), scope, trace, QualifiedExpressionResolver.LookupMode.EVERYTHING, false) } else { - descriptors = qualifiedExpressionResolver.lookupDescriptorsForSimpleNameReference( - (JetSimpleNameExpression) element, rootPackage.getMemberScope(), scope, trace, - QualifiedExpressionResolver.LookupMode.EVERYTHING, false, false); + descriptors = qualifiedExpressionResolver.lookupDescriptorsForSimpleNameReference(element as JetSimpleNameExpression, rootPackage!!.getMemberScope(), scope, trace, QualifiedExpressionResolver.LookupMode.EVERYTHING, false, false) } - for (DeclarationDescriptor descriptor : descriptors) { - if (descriptor instanceof PackageViewDescriptor) { - return ((PackageViewDescriptor) descriptor).getMemberScope(); + for (descriptor in descriptors) { + if (descriptor is PackageViewDescriptor) { + return (descriptor as PackageViewDescriptor).getMemberScope() } } } else { - return rootPackage.getMemberScope(); + return rootPackage!!.getMemberScope() } } // Inside package declaration - JetPackageDirective packageDirective = PsiTreeUtil.getParentOfType(expression, JetPackageDirective.class, false); + val packageDirective = PsiTreeUtil.getParentOfType(expression, javaClass(), false) if (packageDirective != null) { - PackageViewDescriptor packageDescriptor = resolveSession.getModuleDescriptor().getPackage( - packageDirective.getFqName((JetSimpleNameExpression) expression).parent()); + val packageDescriptor = resolveSession.getModuleDescriptor().getPackage(packageDirective.getFqName(expression as JetSimpleNameExpression).parent()) if (packageDescriptor != null) { - return packageDescriptor.getMemberScope(); + return packageDescriptor.getMemberScope() } } } - return null; + return null } - @NotNull - protected abstract AdditionalCheckerProvider getAdditionalCheckerProvider(@NotNull JetFile jetFile); + protected abstract fun getAdditionalCheckerProvider(jetFile: JetFile): AdditionalCheckerProvider - private static class BodyResolveContextForLazy implements BodiesResolveContext { + private class BodyResolveContextForLazy private(private val topDownAnalysisParameters: TopDownAnalysisParameters, private val declaringScopes: Function) : BodiesResolveContext { - private final Function declaringScopes; - private final TopDownAnalysisParameters topDownAnalysisParameters; - - private BodyResolveContextForLazy( - @NotNull TopDownAnalysisParameters parameters, - @NotNull Function declaringScopes - ) { - this.topDownAnalysisParameters = parameters; - this.declaringScopes = declaringScopes; + override fun getStorageManager(): StorageManager { + return topDownAnalysisParameters.getStorageManager() } - @NotNull - @Override - public StorageManager getStorageManager() { - return topDownAnalysisParameters.getStorageManager(); + override fun getExceptionTracker(): ExceptionTracker { + return topDownAnalysisParameters.getExceptionTracker() } - @NotNull - @Override - public ExceptionTracker getExceptionTracker() { - return topDownAnalysisParameters.getExceptionTracker(); + override fun getFiles(): Collection { + return setOf() } - @Override - public Collection getFiles() { - return Collections.emptySet(); + override fun getDeclaredClasses(): Map { + return mapOf() } - @Override - public Map getDeclaredClasses() { - return Collections.emptyMap(); + override fun getAnonymousInitializers(): Map { + return mapOf() } - @Override - public Map getAnonymousInitializers() { - return Collections.emptyMap(); + override fun getSecondaryConstructors(): Map { + return mapOf() } - @Override - public Map getSecondaryConstructors() { - return Collections.emptyMap(); + override fun getProperties(): Map { + return mapOf() } - @Override - public Map getProperties() { - return Collections.emptyMap(); + override fun getFunctions(): Map { + return mapOf() } - @Override - public Map getFunctions() { - return Collections.emptyMap(); - } - - @Override - public Function getDeclaringScopes() { + override fun getDeclaringScopes(): Function { //noinspection unchecked - return (Function) declaringScopes; + return declaringScopes as Function } - @Override - public Map getScripts() { - return Collections.emptyMap(); + override fun getScripts(): Map { + return mapOf() } - @Override - public DataFlowInfo getOuterDataFlowInfo() { - return DataFlowInfo.EMPTY; + override fun getOuterDataFlowInfo(): DataFlowInfo { + return DataFlowInfo.EMPTY } - @NotNull - @Override - public TopDownAnalysisParameters getTopDownAnalysisParameters() { - return topDownAnalysisParameters; + override fun getTopDownAnalysisParameters(): TopDownAnalysisParameters { + return topDownAnalysisParameters } } }