From b8abfbb10d25ccf1baeb3e17841711c52b8ca07f Mon Sep 17 00:00:00 2001 From: Andrey Breslav Date: Wed, 14 Jan 2015 21:45:26 +0100 Subject: [PATCH] LazyClassContext introduced --- .../resolve/lazy/DeclarationScopeProvider.kt | 24 ++++++ .../kotlin/resolve/lazy/LazyClassContext.kt | 37 ++++++++++ .../kotlin/resolve/lazy/ResolveSession.java | 11 ++- .../kotlin/resolve/lazy/ScopeProvider.java | 3 +- .../descriptors/AbstractLazyMemberScope.kt | 16 ++-- .../lazy/descriptors/LazyClassDescriptor.java | 73 +++++++++---------- .../lazy/descriptors/LazyClassMemberScope.kt | 24 +++--- .../descriptors/LazyPackageMemberScope.kt | 2 +- .../LazyScriptClassDescriptor.java | 9 ++- .../descriptors/LazyScriptClassMemberScope.kt | 30 ++++---- .../LazyTypeParameterDescriptor.java | 22 +++--- 11 files changed, 157 insertions(+), 94 deletions(-) create mode 100644 compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/DeclarationScopeProvider.kt create mode 100644 compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/LazyClassContext.kt diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/DeclarationScopeProvider.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/DeclarationScopeProvider.kt new file mode 100644 index 00000000000..c695e1fcf5a --- /dev/null +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/DeclarationScopeProvider.kt @@ -0,0 +1,24 @@ +/* + * Copyright 2010-2015 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.jetbrains.kotlin.resolve.lazy + +import com.intellij.psi.PsiElement +import org.jetbrains.kotlin.resolve.scopes.JetScope + +public trait DeclarationScopeProvider { + fun getResolutionScopeForDeclaration(elementOfDeclaration: PsiElement): JetScope +} diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/LazyClassContext.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/LazyClassContext.kt new file mode 100644 index 00000000000..209dc3da598 --- /dev/null +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/LazyClassContext.kt @@ -0,0 +1,37 @@ +/* + * Copyright 2010-2015 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.jetbrains.kotlin.resolve.lazy + +import org.jetbrains.kotlin.storage.StorageManager +import org.jetbrains.kotlin.resolve.BindingTrace +import org.jetbrains.kotlin.descriptors.ModuleDescriptor +import org.jetbrains.kotlin.resolve.DescriptorResolver +import org.jetbrains.kotlin.resolve.TypeResolver +import org.jetbrains.kotlin.resolve.lazy.declarations.DeclarationProviderFactory +import org.jetbrains.kotlin.resolve.AnnotationResolver + +public trait LazyClassContext { + val scopeProvider: DeclarationScopeProvider + + val storageManager: StorageManager + val trace: BindingTrace + val moduleDescriptor: ModuleDescriptor + val descriptorResolver: DescriptorResolver + val typeResolver: TypeResolver + val declarationProviderFactory: DeclarationProviderFactory + val annotationResolver: AnnotationResolver +} \ No newline at end of file diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/ResolveSession.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/ResolveSession.java index 68c1f59a659..3d7eca9dd85 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/ResolveSession.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/ResolveSession.java @@ -48,7 +48,7 @@ import java.util.Collection; import java.util.Collections; import java.util.List; -public class ResolveSession implements KotlinCodeAnalyzer { +public class ResolveSession implements KotlinCodeAnalyzer, LazyClassContext { private final LazyResolveStorageManager storageManager; private final ExceptionTracker exceptionTracker; @@ -221,13 +221,12 @@ public class ResolveSession implements KotlinCodeAnalyzer { } @NotNull - //@Override + @Override public LazyResolveStorageManager getStorageManager() { return storageManager; } @NotNull - //@Override public ExceptionTracker getExceptionTracker() { return exceptionTracker; } @@ -297,7 +296,6 @@ public class ResolveSession implements KotlinCodeAnalyzer { return (ClassDescriptor) classifier; } - @Override @NotNull public ScriptDescriptor getScriptDescriptor(@NotNull JetScript script) { return scriptDescriptors.invoke(script); @@ -334,11 +332,13 @@ public class ResolveSession implements KotlinCodeAnalyzer { return trace.getBindingContext(); } + @Override @NotNull public BindingTrace getTrace() { return trace; } + @Override @NotNull public DeclarationProviderFactory getDeclarationProviderFactory() { return declarationProviderFactory; @@ -507,16 +507,19 @@ public class ResolveSession implements KotlinCodeAnalyzer { return jetImportFactory; } + @Override @NotNull public AnnotationResolver getAnnotationResolver() { return annotationResolve; } + @Override @NotNull public DescriptorResolver getDescriptorResolver() { return descriptorResolver; } + @Override @NotNull public TypeResolver getTypeResolver() { return typeResolver; diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/ScopeProvider.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/ScopeProvider.java index bb7e2c9febe..0b6f76a94dd 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/ScopeProvider.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/ScopeProvider.java @@ -35,7 +35,7 @@ import java.util.Collection; import java.util.Collections; import java.util.List; -public class ScopeProvider { +public class ScopeProvider implements DeclarationScopeProvider { public static class AdditionalFileScopeProvider { @NotNull public List scopes(@NotNull JetFile file) { @@ -101,6 +101,7 @@ public class ScopeProvider { "LazyFileScope for file " + file.getName()); } + @Override @NotNull public JetScope getResolutionScopeForDeclaration(@NotNull PsiElement elementOfDeclaration) { JetDeclaration jetDeclaration = JetStubbedPsiUtil.getPsiOrStubParent(elementOfDeclaration, JetDeclaration.class, false); diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/AbstractLazyMemberScope.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/AbstractLazyMemberScope.kt index b1fee945b7f..2a409296e81 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/AbstractLazyMemberScope.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/AbstractLazyMemberScope.kt @@ -22,8 +22,6 @@ import org.jetbrains.kotlin.psi.* import org.jetbrains.kotlin.resolve.AnnotationResolver import org.jetbrains.kotlin.resolve.BindingTrace import org.jetbrains.kotlin.resolve.ScriptNameUtil -import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo -import org.jetbrains.kotlin.resolve.lazy.ResolveSession import org.jetbrains.kotlin.resolve.lazy.data.JetScriptInfo import org.jetbrains.kotlin.resolve.lazy.declarations.DeclarationProvider import org.jetbrains.kotlin.name.Name @@ -35,14 +33,16 @@ import java.util.* import org.jetbrains.kotlin.storage.StorageManager import org.jetbrains.kotlin.utils.toReadOnlyList import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter +import org.jetbrains.kotlin.resolve.lazy.ResolveSession +import org.jetbrains.kotlin.resolve.lazy.LazyClassContext public abstract class AbstractLazyMemberScope protected( - protected val resolveSession: ResolveSession, + protected val c: LazyClassContext, protected val declarationProvider: DP, protected val thisDescriptor: D, protected val trace: BindingTrace) : JetScope { - protected val storageManager: StorageManager = resolveSession.getStorageManager() + protected val storageManager: StorageManager = c.storageManager private val classDescriptors: MemoizedFunctionToNotNull> = storageManager.createMemoizedFunction { resolveClassDescriptor(it) } private val functionDescriptors: MemoizedFunctionToNotNull> = storageManager.createMemoizedFunction { doGetFunctions(it) } private val propertyDescriptors: MemoizedFunctionToNotNull> = storageManager.createMemoizedFunction { doGetProperties(it) } @@ -51,9 +51,9 @@ public abstract class AbstractLazyMemberScope forceResolveAllContents; public LazyClassDescriptor( - @NotNull final ResolveSession resolveSession, + @NotNull LazyClassContext c, @NotNull DeclarationDescriptor containingDeclaration, @NotNull Name name, @NotNull JetClassLikeInfo classLikeInfo ) { - super(resolveSession.getStorageManager(), containingDeclaration, name, + super(c.getStorageManager(), containingDeclaration, name, toSourceElement(classLikeInfo.getCorrespondingClassOrObject()) ); - this.resolveSession = resolveSession; + this.c = c; if (classLikeInfo.getCorrespondingClassOrObject() != null) { - this.resolveSession.getTrace().record(BindingContext.CLASS, classLikeInfo.getCorrespondingClassOrObject(), this); + this.c.getTrace().record(BindingContext.CLASS, classLikeInfo.getCorrespondingClassOrObject(), this); } - this.resolveSession.getTrace().record(BindingContext.FQNAME_TO_CLASS_DESCRIPTOR, DescriptorUtils.getFqName(this), this); + this.c.getTrace().record(BindingContext.FQNAME_TO_CLASS_DESCRIPTOR, DescriptorUtils.getFqName(this), this); this.originalClassInfo = classLikeInfo; - this.declarationProvider = resolveSession.getDeclarationProviderFactory().getClassMemberDeclarationProvider(classLikeInfo); + this.declarationProvider = c.getDeclarationProviderFactory().getClassMemberDeclarationProvider(classLikeInfo); - this.unsubstitutedMemberScope = createMemberScope(resolveSession, this.declarationProvider); + this.unsubstitutedMemberScope = createMemberScope(c, this.declarationProvider); this.typeConstructor = new LazyClassTypeConstructor(); @@ -136,21 +134,20 @@ public class LazyClassDescriptor extends ClassDescriptorBase implements ClassDes : resolveVisibilityFromModifiers(modifierList, getDefaultClassVisibility(this)); this.isInner = isInnerClass(modifierList) && !ModifiersChecker.isIllegalInner(this); - StorageManager storageManager = resolveSession.getStorageManager(); + StorageManager storageManager = c.getStorageManager(); if (modifierList != null) { this.annotations = new LazyAnnotations( new LazyAnnotationsContext( - resolveSession.getAnnotationResolver(), + c.getAnnotationResolver(), storageManager, - resolveSession.getTrace() + c.getTrace() ) { @NotNull @Override public JetScope getScope() { - JetClassLikeInfo ownerInfo = declarationProvider.getOwnerInfo(); - return resolveSession.getScopeProvider().getResolutionScopeForDeclaration(ownerInfo.getScopeAnchor()); + return getOuterScope(); } }, modifierList.getAnnotationEntries() @@ -168,9 +165,9 @@ public class LazyClassDescriptor extends ClassDescriptorBase implements ClassDes else { this.danglingAnnotations = new LazyAnnotations( new LazyAnnotationsContext( - resolveSession.getAnnotationResolver(), + c.getAnnotationResolver(), storageManager, - resolveSession.getTrace() + c.getTrace() ) { @NotNull @Override @@ -224,10 +221,10 @@ public class LazyClassDescriptor extends ClassDescriptorBase implements ClassDes // NOTE: Called from constructor! @NotNull protected LazyClassMemberScope createMemberScope( - @NotNull ResolveSession resolveSession, + @NotNull LazyClassContext c, @NotNull ClassMemberDeclarationProvider declarationProvider ) { - return new LazyClassMemberScope(resolveSession, declarationProvider, this, resolveSession.getTrace()); + return new LazyClassMemberScope(c, declarationProvider, this, c.getTrace()); } @NotNull @@ -250,11 +247,12 @@ public class LazyClassDescriptor extends ClassDescriptorBase implements ClassDes } scope.changeLockLevel(WritableScope.LockLevel.READING); - PsiElement scopeAnchor = declarationProvider.getOwnerInfo().getScopeAnchor(); + return new ChainedScope(this, "ScopeForClassHeaderResolution: " + getName(), scope, getOuterScope()); + } - return new ChainedScope(this, "ScopeForClassHeaderResolution: " + getName(), - scope, - getScopeProvider().getResolutionScopeForDeclaration(scopeAnchor)); + @NotNull + protected JetScope getOuterScope() { + return c.getScopeProvider().getResolutionScopeForDeclaration(declarationProvider.getOwnerInfo().getScopeAnchor()); } @Override @@ -382,7 +380,7 @@ public class LazyClassDescriptor extends ClassDescriptorBase implements ClassDes private LazyClassDescriptor computeClassObjectDescriptor(@Nullable JetClassObject classObject) { JetClassLikeInfo classObjectInfo = getClassObjectInfo(classObject); if (classObjectInfo != null) { - return new LazyClassDescriptor(resolveSession, this, getClassObjectName(getName()), classObjectInfo); + return new LazyClassDescriptor(c, this, getClassObjectName(getName()), classObjectInfo); } return null; } @@ -391,7 +389,7 @@ public class LazyClassDescriptor extends ClassDescriptorBase implements ClassDes private JetClassLikeInfo getClassObjectInfo(@Nullable JetClassObject classObject) { if (classObject != null) { if (!isClassObjectAllowed()) { - resolveSession.getTrace().report(CLASS_OBJECT_NOT_ALLOWED.on(classObject)); + c.getTrace().report(CLASS_OBJECT_NOT_ALLOWED.on(classObject)); } return JetClassInfoUtil.createClassLikeInfo(classObject.getObjectDeclaration()); @@ -524,7 +522,7 @@ public class LazyClassDescriptor extends ClassDescriptorBase implements ClassDes } private class LazyClassTypeConstructor extends AbstractClassTypeConstructor implements LazyEntity { - private final NotNullLazyValue supertypes = resolveSession.getStorageManager().createLazyValueWithPostCompute( + private final NotNullLazyValue supertypes = c.getStorageManager().createLazyValueWithPostCompute( new Function0() { @Override public Supertypes invoke() { @@ -542,12 +540,12 @@ public class LazyClassDescriptor extends ClassDescriptorBase implements ClassDes JetClassOrObject classOrObject = info.getCorrespondingClassOrObject(); if (classOrObject == null) { - return new Supertypes(Collections.singleton(resolveSession.getModuleDescriptor().getBuiltIns().getAnyType())); + return new Supertypes(Collections.singleton(c.getModuleDescriptor().getBuiltIns().getAnyType())); } - List allSupertypes = resolveSession.getDescriptorResolver() + List allSupertypes = c.getDescriptorResolver() .resolveSupertypes(getScopeForClassHeaderResolution(), LazyClassDescriptor.this, classOrObject, - resolveSession.getTrace()); + c.getTrace()); return new Supertypes(Lists.newArrayList(Collections2.filter(allSupertypes, VALID_SUPERTYPE))); } @@ -567,7 +565,7 @@ public class LazyClassDescriptor extends ClassDescriptorBase implements ClassDes } ); - private final NotNullLazyValue> parameters = resolveSession.getStorageManager().createLazyValue(new Function0>() { + private final NotNullLazyValue> parameters = c.getStorageManager().createLazyValue(new Function0>() { @Override public List invoke() { JetClassLikeInfo classInfo = declarationProvider.getOwnerInfo(); @@ -575,13 +573,13 @@ public class LazyClassDescriptor extends ClassDescriptorBase implements ClassDes if (typeParameterList == null) return Collections.emptyList(); if (classInfo.getClassKind() == ClassKind.ENUM_CLASS) { - resolveSession.getTrace().report(TYPE_PARAMETERS_IN_ENUM.on(typeParameterList)); + c.getTrace().report(TYPE_PARAMETERS_IN_ENUM.on(typeParameterList)); } List typeParameters = typeParameterList.getParameters(); List parameters = new ArrayList(typeParameters.size()); for (int i = 0; i < typeParameters.size(); i++) { - parameters.add(new LazyTypeParameterDescriptor(resolveSession, LazyClassDescriptor.this, typeParameters.get(i), i)); + parameters.add(new LazyTypeParameterDescriptor(c, LazyClassDescriptor.this, typeParameters.get(i), i)); } return parameters; @@ -589,7 +587,7 @@ public class LazyClassDescriptor extends ClassDescriptorBase implements ClassDes }); private final NullableLazyValue forceResolveAllContents = - resolveSession.getStorageManager().createRecursionTolerantNullableLazyValue(new Function0() { + c.getStorageManager().createRecursionTolerantNullableLazyValue(new Function0() { @Override public Void invoke() { doForceResolveAllContents(); @@ -619,7 +617,7 @@ public class LazyClassDescriptor extends ClassDescriptorBase implements ClassDes ClassifierDescriptor supertypeDescriptor = supertype.getConstructor().getDeclarationDescriptor(); if (supertypeDescriptor instanceof ClassDescriptor) { ClassDescriptor superclass = (ClassDescriptor) supertypeDescriptor; - TypeHierarchyResolver.reportCyclicInheritanceHierarchyError(resolveSession.getTrace(), LazyClassDescriptor.this, + TypeHierarchyResolver.reportCyclicInheritanceHierarchyError(c.getTrace(), LazyClassDescriptor.this, superclass); } } @@ -695,9 +693,4 @@ public class LazyClassDescriptor extends ClassDescriptorBase implements ClassDes ForceResolveUtil.forceResolveAllContents(getParameters()); } } - - @NotNull - private ScopeProvider getScopeProvider() { - return resolveSession.getScopeProvider(); - } } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyClassMemberScope.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyClassMemberScope.kt index db56490a8f3..eb3bf3bd56e 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyClassMemberScope.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyClassMemberScope.kt @@ -23,7 +23,6 @@ import org.jetbrains.kotlin.diagnostics.Errors import org.jetbrains.kotlin.psi.* import org.jetbrains.kotlin.resolve.* import org.jetbrains.kotlin.resolve.dataClassUtils.* -import org.jetbrains.kotlin.resolve.lazy.ResolveSession import org.jetbrains.kotlin.resolve.lazy.declarations.ClassMemberDeclarationProvider import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.resolve.scopes.JetScope @@ -40,12 +39,15 @@ import org.jetbrains.kotlin.resolve.DelegationResolver.generateDelegatedMembers import org.jetbrains.kotlin.storage.NotNullLazyValue import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter import org.jetbrains.kotlin.resolve.varianceChecker.VarianceChecker +import org.jetbrains.kotlin.resolve.lazy.LazyClassContext +import org.jetbrains.kotlin.psi.psiUtil.isObjectLiteral -public open class LazyClassMemberScope(resolveSession: ResolveSession, - declarationProvider: ClassMemberDeclarationProvider, - thisClass: LazyClassDescriptor, - trace: BindingTrace) -: AbstractLazyMemberScope(resolveSession, declarationProvider, thisClass, trace) { +public open class LazyClassMemberScope( + c: LazyClassContext, + declarationProvider: ClassMemberDeclarationProvider, + thisClass: LazyClassDescriptor, + trace: BindingTrace +) : AbstractLazyMemberScope(c, declarationProvider, thisClass, trace) { private val descriptorsFromDeclaredElements = storageManager.createLazyValue { computeDescriptorsFromDeclaredElements(DescriptorKindFilter.ALL, JetScope.ALL_NAME_FILTER) @@ -86,7 +88,7 @@ public open class LazyClassMemberScope(resolveSession: ResolveSession, } private val primaryConstructor: NullableLazyValue - = resolveSession.getStorageManager().createNullableLazyValue { resolvePrimaryConstructor() } + = c.storageManager.createNullableLazyValue { resolvePrimaryConstructor() } override fun getScopeForMemberDeclarationResolution(declaration: JetDeclaration): JetScope { if (declaration is JetProperty) { @@ -219,7 +221,7 @@ public open class LazyClassMemberScope(resolveSession: ResolveSession, val parameter = primaryConstructorParameters.get(valueParameterDescriptor.getIndex()) if (parameter.hasValOrVarNode()) { - val propertyDescriptor = resolveSession.getDescriptorResolver().resolvePrimaryConstructorParameterToAProperty( + val propertyDescriptor = c.descriptorResolver.resolvePrimaryConstructorParameterToAProperty( thisDescriptor, valueParameterDescriptor, thisDescriptor.getScopeForClassHeaderResolution(), parameter, trace) result.add(propertyDescriptor) } @@ -231,7 +233,7 @@ public open class LazyClassMemberScope(resolveSession: ResolveSession, ?: return setOf() // Enum class objects do not have delegated members val lazyTypeResolver = DelegationResolver.TypeResolver { reference -> - resolveSession.getTypeResolver().resolveType(thisDescriptor.getScopeForClassHeaderResolution(), reference, trace, false) + c.typeResolver.resolveType(thisDescriptor.getScopeForClassHeaderResolution(), reference, trace, false) } val lazyMemberExtractor = DelegationResolver.MemberExtractor { type -> extractor.extract(type, name) @@ -274,7 +276,7 @@ public open class LazyClassMemberScope(resolveSession: ResolveSession, if (!thisDescriptor.getKind().isSingleton()) { assert(classOrObject is JetClass) { "No JetClass for $thisDescriptor" } classOrObject as JetClass - val constructor = resolveSession.getDescriptorResolver().resolvePrimaryConstructorDescriptor( + val constructor = c.descriptorResolver.resolvePrimaryConstructorDescriptor( thisDescriptor.getScopeForClassHeaderResolution(), thisDescriptor, classOrObject, trace) assert(constructor != null) { "No constructor created for $thisDescriptor" } setDeferredReturnType(constructor) @@ -290,7 +292,7 @@ public open class LazyClassMemberScope(resolveSession: ResolveSession, } protected fun setDeferredReturnType(descriptor: ConstructorDescriptorImpl) { - descriptor.setReturnType(DeferredType.create(resolveSession.getStorageManager(), trace, { thisDescriptor.getDefaultType() })) + descriptor.setReturnType(DeferredType.create(c.storageManager, trace, { thisDescriptor.getDefaultType() })) } // Do not add details here, they may compromise the laziness during debugging diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyPackageMemberScope.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyPackageMemberScope.kt index 9b8bf40a936..f82b46c805f 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyPackageMemberScope.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyPackageMemberScope.kt @@ -24,7 +24,7 @@ import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter public class LazyPackageMemberScope( - resolveSession: ResolveSession, + private val resolveSession: ResolveSession, declarationProvider: PackageMemberDeclarationProvider, thisPackage: PackageFragmentDescriptor) : AbstractLazyMemberScope(resolveSession, declarationProvider, thisPackage, resolveSession.getTrace()) { diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyScriptClassDescriptor.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyScriptClassDescriptor.java index b9789fd2051..1a81b679724 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyScriptClassDescriptor.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyScriptClassDescriptor.java @@ -17,6 +17,7 @@ package org.jetbrains.kotlin.resolve.lazy.descriptors; import org.jetbrains.annotations.NotNull; +import org.jetbrains.kotlin.resolve.lazy.LazyClassContext; import org.jetbrains.kotlin.descriptors.DeclarationDescriptor; import org.jetbrains.kotlin.descriptors.Visibilities; import org.jetbrains.kotlin.descriptors.Visibility; @@ -39,13 +40,15 @@ public class LazyScriptClassDescriptor extends LazyClassDescriptor { @NotNull @Override protected LazyScriptClassMemberScope createMemberScope( - @NotNull ResolveSession resolveSession, @NotNull ClassMemberDeclarationProvider declarationProvider + @NotNull LazyClassContext c, + @NotNull ClassMemberDeclarationProvider declarationProvider ) { return new LazyScriptClassMemberScope( - resolveSession, + // Must be a ResolveSession for scripts + (ResolveSession) c, declarationProvider, this, - TemporaryBindingTrace.create(resolveSession.getTrace(), "A trace for script class, needed to avoid rewrites on members") + TemporaryBindingTrace.create(c.getTrace(), "A trace for script class, needed to avoid rewrites on members") ); } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyScriptClassMemberScope.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyScriptClassMemberScope.kt index 5f827cc9431..973170de54e 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyScriptClassMemberScope.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyScriptClassMemberScope.kt @@ -1,18 +1,18 @@ /* - * Copyright 2010-2015 JetBrains s.r.o. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ +* Copyright 2010-2015 JetBrains s.r.o. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ package org.jetbrains.kotlin.resolve.lazy.descriptors @@ -28,7 +28,7 @@ import org.jetbrains.kotlin.utils.toReadOnlyList // SCRIPT: Members of a script class public class LazyScriptClassMemberScope protected( - resolveSession: ResolveSession, + private val resolveSession: ResolveSession, declarationProvider: ClassMemberDeclarationProvider, thisClass: LazyClassDescriptor, trace: BindingTrace) diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyTypeParameterDescriptor.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyTypeParameterDescriptor.java index b5c57872ec5..9a62888cda9 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyTypeParameterDescriptor.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyTypeParameterDescriptor.java @@ -18,6 +18,7 @@ package org.jetbrains.kotlin.resolve.lazy.descriptors; import com.google.common.collect.Sets; import org.jetbrains.annotations.NotNull; +import org.jetbrains.kotlin.resolve.lazy.LazyClassContext; import org.jetbrains.kotlin.descriptors.impl.AbstractLazyTypeParameterDescriptor; import org.jetbrains.kotlin.lexer.JetTokens; import org.jetbrains.kotlin.psi.*; @@ -25,7 +26,6 @@ import org.jetbrains.kotlin.resolve.BindingContext; import org.jetbrains.kotlin.resolve.DescriptorResolver; import org.jetbrains.kotlin.resolve.lazy.ForceResolveUtil; import org.jetbrains.kotlin.resolve.lazy.LazyEntity; -import org.jetbrains.kotlin.resolve.lazy.ResolveSession; import org.jetbrains.kotlin.types.JetType; import java.util.Set; @@ -33,17 +33,17 @@ import java.util.Set; import static org.jetbrains.kotlin.resolve.source.SourcePackage.toSourceElement; public class LazyTypeParameterDescriptor extends AbstractLazyTypeParameterDescriptor implements LazyEntity { - private final ResolveSession resolveSession; + private final LazyClassContext c; private final JetTypeParameter jetTypeParameter; public LazyTypeParameterDescriptor( - @NotNull ResolveSession resolveSession, + @NotNull LazyClassContext c, @NotNull LazyClassDescriptor containingDeclaration, @NotNull JetTypeParameter jetTypeParameter, int index) { super( - resolveSession.getStorageManager(), + c.getStorageManager(), containingDeclaration, jetTypeParameter.getNameAsSafeName(), jetTypeParameter.getVariance(), @@ -51,10 +51,10 @@ public class LazyTypeParameterDescriptor extends AbstractLazyTypeParameterDescri index, toSourceElement(jetTypeParameter) ); - this.resolveSession = resolveSession; + this.c = c; this.jetTypeParameter = jetTypeParameter; - this.resolveSession.getTrace().record(BindingContext.TYPE_PARAMETER, jetTypeParameter, this); + this.c.getTrace().record(BindingContext.TYPE_PARAMETER, jetTypeParameter, this); } @NotNull @@ -72,7 +72,7 @@ public class LazyTypeParameterDescriptor extends AbstractLazyTypeParameterDescri resolveUpperBoundsFromWhereClause(upperBounds); if (upperBounds.isEmpty()) { - upperBounds.add(resolveSession.getModuleDescriptor().getBuiltIns().getDefaultBound()); + upperBounds.add(c.getModuleDescriptor().getBuiltIns().getDefaultBound()); } return upperBounds; @@ -83,12 +83,12 @@ public class LazyTypeParameterDescriptor extends AbstractLazyTypeParameterDescri if (classOrObject instanceof JetClass) { JetClass jetClass = (JetClass) classOrObject; for (JetTypeConstraint jetTypeConstraint : jetClass.getTypeConstraints()) { - DescriptorResolver.reportUnsupportedClassObjectConstraint(resolveSession.getTrace(), jetTypeConstraint); + DescriptorResolver.reportUnsupportedClassObjectConstraint(c.getTrace(), jetTypeConstraint); JetSimpleNameExpression constrainedParameterName = jetTypeConstraint.getSubjectTypeParameterName(); if (constrainedParameterName != null) { if (getName().equals(constrainedParameterName.getReferencedNameAsName())) { - resolveSession.getTrace().record(BindingContext.REFERENCE_TARGET, constrainedParameterName, this); + c.getTrace().record(BindingContext.REFERENCE_TARGET, constrainedParameterName, this); JetTypeReference boundTypeReference = jetTypeConstraint.getBoundTypeReference(); if (boundTypeReference != null) { @@ -105,9 +105,9 @@ public class LazyTypeParameterDescriptor extends AbstractLazyTypeParameterDescri } private JetType resolveBoundType(@NotNull JetTypeReference boundTypeReference) { - return resolveSession.getTypeResolver() + return c.getTypeResolver() .resolveType(getContainingDeclaration().getScopeForClassHeaderResolution(), boundTypeReference, - resolveSession.getTrace(), false); + c.getTrace(), false); } @NotNull