From 54ee7456ce34acfeb2ad15b7d7bda5560ee1616c Mon Sep 17 00:00:00 2001 From: Alexander Udalov Date: Wed, 11 Sep 2013 17:51:49 +0200 Subject: [PATCH] Extract LazyResolveStorageManager interface StorageManager will be available at runtime, thus it can't depend on BindingTrace --- .../resolve/java/AnalyzerFacadeForJVM.java | 4 +- .../jet/lang/resolve/lazy/ResolveSession.java | 12 +- .../storage/LazyResolveStorageManager.java | 25 ++++ .../LockBasedLazyResolveStorageManager.java | 136 ++++++++++++++++++ .../lazy/storage/LockBasedStorageManager.java | 116 +-------------- .../resolve/lazy/storage/StorageManager.java | 4 - ...ractLazyResolveDescriptorRendererTest.java | 4 +- .../resolve/lazy/LazyResolveTestUtil.java | 4 +- .../libraries/JetSourceNavigationHelper.java | 4 +- .../k2js/analyze/AnalyzerFacadeForJS.java | 4 +- 10 files changed, 178 insertions(+), 135 deletions(-) create mode 100644 compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/storage/LazyResolveStorageManager.java create mode 100644 compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/storage/LockBasedLazyResolveStorageManager.java diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/AnalyzerFacadeForJVM.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/AnalyzerFacadeForJVM.java index a05d0f6ec78..6b9e19eefc9 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/AnalyzerFacadeForJVM.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/AnalyzerFacadeForJVM.java @@ -35,7 +35,7 @@ import org.jetbrains.jet.lang.resolve.*; import org.jetbrains.jet.lang.resolve.java.mapping.JavaToKotlinClassMap; import org.jetbrains.jet.lang.resolve.lazy.ResolveSession; import org.jetbrains.jet.lang.resolve.lazy.declarations.FileBasedDeclarationProviderFactory; -import org.jetbrains.jet.lang.resolve.lazy.storage.LockBasedStorageManager; +import org.jetbrains.jet.lang.resolve.lazy.storage.LockBasedLazyResolveStorageManager; import org.jetbrains.jet.lang.resolve.name.FqName; import org.jetbrains.jet.lang.resolve.name.Name; import org.jetbrains.jet.lang.resolve.scopes.JetScope; @@ -85,7 +85,7 @@ public enum AnalyzerFacadeForJVM implements AnalyzerFacade { final PsiClassFinder psiClassFinder = injector.getPsiClassFinder(); // TODO: Replace with stub declaration provider - LockBasedStorageManager storageManager = new LockBasedStorageManager(); + LockBasedLazyResolveStorageManager storageManager = new LockBasedLazyResolveStorageManager(); FileBasedDeclarationProviderFactory declarationProviderFactory = new FileBasedDeclarationProviderFactory(storageManager, files, new Predicate() { @Override public boolean apply(FqName fqName) { diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/ResolveSession.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/ResolveSession.java index 44a4e4c1823..9ac7bdd145f 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/ResolveSession.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/ResolveSession.java @@ -38,7 +38,7 @@ import org.jetbrains.jet.lang.resolve.lazy.declarations.DeclarationProviderFacto import org.jetbrains.jet.lang.resolve.lazy.declarations.PackageMemberDeclarationProvider; import org.jetbrains.jet.lang.resolve.lazy.descriptors.LazyClassDescriptor; import org.jetbrains.jet.lang.resolve.lazy.descriptors.LazyPackageDescriptor; -import org.jetbrains.jet.lang.resolve.lazy.storage.StorageManager; +import org.jetbrains.jet.lang.resolve.lazy.storage.LazyResolveStorageManager; import org.jetbrains.jet.lang.resolve.name.FqName; import org.jetbrains.jet.lang.resolve.name.FqNameUnsafe; import org.jetbrains.jet.lang.resolve.name.Name; @@ -57,7 +57,7 @@ public class ResolveSession implements KotlinCodeAnalyzer { } }; - private final StorageManager storageManager; + private final LazyResolveStorageManager storageManager; private final ModuleDescriptor module; private final LazyPackageDescriptor rootPackage; @@ -74,7 +74,7 @@ public class ResolveSession implements KotlinCodeAnalyzer { public ResolveSession( @NotNull Project project, - @NotNull StorageManager storageManager, + @NotNull LazyResolveStorageManager storageManager, @NotNull ModuleDescriptorImpl rootDescriptor, @NotNull DeclarationProviderFactory declarationProviderFactory ) { @@ -85,7 +85,7 @@ public class ResolveSession implements KotlinCodeAnalyzer { public ResolveSession( @NotNull Project project, - @NotNull StorageManager storageManager, + @NotNull LazyResolveStorageManager storageManager, @NotNull ModuleDescriptorImpl rootDescriptor, @NotNull DeclarationProviderFactory declarationProviderFactory, @NotNull BindingTrace delegationTrace @@ -102,7 +102,7 @@ public class ResolveSession implements KotlinCodeAnalyzer { @Deprecated // Internal use only public ResolveSession( @NotNull Project project, - @NotNull StorageManager storageManager, + @NotNull LazyResolveStorageManager storageManager, @NotNull ModuleDescriptorImpl rootDescriptor, @NotNull DeclarationProviderFactory declarationProviderFactory, @NotNull Function classifierAliases, @@ -138,7 +138,7 @@ public class ResolveSession implements KotlinCodeAnalyzer { } @NotNull - public StorageManager getStorageManager() { + public LazyResolveStorageManager getStorageManager() { return storageManager; } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/storage/LazyResolveStorageManager.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/storage/LazyResolveStorageManager.java new file mode 100644 index 00000000000..40107618519 --- /dev/null +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/storage/LazyResolveStorageManager.java @@ -0,0 +1,25 @@ +/* + * 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.lazy.storage; + +import org.jetbrains.annotations.NotNull; +import org.jetbrains.jet.lang.resolve.BindingTrace; + +public interface LazyResolveStorageManager extends StorageManager { + @NotNull + BindingTrace createSafeTrace(@NotNull BindingTrace originalTrace); +} diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/storage/LockBasedLazyResolveStorageManager.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/storage/LockBasedLazyResolveStorageManager.java new file mode 100644 index 00000000000..1c4a8b6e582 --- /dev/null +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/storage/LockBasedLazyResolveStorageManager.java @@ -0,0 +1,136 @@ +/* + * 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.lazy.storage; + +import com.google.common.collect.ImmutableMap; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; +import org.jetbrains.annotations.TestOnly; +import org.jetbrains.jet.lang.diagnostics.Diagnostic; +import org.jetbrains.jet.lang.resolve.BindingContext; +import org.jetbrains.jet.lang.resolve.BindingTrace; +import org.jetbrains.jet.util.slicedmap.ReadOnlySlice; +import org.jetbrains.jet.util.slicedmap.WritableSlice; + +import java.util.Collection; + +public class LockBasedLazyResolveStorageManager extends LockBasedStorageManager implements LazyResolveStorageManager { + @NotNull + @Override + public BindingTrace createSafeTrace(@NotNull BindingTrace originalTrace) { + // It seems safe to have a separate lock for traces: + // no other locks will be acquired inside the trace operations + return new LockProtectedTrace(lock, originalTrace); + } + + private static class LockProtectedContext implements BindingContext { + private final Object lock; + private final BindingContext context; + + private LockProtectedContext(Object lock, BindingContext context) { + this.lock = lock; + this.context = context; + } + + @NotNull + @Override + public Collection getDiagnostics() { + synchronized (lock) { + return context.getDiagnostics(); + } + } + + @Nullable + @Override + public V get(ReadOnlySlice slice, K key) { + synchronized (lock) { + return context.get(slice, key); + } + } + + @NotNull + @Override + public Collection getKeys(WritableSlice slice) { + synchronized (lock) { + return context.getKeys(slice); + } + } + + @NotNull + @Override + @TestOnly + public ImmutableMap getSliceContents(@NotNull ReadOnlySlice slice) { + synchronized (lock) { + return context.getSliceContents(slice); + } + } + } + + private static class LockProtectedTrace implements BindingTrace { + private final Object lock; + private final BindingTrace trace; + private final BindingContext context; + + public LockProtectedTrace(@NotNull Object lock, @NotNull BindingTrace trace) { + this.lock = lock; + this.trace = trace; + this.context = new LockProtectedContext(lock, trace.getBindingContext()); + } + + @Override + public BindingContext getBindingContext() { + return context; + } + + @Override + public void record(WritableSlice slice, K key, V value) { + synchronized (lock) { + trace.record(slice, key, value); + } + } + + @Override + public void record(WritableSlice slice, K key) { + synchronized (lock) { + trace.record(slice, key); + } + } + + @Override + @Nullable + public V get(ReadOnlySlice slice, K key) { + synchronized (lock) { + return trace.get(slice, key); + } + } + + @Override + @NotNull + public Collection getKeys(WritableSlice slice) { + synchronized (lock) { + return trace.getKeys(slice); + } + } + + @Override + public void report(@NotNull Diagnostic diagnostic) { + synchronized (lock) { + trace.report(diagnostic); + } + } + } +} diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/storage/LockBasedStorageManager.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/storage/LockBasedStorageManager.java index df402ffadca..bfc5ee12506 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/storage/LockBasedStorageManager.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/storage/LockBasedStorageManager.java @@ -16,29 +16,21 @@ package org.jetbrains.jet.lang.resolve.lazy.storage; -import com.google.common.collect.ImmutableMap; import com.intellij.openapi.util.Computable; import com.intellij.util.Consumer; import com.intellij.util.Function; import com.intellij.util.containers.ConcurrentWeakValueHashMap; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; -import org.jetbrains.annotations.TestOnly; -import org.jetbrains.jet.lang.diagnostics.Diagnostic; -import org.jetbrains.jet.lang.resolve.BindingContext; -import org.jetbrains.jet.lang.resolve.BindingTrace; -import org.jetbrains.jet.util.slicedmap.ReadOnlySlice; -import org.jetbrains.jet.util.slicedmap.WritableSlice; import org.jetbrains.jet.utils.ExceptionUtils; import org.jetbrains.jet.utils.WrappedValues; -import java.util.Collection; import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.ConcurrentMap; public class LockBasedStorageManager implements StorageManager { - private final Object lock = new Object() { + protected final Object lock = new Object() { @Override public String toString() { return "LockBasedStorageManager centralized lock"; @@ -103,14 +95,6 @@ public class LockBasedStorageManager implements StorageManager { }; } - @NotNull - @Override - public BindingTrace createSafeTrace(@NotNull BindingTrace originalTrace) { - // It seems safe to have a separate lock for traces: - // no other locks will be acquired inside the trace operations - return new LockProtectedTrace(lock, originalTrace); - } - @Override public T compute(@NotNull Computable computable) { synchronized (lock) { @@ -228,102 +212,4 @@ public class LockBasedStorageManager implements StorageManager { return result; } } - - private static class LockProtectedContext implements BindingContext { - private final Object lock; - private final BindingContext context; - - private LockProtectedContext(Object lock, BindingContext context) { - this.lock = lock; - this.context = context; - } - - @NotNull - @Override - public Collection getDiagnostics() { - synchronized (lock) { - return context.getDiagnostics(); - } - } - - @Nullable - @Override - public V get(ReadOnlySlice slice, K key) { - synchronized (lock) { - return context.get(slice, key); - } - } - - @NotNull - @Override - public Collection getKeys(WritableSlice slice) { - synchronized (lock) { - return context.getKeys(slice); - } - } - - @NotNull - @Override - @TestOnly - public ImmutableMap getSliceContents(@NotNull ReadOnlySlice slice) { - synchronized (lock) { - return context.getSliceContents(slice); - } - } - } - - private static class LockProtectedTrace implements BindingTrace { - private final Object lock; - private final BindingTrace trace; - private final BindingContext context; - - public LockProtectedTrace(@NotNull Object lock, @NotNull BindingTrace trace) { - this.lock = lock; - this.trace = trace; - this.context = new LockProtectedContext(lock, trace.getBindingContext()); - } - - @Override - public BindingContext getBindingContext() { - return context; - } - - @Override - public void record(WritableSlice slice, K key, V value) { - synchronized (lock) { - trace.record(slice, key, value); - } - } - - @Override - public void record(WritableSlice slice, K key) { - synchronized (lock) { - trace.record(slice, key); - } - } - - @Override - @Nullable - public V get(ReadOnlySlice slice, K key) { - synchronized (lock) { - return trace.get(slice, key); - } - } - - @Override - @NotNull - public Collection getKeys(WritableSlice slice) { - synchronized (lock) { - return trace.getKeys(slice); - } - } - - @Override - public void report(@NotNull Diagnostic diagnostic) { - synchronized (lock) { - trace.report(diagnostic); - } - } - } - } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/storage/StorageManager.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/storage/StorageManager.java index e17d0f86727..2314cc14d77 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/storage/StorageManager.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/storage/StorageManager.java @@ -20,7 +20,6 @@ import com.intellij.openapi.util.Computable; import com.intellij.util.Consumer; import com.intellij.util.Function; import org.jetbrains.annotations.NotNull; -import org.jetbrains.jet.lang.resolve.BindingTrace; public interface StorageManager { /** @@ -56,9 +55,6 @@ public interface StorageManager { @NotNull NullableLazyValue createNullableLazyValueWithPostCompute(@NotNull Computable computable, @NotNull Consumer postCompute); - @NotNull - BindingTrace createSafeTrace(@NotNull BindingTrace originalTrace); - T compute(@NotNull Computable computable); enum ReferenceKind { diff --git a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveDescriptorRendererTest.java b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveDescriptorRendererTest.java index 38e498dbb58..33cf5be9695 100644 --- a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveDescriptorRendererTest.java +++ b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveDescriptorRendererTest.java @@ -30,7 +30,7 @@ import org.jetbrains.jet.lang.descriptors.*; import org.jetbrains.jet.lang.psi.*; import org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM; import org.jetbrains.jet.lang.resolve.lazy.declarations.FileBasedDeclarationProviderFactory; -import org.jetbrains.jet.lang.resolve.lazy.storage.LockBasedStorageManager; +import org.jetbrains.jet.lang.resolve.lazy.storage.LockBasedLazyResolveStorageManager; import org.jetbrains.jet.lang.resolve.name.FqName; import org.jetbrains.jet.renderer.DescriptorRenderer; @@ -56,7 +56,7 @@ public abstract class AbstractLazyResolveDescriptorRendererTest extends KotlinTe ModuleDescriptorImpl lazyModule = AnalyzerFacadeForJVM.createJavaModule(""); lazyModule.setModuleConfiguration(injectorForTopDownAnalyzer.getModuleDescriptor().getModuleConfiguration()); - LockBasedStorageManager storageManager = new LockBasedStorageManager(); + LockBasedLazyResolveStorageManager storageManager = new LockBasedLazyResolveStorageManager(); final ResolveSession resolveSession = new ResolveSession(getProject(), storageManager, lazyModule, new FileBasedDeclarationProviderFactory(storageManager, files)); diff --git a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveTestUtil.java b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveTestUtil.java index 1bb7f7e62f1..73beb9b9f4b 100644 --- a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveTestUtil.java +++ b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveTestUtil.java @@ -44,7 +44,7 @@ import org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM; import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver; import org.jetbrains.jet.lang.resolve.java.PsiClassFinder; import org.jetbrains.jet.lang.resolve.lazy.declarations.FileBasedDeclarationProviderFactory; -import org.jetbrains.jet.lang.resolve.lazy.storage.LockBasedStorageManager; +import org.jetbrains.jet.lang.resolve.lazy.storage.LockBasedLazyResolveStorageManager; import org.jetbrains.jet.lang.resolve.name.FqName; import org.jetbrains.jet.lang.resolve.name.Name; import org.jetbrains.jet.lang.resolve.scopes.JetScope; @@ -96,7 +96,7 @@ public class LazyResolveTestUtil { final PsiClassFinder psiClassFinder = injector.getPsiClassFinder(); final JavaDescriptorResolver javaDescriptorResolver = injector.getJavaDescriptorResolver(); - LockBasedStorageManager storageManager = new LockBasedStorageManager(); + LockBasedLazyResolveStorageManager storageManager = new LockBasedLazyResolveStorageManager(); FileBasedDeclarationProviderFactory declarationProviderFactory = new FileBasedDeclarationProviderFactory(storageManager, files, new Predicate() { @Override public boolean apply(FqName fqName) { diff --git a/idea/src/org/jetbrains/jet/plugin/libraries/JetSourceNavigationHelper.java b/idea/src/org/jetbrains/jet/plugin/libraries/JetSourceNavigationHelper.java index 4a85b43d1af..68ff22af747 100644 --- a/idea/src/org/jetbrains/jet/plugin/libraries/JetSourceNavigationHelper.java +++ b/idea/src/org/jetbrains/jet/plugin/libraries/JetSourceNavigationHelper.java @@ -55,7 +55,7 @@ import org.jetbrains.jet.lang.resolve.java.mapping.KotlinToJavaTypesMap; import org.jetbrains.jet.lang.resolve.lazy.KotlinCodeAnalyzer; import org.jetbrains.jet.lang.resolve.lazy.ResolveSession; import org.jetbrains.jet.lang.resolve.lazy.declarations.FileBasedDeclarationProviderFactory; -import org.jetbrains.jet.lang.resolve.lazy.storage.LockBasedStorageManager; +import org.jetbrains.jet.lang.resolve.lazy.storage.LockBasedLazyResolveStorageManager; import org.jetbrains.jet.lang.resolve.name.FqName; import org.jetbrains.jet.lang.resolve.name.Name; import org.jetbrains.jet.lang.types.TypeUtils; @@ -214,7 +214,7 @@ public class JetSourceNavigationHelper { } Project project = decompiledDeclaration.getProject(); - LockBasedStorageManager storageManager = new LockBasedStorageManager(); + LockBasedLazyResolveStorageManager storageManager = new LockBasedLazyResolveStorageManager(); FileBasedDeclarationProviderFactory providerFactory = new FileBasedDeclarationProviderFactory(storageManager, getContainingFiles(candidates), new Predicate() { @Override diff --git a/js/js.translator/src/org/jetbrains/k2js/analyze/AnalyzerFacadeForJS.java b/js/js.translator/src/org/jetbrains/k2js/analyze/AnalyzerFacadeForJS.java index 295203e5d01..d6f14dfcf1a 100644 --- a/js/js.translator/src/org/jetbrains/k2js/analyze/AnalyzerFacadeForJS.java +++ b/js/js.translator/src/org/jetbrains/k2js/analyze/AnalyzerFacadeForJS.java @@ -32,7 +32,7 @@ import org.jetbrains.jet.lang.psi.JetFile; import org.jetbrains.jet.lang.resolve.*; import org.jetbrains.jet.lang.resolve.lazy.ResolveSession; import org.jetbrains.jet.lang.resolve.lazy.declarations.FileBasedDeclarationProviderFactory; -import org.jetbrains.jet.lang.resolve.lazy.storage.LockBasedStorageManager; +import org.jetbrains.jet.lang.resolve.lazy.storage.LockBasedLazyResolveStorageManager; import org.jetbrains.jet.lang.resolve.name.FqName; import org.jetbrains.jet.lang.resolve.name.Name; import org.jetbrains.k2js.config.Config; @@ -140,7 +140,7 @@ public final class AnalyzerFacadeForJS { @NotNull public static ResolveSession getLazyResolveSession(Collection files, Config config) { - LockBasedStorageManager storageManager = new LockBasedStorageManager(); + LockBasedLazyResolveStorageManager storageManager = new LockBasedLazyResolveStorageManager(); FileBasedDeclarationProviderFactory declarationProviderFactory = new FileBasedDeclarationProviderFactory( storageManager, Config.withJsLibAdded(files, config), Predicates.alwaysFalse()); ModuleDescriptorImpl lazyModule = createJsModule("");