From 4b025adde96e041b31c346d020e5ed3eb18d11bc Mon Sep 17 00:00:00 2001 From: Stepan Koltsov Date: Wed, 30 Nov 2011 02:59:58 +0400 Subject: [PATCH] Revert "WritableScope.changeLockLevel()" This reverts commit 1866a245faefa5284718181b802ea17efb8323e1. Stupid git --- .../descriptors/FunctionDescriptorUtil.java | 1 - .../descriptors/MutableClassDescriptor.java | 13 ----- .../jet/lang/resolve/AnalyzingUtils.java | 1 - .../jet/lang/resolve/BodyResolver.java | 4 -- .../jet/lang/resolve/DescriptorResolver.java | 11 +---- .../jet/lang/resolve/TopDownAnalyzer.java | 10 ---- .../lang/resolve/TypeHierarchyResolver.java | 5 +- .../lang/resolve/scopes/WritableScope.java | 8 --- .../resolve/scopes/WritableScopeImpl.java | 49 ------------------- .../scopes/WritableScopeWithImports.java | 46 ----------------- .../resolve/scopes/WriteThroughScope.java | 44 ----------------- .../jet/lang/types/JetStandardClasses.java | 2 - .../jet/lang/types/JetStandardLibrary.java | 2 - .../expressions/ExpressionTypingServices.java | 1 - .../expressions/ExpressionTypingUtils.java | 5 +- .../JetDefaultModalityModifiersTest.java | 2 - .../jet/types/JetTypeCheckerTest.java | 3 -- 17 files changed, 4 insertions(+), 203 deletions(-) diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/FunctionDescriptorUtil.java b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/FunctionDescriptorUtil.java index 8208b807e8f..e4bc91d4854 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/FunctionDescriptorUtil.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/FunctionDescriptorUtil.java @@ -80,7 +80,6 @@ public class FunctionDescriptorUtil { parameterScope.addVariableDescriptor(valueParameterDescriptor); } parameterScope.addLabeledDeclaration(descriptor); - parameterScope.changeLockLevel(WritableScope.LockLevel.READING); return parameterScope; } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/MutableClassDescriptor.java b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/MutableClassDescriptor.java index 525a8d93d05..669af46b9ae 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/MutableClassDescriptor.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/MutableClassDescriptor.java @@ -49,11 +49,8 @@ public class MutableClassDescriptor extends MutableDeclarationDescriptor impleme super(containingDeclaration); TraceBasedRedeclarationHandler redeclarationHandler = new TraceBasedRedeclarationHandler(trace); this.scopeForMemberLookup = new WritableScopeImpl(JetScope.EMPTY, this, redeclarationHandler).setDebugName("MemberLookup"); - this.scopeForMemberLookup.changeLockLevel(WritableScope.LockLevel.BOTH); this.scopeForSupertypeResolution = new WritableScopeImpl(outerScope, this, redeclarationHandler).setDebugName("SupertypeResolution"); - this.scopeForSupertypeResolution.changeLockLevel(WritableScope.LockLevel.BOTH); this.scopeForMemberResolution = new WritableScopeImpl(scopeForSupertypeResolution, this, redeclarationHandler).setDebugName("MemberResolution"); - this.scopeForMemberResolution.changeLockLevel(WritableScope.LockLevel.BOTH); this.kind = kind; } @@ -183,7 +180,6 @@ public class MutableClassDescriptor extends MutableDeclarationDescriptor impleme this.typeParameters.add(typeParameterDescriptor); scopeForSupertypeResolution.addTypeParameterDescriptor(typeParameterDescriptor); } - scopeForSupertypeResolution.changeLockLevel(WritableScope.LockLevel.READING); } //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// @@ -348,13 +344,4 @@ public class MutableClassDescriptor extends MutableDeclarationDescriptor impleme } return implicitReceiver; } - - public void lockScopes() { - scopeForSupertypeResolution.changeLockLevel(WritableScope.LockLevel.READING); - scopeForMemberLookup.changeLockLevel(WritableScope.LockLevel.READING); - scopeForMemberResolution.changeLockLevel(WritableScope.LockLevel.READING); - if (classObjectDescriptor != null) { - classObjectDescriptor.lockScopes(); - } - } } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/AnalyzingUtils.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/AnalyzingUtils.java index 13cb17841bc..da5cb3020b5 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/AnalyzingUtils.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/AnalyzingUtils.java @@ -96,7 +96,6 @@ public class AnalyzingUtils { final WritableScope scope = new WritableScopeImpl(JetScope.EMPTY, owner, new TraceBasedRedeclarationHandler(bindingTraceContext)).setDebugName("Root scope in analyzeNamespace"); importingStrategy.addImports(project, semanticServices, bindingTraceContext, scope); scope.importScope(libraryScope); - scope.changeLockLevel(WritableScope.LockLevel.BOTH); TopDownAnalyzer.process(semanticServices, bindingTraceContext, scope, new NamespaceLike.Adapter(owner) { diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BodyResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BodyResolver.java index eeab159c182..dd45fdd7af9 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BodyResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BodyResolver.java @@ -382,8 +382,6 @@ public class BodyResolver { } constructorScope.addLabeledDeclaration(descriptor); // TODO : Labels for constructors?! - - constructorScope.changeLockLevel(WritableScope.LockLevel.READING); return constructorScope; } @@ -444,7 +442,6 @@ public class BodyResolver { if (receiver.exists()) { result.setImplicitReceiver(receiver); } - result.changeLockLevel(WritableScope.LockLevel.READING); return result; } @@ -453,7 +450,6 @@ public class BodyResolver { WritableScope accessorScope = new WritableScopeImpl(getPropertyDeclarationInnerScope(declaringScope, propertyDescriptor), declaringScope.getContainingDeclaration(), new TraceBasedRedeclarationHandler(context.getTrace())).setDebugName("Accessor scope"); accessorScope.addPropertyDescriptorByFieldName("$" + propertyDescriptor.getName(), propertyDescriptor); - accessorScope.changeLockLevel(WritableScope.LockLevel.READING); JetPropertyAccessor getter = property.getGetter(); PropertyGetterDescriptor getterDescriptor = propertyDescriptor.getGetter(); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DescriptorResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DescriptorResolver.java index 8cf81b34574..8be709898fd 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DescriptorResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DescriptorResolver.java @@ -146,7 +146,6 @@ public class DescriptorResolver { innerScope.addLabeledDeclaration(functionDescriptor); List typeParameterDescriptors = resolveTypeParameters(functionDescriptor, innerScope, function.getTypeParameters()); - innerScope.changeLockLevel(WritableScope.LockLevel.BOTH); resolveGenericBounds(function, innerScope, typeParameterDescriptors); JetType receiverType = null; @@ -158,10 +157,8 @@ public class DescriptorResolver { : scope; receiverType = typeResolver.resolveType(scopeForReceiver, receiverTypeRef); } - + List valueParameterDescriptors = resolveValueParameters(functionDescriptor, innerScope, function.getValueParameters()); - - innerScope.changeLockLevel(WritableScope.LockLevel.READING); JetTypeReference returnTypeRef = function.getReturnTypeRef(); JetType returnType; @@ -502,10 +499,8 @@ public class DescriptorResolver { } else { WritableScope writableScope = new WritableScopeImpl(scope, containingDeclaration, new TraceBasedRedeclarationHandler(trace)).setDebugName("Scope with type parameters of a property"); - writableScope.changeLockLevel(WritableScope.LockLevel.BOTH); typeParameterDescriptors = resolveTypeParameters(containingDeclaration, writableScope, typeParameters); resolveGenericBounds(property, writableScope, typeParameterDescriptors); - writableScope.changeLockLevel(WritableScope.LockLevel.READING); scopeWithTypeParameters = writableScope; } @@ -766,13 +761,11 @@ public class DescriptorResolver { isPrimary ); trace.record(BindingContext.CONSTRUCTOR, declarationToTrace, constructorDescriptor); - WritableScopeImpl parameterScope = new WritableScopeImpl(scope, classDescriptor, new TraceBasedRedeclarationHandler(trace)).setDebugName("Scope with value parameters of a constructor"); - parameterScope.changeLockLevel(WritableScope.LockLevel.BOTH); return constructorDescriptor.initialize( typeParameters, resolveValueParameters( constructorDescriptor, - parameterScope, + new WritableScopeImpl(scope, classDescriptor, new TraceBasedRedeclarationHandler(trace)).setDebugName("Scope with value parameters of a constructor"), valueParameters), Modality.FINAL, resolveVisibilityFromModifiers(modifierList)); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalyzer.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalyzer.java index 89bed40037e..e6a9f31e64d 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalyzer.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalyzer.java @@ -60,7 +60,6 @@ public class TopDownAnalyzer { new TypeHierarchyResolver(context).process(outerScope, owner, declarations); new DeclarationResolver(context).process(); new DelegationResolver(context).process(); - lockClasses(context); new OverrideResolver(context).process(); new OverloadResolver(context).process(); if (!context.analyzingBootstrapLibrary()) { @@ -73,15 +72,6 @@ public class TopDownAnalyzer { context.printDebugOutput(System.out); } - private static void lockClasses(TopDownAnalysisContext context) { - for (MutableClassDescriptor mutableClassDescriptor : context.getClasses().values()) { - mutableClassDescriptor.lockScopes(); - } - for (MutableClassDescriptor mutableClassDescriptor : context.getObjects().values()) { - mutableClassDescriptor.lockScopes(); - } - } - public static void processStandardLibraryNamespace( @NotNull JetSemanticServices semanticServices, @NotNull BindingTrace trace, diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TypeHierarchyResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TypeHierarchyResolver.java index ca5c16a1887..2585e655d35 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TypeHierarchyResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TypeHierarchyResolver.java @@ -78,16 +78,13 @@ public class TypeHierarchyResolver { Collections.emptyList(), // TODO: annotations name ); - WritableScopeImpl memberScope = new WritableScopeImpl(JetScope.EMPTY, namespaceDescriptor, new TraceBasedRedeclarationHandler(context.getTrace())).setDebugName("Namespace member scope"); - memberScope.changeLockLevel(WritableScope.LockLevel.BOTH); - namespaceDescriptor.initialize(memberScope); + namespaceDescriptor.initialize(new WritableScopeImpl(JetScope.EMPTY, namespaceDescriptor, new TraceBasedRedeclarationHandler(context.getTrace())).setDebugName("Namespace member scope")); owner.addNamespace(namespaceDescriptor); context.getTrace().record(BindingContext.NAMESPACE, namespace, namespaceDescriptor); } context.getNamespaceDescriptors().put(namespace, namespaceDescriptor); WriteThroughScope namespaceScope = new WriteThroughScope(outerScope, namespaceDescriptor.getMemberScope(), new TraceBasedRedeclarationHandler(context.getTrace())); - namespaceScope.changeLockLevel(WritableScope.LockLevel.BOTH); context.getNamespaceScopes().put(namespace, namespaceScope); context.getDeclaringScopes().put(namespace, outerScope); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/WritableScope.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/WritableScope.java index 4716d808cc0..f56816079fb 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/WritableScope.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/WritableScope.java @@ -9,14 +9,6 @@ import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor; * @author abreslav */ public interface WritableScope extends JetScope { - enum LockLevel { - WRITING, - BOTH, - READING, - } - - void changeLockLevel(LockLevel lockLevel); - void addLabeledDeclaration(@NotNull DeclarationDescriptor descriptor); void addVariableDescriptor(@NotNull VariableDescriptor variableDescriptor); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/WritableScopeImpl.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/WritableScopeImpl.java index 97bd74167b8..ed1febfd63a 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/WritableScopeImpl.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/WritableScopeImpl.java @@ -55,22 +55,17 @@ public class WritableScopeImpl extends WritableScopeWithImports { @Override public void importScope(@NotNull JetScope imported) { - checkMayWrite(); super.importScope(imported); } @Override public void importClassifierAlias(@NotNull String importedClassifierName, @NotNull ClassifierDescriptor classifierDescriptor) { - checkMayWrite(); - allDescriptors.add(classifierDescriptor); super.importClassifierAlias(importedClassifierName, classifierDescriptor); } @Override public void importNamespaceAlias(String aliasName, NamespaceDescriptor namespaceDescriptor) { - checkMayWrite(); - allDescriptors.add(namespaceDescriptor); super.importNamespaceAlias(aliasName, namespaceDescriptor); } @@ -78,8 +73,6 @@ public class WritableScopeImpl extends WritableScopeWithImports { @NotNull @Override public Collection getAllDescriptors() { - checkMayRead(); - if (!allDescriptorsDone) { allDescriptorsDone = true; allDescriptors.addAll(getWorkerScope().getAllDescriptors()); @@ -101,8 +94,6 @@ public class WritableScopeImpl extends WritableScopeWithImports { @NotNull @Override public Collection getDeclarationsByLabel(@NotNull String labelName) { - checkMayRead(); - Collection superResult = super.getDeclarationsByLabel(labelName); Map> labelsToDescriptors = getLabelsToDescriptors(); List declarationDescriptors = labelsToDescriptors.get(labelName); @@ -117,8 +108,6 @@ public class WritableScopeImpl extends WritableScopeWithImports { @Override public void addLabeledDeclaration(@NotNull DeclarationDescriptor descriptor) { - checkMayWrite(); - Map> labelsToDescriptors = getLabelsToDescriptors(); String name = descriptor.getName(); assert name != null; @@ -148,8 +137,6 @@ public class WritableScopeImpl extends WritableScopeWithImports { @Override public void addVariableDescriptor(@NotNull VariableDescriptor variableDescriptor) { - checkMayWrite(); - Map variableClassOrNamespaceDescriptors = getVariableClassOrNamespaceDescriptors(); DeclarationDescriptor existingDescriptor = variableClassOrNamespaceDescriptors.get(variableDescriptor.getName()); if (existingDescriptor != null) { @@ -162,8 +149,6 @@ public class WritableScopeImpl extends WritableScopeWithImports { @Override public VariableDescriptor getVariable(@NotNull String name) { - checkMayRead(); - Map variableClassOrNamespaceDescriptors = getVariableClassOrNamespaceDescriptors(); DeclarationDescriptor descriptor = variableClassOrNamespaceDescriptors.get(name); if (descriptor instanceof VariableDescriptor) { @@ -187,8 +172,6 @@ public class WritableScopeImpl extends WritableScopeWithImports { @Override public void addFunctionDescriptor(@NotNull FunctionDescriptor functionDescriptor) { - checkMayWrite(); - getFunctionGroups().put(functionDescriptor.getName(), functionDescriptor); allDescriptors.add(functionDescriptor); } @@ -196,8 +179,6 @@ public class WritableScopeImpl extends WritableScopeWithImports { @Override @NotNull public Set getFunctions(@NotNull String name) { - checkMayRead(); - Set result = Sets.newLinkedHashSet(getFunctionGroups().get(name)); result.addAll(getWorkerScope().getFunctions(name)); @@ -209,23 +190,17 @@ public class WritableScopeImpl extends WritableScopeWithImports { @Override public void addTypeParameterDescriptor(@NotNull TypeParameterDescriptor typeParameterDescriptor) { - checkMayWrite(); - String name = typeParameterDescriptor.getName(); addClassifierAlias(name, typeParameterDescriptor); } @Override public void addClassifierDescriptor(@NotNull ClassifierDescriptor classDescriptor) { - checkMayWrite(); - addClassifierAlias(classDescriptor.getName(), classDescriptor); } @Override public void addClassifierAlias(@NotNull String name, @NotNull ClassifierDescriptor classifierDescriptor) { - checkMayWrite(); - checkForRedeclaration(name, classifierDescriptor); getVariableClassOrNamespaceDescriptors().put(name, classifierDescriptor); allDescriptors.add(classifierDescriptor); @@ -233,8 +208,6 @@ public class WritableScopeImpl extends WritableScopeWithImports { @Override public void addNamespaceAlias(@NotNull String name, @NotNull NamespaceDescriptor namespaceDescriptor) { - checkMayWrite(); - checkForRedeclaration(name, namespaceDescriptor); getNamespaceAliases().put(name, namespaceDescriptor); allDescriptors.add(namespaceDescriptor); @@ -249,8 +222,6 @@ public class WritableScopeImpl extends WritableScopeWithImports { @Override public ClassifierDescriptor getClassifier(@NotNull String name) { - checkMayRead(); - Map variableClassOrNamespaceDescriptors = getVariableClassOrNamespaceDescriptors(); DeclarationDescriptor descriptor = variableClassOrNamespaceDescriptors.get(name); if (descriptor instanceof ClassifierDescriptor) return (ClassifierDescriptor) descriptor; @@ -263,8 +234,6 @@ public class WritableScopeImpl extends WritableScopeWithImports { @Override public void addNamespace(@NotNull NamespaceDescriptor namespaceDescriptor) { - checkMayWrite(); - Map variableClassOrNamespaceDescriptors = getVariableClassOrNamespaceDescriptors(); DeclarationDescriptor oldValue = variableClassOrNamespaceDescriptors.put(namespaceDescriptor.getName(), namespaceDescriptor); if (oldValue != null) { @@ -275,8 +244,6 @@ public class WritableScopeImpl extends WritableScopeWithImports { @Override public NamespaceDescriptor getDeclaredNamespace(@NotNull String name) { - checkMayRead(); - Map variableClassOrNamespaceDescriptors = getVariableClassOrNamespaceDescriptors(); DeclarationDescriptor namespaceDescriptor = variableClassOrNamespaceDescriptors.get(name); if (namespaceDescriptor instanceof NamespaceDescriptor) return (NamespaceDescriptor) namespaceDescriptor; @@ -285,8 +252,6 @@ public class WritableScopeImpl extends WritableScopeWithImports { @Override public NamespaceDescriptor getNamespace(@NotNull String name) { - checkMayRead(); - NamespaceDescriptor declaredNamespace = getDeclaredNamespace(name); if (declaredNamespace != null) return declaredNamespace; @@ -301,8 +266,6 @@ public class WritableScopeImpl extends WritableScopeWithImports { @NotNull @Override public ReceiverDescriptor getImplicitReceiver() { - checkMayRead(); - if (implicitReceiver == null) { return super.getImplicitReceiver(); } @@ -311,8 +274,6 @@ public class WritableScopeImpl extends WritableScopeWithImports { @Override public void setImplicitReceiver(@NotNull ReceiverDescriptor implicitReceiver) { - checkMayWrite(); - if (this.implicitReceiver != null) { throw new UnsupportedOperationException("Receiver redeclared"); } @@ -321,8 +282,6 @@ public class WritableScopeImpl extends WritableScopeWithImports { @Override public void getImplicitReceiversHierarchy(@NotNull List result) { - checkMayRead(); - if (implicitReceiver != null && implicitReceiver.exists()) { result.add(implicitReceiver); } @@ -344,8 +303,6 @@ public class WritableScopeImpl extends WritableScopeWithImports { throw new IllegalStateException(); } - checkMayWrite(); - getPropertyDescriptorsByFieldNames().put(fieldName, propertyDescriptor); } @@ -355,16 +312,12 @@ public class WritableScopeImpl extends WritableScopeWithImports { throw new IllegalStateException(); } - checkMayRead(); - PropertyDescriptor descriptor = getPropertyDescriptorsByFieldNames().get(fieldName); if (descriptor != null) return descriptor; return super.getPropertyByFieldReference(fieldName); } public List getDeclaredVariables() { - checkMayRead(); - List result = Lists.newArrayList(); for (DeclarationDescriptor descriptor : getVariableClassOrNamespaceDescriptors().values()) { if (descriptor instanceof VariableDescriptor) { @@ -381,8 +334,6 @@ public class WritableScopeImpl extends WritableScopeWithImports { @Override public WritableScopeImpl setDebugName(@NotNull String debugName) { - checkMayWrite(); - super.setDebugName(debugName); return this; } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/WritableScopeWithImports.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/WritableScopeWithImports.java index ecca869bd2c..97cdb1df602 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/WritableScopeWithImports.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/WritableScopeWithImports.java @@ -31,36 +31,7 @@ public abstract class WritableScopeWithImports extends JetScopeAdapter implement this.redeclarationHandler = redeclarationHandler; } - - - private LockLevel lockLevel = LockLevel.WRITING; - - @Override - public void changeLockLevel(LockLevel lockLevel) { - if (lockLevel.ordinal() < this.lockLevel.ordinal()) { - throw new IllegalStateException("cannot lower lock level from " + this.lockLevel + " to " + lockLevel); - } - this.lockLevel = lockLevel; - } - - protected void checkMayRead() { - if (lockLevel != LockLevel.READING && lockLevel != LockLevel.BOTH) { - throw new IllegalStateException("cannot read with lock level " + lockLevel); - } - } - - protected void checkMayWrite() { - if (lockLevel != LockLevel.WRITING && lockLevel != LockLevel.BOTH) { - throw new IllegalStateException("cannot write with lock level " + lockLevel); - } - } - - - - public WritableScopeWithImports setDebugName(@NotNull String debugName) { - checkMayWrite(); - assert this.debugName == null : this.debugName; this.debugName = debugName; return this; @@ -76,16 +47,12 @@ public abstract class WritableScopeWithImports extends JetScopeAdapter implement @Override public void importScope(@NotNull JetScope imported) { - checkMayWrite(); - getImports().add(0, imported); currentIndividualImportScope = null; } @Override public void getImplicitReceiversHierarchy(@NotNull List result) { - checkMayRead(); - super.getImplicitReceiversHierarchy(result); // Imported scopes come with their receivers // Example: class member resolution scope imports a scope of it's class object @@ -100,8 +67,6 @@ public abstract class WritableScopeWithImports extends JetScopeAdapter implement @Override public VariableDescriptor getVariable(@NotNull String name) { - checkMayRead(); - // Meaningful lookup goes here for (JetScope imported : getImports()) { VariableDescriptor importedDescriptor = imported.getVariable(name); @@ -115,8 +80,6 @@ public abstract class WritableScopeWithImports extends JetScopeAdapter implement @NotNull @Override public Set getFunctions(@NotNull String name) { - checkMayRead(); - if (getImports().isEmpty()) { return Collections.emptySet(); } @@ -129,8 +92,6 @@ public abstract class WritableScopeWithImports extends JetScopeAdapter implement @Override public ClassifierDescriptor getClassifier(@NotNull String name) { - checkMayRead(); - for (JetScope imported : getImports()) { ClassifierDescriptor importedClassifier = imported.getClassifier(name); if (importedClassifier != null) { @@ -142,8 +103,6 @@ public abstract class WritableScopeWithImports extends JetScopeAdapter implement @Override public NamespaceDescriptor getNamespace(@NotNull String name) { - checkMayRead(); - for (JetScope imported : getImports()) { NamespaceDescriptor importedDescriptor = imported.getNamespace(name); if (importedDescriptor != null) { @@ -156,7 +115,6 @@ public abstract class WritableScopeWithImports extends JetScopeAdapter implement private WritableScope getCurrentIndividualImportScope() { if (currentIndividualImportScope == null) { WritableScopeImpl writableScope = new WritableScopeImpl(EMPTY, getContainingDeclaration(), RedeclarationHandler.DO_NOTHING).setDebugName("Individual import scope"); - writableScope.changeLockLevel(LockLevel.BOTH); importScope(writableScope); currentIndividualImportScope = writableScope; } @@ -165,16 +123,12 @@ public abstract class WritableScopeWithImports extends JetScopeAdapter implement @Override public void importClassifierAlias(@NotNull String importedClassifierName, @NotNull ClassifierDescriptor classifierDescriptor) { - checkMayWrite(); - getCurrentIndividualImportScope().addClassifierAlias(importedClassifierName, classifierDescriptor); } @Override public void importNamespaceAlias(String aliasName, NamespaceDescriptor namespaceDescriptor) { - checkMayWrite(); - getCurrentIndividualImportScope().addNamespaceAlias(aliasName, namespaceDescriptor); } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/WriteThroughScope.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/WriteThroughScope.java index c00a3e04547..9c3a2abc7e6 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/WriteThroughScope.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/WriteThroughScope.java @@ -25,40 +25,30 @@ public class WriteThroughScope extends WritableScopeWithImports { @Override @Nullable public PropertyDescriptor getPropertyByFieldReference(@NotNull String fieldName) { - checkMayRead(); - return writableWorker.getPropertyByFieldReference(fieldName); } @Override @NotNull public Collection getDeclarationsByLabel(String labelName) { - checkMayRead(); - return writableWorker.getDeclarationsByLabel(labelName); } @Override @NotNull public DeclarationDescriptor getContainingDeclaration() { - checkMayRead(); - return writableWorker.getContainingDeclaration(); } @Override @NotNull public ReceiverDescriptor getImplicitReceiver() { - checkMayRead(); - return writableWorker.getImplicitReceiver(); } @Override @NotNull public Set getFunctions(@NotNull String name) { - checkMayRead(); - Set result = Sets.newLinkedHashSet(); result.addAll(writableWorker.getFunctions(name)); @@ -73,8 +63,6 @@ public class WriteThroughScope extends WritableScopeWithImports { @Override @Nullable public VariableDescriptor getVariable(@NotNull String name) { - checkMayRead(); - VariableDescriptor variable = writableWorker.getVariable(name); if (variable != null) return variable; @@ -87,8 +75,6 @@ public class WriteThroughScope extends WritableScopeWithImports { @Override @Nullable public NamespaceDescriptor getNamespace(@NotNull String name) { - checkMayRead(); - NamespaceDescriptor namespace = writableWorker.getNamespace(name); if (namespace != null) return namespace; @@ -101,8 +87,6 @@ public class WriteThroughScope extends WritableScopeWithImports { @Override @Nullable public ClassifierDescriptor getClassifier(@NotNull String name) { - checkMayRead(); - ClassifierDescriptor classifier = writableWorker.getClassifier(name); if (classifier != null) return classifier; @@ -114,94 +98,68 @@ public class WriteThroughScope extends WritableScopeWithImports { @Override public void addLabeledDeclaration(@NotNull DeclarationDescriptor descriptor) { - checkMayWrite(); - writableWorker.addLabeledDeclaration(descriptor); // TODO : review } @Override public void addVariableDescriptor(@NotNull VariableDescriptor variableDescriptor) { - checkMayWrite(); - writableWorker.addVariableDescriptor(variableDescriptor); } @Override public void addFunctionDescriptor(@NotNull FunctionDescriptor functionDescriptor) { - checkMayWrite(); - writableWorker.addFunctionDescriptor(functionDescriptor); } @Override public void addTypeParameterDescriptor(@NotNull TypeParameterDescriptor typeParameterDescriptor) { - checkMayWrite(); - writableWorker.addTypeParameterDescriptor(typeParameterDescriptor); } @Override public void addClassifierDescriptor(@NotNull ClassifierDescriptor classDescriptor) { - checkMayWrite(); - writableWorker.addClassifierDescriptor(classDescriptor); } @Override public void addClassifierAlias(@NotNull String name, @NotNull ClassifierDescriptor classifierDescriptor) { - checkMayWrite(); - writableWorker.addClassifierAlias(name, classifierDescriptor); } @Override public void addNamespaceAlias(@NotNull String name, @NotNull NamespaceDescriptor namespaceDescriptor) { - checkMayWrite(); - writableWorker.addNamespaceAlias(name, namespaceDescriptor); } @Override public void addNamespace(@NotNull NamespaceDescriptor namespaceDescriptor) { - checkMayWrite(); - writableWorker.addNamespace(namespaceDescriptor); } @Override @Nullable public NamespaceDescriptor getDeclaredNamespace(@NotNull String name) { - checkMayRead(); - return writableWorker.getDeclaredNamespace(name); } @Override public void addPropertyDescriptorByFieldName(@NotNull String fieldName, @NotNull PropertyDescriptor propertyDescriptor) { - checkMayWrite(); - writableWorker.addPropertyDescriptorByFieldName(fieldName, propertyDescriptor); } @Override public void importScope(@NotNull JetScope imported) { - checkMayWrite(); - super.importScope(imported); // } @Override public void setImplicitReceiver(@NotNull ReceiverDescriptor implicitReceiver) { - checkMayWrite(); - writableWorker.setImplicitReceiver(implicitReceiver); } @NotNull @Override public Collection getAllDescriptors() { - checkMayRead(); - if (allDescriptors == null) { allDescriptors = Lists.newArrayList(); allDescriptors.addAll(writableWorker.getAllDescriptors()); @@ -212,8 +170,6 @@ public class WriteThroughScope extends WritableScopeWithImports { @NotNull public JetScope getOuterScope() { - checkMayRead(); - return getWorkerScope(); } } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/types/JetStandardClasses.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/JetStandardClasses.java index a6e120b1e8d..55908afd1b6 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/types/JetStandardClasses.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/JetStandardClasses.java @@ -194,8 +194,6 @@ public class JetStandardClasses { static { WritableScope writableScope = new WritableScopeImpl(JetScope.EMPTY, STANDARD_CLASSES_NAMESPACE, RedeclarationHandler.DO_NOTHING).setDebugName("JetStandardClasses.STANDARD_CLASSES"); - writableScope.changeLockLevel(WritableScope.LockLevel.BOTH); - STANDARD_CLASSES = writableScope; writableScope.addClassifierAlias("Unit", getTuple(0)); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/types/JetStandardLibrary.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/JetStandardLibrary.java index 0b99cbe5f69..c095764a3ab 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/types/JetStandardLibrary.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/JetStandardLibrary.java @@ -13,7 +13,6 @@ import org.jetbrains.jet.lang.psi.JetFile; import org.jetbrains.jet.lang.resolve.*; import org.jetbrains.jet.lang.resolve.scopes.JetScope; import org.jetbrains.jet.lang.resolve.scopes.RedeclarationHandler; -import org.jetbrains.jet.lang.resolve.scopes.WritableScope; import org.jetbrains.jet.lang.resolve.scopes.WritableScopeImpl; import org.jetbrains.jet.plugin.JetFileType; @@ -134,7 +133,6 @@ public class JetStandardLibrary { JetSemanticServices bootstrappingSemanticServices = JetSemanticServices.createSemanticServices(this); BindingTraceContext bindingTraceContext = new BindingTraceContext(); WritableScopeImpl writableScope = new WritableScopeImpl(JetStandardClasses.STANDARD_CLASSES, JetStandardClasses.STANDARD_CLASSES_NAMESPACE, RedeclarationHandler.THROW_EXCEPTION).setDebugName("Root bootstrap scope"); - writableScope.changeLockLevel(WritableScope.LockLevel.BOTH); // this.libraryScope = bootstrappingTDA.process(JetStandardClasses.STANDARD_CLASSES, file.getRootNamespace().getDeclarations()); // bootstrappingTDA.process(writableScope, JetStandardClasses.STANDARD_CLASSES_NAMESPACE, file.getRootNamespace().getDeclarations()); TopDownAnalyzer.processStandardLibraryNamespace(bootstrappingSemanticServices, bindingTraceContext, writableScope, JetStandardClasses.STANDARD_CLASSES_NAMESPACE, file.getRootNamespace()); 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 a6be38a744c..db493f27c06 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 @@ -140,7 +140,6 @@ public class ExpressionTypingServices { DeclarationDescriptor containingDescriptor = outerScope.getContainingDeclaration(); WritableScope scope = new WritableScopeImpl(outerScope, containingDescriptor, new TraceBasedRedeclarationHandler(context.trace)).setDebugName("getBlockReturnedType"); - scope.changeLockLevel(WritableScope.LockLevel.BOTH); return getBlockReturnedTypeWithWritableScope(scope, block, coercionStrategyForLastExpression, context); } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingUtils.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingUtils.java index 368b8e912b3..f9cdac37fcb 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingUtils.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingUtils.java @@ -13,7 +13,6 @@ import org.jetbrains.jet.lang.psi.JetExpression; import org.jetbrains.jet.lang.psi.JetSimpleNameExpression; import org.jetbrains.jet.lang.resolve.BindingContextUtils; import org.jetbrains.jet.lang.resolve.TraceBasedRedeclarationHandler; -import org.jetbrains.jet.lang.resolve.scopes.WritableScope; import org.jetbrains.jet.lang.resolve.scopes.WritableScopeImpl; import org.jetbrains.jet.lang.resolve.scopes.receivers.ExpressionReceiver; import org.jetbrains.jet.lang.types.JetStandardClasses; @@ -43,9 +42,7 @@ public class ExpressionTypingUtils { @NotNull public static WritableScopeImpl newWritableScopeImpl(ExpressionTypingContext context) { - WritableScopeImpl scope = new WritableScopeImpl(context.scope, context.scope.getContainingDeclaration(), new TraceBasedRedeclarationHandler(context.trace)); - scope.changeLockLevel(WritableScope.LockLevel.BOTH); - return scope; + return new WritableScopeImpl(context.scope, context.scope.getContainingDeclaration(), new TraceBasedRedeclarationHandler(context.trace)); } public static boolean isBoolean(@NotNull JetSemanticServices semanticServices, @NotNull JetType type) { diff --git a/compiler/tests/org/jetbrains/jet/types/JetDefaultModalityModifiersTest.java b/compiler/tests/org/jetbrains/jet/types/JetDefaultModalityModifiersTest.java index ea1f05d8935..fb9556a89c3 100644 --- a/compiler/tests/org/jetbrains/jet/types/JetDefaultModalityModifiersTest.java +++ b/compiler/tests/org/jetbrains/jet/types/JetDefaultModalityModifiersTest.java @@ -10,7 +10,6 @@ import org.jetbrains.jet.lang.resolve.DescriptorResolver; import org.jetbrains.jet.lang.resolve.java.AnalyzerFacade; import org.jetbrains.jet.lang.resolve.scopes.JetScope; import org.jetbrains.jet.lang.resolve.scopes.RedeclarationHandler; -import org.jetbrains.jet.lang.resolve.scopes.WritableScope; import org.jetbrains.jet.lang.resolve.scopes.WritableScopeImpl; import org.jetbrains.jet.lang.types.JetStandardLibrary; @@ -50,7 +49,6 @@ public class JetDefaultModalityModifiersTest extends JetLiteFixture { WritableScopeImpl scope = new WritableScopeImpl(libraryScope, root, RedeclarationHandler.DO_NOTHING); assert classDescriptor instanceof ClassifierDescriptor; scope.addClassifierDescriptor((ClassifierDescriptor) classDescriptor); - scope.changeLockLevel(WritableScope.LockLevel.READING); return scope; } diff --git a/compiler/tests/org/jetbrains/jet/types/JetTypeCheckerTest.java b/compiler/tests/org/jetbrains/jet/types/JetTypeCheckerTest.java index e765cef474a..1ead89fcde2 100644 --- a/compiler/tests/org/jetbrains/jet/types/JetTypeCheckerTest.java +++ b/compiler/tests/org/jetbrains/jet/types/JetTypeCheckerTest.java @@ -545,7 +545,6 @@ public class JetTypeCheckerTest extends JetLiteFixture { JavaSemanticServices javaSemanticServices = new JavaSemanticServices(getProject(), semanticServices, JetTestUtils.DUMMY_TRACE); writableScope.importScope(new JavaPackageScope("", null, javaSemanticServices)); writableScope.importScope(new JavaPackageScope("java.lang", null, javaSemanticServices)); - writableScope.changeLockLevel(WritableScope.LockLevel.BOTH); return writableScope; } @@ -642,7 +641,6 @@ public class JetTypeCheckerTest extends JetLiteFixture { trace.record(BindingContext.CLASS, classElement, classDescriptor); final WritableScope parameterScope = new WritableScopeImpl(scope, classDescriptor, new TraceBasedRedeclarationHandler(trace)); - parameterScope.changeLockLevel(WritableScope.LockLevel.BOTH); // This call has side-effects on the parameterScope (fills it in) List typeParameters @@ -662,7 +660,6 @@ public class JetTypeCheckerTest extends JetLiteFixture { boolean open = classElement.hasModifier(JetTokens.OPEN_KEYWORD); final WritableScope memberDeclarations = new WritableScopeImpl(JetScope.EMPTY, classDescriptor, new TraceBasedRedeclarationHandler(trace)); - memberDeclarations.changeLockLevel(WritableScope.LockLevel.BOTH); List declarations = classElement.getDeclarations(); for (JetDeclaration declaration : declarations) {