From c2a3fde9698e48e062ea45d07bb29c6e643a40dd Mon Sep 17 00:00:00 2001 From: Valentin Kipyatkov Date: Tue, 28 Oct 2014 12:09:57 +0300 Subject: [PATCH] Converted JetScope to Kotlin --- .../codegen/CollectionStubMethodGenerator.kt | 2 +- .../binding/CodegenAnnotatingVisitor.java | 2 +- .../jet/codegen/binding/CodegenBinding.java | 2 +- .../jet/cli/jvm/repl/ReplInterpreter.java | 2 +- .../PropagationHeuristics.java | 2 +- .../IncrementalPackageFragmentProvider.kt | 4 +- .../impl/MutableClassDescriptor.java | 2 +- .../MutablePackageFragmentDescriptor.java | 2 +- .../impl/ScriptDescriptorImpl.java | 2 +- .../jet/lang/resolve/lazy/LazyImportScope.kt | 2 +- .../lazy/descriptors/LazyClassDescriptor.java | 8 +- .../lazy/descriptors/LazyScriptDescriptor.kt | 2 +- .../scopes/WritableScopeWithImports.kt | 2 +- .../expressions/ExpressionTypingServices.java | 2 +- .../constraintSystem/MyDeclarations.kt | 2 +- .../jet/types/TypeSubstitutorTest.java | 2 +- .../lazy/descriptors/LazyJavaStaticScope.kt | 4 +- .../jet/lang/resolve/scopes/JetScope.java | 99 ------------------- .../jet/lang/resolve/scopes/JetScope.kt | 74 ++++++++++++++ .../jet/lang/types/CommonSupertypes.java | 2 +- .../textBuilder/missingDependencies.kt | 2 +- 21 files changed, 98 insertions(+), 123 deletions(-) delete mode 100644 core/descriptors/src/org/jetbrains/jet/lang/resolve/scopes/JetScope.java create mode 100644 core/descriptors/src/org/jetbrains/jet/lang/resolve/scopes/JetScope.kt diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/CollectionStubMethodGenerator.kt b/compiler/backend/src/org/jetbrains/jet/codegen/CollectionStubMethodGenerator.kt index 08b213f3877..79ea64c48a1 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/CollectionStubMethodGenerator.kt +++ b/compiler/backend/src/org/jetbrains/jet/codegen/CollectionStubMethodGenerator.kt @@ -190,7 +190,7 @@ class CollectionStubMethodGenerator( } private fun createSyntheticSubclass(): Pair> { - val child = MutableClassDescriptor(descriptor.getContainingDeclaration(), JetScope.EMPTY, ClassKind.CLASS, false, + val child = MutableClassDescriptor(descriptor.getContainingDeclaration(), JetScope.Empty, ClassKind.CLASS, false, Name.special(""), descriptor.getSource()) child.setModality(Modality.FINAL) child.setVisibility(Visibilities.PUBLIC) diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/binding/CodegenAnnotatingVisitor.java b/compiler/backend/src/org/jetbrains/jet/codegen/binding/CodegenAnnotatingVisitor.java index 2a28cd17032..547d2a2c6a9 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/binding/CodegenAnnotatingVisitor.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/binding/CodegenAnnotatingVisitor.java @@ -117,7 +117,7 @@ class CodegenAnnotatingVisitor extends JetVisitorVoid { funDescriptor.getContainingDeclaration(), Name.special(""), Modality.FINAL, supertypes, SourcePackage.toSourceElement(element) ); - classDescriptor.initialize(JetScope.EMPTY, Collections.emptySet(), null); + classDescriptor.initialize(JetScope.Empty.INSTANCE$, Collections.emptySet(), null); bindingTrace.record(CLASS_FOR_FUNCTION, funDescriptor, classDescriptor); return classDescriptor; diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/binding/CodegenBinding.java b/compiler/backend/src/org/jetbrains/jet/codegen/binding/CodegenBinding.java index e0b748a5378..f7dafed09bd 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/binding/CodegenBinding.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/binding/CodegenBinding.java @@ -200,7 +200,7 @@ public class CodegenBinding { ClassDescriptorImpl classDescriptor = new ClassDescriptorImpl(descriptor, Name.special(""), Modality.FINAL, Collections.singleton(KotlinBuiltIns.getInstance().getAnyType()), toSourceElement(script)); - classDescriptor.initialize(JetScope.EMPTY, Collections.emptySet(), null); + classDescriptor.initialize(JetScope.Empty.INSTANCE$, Collections.emptySet(), null); recordClosure(trace, classDescriptor, null, asmType); diff --git a/compiler/cli/src/org/jetbrains/jet/cli/jvm/repl/ReplInterpreter.java b/compiler/cli/src/org/jetbrains/jet/cli/jvm/repl/ReplInterpreter.java index 77d01d2936f..2878b19f45e 100644 --- a/compiler/cli/src/org/jetbrains/jet/cli/jvm/repl/ReplInterpreter.java +++ b/compiler/cli/src/org/jetbrains/jet/cli/jvm/repl/ReplInterpreter.java @@ -321,7 +321,7 @@ public class ReplInterpreter { @Nullable private ScriptDescriptor doAnalyze(@NotNull JetFile psiFile, @NotNull MessageCollector messageCollector) { WritableScope scope = new WritableScopeImpl( - JetScope.EMPTY, module, + JetScope.Empty.INSTANCE$, module, new TraceBasedRedeclarationHandler(trace), "Root scope in analyzePackage" ); diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/PropagationHeuristics.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/PropagationHeuristics.java index b8a0da70239..05eb2807790 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/PropagationHeuristics.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/PropagationHeuristics.java @@ -66,7 +66,7 @@ class PropagationHeuristics { arrayTypeFromSuper.getConstructor(), arrayTypeFromSuper.isNullable(), Arrays.asList(new TypeProjectionImpl(Variance.OUT_VARIANCE, elementTypeInSuper)), - JetScope.EMPTY); + JetScope.Empty.INSTANCE$); data.reportError("Return type is not a subtype of overridden method. " + "To fix it, add annotation with Kotlin signature to super method with type " diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/kotlin/incremental/IncrementalPackageFragmentProvider.kt b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/kotlin/incremental/IncrementalPackageFragmentProvider.kt index 9fd9bfef81f..18f863e0037 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/kotlin/incremental/IncrementalPackageFragmentProvider.kt +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/kotlin/incremental/IncrementalPackageFragmentProvider.kt @@ -96,12 +96,12 @@ public class IncrementalPackageFragmentProvider( val _memberScope: NotNullLazyValue = storageManager.createLazyValue { if (fqName !in fqNamesToLoad) { - JetScope.EMPTY + JetScope.Empty } else { val packageDataBytes = incrementalCache.getPackageData(fqName) if (packageDataBytes == null) { - JetScope.EMPTY + JetScope.Empty } else { IncrementalPackageScope(JavaProtoBufUtil.readPackageDataFrom(packageDataBytes)) diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/impl/MutableClassDescriptor.java b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/impl/MutableClassDescriptor.java index 6fa6484dea8..62e9b4a885d 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/impl/MutableClassDescriptor.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/impl/MutableClassDescriptor.java @@ -75,7 +75,7 @@ public class MutableClassDescriptor extends ClassDescriptorBase implements Class RedeclarationHandler redeclarationHandler = RedeclarationHandler.DO_NOTHING; - setScopeForMemberLookup(new WritableScopeImpl(JetScope.EMPTY, this, redeclarationHandler, "MemberLookup") + setScopeForMemberLookup(new WritableScopeImpl(JetScope.Empty.INSTANCE$, this, redeclarationHandler, "MemberLookup") .changeLockLevel(WritableScope.LockLevel.BOTH)); this.scopeForSupertypeResolution = new WritableScopeImpl(outerScope, this, redeclarationHandler, "SupertypeResolution") .changeLockLevel(WritableScope.LockLevel.BOTH); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/impl/MutablePackageFragmentDescriptor.java b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/impl/MutablePackageFragmentDescriptor.java index 9ab551b014b..33e55022893 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/impl/MutablePackageFragmentDescriptor.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/impl/MutablePackageFragmentDescriptor.java @@ -31,7 +31,7 @@ public class MutablePackageFragmentDescriptor extends PackageFragmentDescriptorI public MutablePackageFragmentDescriptor(@NotNull ModuleDescriptor module, @NotNull FqName fqName) { super(module, fqName); - scope = new WritableScopeImpl(JetScope.EMPTY, this, RedeclarationHandler.DO_NOTHING, "Members of " + fqName + " in " + module); + scope = new WritableScopeImpl(JetScope.Empty.INSTANCE$, this, RedeclarationHandler.DO_NOTHING, "Members of " + fqName + " in " + module); scope.changeLockLevel(WritableScope.LockLevel.BOTH); builder = new ScopeBasedPackageLikeBuilder(this, scope); } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/impl/ScriptDescriptorImpl.java b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/impl/ScriptDescriptorImpl.java index 7965e16b8da..f9a558c5f2b 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/impl/ScriptDescriptorImpl.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/impl/ScriptDescriptorImpl.java @@ -70,7 +70,7 @@ public class ScriptDescriptorImpl extends DeclarationDescriptorNonRootImpl imple classDescriptor.setVisibility(Visibilities.PUBLIC); classDescriptor.setTypeParameterDescriptors(Collections.emptyList()); - classScope = new WritableScopeImpl(JetScope.EMPTY, classDescriptor, RedeclarationHandler.DO_NOTHING, "script members"); + classScope = new WritableScopeImpl(JetScope.Empty.INSTANCE$, classDescriptor, RedeclarationHandler.DO_NOTHING, "script members"); classScope.changeLockLevel(WritableScope.LockLevel.BOTH); classDescriptor.setScopeForMemberLookup(classScope); classDescriptor.createTypeConstructor(); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/LazyImportScope.kt b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/LazyImportScope.kt index 690877e2b8a..6365a57be68 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/LazyImportScope.kt +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/LazyImportScope.kt @@ -65,7 +65,7 @@ public class LazyImportScope(private val resolveSession: ResolveSession, cachedStatus.scope } else { - val directiveImportScope = WritableScopeImpl(JetScope.EMPTY, containingDeclaration, RedeclarationHandler.DO_NOTHING, "Scope for import '" + directive.getDebugText() + "' resolve in " + toString()) + val directiveImportScope = WritableScopeImpl(JetScope.Empty, containingDeclaration, RedeclarationHandler.DO_NOTHING, "Scope for import '" + directive.getDebugText() + "' resolve in " + toString()) directiveImportScope.changeLockLevel(WritableScope.LockLevel.BOTH) val importer = Importer.StandardImporter(directiveImportScope) diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/descriptors/LazyClassDescriptor.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/descriptors/LazyClassDescriptor.java index c9152882b5a..88dd7b47f99 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/descriptors/LazyClassDescriptor.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/descriptors/LazyClassDescriptor.java @@ -221,7 +221,7 @@ public class LazyClassDescriptor extends ClassDescriptorBase implements ClassDes @NotNull private JetScope computeScopeForClassHeaderResolution() { - WritableScopeImpl scope = new WritableScopeImpl(JetScope.EMPTY, this, RedeclarationHandler.DO_NOTHING, "Scope with type parameters for " + getName()); + WritableScopeImpl scope = new WritableScopeImpl(JetScope.Empty.INSTANCE$, this, RedeclarationHandler.DO_NOTHING, "Scope with type parameters for " + getName()); for (TypeParameterDescriptor typeParameterDescriptor : getTypeConstructor().getParameters()) { scope.addClassifierDescriptor(typeParameterDescriptor); } @@ -242,13 +242,13 @@ public class LazyClassDescriptor extends ClassDescriptorBase implements ClassDes @NotNull private JetScope computeScopeForMemberDeclarationResolution() { - WritableScopeImpl thisScope = new WritableScopeImpl(JetScope.EMPTY, this, RedeclarationHandler.DO_NOTHING, "Scope with 'this' for " + getName()); + WritableScopeImpl thisScope = new WritableScopeImpl(JetScope.Empty.INSTANCE$, this, RedeclarationHandler.DO_NOTHING, "Scope with 'this' for " + getName()); thisScope.addLabeledDeclaration(this); thisScope.setImplicitReceiver(this.getThisAsReceiverParameter()); thisScope.changeLockLevel(WritableScope.LockLevel.READING); ClassDescriptor classObject = getClassObjectDescriptor(); - JetScope classObjectAdapterScope = (classObject != null) ? new ClassObjectMixinScope(classObject) : JetScope.EMPTY; + JetScope classObjectAdapterScope = (classObject != null) ? new ClassObjectMixinScope(classObject) : JetScope.Empty.INSTANCE$; return new ChainedScope( this, @@ -288,7 +288,7 @@ public class LazyClassDescriptor extends ClassDescriptorBase implements ClassDes ConstructorDescriptor primaryConstructor = getUnsubstitutedPrimaryConstructor(); if (primaryConstructor == null) return getScopeForMemberDeclarationResolution(); - WritableScopeImpl scope = new WritableScopeImpl(JetScope.EMPTY, primaryConstructor, RedeclarationHandler.DO_NOTHING, "Scope with constructor parameters in " + getName()); + WritableScopeImpl scope = new WritableScopeImpl(JetScope.Empty.INSTANCE$, primaryConstructor, RedeclarationHandler.DO_NOTHING, "Scope with constructor parameters in " + getName()); for (int i = 0; i < originalClassInfo.getPrimaryConstructorParameters().size(); i++) { JetParameter jetParameter = originalClassInfo.getPrimaryConstructorParameters().get(i); if (!jetParameter.hasValOrVarNode()) { diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/descriptors/LazyScriptDescriptor.kt b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/descriptors/LazyScriptDescriptor.kt index 06b814df68d..174744eb7e6 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/descriptors/LazyScriptDescriptor.kt +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/descriptors/LazyScriptDescriptor.kt @@ -85,7 +85,7 @@ public class LazyScriptDescriptor( override fun getScriptCodeDescriptor() = _scriptCodeDescriptor() override fun getScopeForBodyResolution(): JetScope { - val parametersScope = WritableScopeImpl(JetScope.EMPTY, this, RedeclarationHandler.DO_NOTHING, "Parameters of " + this) + val parametersScope = WritableScopeImpl(JetScope.Empty, this, RedeclarationHandler.DO_NOTHING, "Parameters of " + this) parametersScope.setImplicitReceiver(_implicitReceiver) for (valueParameterDescriptor in getScriptCodeDescriptor().getValueParameters()) { parametersScope.addVariableDescriptor(valueParameterDescriptor) diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/WritableScopeWithImports.kt b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/WritableScopeWithImports.kt index 25e1e816e41..5d9bf2c9c50 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/WritableScopeWithImports.kt +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/WritableScopeWithImports.kt @@ -165,7 +165,7 @@ public abstract class WritableScopeWithImports(override val workerScope: JetScop private fun getCurrentIndividualImportScope(): WritableScope { if (currentIndividualImportScope == null) { - val writableScope = WritableScopeImpl(JetScope.EMPTY, getContainingDeclaration(), RedeclarationHandler.DO_NOTHING, "Individual import scope") + val writableScope = WritableScopeImpl(JetScope.Empty, getContainingDeclaration(), RedeclarationHandler.DO_NOTHING, "Individual import scope") writableScope.changeLockLevel(WritableScope.LockLevel.BOTH) importScope(writableScope) currentIndividualImportScope = writableScope diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingServices.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingServices.java index aded68421d4..742b19d2809 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingServices.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingServices.java @@ -401,6 +401,6 @@ public class ExpressionTypingServices { @NotNull public CallResolverExtension createExtension(@NotNull JetScope scope, boolean isAnnotationContext) { - return extensionProvider.createExtension(scope == JetScope.EMPTY ? null : scope.getContainingDeclaration(), isAnnotationContext); + return extensionProvider.createExtension(scope == JetScope.Empty.INSTANCE$ ? null : scope.getContainingDeclaration(), isAnnotationContext); } } diff --git a/compiler/tests/org/jetbrains/jet/resolve/constraintSystem/MyDeclarations.kt b/compiler/tests/org/jetbrains/jet/resolve/constraintSystem/MyDeclarations.kt index cab51ef5bd9..46f090246d8 100644 --- a/compiler/tests/org/jetbrains/jet/resolve/constraintSystem/MyDeclarations.kt +++ b/compiler/tests/org/jetbrains/jet/resolve/constraintSystem/MyDeclarations.kt @@ -67,7 +67,7 @@ public class MyDeclarations( val matcher = INTEGER_VALUE_TYPE_PATTERN.matcher(name) if (matcher.find()) { val number = matcher.group(1)!! - return JetTypeImpl(Annotations.EMPTY, IntegerValueTypeConstructor(number.toLong()), false, listOf(), JetScope.EMPTY) + return JetTypeImpl(Annotations.EMPTY, IntegerValueTypeConstructor(number.toLong()), false, listOf(), JetScope.Empty) } return typeResolver.resolveType( scopeToResolveTypeParameters, JetPsiFactory(project).createType(name), diff --git a/compiler/tests/org/jetbrains/jet/types/TypeSubstitutorTest.java b/compiler/tests/org/jetbrains/jet/types/TypeSubstitutorTest.java index ffd91a00e7e..29a76e906e2 100644 --- a/compiler/tests/org/jetbrains/jet/types/TypeSubstitutorTest.java +++ b/compiler/tests/org/jetbrains/jet/types/TypeSubstitutorTest.java @@ -87,7 +87,7 @@ public class TypeSubstitutorTest extends KotlinTestWithEnvironment { JetScope topLevelDeclarations = module.getPackage(FqName.ROOT).getMemberScope(); ClassifierDescriptor contextClass = topLevelDeclarations.getClassifier(Name.identifier("___Context")); assert contextClass instanceof ClassDescriptor; - WritableScopeImpl typeParameters = new WritableScopeImpl(JetScope.EMPTY, module, RedeclarationHandler.THROW_EXCEPTION, + WritableScopeImpl typeParameters = new WritableScopeImpl(JetScope.Empty.INSTANCE$, module, RedeclarationHandler.THROW_EXCEPTION, "Type parameter scope"); for (TypeParameterDescriptor parameterDescriptor : contextClass.getTypeConstructor().getParameters()) { typeParameters.addClassifierDescriptor(parameterDescriptor); diff --git a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/lazy/descriptors/LazyJavaStaticScope.kt b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/lazy/descriptors/LazyJavaStaticScope.kt index 803020fbbec..a172ea1f989 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/lazy/descriptors/LazyJavaStaticScope.kt +++ b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/lazy/descriptors/LazyJavaStaticScope.kt @@ -85,9 +85,9 @@ public class LazyPackageFragmentScopeForJavaPackage( private val deserializedPackageScope = c.storageManager.createLazyValue { val kotlinBinaryClass = kotlinBinaryClass if (kotlinBinaryClass == null) - JetScope.EMPTY + JetScope.Empty else - c.deserializedDescriptorResolver.createKotlinPackageScope(packageFragment, kotlinBinaryClass) ?: JetScope.EMPTY + c.deserializedDescriptorResolver.createKotlinPackageScope(packageFragment, kotlinBinaryClass) ?: JetScope.Empty } private val classes = c.storageManager.createMemoizedFunctionWithNullableValues { diff --git a/core/descriptors/src/org/jetbrains/jet/lang/resolve/scopes/JetScope.java b/core/descriptors/src/org/jetbrains/jet/lang/resolve/scopes/JetScope.java deleted file mode 100644 index cadc3451cf1..00000000000 --- a/core/descriptors/src/org/jetbrains/jet/lang/resolve/scopes/JetScope.java +++ /dev/null @@ -1,99 +0,0 @@ -/* - * Copyright 2010-2013 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.jet.lang.resolve.scopes; - -import org.jetbrains.annotations.NotNull; -import org.jetbrains.annotations.Nullable; -import org.jetbrains.annotations.ReadOnly; -import org.jetbrains.jet.lang.descriptors.*; -import org.jetbrains.jet.lang.resolve.name.Name; -import org.jetbrains.jet.utils.Printer; - -import java.util.Collection; -import java.util.List; - -public interface JetScope { - JetScope EMPTY = new JetScopeImpl() { - @NotNull - @Override - public DeclarationDescriptor getContainingDeclaration() { - throw new UnsupportedOperationException("Don't take containing declaration of the EMPTY scope"); - } - - @Override - public String toString() { - return "EMPTY"; - } - - @Override - public void printScopeStructure(@NotNull Printer p) { - p.println("EMPTY"); - } - }; - - /** - * Should not return object (class object or enum entry) class descriptors. - */ - @Nullable - ClassifierDescriptor getClassifier(@NotNull Name name); - - @Nullable - PackageViewDescriptor getPackage(@NotNull Name name); - - @NotNull - @ReadOnly - Collection getProperties(@NotNull Name name); - - @Nullable - VariableDescriptor getLocalVariable(@NotNull Name name); - - @NotNull - @ReadOnly - Collection getFunctions(@NotNull Name name); - - @NotNull - DeclarationDescriptor getContainingDeclaration(); - - @NotNull - @ReadOnly - Collection getDeclarationsByLabel(@NotNull Name labelName); - - /** - * All visible descriptors from current scope. - * - * @return All visible descriptors from current scope. - */ - @NotNull - @ReadOnly - Collection getAllDescriptors(); - - /** - * Adds receivers to the list in order of locality, so that the closest (the most local) receiver goes first - */ - @NotNull - @ReadOnly - List getImplicitReceiversHierarchy(); - - @NotNull - @ReadOnly - Collection getOwnDeclaredDescriptors(); - - /** - * Is supposed to be used in tests and debug only - */ - void printScopeStructure(@NotNull Printer p); -} diff --git a/core/descriptors/src/org/jetbrains/jet/lang/resolve/scopes/JetScope.kt b/core/descriptors/src/org/jetbrains/jet/lang/resolve/scopes/JetScope.kt new file mode 100644 index 00000000000..574461d9723 --- /dev/null +++ b/core/descriptors/src/org/jetbrains/jet/lang/resolve/scopes/JetScope.kt @@ -0,0 +1,74 @@ +/* + * Copyright 2010-2014 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.jet.lang.resolve.scopes + +import org.jetbrains.annotations.ReadOnly +import org.jetbrains.jet.lang.descriptors.* +import org.jetbrains.jet.lang.resolve.name.Name +import org.jetbrains.jet.utils.Printer + +public trait JetScope { + + /** + * Should not return object (class object or enum entry) class descriptors. + */ + public fun getClassifier(name: Name): ClassifierDescriptor? + + public fun getPackage(name: Name): PackageViewDescriptor? + + public fun getProperties(name: Name): Collection + + public fun getLocalVariable(name: Name): VariableDescriptor? + + public fun getFunctions(name: Name): Collection + + public fun getContainingDeclaration(): DeclarationDescriptor + + public fun getDeclarationsByLabel(labelName: Name): Collection + + /** + * All visible descriptors from current scope. + * + * @return All visible descriptors from current scope. + */ + public fun getAllDescriptors(): Collection + + /** + * Adds receivers to the list in order of locality, so that the closest (the most local) receiver goes first + */ + public fun getImplicitReceiversHierarchy(): List + + public fun getOwnDeclaredDescriptors(): Collection + + /** + * Is supposed to be used in tests and debug only + */ + public fun printScopeStructure(p: Printer) + + object Empty : JetScopeImpl() { + override fun getContainingDeclaration(): DeclarationDescriptor { + throw UnsupportedOperationException("Don't take containing declaration of the Empty scope") + } + + override fun toString() = "Empty" + + override fun printScopeStructure(p: Printer) { + p.println("Empty") + } + } +} + diff --git a/core/descriptors/src/org/jetbrains/jet/lang/types/CommonSupertypes.java b/core/descriptors/src/org/jetbrains/jet/lang/types/CommonSupertypes.java index fb1641fc056..9d9aa4d21bb 100644 --- a/core/descriptors/src/org/jetbrains/jet/lang/types/CommonSupertypes.java +++ b/core/descriptors/src/org/jetbrains/jet/lang/types/CommonSupertypes.java @@ -224,7 +224,7 @@ public class CommonSupertypes { } // TODO : attributes? - JetScope newScope = JetScope.EMPTY; + JetScope newScope = JetScope.Empty.INSTANCE$; DeclarationDescriptor declarationDescriptor = constructor.getDeclarationDescriptor(); if (declarationDescriptor instanceof ClassDescriptor) { newScope = ((ClassDescriptor) declarationDescriptor).getMemberScope(newProjections); diff --git a/idea/idea-analysis/src/org/jetbrains/jet/plugin/decompiler/textBuilder/missingDependencies.kt b/idea/idea-analysis/src/org/jetbrains/jet/plugin/decompiler/textBuilder/missingDependencies.kt index 3377e29fb38..9c04732e0a2 100644 --- a/idea/idea-analysis/src/org/jetbrains/jet/plugin/decompiler/textBuilder/missingDependencies.kt +++ b/idea/idea-analysis/src/org/jetbrains/jet/plugin/decompiler/textBuilder/missingDependencies.kt @@ -87,6 +87,6 @@ private class MissingDependencyErrorClassDescriptor(containing: DeclarationDescr val emptyConstructor = ConstructorDescriptorImpl.create(this, Annotations.EMPTY, true, SourceElement.NO_SOURCE) emptyConstructor.initialize(listOf(), listOf(), Visibilities.INTERNAL) emptyConstructor.setReturnType(createErrorType("")) - initialize(JetScope.EMPTY, setOf(emptyConstructor), emptyConstructor) + initialize(JetScope.Empty, setOf(emptyConstructor), emptyConstructor) } }