From 239ca9728dcc04f7c5c3f5ec598ae31344c1be00 Mon Sep 17 00:00:00 2001 From: Andrey Breslav Date: Fri, 4 Oct 2013 19:52:17 +0400 Subject: [PATCH] StorageManager API does not use Computable and Function and more --- .../AbstractDescriptorFinder.java | 6 +- .../serialization/TypeDeserializer.java | 22 ++--- .../DeserializedClassDescriptor.java | 32 +++---- .../descriptors/DeserializedMemberScope.java | 26 +++--- .../jet/lang/resolve/DescriptorResolver.java | 21 ++--- .../jet/lang/resolve/TypeResolver.java | 6 +- .../lang/resolve/lazy/ImportsProvider.java | 8 +- .../lang/resolve/lazy/LazyImportScope.java | 26 +++--- .../jet/lang/resolve/lazy/ResolveSession.java | 6 +- .../jet/lang/resolve/lazy/ScopeProvider.java | 16 ++-- .../lazy/data/FilteringClassLikeInfo.java | 8 +- .../AbstractPsiBasedDeclarationProvider.java | 8 +- .../FileBasedDeclarationProviderFactory.java | 13 +-- ...BasedPackageMemberDeclarationProvider.java | 10 +-- .../descriptors/AbstractLazyMemberScope.java | 29 +++--- .../lazy/descriptors/LazyClassDescriptor.java | 46 +++++----- .../descriptors/LazyClassMemberScope.java | 10 +-- .../descriptors/LazyPackageMemberScope.java | 10 +-- .../jet/lang/types/DeferredType.java | 4 +- .../ClosureExpressionsTypingVisitor.java | 6 +- .../jet/storage/StorageManagerTest.java | 90 ++++++++++--------- .../AnnotationDescriptorDeserializer.java | 6 +- .../AbstractLazyTypeParameterDescriptor.java | 22 ++--- .../impl/TypeParameterDescriptorImpl.java | 6 +- .../lang/BuiltinsNamespaceDescriptorImpl.java | 10 +-- .../jet/storage/LockBasedStorageManager.java | 51 ++++++----- .../jetbrains/jet/storage/StorageManager.java | 29 +++--- .../jetbrains/jet/storage/StorageUtil.java | 21 +++-- .../plugin/project/ResolveElementCache.java | 5 +- 29 files changed, 284 insertions(+), 269 deletions(-) diff --git a/compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/AbstractDescriptorFinder.java b/compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/AbstractDescriptorFinder.java index 55d6cbf800d..3ba23c787e7 100644 --- a/compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/AbstractDescriptorFinder.java +++ b/compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/AbstractDescriptorFinder.java @@ -16,7 +16,7 @@ package org.jetbrains.jet.descriptors.serialization; -import com.intellij.util.Function; +import jet.Function1; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.descriptors.serialization.descriptors.AnnotationDeserializer; @@ -38,9 +38,9 @@ public abstract class AbstractDescriptorFinder implements DescriptorFinder { ) { this.annotationDeserializer = annotationDeserializer; - this.findClass = storageManager.createMemoizedFunctionWithNullableValues(new Function() { + this.findClass = storageManager.createMemoizedFunctionWithNullableValues(new Function1() { @Override - public ClassDescriptor fun(ClassId classId) { + public ClassDescriptor invoke(ClassId classId) { ClassData classData = getClassData(classId); if (classData == null) { return null; diff --git a/compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/TypeDeserializer.java b/compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/TypeDeserializer.java index e6adcdd8f24..469ceef1f4e 100644 --- a/compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/TypeDeserializer.java +++ b/compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/TypeDeserializer.java @@ -16,9 +16,9 @@ package org.jetbrains.jet.descriptors.serialization; -import com.intellij.openapi.util.Computable; -import com.intellij.util.Function; import gnu.trove.TIntObjectHashMap; +import jet.Function0; +import jet.Function1; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.descriptors.serialization.descriptors.DeserializedTypeParameterDescriptor; @@ -26,12 +26,12 @@ import org.jetbrains.jet.lang.descriptors.ClassDescriptor; import org.jetbrains.jet.lang.descriptors.ClassifierDescriptor; import org.jetbrains.jet.lang.descriptors.TypeParameterDescriptor; import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor; -import org.jetbrains.jet.storage.MemoizedFunctionToNullable; -import org.jetbrains.jet.storage.NotNullLazyValue; -import org.jetbrains.jet.storage.StorageManager; import org.jetbrains.jet.lang.resolve.scopes.JetScope; import org.jetbrains.jet.lang.types.*; import org.jetbrains.jet.lang.types.checker.JetTypeChecker; +import org.jetbrains.jet.storage.MemoizedFunctionToNullable; +import org.jetbrains.jet.storage.NotNullLazyValue; +import org.jetbrains.jet.storage.StorageManager; import java.util.ArrayList; import java.util.Collections; @@ -94,9 +94,9 @@ public class TypeDeserializer { typeParameterDescriptors.put(typeParameterDescriptor.getProtoId(), typeParameterDescriptor); } - this.classDescriptors = storageManager.createMemoizedFunctionWithNullableValues(new Function() { + this.classDescriptors = storageManager.createMemoizedFunctionWithNullableValues(new Function1() { @Override - public ClassDescriptor fun(Integer fqNameIndex) { + public ClassDescriptor invoke(Integer fqNameIndex) { return computeClassDescriptor(fqNameIndex); } }, STRONG); @@ -210,15 +210,15 @@ public class TypeDeserializer { this.typeProto = proto; this.arguments = typeArguments(proto.getArgumentList()); - this.constructor = storageManager.createLazyValue(new Computable() { + this.constructor = storageManager.createLazyValue(new Function0() { @Override - public TypeConstructor compute() { + public TypeConstructor invoke() { return typeConstructor(typeProto); } }); - this.memberScope = storageManager.createLazyValue(new Computable() { + this.memberScope = storageManager.createLazyValue(new Function0() { @Override - public JetScope compute() { + public JetScope invoke() { return computeMemberScope(); } }); diff --git a/compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/DeserializedClassDescriptor.java b/compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/DeserializedClassDescriptor.java index 1ada386a2ab..913d5e4e5ea 100644 --- a/compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/DeserializedClassDescriptor.java +++ b/compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/DeserializedClassDescriptor.java @@ -16,8 +16,8 @@ package org.jetbrains.jet.descriptors.serialization.descriptors; -import com.intellij.openapi.util.Computable; -import com.intellij.util.Function; +import jet.Function0; +import jet.Function1; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.descriptors.serialization.*; @@ -26,10 +26,6 @@ import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor; import org.jetbrains.jet.lang.descriptors.impl.*; import org.jetbrains.jet.lang.resolve.DescriptorFactory; import org.jetbrains.jet.lang.resolve.OverridingUtil; -import org.jetbrains.jet.storage.MemoizedFunctionToNullable; -import org.jetbrains.jet.storage.NotNullLazyValue; -import org.jetbrains.jet.storage.NullableLazyValue; -import org.jetbrains.jet.storage.StorageManager; import org.jetbrains.jet.lang.resolve.name.Name; import org.jetbrains.jet.lang.resolve.scopes.InnerClassesScopeWrapper; import org.jetbrains.jet.lang.resolve.scopes.JetScope; @@ -39,6 +35,10 @@ import org.jetbrains.jet.lang.types.ErrorUtils; import org.jetbrains.jet.lang.types.JetType; import org.jetbrains.jet.lang.types.TypeConstructor; import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; +import org.jetbrains.jet.storage.MemoizedFunctionToNullable; +import org.jetbrains.jet.storage.NotNullLazyValue; +import org.jetbrains.jet.storage.NullableLazyValue; +import org.jetbrains.jet.storage.StorageManager; import java.util.*; @@ -96,9 +96,9 @@ public class DeserializedClassDescriptor extends AbstractClassDescriptor impleme this.deserializer = outerDeserializer.createChildDeserializer(this, classProto.getTypeParameterList(), typeParameters); this.typeDeserializer = deserializer.getTypeDeserializer(); - this.containingDeclaration = storageManager.createLazyValue(new Computable() { + this.containingDeclaration = storageManager.createLazyValue(new Function0() { @Override - public DeclarationDescriptor compute() { + public DeclarationDescriptor invoke() { return computeContainingDeclaration(); } }); @@ -115,23 +115,23 @@ public class DeserializedClassDescriptor extends AbstractClassDescriptor impleme this.isInner = Flags.INNER.get(flags); this.annotationDeserializer = annotationResolver; - this.annotations = storageManager.createLazyValue(new Computable>() { + this.annotations = storageManager.createLazyValue(new Function0>() { @Override - public List compute() { + public List invoke() { return computeAnnotations(); } }); - this.primaryConstructor = storageManager.createNullableLazyValue(new Computable() { + this.primaryConstructor = storageManager.createNullableLazyValue(new Function0() { @Override - public ConstructorDescriptor compute() { + public ConstructorDescriptor invoke() { return computePrimaryConstructor(); } }); - this.classObjectDescriptor = storageManager.createNullableLazyValue(new Computable() { + this.classObjectDescriptor = storageManager.createNullableLazyValue(new Function0() { @Override - public ClassDescriptor compute() { + public ClassDescriptor invoke() { return computeClassObjectDescriptor(); } }); @@ -490,9 +490,9 @@ public class DeserializedClassDescriptor extends AbstractClassDescriptor impleme public NestedClassDescriptors(@NotNull StorageManager storageManager, @NotNull Set declaredNames) { this.declaredNames = declaredNames; - this.findClass = storageManager.createMemoizedFunctionWithNullableValues(new Function() { + this.findClass = storageManager.createMemoizedFunctionWithNullableValues(new Function1() { @Override - public ClassDescriptor fun(Name name) { + public ClassDescriptor invoke(Name name) { return NestedClassDescriptors.this.declaredNames.contains(name) ? descriptorFinder.findClass(classId.createNestedClassId(name)) : null; diff --git a/compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/DeserializedMemberScope.java b/compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/DeserializedMemberScope.java index 5d783237b0d..8add30c7564 100644 --- a/compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/DeserializedMemberScope.java +++ b/compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/DeserializedMemberScope.java @@ -16,20 +16,20 @@ package org.jetbrains.jet.descriptors.serialization.descriptors; -import com.intellij.openapi.util.Computable; -import com.intellij.util.Function; +import jet.Function0; +import jet.Function1; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.descriptors.serialization.DescriptorDeserializer; import org.jetbrains.jet.descriptors.serialization.Flags; import org.jetbrains.jet.descriptors.serialization.ProtoBuf; import org.jetbrains.jet.lang.descriptors.*; -import org.jetbrains.jet.storage.MemoizedFunctionToNotNull; -import org.jetbrains.jet.storage.NotNullLazyValue; -import org.jetbrains.jet.storage.StorageManager; import org.jetbrains.jet.lang.resolve.name.LabelName; import org.jetbrains.jet.lang.resolve.name.Name; import org.jetbrains.jet.lang.resolve.scopes.JetScope; +import org.jetbrains.jet.storage.MemoizedFunctionToNotNull; +import org.jetbrains.jet.storage.NotNullLazyValue; +import org.jetbrains.jet.storage.StorageManager; import java.util.*; @@ -73,27 +73,27 @@ public abstract class DeserializedMemberScope implements JetScope { this.deserializer = deserializer; this.membersProtos = groupByName(membersList); - this.functions = storageManager.createMemoizedFunction(new Function>() { + this.functions = storageManager.createMemoizedFunction(new Function1>() { @Override - public Collection fun(Name name) { + public Collection invoke(Name name) { return computeFunctions(name); } }, STRONG); - this.properties = storageManager.createMemoizedFunction(new Function>() { + this.properties = storageManager.createMemoizedFunction(new Function1>() { @Override - public Collection fun(Name name) { + public Collection invoke(Name name) { return computeProperties(name); } }, STRONG); - this.allDescriptors = storageManager.createLazyValue(new Computable>() { + this.allDescriptors = storageManager.createLazyValue(new Function0>() { @Override - public Collection compute() { + public Collection invoke() { return computeAllDescriptors(); } }); - this.objectDescriptors = storageManager.createLazyValue(new Computable>() { + this.objectDescriptors = storageManager.createLazyValue(new Function0>() { @Override - public Collection compute() { + public Collection invoke() { return computeAllObjectDescriptors(); } }); 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 9bc62b940a1..22dc0745c46 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DescriptorResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DescriptorResolver.java @@ -23,6 +23,7 @@ import com.intellij.openapi.util.Computable; import com.intellij.psi.PsiElement; import com.intellij.psi.tree.IElementType; import com.intellij.psi.util.PsiTreeUtil; +import jet.Function0; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.lang.descriptors.*; @@ -316,9 +317,9 @@ public class DescriptorResolver { DeferredType.create(trace, createRecursionIntolerantLazyValueWithDefault( ErrorUtils.createErrorType("Recursive dependency"), - new Computable() { + new Function0() { @Override - public JetType compute() { + public JetType invoke() { JetType type = expressionTypingServices .getBodyExpressionType(trace, scope, dataFlowInfo, function, functionDescriptor); @@ -1037,9 +1038,9 @@ public class DescriptorResolver { trace, createRecursionIntolerantLazyValueWithDefault( ErrorUtils.createErrorType("Recursive dependency"), - new Computable() { + new Function0() { @Override - public JetType compute() { + public JetType invoke() { return resolveDelegatedPropertyType((PropertyDescriptor) variableDescriptor, scope, propertyDelegateExpression, dataFlowInfo, trace); } @@ -1056,9 +1057,9 @@ public class DescriptorResolver { return DeferredType.create(trace, createRecursionIntolerantLazyValueWithDefault( ErrorUtils.createErrorType("Recursive dependency"), - new Computable() { + new Function0() { @Override - public JetType compute() { + public JetType invoke() { JetType type = resolveInitializerType(scope, initializer, dataFlowInfo, trace); @@ -1384,9 +1385,9 @@ public class DescriptorResolver { final ClassDescriptor enumClassDescriptor = (ClassDescriptor) classObject.getContainingDeclaration(); assert DescriptorUtils.isEnumClass(enumClassDescriptor) : "values should be created in enum class: " + enumClassDescriptor; return DescriptorFactory - .createEnumClassObjectValuesMethod(classObject, DeferredType.create(trace, new Computable() { + .createEnumClassObjectValuesMethod(classObject, DeferredType.create(trace, new Function0() { @Override - public JetType compute() { + public JetType invoke() { return KotlinBuiltIns.getInstance().getArrayType(enumClassDescriptor.getDefaultType()); } })); @@ -1401,9 +1402,9 @@ public class DescriptorResolver { final ClassDescriptor enumClassDescriptor = (ClassDescriptor) classObject.getContainingDeclaration(); assert DescriptorUtils.isEnumClass(enumClassDescriptor) : "valueOf should be created in enum class: " + enumClassDescriptor; return DescriptorFactory - .createEnumClassObjectValueOfMethod(classObject, DeferredType.create(trace, new Computable() { + .createEnumClassObjectValueOfMethod(classObject, DeferredType.create(trace, new Function0() { @Override - public JetType compute() { + public JetType invoke() { return enumClassDescriptor.getDefaultType(); } })); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TypeResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TypeResolver.java index 0a72f632d41..1b577494b12 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TypeResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TypeResolver.java @@ -16,7 +16,7 @@ package org.jetbrains.jet.lang.resolve; -import com.intellij.openapi.util.Computable; +import jet.Function0; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.lang.descriptors.*; @@ -240,9 +240,9 @@ public class TypeResolver { return typeParameterDescriptor.getUpperBoundsAsType().getMemberScope(); } else { - return new LazyScopeAdapter(NO_LOCKS.createLazyValue(new Computable() { + return new LazyScopeAdapter(NO_LOCKS.createLazyValue(new Function0() { @Override - public JetScope compute() { + public JetScope invoke() { return typeParameterDescriptor.getUpperBoundsAsType().getMemberScope(); } })); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/ImportsProvider.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/ImportsProvider.java index 1eb3ff79f84..2bf3af83fd0 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/ImportsProvider.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/ImportsProvider.java @@ -17,14 +17,14 @@ package org.jetbrains.jet.lang.resolve.lazy; import com.google.common.collect.*; -import com.intellij.openapi.util.Computable; +import jet.Function0; import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.lang.psi.JetImportDirective; import org.jetbrains.jet.lang.psi.JetPsiUtil; import org.jetbrains.jet.lang.resolve.ImportPath; +import org.jetbrains.jet.lang.resolve.name.Name; import org.jetbrains.jet.storage.NotNullLazyValue; import org.jetbrains.jet.storage.StorageManager; -import org.jetbrains.jet.lang.resolve.name.Name; import java.util.List; import java.util.Set; @@ -35,9 +35,9 @@ class ImportsProvider { public ImportsProvider(StorageManager storageManager, final List importDirectives) { this.importDirectives = importDirectives; - this.importsCacheValue = storageManager.createLazyValue(new Computable() { + this.importsCacheValue = storageManager.createLazyValue(new Function0() { @Override - public NameToImportsCache compute() { + public NameToImportsCache invoke() { return NameToImportsCache.createIndex(importDirectives); } }); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/LazyImportScope.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/LazyImportScope.java index 4d5ed124611..3c499763efc 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/LazyImportScope.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/LazyImportScope.java @@ -18,8 +18,8 @@ package org.jetbrains.jet.lang.resolve.lazy; import com.google.common.collect.Lists; import com.google.common.collect.Sets; -import com.intellij.openapi.util.Computable; -import com.intellij.util.Function; +import jet.Function0; +import jet.Function1; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.lang.descriptors.*; @@ -27,11 +27,11 @@ import org.jetbrains.jet.lang.psi.JetFile; import org.jetbrains.jet.lang.psi.JetImportDirective; import org.jetbrains.jet.lang.resolve.BindingTrace; import org.jetbrains.jet.lang.resolve.Importer; -import org.jetbrains.jet.storage.MemoizedFunctionToNotNull; import org.jetbrains.jet.lang.resolve.name.FqName; import org.jetbrains.jet.lang.resolve.name.LabelName; import org.jetbrains.jet.lang.resolve.name.Name; import org.jetbrains.jet.lang.resolve.scopes.*; +import org.jetbrains.jet.storage.MemoizedFunctionToNotNull; import java.util.Collection; import java.util.Collections; @@ -75,9 +75,9 @@ public class LazyImportScope implements JetScope { return status.scope; } - return resolveSession.getStorageManager().compute(new Computable() { + return resolveSession.getStorageManager().compute(new Function0() { @Override - public JetScope compute() { + public JetScope invoke() { ImportResolveStatus cachedStatus = importResolveStatus; if (cachedStatus != null && (cachedStatus.lookupMode == mode || cachedStatus.lookupMode == LookupMode.EVERYTHING)) { return cachedStatus.scope; @@ -130,9 +130,9 @@ public class LazyImportScope implements JetScope { this.traceForImportResolve = traceForImportResolve; this.debugName = debugName; - this.importedScopesProvider = resolveSession.getStorageManager().createMemoizedFunction(new Function() { + this.importedScopesProvider = resolveSession.getStorageManager().createMemoizedFunction(new Function1() { @Override - public ImportDirectiveResolveCache fun(JetImportDirective directive) { + public ImportDirectiveResolveCache invoke(JetImportDirective directive) { return new ImportDirectiveResolveCache(directive); } }, STRONG); @@ -165,9 +165,9 @@ public class LazyImportScope implements JetScope { final LookupMode lookupMode, final JetScopeSelectorUtil.ScopeByNameSelector descriptorSelector ) { - return resolveSession.getStorageManager().compute(new Computable() { + return resolveSession.getStorageManager().compute(new Function0() { @Override - public D compute() { + public D invoke() { for (JetImportDirective directive : importsProvider.getImports(name)) { if (directive == directiveUnderResolve) { // This is the recursion in imports analysis @@ -191,9 +191,9 @@ public class LazyImportScope implements JetScope { final LookupMode lookupMode, final JetScopeSelectorUtil.ScopeByNameMultiSelector descriptorsSelector ) { - return resolveSession.getStorageManager().compute(new Computable>() { + return resolveSession.getStorageManager().compute(new Function0>() { @Override - public Collection compute() { + public Collection invoke() { Set descriptors = Sets.newHashSet(); for (JetImportDirective directive : importsProvider.getImports(name)) { if (directive == directiveUnderResolve) { @@ -214,9 +214,9 @@ public class LazyImportScope implements JetScope { final LookupMode lookupMode, final JetScopeSelectorUtil.ScopeDescriptorSelector descriptorsSelector ) { - return resolveSession.getStorageManager().compute(new Computable>() { + return resolveSession.getStorageManager().compute(new Function0>() { @Override - public Collection compute() { + public Collection invoke() { Set descriptors = Sets.newHashSet(); for (JetImportDirective directive : importsProvider.getAllImports()) { if (directive == directiveUnderResolve) { 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 f8758c78175..f25d8cf04cd 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 @@ -19,10 +19,10 @@ package org.jetbrains.jet.lang.resolve.lazy; import com.google.common.base.Predicate; import com.google.common.base.Predicates; import com.intellij.openapi.project.Project; -import com.intellij.openapi.util.Computable; import com.intellij.psi.PsiElement; import com.intellij.psi.util.PsiTreeUtil; import com.intellij.util.Function; +import jet.Function0; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.di.InjectorForLazyResolve; @@ -216,9 +216,9 @@ public class ResolveSession implements KotlinCodeAnalyzer { final JetClassLikeInfo classObjectInfo = parentClassDescriptor.getClassObjectInfo(classObject); if (classObjectInfo != null) { final Name name = DescriptorUtils.getClassObjectName(parentClassDescriptor.getName()); - return storageManager.compute(new Computable() { + return storageManager.compute(new Function0() { @Override - public LazyClassDescriptor compute() { + public LazyClassDescriptor invoke() { // Create under lock to avoid premature access to published 'this' return new LazyClassDescriptor(ResolveSession.this, parentClassDescriptor, name, classObjectInfo); } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/ScopeProvider.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/ScopeProvider.java index 53a1194ee2d..d7eba239399 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/ScopeProvider.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/ScopeProvider.java @@ -17,21 +17,21 @@ package org.jetbrains.jet.lang.resolve.lazy; import com.google.common.collect.Lists; -import com.intellij.openapi.util.Computable; import com.intellij.psi.PsiElement; import com.intellij.psi.util.PsiTreeUtil; -import com.intellij.util.Function; +import jet.Function0; +import jet.Function1; import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor; import org.jetbrains.jet.lang.psi.*; import org.jetbrains.jet.lang.resolve.ImportPath; import org.jetbrains.jet.lang.resolve.TemporaryBindingTrace; import org.jetbrains.jet.lang.resolve.lazy.descriptors.LazyClassDescriptor; -import org.jetbrains.jet.storage.MemoizedFunctionToNotNull; -import org.jetbrains.jet.storage.NotNullLazyValue; import org.jetbrains.jet.lang.resolve.name.FqName; import org.jetbrains.jet.lang.resolve.scopes.ChainedScope; import org.jetbrains.jet.lang.resolve.scopes.JetScope; +import org.jetbrains.jet.storage.MemoizedFunctionToNotNull; +import org.jetbrains.jet.storage.NotNullLazyValue; import java.util.Collection; import java.util.List; @@ -48,16 +48,16 @@ public class ScopeProvider { public ScopeProvider(@NotNull ResolveSession resolveSession) { this.resolveSession = resolveSession; - this.fileScopes = resolveSession.getStorageManager().createMemoizedFunction(new Function() { + this.fileScopes = resolveSession.getStorageManager().createMemoizedFunction(new Function1() { @Override - public JetScope fun(@NotNull JetFile file) { + public JetScope invoke(@NotNull JetFile file) { return createFileScope(file); } }, WEAK); - this.defaultImportsScope = resolveSession.getStorageManager().createLazyValue(new Computable() { + this.defaultImportsScope = resolveSession.getStorageManager().createLazyValue(new Function0() { @Override - public JetScope compute() { + public JetScope invoke() { return createScopeWithDefaultImports(); } }); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/data/FilteringClassLikeInfo.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/data/FilteringClassLikeInfo.java index 7989e7ce473..b2878fb98c0 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/data/FilteringClassLikeInfo.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/data/FilteringClassLikeInfo.java @@ -19,15 +19,15 @@ package org.jetbrains.jet.lang.resolve.lazy.data; import com.google.common.base.Predicate; import com.google.common.collect.Collections2; import com.google.common.collect.Lists; -import com.intellij.openapi.util.Computable; import com.intellij.psi.PsiElement; +import jet.Function0; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.lang.descriptors.ClassKind; import org.jetbrains.jet.lang.psi.*; +import org.jetbrains.jet.lang.resolve.name.FqName; import org.jetbrains.jet.storage.NotNullLazyValue; import org.jetbrains.jet.storage.StorageManager; -import org.jetbrains.jet.lang.resolve.name.FqName; import java.util.List; @@ -41,9 +41,9 @@ public class FilteringClassLikeInfo implements JetClassLikeInfo { @NotNull final Predicate declarationFilter ) { this.delegate = delegate; - this.filteredDeclarations = storageManager.createLazyValue(new Computable>() { + this.filteredDeclarations = storageManager.createLazyValue(new Function0>() { @Override - public List compute() { + public List invoke() { return Lists.newArrayList(Collections2.filter(delegate.getDeclarations(), declarationFilter)); } }); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/declarations/AbstractPsiBasedDeclarationProvider.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/declarations/AbstractPsiBasedDeclarationProvider.java index c984b2026f7..cf4893286e9 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/declarations/AbstractPsiBasedDeclarationProvider.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/declarations/AbstractPsiBasedDeclarationProvider.java @@ -20,12 +20,12 @@ import com.google.common.collect.ArrayListMultimap; import com.google.common.collect.HashMultimap; import com.google.common.collect.Lists; import com.google.common.collect.Multimap; -import com.intellij.openapi.util.Computable; +import jet.Function0; import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.lang.psi.*; +import org.jetbrains.jet.lang.resolve.name.Name; import org.jetbrains.jet.storage.NotNullLazyValue; import org.jetbrains.jet.storage.StorageManager; -import org.jetbrains.jet.lang.resolve.name.Name; import java.util.Collection; import java.util.List; @@ -70,9 +70,9 @@ public abstract class AbstractPsiBasedDeclarationProvider implements Declaration private final NotNullLazyValue index; public AbstractPsiBasedDeclarationProvider(@NotNull StorageManager storageManager) { - index = storageManager.createLazyValue(new Computable() { + index = storageManager.createLazyValue(new Function0() { @Override - public Index compute() { + public Index invoke() { Index index = new Index(); doCreateIndex(index); return index; diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/declarations/FileBasedDeclarationProviderFactory.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/declarations/FileBasedDeclarationProviderFactory.java index b3daa6478a1..faba7ee4b0e 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/declarations/FileBasedDeclarationProviderFactory.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/declarations/FileBasedDeclarationProviderFactory.java @@ -19,20 +19,21 @@ package org.jetbrains.jet.lang.resolve.lazy.declarations; import com.google.common.base.Predicate; import com.google.common.base.Predicates; import com.google.common.collect.*; -import com.intellij.openapi.util.Computable; import com.intellij.psi.NavigatablePsiElement; import com.intellij.util.Function; import com.intellij.util.containers.ContainerUtil; +import jet.Function0; +import jet.Function1; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.lang.psi.JetFile; import org.jetbrains.jet.lang.psi.JetNamespaceHeader; import org.jetbrains.jet.lang.psi.JetPsiUtil; import org.jetbrains.jet.lang.resolve.lazy.data.JetClassLikeInfo; +import org.jetbrains.jet.lang.resolve.name.FqName; import org.jetbrains.jet.storage.MemoizedFunctionToNullable; import org.jetbrains.jet.storage.NotNullLazyValue; import org.jetbrains.jet.storage.StorageManager; -import org.jetbrains.jet.lang.resolve.name.FqName; import org.jetbrains.jet.util.QualifiedNamesUtil; import java.util.Collection; @@ -64,15 +65,15 @@ public class FileBasedDeclarationProviderFactory implements DeclarationProviderF ) { this.storageManager = storageManager; this.isPackageDeclaredExternally = isPackageDeclaredExternally; - this.index = storageManager.createLazyValue(new Computable() { + this.index = storageManager.createLazyValue(new Function0() { @Override - public Index compute() { + public Index invoke() { return computeFilesByPackage(files); } }); - this.packageDeclarationProviders = storageManager.createMemoizedFunctionWithNullableValues(new Function() { + this.packageDeclarationProviders = storageManager.createMemoizedFunctionWithNullableValues(new Function1() { @Override - public PackageMemberDeclarationProvider fun(FqName fqName) { + public PackageMemberDeclarationProvider invoke(FqName fqName) { return createPackageMemberDeclarationProvider(fqName); } }, StorageManager.ReferenceKind.STRONG); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/declarations/FileBasedPackageMemberDeclarationProvider.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/declarations/FileBasedPackageMemberDeclarationProvider.java index 042b88a0237..ade4c69ff2d 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/declarations/FileBasedPackageMemberDeclarationProvider.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/declarations/FileBasedPackageMemberDeclarationProvider.java @@ -16,15 +16,15 @@ package org.jetbrains.jet.lang.resolve.lazy.declarations; -import com.intellij.openapi.util.Computable; import com.intellij.psi.NavigatablePsiElement; +import jet.Function0; import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.lang.psi.JetDeclaration; import org.jetbrains.jet.lang.psi.JetFile; -import org.jetbrains.jet.storage.NotNullLazyValue; -import org.jetbrains.jet.storage.StorageManager; import org.jetbrains.jet.lang.resolve.name.FqName; import org.jetbrains.jet.lang.resolve.name.Name; +import org.jetbrains.jet.storage.NotNullLazyValue; +import org.jetbrains.jet.storage.StorageManager; import java.util.Collection; @@ -46,9 +46,9 @@ public class FileBasedPackageMemberDeclarationProvider extends AbstractPsiBasedD this.fqName = _fqName; this.factory = _factory; this.packageFiles = packageFiles; - this.allDeclaredPackages = storageManager.createLazyValue(new Computable>() { + this.allDeclaredPackages = storageManager.createLazyValue(new Function0>() { @Override - public Collection compute() { + public Collection invoke() { return factory.getAllDeclaredSubPackagesOf(fqName); } }); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/descriptors/AbstractLazyMemberScope.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/descriptors/AbstractLazyMemberScope.java index d11fea9580c..34beab6ebf5 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/descriptors/AbstractLazyMemberScope.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/descriptors/AbstractLazyMemberScope.java @@ -17,9 +17,10 @@ package org.jetbrains.jet.lang.resolve.lazy.descriptors; import com.google.common.collect.Sets; -import com.intellij.openapi.util.Computable; import com.intellij.util.Function; import com.intellij.util.containers.ContainerUtil; +import jet.Function0; +import jet.Function1; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.lang.descriptors.*; @@ -28,12 +29,12 @@ import org.jetbrains.jet.lang.resolve.calls.autocasts.DataFlowInfo; import org.jetbrains.jet.lang.resolve.lazy.ResolveSession; import org.jetbrains.jet.lang.resolve.lazy.data.JetClassInfoUtil; import org.jetbrains.jet.lang.resolve.lazy.declarations.DeclarationProvider; -import org.jetbrains.jet.storage.MemoizedFunctionToNotNull; -import org.jetbrains.jet.storage.NotNullLazyValue; -import org.jetbrains.jet.storage.StorageManager; import org.jetbrains.jet.lang.resolve.name.LabelName; import org.jetbrains.jet.lang.resolve.name.Name; import org.jetbrains.jet.lang.resolve.scopes.JetScope; +import org.jetbrains.jet.storage.MemoizedFunctionToNotNull; +import org.jetbrains.jet.storage.NotNullLazyValue; +import org.jetbrains.jet.storage.StorageManager; import java.util.Collection; import java.util.Collections; @@ -71,35 +72,35 @@ public abstract class AbstractLazyMemberScope>() { + this.classDescriptors = storageManager.createMemoizedFunction(new Function1>() { @Override - public List fun(Name name) { + public List invoke(Name name) { return resolveClassOrObjectDescriptor(name, false); } }, STRONG); - this.objectDescriptors = storageManager.createMemoizedFunction(new Function>() { + this.objectDescriptors = storageManager.createMemoizedFunction(new Function1>() { @Override - public List fun(Name name) { + public List invoke(Name name) { return resolveClassOrObjectDescriptor(name, true); } }, STRONG); - this.functionDescriptors = storageManager.createMemoizedFunction(new Function>() { + this.functionDescriptors = storageManager.createMemoizedFunction(new Function1>() { @Override - public Set fun(Name name) { + public Set invoke(Name name) { return doGetFunctions(name); } }, STRONG); - this.propertyDescriptors = storageManager.createMemoizedFunction(new Function>() { + this.propertyDescriptors = storageManager.createMemoizedFunction(new Function1>() { @Override - public Set fun(Name name) { + public Set invoke(Name name) { return doGetProperties(name); } }, STRONG); - this.allDescriptors = storageManager.createLazyValue(new Computable() { + this.allDescriptors = storageManager.createLazyValue(new Function0() { @Override - public AllDescriptors compute() { + public AllDescriptors invoke() { return computeAllDescriptors(); } }); 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 7c506e30d2a..4245de36633 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 @@ -20,10 +20,9 @@ import com.google.common.base.Predicate; import com.google.common.base.Predicates; import com.google.common.collect.Collections2; import com.google.common.collect.Lists; -import com.intellij.openapi.util.Computable; import com.intellij.psi.PsiElement; -import com.intellij.util.Consumer; -import com.intellij.util.Function; +import jet.Function0; +import jet.Function1; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.lang.descriptors.*; @@ -124,39 +123,39 @@ public class LazyClassDescriptor extends ClassDescriptorBase implements LazyDesc this.isInner = isInnerClass(modifierList); StorageManager storageManager = resolveSession.getStorageManager(); - this.thisAsReceiverParameter = storageManager.createLazyValue(new Computable() { + this.thisAsReceiverParameter = storageManager.createLazyValue(new Function0() { @Override - public ReceiverParameterDescriptor compute() { + public ReceiverParameterDescriptor invoke() { return DescriptorFactory.createLazyReceiverParameterDescriptor(LazyClassDescriptor.this); } }); - this.annotations = storageManager.createLazyValue(new Computable>() { + this.annotations = storageManager.createLazyValue(new Function0>() { @Override - public List compute() { + public List invoke() { return resolveAnnotations(); } }); - this.classObjectDescriptor = storageManager.createNullableLazyValue(new Computable() { + this.classObjectDescriptor = storageManager.createNullableLazyValue(new Function0() { @Override - public ClassDescriptor compute() { + public ClassDescriptor invoke() { return computeClassObjectDescriptor(); } }); - this.scopeForClassHeaderResolution = storageManager.createLazyValue(new Computable() { + this.scopeForClassHeaderResolution = storageManager.createLazyValue(new Function0() { @Override - public JetScope compute() { + public JetScope invoke() { return computeScopeForClassHeaderResolution(); } }); - this.scopeForMemberDeclarationResolution = storageManager.createLazyValue(new Computable() { + this.scopeForMemberDeclarationResolution = storageManager.createLazyValue(new Function0() { @Override - public JetScope compute() { + public JetScope invoke() { return computeScopeForMemberDeclarationResolution(); } }); - this.scopeForPropertyInitializerResolution = storageManager.createLazyValue(new Computable() { + this.scopeForPropertyInitializerResolution = storageManager.createLazyValue(new Function0() { @Override - public JetScope compute() { + public JetScope invoke() { return computeScopeForPropertyInitializerResolution(); } }); @@ -374,9 +373,9 @@ public class LazyClassDescriptor extends ClassDescriptorBase implements LazyDesc private class LazyClassTypeConstructor implements LazyDescriptor, TypeConstructor { private final NotNullLazyValue> supertypes = resolveSession.getStorageManager().createLazyValueWithPostCompute( - new Computable>() { + new Function0>() { @Override - public Collection compute() { + public Collection invoke() { if (resolveSession.isClassSpecial(DescriptorUtils.getFQName(LazyClassDescriptor.this))) { return Collections.emptyList(); } @@ -396,22 +395,23 @@ public class LazyClassDescriptor extends ClassDescriptorBase implements LazyDesc } } }, - new Function>() { + new Function1>() { @Override - public Collection fun(Boolean firstTime) { + public Collection invoke(Boolean firstTime) { return Collections.emptyList(); } }, - new Consumer>() { + new Function1, Void>() { @Override - public void consume(@NotNull Collection supertypes) { + public Void invoke(@NotNull Collection supertypes) { findAndDisconnectLoopsInTypeHierarchy(supertypes); + return null; } }); - private final NotNullLazyValue> parameters = resolveSession.getStorageManager().createLazyValue(new Computable>() { + private final NotNullLazyValue> parameters = resolveSession.getStorageManager().createLazyValue(new Function0>() { @Override - public List compute() { + public List invoke() { JetClassLikeInfo classInfo = declarationProvider.getOwnerInfo(); List typeParameters = classInfo.getTypeParameters(); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/descriptors/LazyClassMemberScope.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/descriptors/LazyClassMemberScope.java index 575c9304222..1bcafa9c40d 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/descriptors/LazyClassMemberScope.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/descriptors/LazyClassMemberScope.java @@ -18,7 +18,7 @@ package org.jetbrains.jet.lang.resolve.lazy.descriptors; import com.google.common.collect.ImmutableSet; import com.google.common.collect.Lists; -import com.intellij.openapi.util.Computable; +import jet.Function0; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.lang.descriptors.*; @@ -82,9 +82,9 @@ public class LazyClassMemberScope extends AbstractLazyMemberScope() { + this.primaryConstructor = resolveSession.getStorageManager().createNullableLazyValue(new Function0() { @Override - public ConstructorDescriptor compute() { + public ConstructorDescriptor invoke() { return resolvePrimaryConstructor(); } }); @@ -378,9 +378,9 @@ public class LazyClassMemberScope extends AbstractLazyMemberScope() { + new Function0() { @Override - public JetType compute() { + public JetType invoke() { return thisDescriptor.getDefaultType(); } }) diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/descriptors/LazyPackageMemberScope.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/descriptors/LazyPackageMemberScope.java index 058d2605ed8..5baab77b42e 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/descriptors/LazyPackageMemberScope.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/descriptors/LazyPackageMemberScope.java @@ -16,7 +16,7 @@ package org.jetbrains.jet.lang.resolve.lazy.descriptors; -import com.intellij.util.Function; +import jet.Function1; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.lang.descriptors.*; @@ -25,11 +25,11 @@ import org.jetbrains.jet.lang.psi.JetFile; import org.jetbrains.jet.lang.resolve.DescriptorUtils; import org.jetbrains.jet.lang.resolve.lazy.ResolveSession; import org.jetbrains.jet.lang.resolve.lazy.declarations.PackageMemberDeclarationProvider; -import org.jetbrains.jet.storage.MemoizedFunctionToNullable; -import org.jetbrains.jet.storage.StorageManager; import org.jetbrains.jet.lang.resolve.name.FqName; import org.jetbrains.jet.lang.resolve.name.Name; import org.jetbrains.jet.lang.resolve.scopes.JetScope; +import org.jetbrains.jet.storage.MemoizedFunctionToNullable; +import org.jetbrains.jet.storage.StorageManager; import java.util.Collection; import java.util.Set; @@ -44,9 +44,9 @@ public class LazyPackageMemberScope extends AbstractLazyMemberScope() { + new Function1() { @Override - public NamespaceDescriptor fun(Name name) { + public NamespaceDescriptor invoke(Name name) { return createPackageDescriptor(name); } }, StorageManager.ReferenceKind.STRONG); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/types/DeferredType.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/DeferredType.java index c93bf37ca99..a77d19697bf 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/types/DeferredType.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/DeferredType.java @@ -16,7 +16,7 @@ package org.jetbrains.jet.lang.types; -import com.intellij.openapi.util.Computable; +import jet.Function0; import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor; import org.jetbrains.jet.lang.resolve.BindingTrace; @@ -38,7 +38,7 @@ public class DeferredType implements JetType { return deferredType; } - public static DeferredType create(BindingTrace trace, Computable compute) { + public static DeferredType create(BindingTrace trace, Function0 compute) { return create(trace, LockBasedStorageManager.NO_LOCKS.createLazyValue(compute)); } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ClosureExpressionsTypingVisitor.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ClosureExpressionsTypingVisitor.java index 6dead58bf02..8e701d45dec 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ClosureExpressionsTypingVisitor.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ClosureExpressionsTypingVisitor.java @@ -17,10 +17,10 @@ package org.jetbrains.jet.lang.types.expressions; import com.google.common.collect.Lists; -import com.intellij.openapi.util.Computable; import com.intellij.psi.PsiElement; import com.intellij.util.Function; import com.intellij.util.containers.ContainerUtil; +import jet.Function0; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.lang.descriptors.*; @@ -69,9 +69,9 @@ public class ClosureExpressionsTypingVisitor extends ExpressionTypingVisitor { if (slice == CLASS && declaration == expression.getObjectDeclaration()) { JetType defaultType = DeferredType.create(context.trace, createRecursionIntolerantLazyValueWithDefault( ErrorUtils.createErrorType("Recursive dependency"), - new Computable() { + new Function0() { @Override - public JetType compute() { + public JetType invoke() { return descriptor.getDefaultType(); } })); diff --git a/compiler/tests/org/jetbrains/jet/storage/StorageManagerTest.java b/compiler/tests/org/jetbrains/jet/storage/StorageManagerTest.java index 49712cf1481..03c08e4b158 100644 --- a/compiler/tests/org/jetbrains/jet/storage/StorageManagerTest.java +++ b/compiler/tests/org/jetbrains/jet/storage/StorageManagerTest.java @@ -1,8 +1,5 @@ package org.jetbrains.jet.storage; -import com.intellij.openapi.util.Computable; -import com.intellij.util.Consumer; -import com.intellij.util.Function; import jet.Function0; import jet.Function1; import junit.framework.TestCase; @@ -167,9 +164,9 @@ public class StorageManagerTest extends TestCase { public void testRecursionIntolerance() throws Exception { class C { - NotNullLazyValue rec = m.createLazyValue(new Computable() { + NotNullLazyValue rec = m.createLazyValue(new Function0() { @Override - public String compute() { + public String invoke() { return rec.invoke(); } }); @@ -186,9 +183,9 @@ public class StorageManagerTest extends TestCase { public void testNullableRecursionIntolerance() throws Exception { class C { - NullableLazyValue rec = m.createNullableLazyValue(new Computable() { + NullableLazyValue rec = m.createNullableLazyValue(new Function0() { @Override - public String compute() { + public String invoke() { return rec.invoke(); } }); @@ -205,9 +202,9 @@ public class StorageManagerTest extends TestCase { public void testRecursionTolerance() throws Exception { class C { - NotNullLazyValue rec = m.createRecursionTolerantLazyValue(new Computable() { + NotNullLazyValue rec = m.createRecursionTolerantLazyValue(new Function0() { @Override - public String compute() { + public String invoke() { assertEquals("rec", rec.invoke()); return "tolerant!"; } @@ -219,9 +216,9 @@ public class StorageManagerTest extends TestCase { public void testNullableRecursionTolerance() throws Exception { class C { - NullableLazyValue rec = m.createRecursionTolerantNullableLazyValue(new Computable() { + NullableLazyValue rec = m.createRecursionTolerantNullableLazyValue(new Function0() { @Override - public String compute() { + public String invoke() { assertEquals(null, rec.invoke()); return "tolerant!"; } @@ -235,14 +232,19 @@ public class StorageManagerTest extends TestCase { @SuppressWarnings("unchecked") class C { NotNullLazyValue rec = m.createLazyValueWithPostCompute( - new Computable() { + new Function0() { @Override - public String compute() { + public String invoke() { return rec.invoke(); } }, null, - Consumer.EMPTY_CONSUMER + new Function1() { + @Override + public Void invoke(String s) { + return null; + } + } ); } @@ -259,23 +261,24 @@ public class StorageManagerTest extends TestCase { final CounterImpl counter = new CounterImpl(); class C { NotNullLazyValue rec = m.createLazyValueWithPostCompute( - new Computable() { + new Function0() { @Override - public String compute() { + public String invoke() { return rec.invoke(); } }, - new Function() { + new Function1() { @Override - public String fun(Boolean aBoolean) { + public String invoke(Boolean aBoolean) { return "tolerant"; } }, - new Consumer() { + new Function1() { @Override - public void consume(String s) { + public Void invoke(String s) { counter.inc(); assertEquals("tolerant", s); + return null; } } ); @@ -290,20 +293,21 @@ public class StorageManagerTest extends TestCase { public void testPostComputeNoRecursion() throws Exception { final CounterImpl counter = new CounterImpl(); NotNullLazyValue> v = m.createLazyValueWithPostCompute( - new Computable>() { + new Function0>() { @Override - public Collection compute() { + public Collection invoke() { List strings = new ArrayList(); strings.add("first"); return strings; } }, null, - new Consumer>() { + new Function1, Void>() { @Override - public void consume(Collection strings) { + public Void invoke(Collection strings) { counter.inc(); strings.add("postComputed"); + return null; } } ); @@ -316,19 +320,20 @@ public class StorageManagerTest extends TestCase { public void testNullablePostComputeNoRecursion() throws Exception { final CounterImpl counter = new CounterImpl(); NullableLazyValue> v = m.createNullableLazyValueWithPostCompute( - new Computable>() { + new Function0>() { @Override - public Collection compute() { + public Collection invoke() { ArrayList strings = new ArrayList(); strings.add("first"); return strings; } }, - new Consumer>() { + new Function1, Void>() { @Override - public void consume(Collection strings) { + public Void invoke(Collection strings) { counter.inc(); strings.add("postComputed"); + return null; } } ); @@ -342,25 +347,26 @@ public class StorageManagerTest extends TestCase { @SuppressWarnings("unchecked") class C { NotNullLazyValue rec = m.createLazyValueWithPostCompute( - new Computable() { + new Function0() { @Override - public String compute() { + public String invoke() { return rec.invoke(); } }, - new Function() { + new Function1() { @Override - public String fun(Boolean firstTime) { + public String invoke(Boolean firstTime) { if (firstTime) { throw new ReenteringLazyValueComputationException(); } return "second"; } }, - new Consumer() { + new Function1() { @Override - public void consume(String s) { + public Void invoke(String s) { fail("Recursion-tolerating value should not be post computed"); + return null; } } ); @@ -407,9 +413,9 @@ public class StorageManagerTest extends TestCase { } } - private static class CounterValueNull extends CounterImpl implements Computable, Counter { + private static class CounterValueNull extends CounterImpl implements Function0, Counter { @Override - public String compute() { + public String invoke() { inc(); return null; } @@ -417,7 +423,7 @@ public class StorageManagerTest extends TestCase { private static class CounterValue extends CounterValueNull { @Override - public String compute() { + public String invoke() { inc(); return "ok" + getCount(); } @@ -425,15 +431,15 @@ public class StorageManagerTest extends TestCase { private static class ExceptionCounterValue extends CounterValueNull { @Override - public String compute() { + public String invoke() { inc(); throw new UnsupportedOperationException(); } } - private static class CounterFunctionToNull extends CounterImpl implements Function, Counter { + private static class CounterFunctionToNull extends CounterImpl implements Function1, Counter { @Override - public String fun(String s) { + public String invoke(String s) { inc(); return null; } @@ -441,7 +447,7 @@ public class StorageManagerTest extends TestCase { private static class CounterFunction extends CounterFunctionToNull { @Override - public String fun(String s) { + public String invoke(String s) { inc(); return s + getCount(); } @@ -449,7 +455,7 @@ public class StorageManagerTest extends TestCase { private static class ExceptionCounterFunction extends CounterFunctionToNull { @Override - public String fun(String s) { + public String invoke(String s) { inc(); throw new UnsupportedOperationException(); } diff --git a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/kotlin/AnnotationDescriptorDeserializer.java b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/kotlin/AnnotationDescriptorDeserializer.java index a1dc0fefefc..49341206263 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/kotlin/AnnotationDescriptorDeserializer.java +++ b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/kotlin/AnnotationDescriptorDeserializer.java @@ -16,7 +16,7 @@ package org.jetbrains.jet.lang.resolve.kotlin; -import com.intellij.util.Function; +import jet.Function1; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.descriptors.serialization.JavaProtoBuf; @@ -62,10 +62,10 @@ public class AnnotationDescriptorDeserializer implements AnnotationDeserializer private final MemoizedFunctionToNotNull>> memberAnnotations = storageManager.createMemoizedFunction( - new Function>>() { + new Function1>>() { @NotNull @Override - public Map> fun(@NotNull KotlinJvmBinaryClass kotlinClass) { + public Map> invoke(@NotNull KotlinJvmBinaryClass kotlinClass) { try { return loadMemberAnnotationsFromClass(kotlinClass); } diff --git a/core/descriptors/src/org/jetbrains/jet/lang/descriptors/impl/AbstractLazyTypeParameterDescriptor.java b/core/descriptors/src/org/jetbrains/jet/lang/descriptors/impl/AbstractLazyTypeParameterDescriptor.java index e389fabe629..7f7cc67a3fe 100644 --- a/core/descriptors/src/org/jetbrains/jet/lang/descriptors/impl/AbstractLazyTypeParameterDescriptor.java +++ b/core/descriptors/src/org/jetbrains/jet/lang/descriptors/impl/AbstractLazyTypeParameterDescriptor.java @@ -16,7 +16,7 @@ package org.jetbrains.jet.lang.descriptors.impl; -import com.intellij.openapi.util.Computable; +import jet.Function0; import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.lang.descriptors.ClassifierDescriptor; import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor; @@ -65,27 +65,27 @@ public abstract class AbstractLazyTypeParameterDescriptor implements TypeParamet this.name = name; this.reified = isReified; - this.typeConstructor = storageManager.createLazyValue(new Computable() { + this.typeConstructor = storageManager.createLazyValue(new Function0() { @Override - public TypeConstructor compute() { + public TypeConstructor invoke() { return createTypeConstructor(); } }); - this.defaultType = storageManager.createLazyValue(new Computable() { + this.defaultType = storageManager.createLazyValue(new Function0() { @Override - public JetType compute() { + public JetType invoke() { return createDefaultType(storageManager); } }); - this.upperBounds = storageManager.createLazyValue(new Computable>() { + this.upperBounds = storageManager.createLazyValue(new Function0>() { @Override - public Set compute() { + public Set invoke() { return resolveUpperBounds(); } }); - this.upperBoundsAsType = storageManager.createLazyValue(new Computable() { + this.upperBoundsAsType = storageManager.createLazyValue(new Function0() { @Override - public JetType compute() { + public JetType invoke() { return computeUpperBoundsAsType(); } }); @@ -198,9 +198,9 @@ public abstract class AbstractLazyTypeParameterDescriptor implements TypeParamet @NotNull private JetType createDefaultType(@NotNull StorageManager storageManager) { return new JetTypeImpl(getTypeConstructor(), new LazyScopeAdapter(storageManager.createLazyValue( - new Computable() { + new Function0() { @Override - public JetScope compute() { + public JetScope invoke() { return getUpperBoundsAsType().getMemberScope(); } } diff --git a/core/descriptors/src/org/jetbrains/jet/lang/descriptors/impl/TypeParameterDescriptorImpl.java b/core/descriptors/src/org/jetbrains/jet/lang/descriptors/impl/TypeParameterDescriptorImpl.java index 374d88cc069..282da0a42aa 100644 --- a/core/descriptors/src/org/jetbrains/jet/lang/descriptors/impl/TypeParameterDescriptorImpl.java +++ b/core/descriptors/src/org/jetbrains/jet/lang/descriptors/impl/TypeParameterDescriptorImpl.java @@ -17,7 +17,7 @@ package org.jetbrains.jet.lang.descriptors.impl; import com.google.common.collect.Sets; -import com.intellij.openapi.util.Computable; +import jet.Function0; import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor; import org.jetbrains.jet.lang.descriptors.DeclarationDescriptorVisitor; @@ -224,9 +224,9 @@ public class TypeParameterDescriptorImpl extends DeclarationDescriptorNonRootImp getTypeConstructor(), TypeUtils.hasNullableLowerBound(this), Collections.emptyList(), - new LazyScopeAdapter(NO_LOCKS.createLazyValue(new Computable() { + new LazyScopeAdapter(NO_LOCKS.createLazyValue(new Function0() { @Override - public JetScope compute() { + public JetScope invoke() { return getUpperBoundsAsType().getMemberScope(); } }))); diff --git a/core/descriptors/src/org/jetbrains/jet/lang/types/lang/BuiltinsNamespaceDescriptorImpl.java b/core/descriptors/src/org/jetbrains/jet/lang/types/lang/BuiltinsNamespaceDescriptorImpl.java index 2fa1d75075d..b7349006c45 100644 --- a/core/descriptors/src/org/jetbrains/jet/lang/types/lang/BuiltinsNamespaceDescriptorImpl.java +++ b/core/descriptors/src/org/jetbrains/jet/lang/types/lang/BuiltinsNamespaceDescriptorImpl.java @@ -1,6 +1,6 @@ package org.jetbrains.jet.lang.types.lang; -import com.intellij.openapi.util.Computable; +import jet.Function0; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.descriptors.serialization.*; @@ -8,11 +8,11 @@ import org.jetbrains.jet.descriptors.serialization.descriptors.DeserializedPacka import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor; import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor; import org.jetbrains.jet.lang.descriptors.impl.AbstractNamespaceDescriptorImpl; -import org.jetbrains.jet.storage.NotNullLazyValue; -import org.jetbrains.jet.storage.StorageManager; import org.jetbrains.jet.lang.resolve.name.FqName; import org.jetbrains.jet.lang.resolve.name.Name; import org.jetbrains.jet.lang.resolve.scopes.JetScope; +import org.jetbrains.jet.storage.NotNullLazyValue; +import org.jetbrains.jet.storage.StorageManager; import java.io.DataInputStream; import java.io.IOException; @@ -81,10 +81,10 @@ class BuiltinsNamespaceDescriptorImpl extends AbstractNamespaceDescriptorImpl { public BuiltInsDescriptorFinder(@NotNull StorageManager storageManager) { super(storageManager, UNSUPPORTED); - classNames = storageManager.createLazyValue(new Computable>() { + classNames = storageManager.createLazyValue(new Function0>() { @Override @NotNull - public Collection compute() { + public Collection invoke() { InputStream in = getStream(BuiltInsSerializationUtil.getClassNamesFilePath(BuiltinsNamespaceDescriptorImpl.this)); try { diff --git a/core/util.runtime/src/org/jetbrains/jet/storage/LockBasedStorageManager.java b/core/util.runtime/src/org/jetbrains/jet/storage/LockBasedStorageManager.java index 3591689691b..1d4782fed56 100644 --- a/core/util.runtime/src/org/jetbrains/jet/storage/LockBasedStorageManager.java +++ b/core/util.runtime/src/org/jetbrains/jet/storage/LockBasedStorageManager.java @@ -16,10 +16,9 @@ package org.jetbrains.jet.storage; -import com.intellij.openapi.util.Computable; -import com.intellij.util.Consumer; -import com.intellij.util.Function; import com.intellij.util.containers.ConcurrentWeakValueHashMap; +import jet.Function0; +import jet.Function1; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.utils.ExceptionUtils; @@ -52,7 +51,7 @@ public class LockBasedStorageManager implements StorageManager { @NotNull @Override public MemoizedFunctionToNotNull createMemoizedFunction( - @NotNull Function compute, @NotNull ReferenceKind valuesReferenceKind + @NotNull Function1 compute, @NotNull ReferenceKind valuesReferenceKind ) { ConcurrentMap map = createConcurrentMap(valuesReferenceKind); return new MapBasedMemoizedFunctionToNotNull(lock, map, compute); @@ -61,7 +60,7 @@ public class LockBasedStorageManager implements StorageManager { @NotNull @Override public MemoizedFunctionToNullable createMemoizedFunctionWithNullableValues( - @NotNull Function compute, @NotNull ReferenceKind valuesReferenceKind + @NotNull Function1 compute, @NotNull ReferenceKind valuesReferenceKind ) { ConcurrentMap map = createConcurrentMap(valuesReferenceKind); return new MapBasedMemoizedFunction(lock, map, compute); @@ -73,14 +72,14 @@ public class LockBasedStorageManager implements StorageManager { @NotNull @Override - public NotNullLazyValue createLazyValue(@NotNull Computable computable) { + public NotNullLazyValue createLazyValue(@NotNull Function0 computable) { return new LockBasedNotNullLazyValue(lock, computable); } @NotNull @Override public NotNullLazyValue createRecursionTolerantLazyValue( - @NotNull Computable computable, @NotNull final T onRecursiveCall + @NotNull Function0 computable, @NotNull final T onRecursiveCall ) { return new LockBasedNotNullLazyValue(lock, computable) { @Override @@ -93,9 +92,9 @@ public class LockBasedStorageManager implements StorageManager { @NotNull @Override public NotNullLazyValue createLazyValueWithPostCompute( - @NotNull Computable computable, - final Function onRecursiveCall, - @NotNull final Consumer postCompute + @NotNull Function0 computable, + final Function1 onRecursiveCall, + @NotNull final Function1 postCompute ) { return new LockBasedNotNullLazyValue(lock, computable) { @Nullable @@ -104,25 +103,25 @@ public class LockBasedStorageManager implements StorageManager { if (onRecursiveCall == null) { return super.recursionDetected(firstTime); } - return onRecursiveCall.fun(firstTime); + return onRecursiveCall.invoke(firstTime); } @Override protected void postCompute(@NotNull T value) { - postCompute.consume(value); + postCompute.invoke(value); } }; } @NotNull @Override - public NullableLazyValue createNullableLazyValue(@NotNull Computable computable) { + public NullableLazyValue createNullableLazyValue(@NotNull Function0 computable) { return new LockBasedLazyValue(lock, computable); } @NotNull @Override - public NullableLazyValue createRecursionTolerantNullableLazyValue(@NotNull Computable computable, final T onRecursiveCall) { + public NullableLazyValue createRecursionTolerantNullableLazyValue(@NotNull Function0 computable, final T onRecursiveCall) { return new LockBasedLazyValue(lock, computable) { @Override protected T recursionDetected(boolean firstTime) { @@ -134,21 +133,21 @@ public class LockBasedStorageManager implements StorageManager { @NotNull @Override public NullableLazyValue createNullableLazyValueWithPostCompute( - @NotNull Computable computable, @NotNull final Consumer postCompute + @NotNull Function0 computable, @NotNull final Function1 postCompute ) { return new LockBasedLazyValue(lock, computable) { @Override protected void postCompute(@Nullable T value) { - postCompute.consume(value); + postCompute.invoke(value); } }; } @Override - public T compute(@NotNull Computable computable) { + public T compute(@NotNull Function0 computable) { lock.lock(); try { - return computable.compute(); + return computable.invoke(); } finally { lock.unlock(); @@ -164,12 +163,12 @@ public class LockBasedStorageManager implements StorageManager { } private final Lock lock; - private final Computable computable; + private final Function0 computable; @Nullable private volatile Object value = NotValue.NOT_COMPUTED; - public LockBasedLazyValue(@NotNull Lock lock, @NotNull Computable computable) { + public LockBasedLazyValue(@NotNull Lock lock, @NotNull Function0 computable) { this.lock = lock; this.computable = computable; } @@ -200,7 +199,7 @@ public class LockBasedStorageManager implements StorageManager { value = NotValue.COMPUTING; try { - T typedValue = computable.compute(); + T typedValue = computable.invoke(); value = typedValue; postCompute(typedValue); return typedValue; @@ -234,7 +233,7 @@ public class LockBasedStorageManager implements StorageManager { private static class LockBasedNotNullLazyValue extends LockBasedLazyValue implements NotNullLazyValue { - public LockBasedNotNullLazyValue(@NotNull Lock lock, @NotNull Computable computable) { + public LockBasedNotNullLazyValue(@NotNull Lock lock, @NotNull Function0 computable) { super(lock, computable); } @@ -250,9 +249,9 @@ public class LockBasedStorageManager implements StorageManager { private static class MapBasedMemoizedFunction implements MemoizedFunctionToNullable { private final Lock lock; private final ConcurrentMap cache; - private final Function compute; + private final Function1 compute; - public MapBasedMemoizedFunction(@NotNull Lock lock, @NotNull ConcurrentMap map, @NotNull Function compute) { + public MapBasedMemoizedFunction(@NotNull Lock lock, @NotNull ConcurrentMap map, @NotNull Function1 compute) { this.lock = lock; this.cache = map; this.compute = compute; @@ -270,7 +269,7 @@ public class LockBasedStorageManager implements StorageManager { if (value != null) return WrappedValues.unescapeExceptionOrNull(value); try { - V typedValue = compute.fun(input); + V typedValue = compute.invoke(input); Object oldValue = cache.put(input, WrappedValues.escapeNull(typedValue)); assert oldValue == null : "Race condition detected"; @@ -294,7 +293,7 @@ public class LockBasedStorageManager implements StorageManager { public MapBasedMemoizedFunctionToNotNull( @NotNull Lock lock, @NotNull ConcurrentMap map, - @NotNull Function compute + @NotNull Function1 compute ) { super(lock, map, compute); } diff --git a/core/util.runtime/src/org/jetbrains/jet/storage/StorageManager.java b/core/util.runtime/src/org/jetbrains/jet/storage/StorageManager.java index f1e18c03597..290775e3f8b 100644 --- a/core/util.runtime/src/org/jetbrains/jet/storage/StorageManager.java +++ b/core/util.runtime/src/org/jetbrains/jet/storage/StorageManager.java @@ -16,9 +16,8 @@ package org.jetbrains.jet.storage; -import com.intellij.openapi.util.Computable; -import com.intellij.util.Consumer; -import com.intellij.util.Function; +import jet.Function0; +import jet.Function1; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; @@ -29,20 +28,20 @@ public interface StorageManager { * @param valuesReferenceKind how to store the memoized values * * NOTE: if compute() has side-effects the WEAK reference kind is dangerous: the side-effects will be repeated if - * the value gets collected and then re-computed */ @NotNull - MemoizedFunctionToNotNull createMemoizedFunction(@NotNull Function compute, @NotNull ReferenceKind valuesReferenceKind); + MemoizedFunctionToNotNull createMemoizedFunction(@NotNull Function1 compute, @NotNull ReferenceKind valuesReferenceKind); @NotNull - MemoizedFunctionToNullable createMemoizedFunctionWithNullableValues(@NotNull Function compute, @NotNull ReferenceKind valuesReferenceKind); + MemoizedFunctionToNullable createMemoizedFunctionWithNullableValues(@NotNull Function1 compute, @NotNull ReferenceKind valuesReferenceKind); @NotNull - NotNullLazyValue createLazyValue(@NotNull Computable computable); + NotNullLazyValue createLazyValue(@NotNull Function0 computable); @NotNull - NotNullLazyValue createRecursionTolerantLazyValue(@NotNull Computable computable, @NotNull T onRecursiveCall); + NotNullLazyValue createRecursionTolerantLazyValue(@NotNull Function0 computable, @NotNull T onRecursiveCall); /** + * @param computable * @param onRecursiveCall is called if the computation calls itself recursively. * The parameter to it is {@code true} for the first call, {@code false} otherwise. * If {@code onRecursiveCall} is {@code null}, an exception will be thrown on a recursive call, @@ -51,25 +50,25 @@ public interface StorageManager { */ @NotNull NotNullLazyValue createLazyValueWithPostCompute( - @NotNull Computable computable, - @Nullable Function onRecursiveCall, - @NotNull Consumer postCompute + @NotNull Function0 computable, + @Nullable Function1 onRecursiveCall, + @NotNull Function1 postCompute ); @NotNull - NullableLazyValue createNullableLazyValue(@NotNull Computable computable); + NullableLazyValue createNullableLazyValue(@NotNull Function0 computable); @NotNull - NullableLazyValue createRecursionTolerantNullableLazyValue(@NotNull Computable computable, @Nullable T onRecursiveCall); + NullableLazyValue createRecursionTolerantNullableLazyValue(@NotNull Function0 computable, @Nullable T onRecursiveCall); /** * {@code postCompute} is called after the value is computed, but before any other thread sees it (the current thread may * see it in between) */ @NotNull - NullableLazyValue createNullableLazyValueWithPostCompute(@NotNull Computable computable, @NotNull Consumer postCompute); + NullableLazyValue createNullableLazyValueWithPostCompute(@NotNull Function0 computable, @NotNull Function1 postCompute); - T compute(@NotNull Computable computable); + T compute(@NotNull Function0 computable); enum ReferenceKind { STRONG, diff --git a/core/util.runtime/src/org/jetbrains/jet/storage/StorageUtil.java b/core/util.runtime/src/org/jetbrains/jet/storage/StorageUtil.java index d31fe3a6040..9d002302488 100644 --- a/core/util.runtime/src/org/jetbrains/jet/storage/StorageUtil.java +++ b/core/util.runtime/src/org/jetbrains/jet/storage/StorageUtil.java @@ -16,29 +16,36 @@ package org.jetbrains.jet.storage; -import com.intellij.openapi.util.Computable; -import com.intellij.util.Consumer; -import com.intellij.util.Function; +import jet.Function0; +import jet.Function1; import org.jetbrains.annotations.NotNull; import static org.jetbrains.jet.storage.LockBasedStorageManager.NO_LOCKS; public class StorageUtil { + private static final Function1 EMPTY_CONSUMER = new Function1() { + @Override + public Void invoke(Object t) { + return null; + } + }; + + public static NotNullLazyValue createRecursionIntolerantLazyValueWithDefault( @NotNull final T defaultValue, - @NotNull Computable compute + @NotNull Function0 compute ) { //noinspection unchecked return NO_LOCKS.createLazyValueWithPostCompute( compute, - new Function() { + new Function1() { @Override - public T fun(Boolean firstTime) { + public T invoke(Boolean firstTime) { if (firstTime) throw new ReenteringLazyValueComputationException(); return defaultValue; } }, - Consumer.EMPTY_CONSUMER + EMPTY_CONSUMER ); } } diff --git a/idea/src/org/jetbrains/jet/plugin/project/ResolveElementCache.java b/idea/src/org/jetbrains/jet/plugin/project/ResolveElementCache.java index a6757ef7d90..61c6c470275 100644 --- a/idea/src/org/jetbrains/jet/plugin/project/ResolveElementCache.java +++ b/idea/src/org/jetbrains/jet/plugin/project/ResolveElementCache.java @@ -23,6 +23,7 @@ import com.intellij.openapi.project.Project; import com.intellij.psi.PsiElement; import com.intellij.psi.PsiFile; import com.intellij.psi.util.*; +import jet.Function1; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.di.InjectorForBodyResolve; @@ -67,9 +68,9 @@ public class ResolveElementCache { public Result> compute() { StorageManager manager = ResolveElementCache.this.resolveSession.getStorageManager(); MemoizedFunctionToNotNull elementsCacheFunction = - manager.createMemoizedFunction(new com.intellij.util.Function() { + manager.createMemoizedFunction(new Function1() { @Override - public BindingContext fun(JetElement jetElement) { + public BindingContext invoke(JetElement jetElement) { return elementAdditionalResolve(jetElement); } }, StorageManager.ReferenceKind.WEAK);