StorageManager API does not use Computable and Function and more

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<ClassId, ClassDescriptor>() {
+        this.findClass = storageManager.createMemoizedFunctionWithNullableValues(new Function1<ClassId, ClassDescriptor>() {
             @Override
-            public ClassDescriptor fun(ClassId classId) {
+            public ClassDescriptor invoke(ClassId classId) {
                 ClassData classData = getClassData(classId);
                 if (classData == null) {
                     return null;

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<Integer, ClassDescriptor>() {
+        this.classDescriptors = storageManager.createMemoizedFunctionWithNullableValues(new Function1<Integer, ClassDescriptor>() {
             @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<TypeConstructor>() {
+            this.constructor = storageManager.createLazyValue(new Function0<TypeConstructor>() {
                 @Override
-                public TypeConstructor compute() {
+                public TypeConstructor invoke() {
                     return typeConstructor(typeProto);
                 }
             });
-            this.memberScope = storageManager.createLazyValue(new Computable<JetScope>() {
+            this.memberScope = storageManager.createLazyValue(new Function0<JetScope>() {
                 @Override
-                public JetScope compute() {
+                public JetScope invoke() {
                     return computeMemberScope();
                 }
             });

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 jet.Function0;
-import com.intellij.util.Function;
+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<DeclarationDescriptor>() {
+        this.containingDeclaration = storageManager.createLazyValue(new Function0<DeclarationDescriptor>() {
             @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<List<AnnotationDescriptor>>() {
+        this.annotations = storageManager.createLazyValue(new Function0<List<AnnotationDescriptor>>() {
             @Override
-            public List<AnnotationDescriptor> compute() {
+            public List<AnnotationDescriptor> invoke() {
                 return computeAnnotations();
             }
         });
 
-        this.primaryConstructor = storageManager.createNullableLazyValue(new Computable<ConstructorDescriptor>() {
+        this.primaryConstructor = storageManager.createNullableLazyValue(new Function0<ConstructorDescriptor>() {
             @Override
-            public ConstructorDescriptor compute() {
+            public ConstructorDescriptor invoke() {
                 return computePrimaryConstructor();
             }
         });
 
-        this.classObjectDescriptor = storageManager.createNullableLazyValue(new Computable<ClassDescriptor>() {
+        this.classObjectDescriptor = storageManager.createNullableLazyValue(new Function0<ClassDescriptor>() {
             @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<Name> declaredNames) {
             this.declaredNames = declaredNames;
-            this.findClass = storageManager.createMemoizedFunctionWithNullableValues(new Function<Name, ClassDescriptor>() {
+            this.findClass = storageManager.createMemoizedFunctionWithNullableValues(new Function1<Name, ClassDescriptor>() {
                 @Override
-                public ClassDescriptor fun(Name name) {
+                public ClassDescriptor invoke(Name name) {
                     return NestedClassDescriptors.this.declaredNames.contains(name) ?
                            descriptorFinder.findClass(classId.createNestedClassId(name)) :
                            null;

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 jet.Function0;
-import com.intellij.util.Function;
+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<Name, Collection<FunctionDescriptor>>() {
+        this.functions = storageManager.createMemoizedFunction(new Function1<Name, Collection<FunctionDescriptor>>() {
             @Override
-            public Collection<FunctionDescriptor> fun(Name name) {
+            public Collection<FunctionDescriptor> invoke(Name name) {
                 return computeFunctions(name);
             }
         }, STRONG);
-        this.properties = storageManager.createMemoizedFunction(new Function<Name, Collection<VariableDescriptor>>() {
+        this.properties = storageManager.createMemoizedFunction(new Function1<Name, Collection<VariableDescriptor>>() {
             @Override
-            public Collection<VariableDescriptor> fun(Name name) {
+            public Collection<VariableDescriptor> invoke(Name name) {
                 return computeProperties(name);
             }
         }, STRONG);
-        this.allDescriptors = storageManager.createLazyValue(new Computable<Collection<DeclarationDescriptor>>() {
+        this.allDescriptors = storageManager.createLazyValue(new Function0<Collection<DeclarationDescriptor>>() {
             @Override
-            public Collection<DeclarationDescriptor> compute() {
+            public Collection<DeclarationDescriptor> invoke() {
                 return computeAllDescriptors();
             }
         });
-        this.objectDescriptors = storageManager.createLazyValue(new Computable<Collection<ClassDescriptor>>() {
+        this.objectDescriptors = storageManager.createLazyValue(new Function0<Collection<ClassDescriptor>>() {
             @Override
-            public Collection<ClassDescriptor> compute() {
+            public Collection<ClassDescriptor> invoke() {
                 return computeAllObjectDescriptors();
             }
         });

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<JetType>() {
+                                                    new Function0<JetType>() {
                                                         @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<JetType>() {
+                                        new Function0<JetType>() {
                                             @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<JetType>() {
+                                                       new Function0<JetType>() {
                                                            @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<JetType>() {
+                .createEnumClassObjectValuesMethod(classObject, DeferredType.create(trace, new Function0<JetType>() {
                     @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<JetType>() {
+                .createEnumClassObjectValueOfMethod(classObject, DeferredType.create(trace, new Function0<JetType>() {
                     @Override
-                    public JetType compute() {
+                    public JetType invoke() {
                         return enumClassDescriptor.getDefaultType();
                     }
                 }));

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<JetScope>() {
+            return new LazyScopeAdapter(NO_LOCKS.createLazyValue(new Function0<JetScope>() {
                 @Override
-                public JetScope compute() {
+                public JetScope invoke() {
                     return typeParameterDescriptor.getUpperBoundsAsType().getMemberScope();
                 }
             }));

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<JetImportDirective> importDirectives) {
         this.importDirectives = importDirectives;
-        this.importsCacheValue = storageManager.createLazyValue(new Computable<NameToImportsCache>() {
+        this.importsCacheValue = storageManager.createLazyValue(new Function0<NameToImportsCache>() {
             @Override
-            public NameToImportsCache compute() {
+            public NameToImportsCache invoke() {
                 return NameToImportsCache.createIndex(importDirectives);
             }
         });

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 jet.Function0;
-import com.intellij.util.Function;
+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<JetScope>() {
+            return resolveSession.getStorageManager().compute(new Function0<JetScope>() {
                 @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<JetImportDirective, ImportDirectiveResolveCache>() {
+        this.importedScopesProvider = resolveSession.getStorageManager().createMemoizedFunction(new Function1<JetImportDirective, ImportDirectiveResolveCache>() {
             @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<D> descriptorSelector
     ) {
-        return resolveSession.getStorageManager().compute(new Computable<D>() {
+        return resolveSession.getStorageManager().compute(new Function0<D>() {
             @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<D> descriptorsSelector
     ) {
-        return resolveSession.getStorageManager().compute(new Computable<Collection<D>>() {
+        return resolveSession.getStorageManager().compute(new Function0<Collection<D>>() {
             @Override
-            public Collection<D> compute() {
+            public Collection<D> invoke() {
                 Set<D> 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<D> descriptorsSelector
     ) {
-        return resolveSession.getStorageManager().compute(new Computable<Collection<D>>() {
+        return resolveSession.getStorageManager().compute(new Function0<Collection<D>>() {
             @Override
-            public Collection<D> compute() {
+            public Collection<D> invoke() {
                 Set<D> descriptors = Sets.newHashSet();
                 for (JetImportDirective directive : importsProvider.getAllImports()) {
                     if (directive == directiveUnderResolve) {

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<LazyClassDescriptor>() {
+                return storageManager.compute(new Function0<LazyClassDescriptor>() {
                     @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);
                     }

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<JetFile, JetScope>() {
+        this.fileScopes = resolveSession.getStorageManager().createMemoizedFunction(new Function1<JetFile, JetScope>() {
             @Override
-            public JetScope fun(@NotNull JetFile file) {
+            public JetScope invoke(@NotNull JetFile file) {
                 return createFileScope(file);
             }
         }, WEAK);
 
-        this.defaultImportsScope = resolveSession.getStorageManager().createLazyValue(new Computable<JetScope>() {
+        this.defaultImportsScope = resolveSession.getStorageManager().createLazyValue(new Function0<JetScope>() {
             @Override
-            public JetScope compute() {
+            public JetScope invoke() {
                 return createScopeWithDefaultImports();
             }
         });

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<? super JetDeclaration> declarationFilter
     ) {
         this.delegate = delegate;
-        this.filteredDeclarations = storageManager.createLazyValue(new Computable<List<JetDeclaration>>() {
+        this.filteredDeclarations = storageManager.createLazyValue(new Function0<List<JetDeclaration>>() {
             @Override
-            public List<JetDeclaration> compute() {
+            public List<JetDeclaration> invoke() {
                 return Lists.newArrayList(Collections2.filter(delegate.getDeclarations(), declarationFilter));
             }
         });

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> index;
 
     public AbstractPsiBasedDeclarationProvider(@NotNull StorageManager storageManager) {
-        index = storageManager.createLazyValue(new Computable<Index>() {
+        index = storageManager.createLazyValue(new Function0<Index>() {
             @Override
-            public Index compute() {
+            public Index invoke() {
                 Index index = new Index();
                 doCreateIndex(index);
                 return index;

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<Index>() {
+        this.index = storageManager.createLazyValue(new Function0<Index>() {
             @Override
-            public Index compute() {
+            public Index invoke() {
                 return computeFilesByPackage(files);
             }
         });
-        this.packageDeclarationProviders = storageManager.createMemoizedFunctionWithNullableValues(new Function<FqName, PackageMemberDeclarationProvider>() {
+        this.packageDeclarationProviders = storageManager.createMemoizedFunctionWithNullableValues(new Function1<FqName, PackageMemberDeclarationProvider>() {
             @Override
-            public PackageMemberDeclarationProvider fun(FqName fqName) {
+            public PackageMemberDeclarationProvider invoke(FqName fqName) {
                 return createPackageMemberDeclarationProvider(fqName);
             }
         }, StorageManager.ReferenceKind.STRONG);

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<Collection<FqName>>() {
+        this.allDeclaredPackages = storageManager.createLazyValue(new Function0<Collection<FqName>>() {
             @Override
-            public Collection<FqName> compute() {
+            public Collection<FqName> invoke() {
                 return factory.getAllDeclaredSubPackagesOf(fqName);
             }
         });

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<D extends DeclarationDescriptor, D
         this.thisDescriptor = thisDescriptor;
 
         StorageManager storageManager = resolveSession.getStorageManager();
-        this.classDescriptors = storageManager.createMemoizedFunction(new Function<Name, List<ClassDescriptor>>() {
+        this.classDescriptors = storageManager.createMemoizedFunction(new Function1<Name, List<ClassDescriptor>>() {
             @Override
-            public List<ClassDescriptor> fun(Name name) {
+            public List<ClassDescriptor> invoke(Name name) {
                 return resolveClassOrObjectDescriptor(name, false);
             }
         }, STRONG);
-        this.objectDescriptors = storageManager.createMemoizedFunction(new Function<Name, List<ClassDescriptor>>() {
+        this.objectDescriptors = storageManager.createMemoizedFunction(new Function1<Name, List<ClassDescriptor>>() {
             @Override
-            public List<ClassDescriptor> fun(Name name) {
+            public List<ClassDescriptor> invoke(Name name) {
                 return resolveClassOrObjectDescriptor(name, true);
             }
         }, STRONG);
 
-        this.functionDescriptors = storageManager.createMemoizedFunction(new Function<Name, Set<FunctionDescriptor>>() {
+        this.functionDescriptors = storageManager.createMemoizedFunction(new Function1<Name, Set<FunctionDescriptor>>() {
             @Override
-            public Set<FunctionDescriptor> fun(Name name) {
+            public Set<FunctionDescriptor> invoke(Name name) {
                 return doGetFunctions(name);
             }
         }, STRONG);
-        this.propertyDescriptors = storageManager.createMemoizedFunction(new Function<Name, Set<VariableDescriptor>>() {
+        this.propertyDescriptors = storageManager.createMemoizedFunction(new Function1<Name, Set<VariableDescriptor>>() {
             @Override
-            public Set<VariableDescriptor> fun(Name name) {
+            public Set<VariableDescriptor> invoke(Name name) {
                 return doGetProperties(name);
             }
         }, STRONG);
 
-        this.allDescriptors = storageManager.createLazyValue(new Computable<AllDescriptors>() {
+        this.allDescriptors = storageManager.createLazyValue(new Function0<AllDescriptors>() {
             @Override
-            public AllDescriptors compute() {
+            public AllDescriptors invoke() {
                 return computeAllDescriptors();
             }
         });

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 jet.Function0;
-import com.intellij.util.Function;
+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<ReceiverParameterDescriptor>() {
+        this.thisAsReceiverParameter = storageManager.createLazyValue(new Function0<ReceiverParameterDescriptor>() {
             @Override
-            public ReceiverParameterDescriptor compute() {
+            public ReceiverParameterDescriptor invoke() {
                 return DescriptorFactory.createLazyReceiverParameterDescriptor(LazyClassDescriptor.this);
             }
         });
-        this.annotations = storageManager.createLazyValue(new Computable<List<AnnotationDescriptor>>() {
+        this.annotations = storageManager.createLazyValue(new Function0<List<AnnotationDescriptor>>() {
             @Override
-            public List<AnnotationDescriptor> compute() {
+            public List<AnnotationDescriptor> invoke() {
                 return resolveAnnotations();
             }
         });
-        this.classObjectDescriptor = storageManager.createNullableLazyValue(new Computable<ClassDescriptor>() {
+        this.classObjectDescriptor = storageManager.createNullableLazyValue(new Function0<ClassDescriptor>() {
             @Override
-            public ClassDescriptor compute() {
+            public ClassDescriptor invoke() {
                 return computeClassObjectDescriptor();
             }
         });
-        this.scopeForClassHeaderResolution = storageManager.createLazyValue(new Computable<JetScope>() {
+        this.scopeForClassHeaderResolution = storageManager.createLazyValue(new Function0<JetScope>() {
             @Override
-            public JetScope compute() {
+            public JetScope invoke() {
                 return computeScopeForClassHeaderResolution();
             }
         });
-        this.scopeForMemberDeclarationResolution = storageManager.createLazyValue(new Computable<JetScope>() {
+        this.scopeForMemberDeclarationResolution = storageManager.createLazyValue(new Function0<JetScope>() {
             @Override
-            public JetScope compute() {
+            public JetScope invoke() {
                 return computeScopeForMemberDeclarationResolution();
             }
         });
-        this.scopeForPropertyInitializerResolution = storageManager.createLazyValue(new Computable<JetScope>() {
+        this.scopeForPropertyInitializerResolution = storageManager.createLazyValue(new Function0<JetScope>() {
             @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<Collection<JetType>> supertypes = resolveSession.getStorageManager().createLazyValueWithPostCompute(
-                new Computable<Collection<JetType>>() {
+                new Function0<Collection<JetType>>() {
                     @Override
-                    public Collection<JetType> compute() {
+                    public Collection<JetType> invoke() {
                         if (resolveSession.isClassSpecial(DescriptorUtils.getFQName(LazyClassDescriptor.this))) {
                             return Collections.emptyList();
                         }
@@ -396,22 +395,23 @@ public class LazyClassDescriptor extends ClassDescriptorBase implements LazyDesc
                         }
                     }
                 },
-                new Function<Boolean, Collection<JetType>>() {
+                new Function1<Boolean, Collection<JetType>>() {
                     @Override
-                    public Collection<JetType> fun(Boolean firstTime) {
+                    public Collection<JetType> invoke(Boolean firstTime) {
                         return Collections.emptyList();
                     }
                 },
-                new Consumer<Collection<JetType>>() {
+                new Function1<Collection<JetType>, Void>() {
                     @Override
-                    public void consume(@NotNull Collection<JetType> supertypes) {
+                    public Void invoke(@NotNull Collection<JetType> supertypes) {
                         findAndDisconnectLoopsInTypeHierarchy(supertypes);
+                        return null;
                     }
                 });
 
-        private final NotNullLazyValue<List<TypeParameterDescriptor>> parameters = resolveSession.getStorageManager().createLazyValue(new Computable<List<TypeParameterDescriptor>>() {
+        private final NotNullLazyValue<List<TypeParameterDescriptor>> parameters = resolveSession.getStorageManager().createLazyValue(new Function0<List<TypeParameterDescriptor>>() {
             @Override
-            public List<TypeParameterDescriptor> compute() {
+            public List<TypeParameterDescriptor> invoke() {
                 JetClassLikeInfo classInfo = declarationProvider.getOwnerInfo();
                 List<JetTypeParameter> typeParameters = classInfo.getTypeParameters();
 

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<LazyClassDescr
             @NotNull LazyClassDescriptor thisClass
     ) {
         super(resolveSession, declarationProvider, thisClass);
-        this.primaryConstructor = resolveSession.getStorageManager().createNullableLazyValue(new Computable<ConstructorDescriptor>() {
+        this.primaryConstructor = resolveSession.getStorageManager().createNullableLazyValue(new Function0<ConstructorDescriptor>() {
             @Override
-            public ConstructorDescriptor compute() {
+            public ConstructorDescriptor invoke() {
                 return resolvePrimaryConstructor();
             }
         });
@@ -378,9 +378,9 @@ public class LazyClassMemberScope extends AbstractLazyMemberScope<LazyClassDescr
 
     private void setDeferredReturnType(@NotNull ConstructorDescriptorImpl descriptor) {
         descriptor.setReturnType(DeferredType.create(resolveSession.getTrace(), resolveSession.getStorageManager().createLazyValue(
-                new Computable<JetType>() {
+                new Function0<JetType>() {
                     @Override
-                    public JetType compute() {
+                    public JetType invoke() {
                         return thisDescriptor.getDefaultType();
                     }
                 })

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<NamespaceDes
         super(resolveSession, declarationProvider, thisPackage);
 
         this.packageDescriptors = resolveSession.getStorageManager().createMemoizedFunctionWithNullableValues(
-                new Function<Name, NamespaceDescriptor>() {
+                new Function1<Name, NamespaceDescriptor>() {
                     @Override
-                    public NamespaceDescriptor fun(Name name) {
+                    public NamespaceDescriptor invoke(Name name) {
                         return createPackageDescriptor(name);
                     }
                 }, StorageManager.ReferenceKind.STRONG);

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<JetType> compute) {
+    public static DeferredType create(BindingTrace trace, Function0<JetType> compute) {
         return create(trace, LockBasedStorageManager.NO_LOCKS.createLazyValue(compute));
     }
 

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<JetType>() {
+                            new Function0<JetType>() {
                                 @Override
-                                public JetType compute() {
+                                public JetType invoke() {
                                     return descriptor.getDefaultType();
                                 }
                             }));

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<String> rec = m.createLazyValue(new Computable<String>() {
+            NotNullLazyValue<String> rec = m.createLazyValue(new Function0<String>() {
                 @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<String> rec = m.createNullableLazyValue(new Computable<String>() {
+            NullableLazyValue<String> rec = m.createNullableLazyValue(new Function0<String>() {
                 @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<String> rec = m.createRecursionTolerantLazyValue(new Computable<String>() {
+            NotNullLazyValue<String> rec = m.createRecursionTolerantLazyValue(new Function0<String>() {
                 @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<String> rec = m.createRecursionTolerantNullableLazyValue(new Computable<String>() {
+            NullableLazyValue<String> rec = m.createRecursionTolerantNullableLazyValue(new Function0<String>() {
                 @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<String> rec = m.createLazyValueWithPostCompute(
-                    new Computable<String>() {
+                    new Function0<String>() {
                         @Override
-                        public String compute() {
+                        public String invoke() {
                             return rec.invoke();
                         }
                     },
                     null,
-                    Consumer.EMPTY_CONSUMER
+                    new Function1<String, Void>() {
+                        @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<String> rec = m.createLazyValueWithPostCompute(
-                    new Computable<String>() {
+                    new Function0<String>() {
                         @Override
-                        public String compute() {
+                        public String invoke() {
                             return rec.invoke();
                         }
                     },
-                    new Function<Boolean, String>() {
+                    new Function1<Boolean, String>() {
                         @Override
-                        public String fun(Boolean aBoolean) {
+                        public String invoke(Boolean aBoolean) {
                             return "tolerant";
                         }
                     },
-                    new Consumer<String>() {
+                    new Function1<String, Void>() {
                         @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<Collection<String>> v = m.createLazyValueWithPostCompute(
-                new Computable<Collection<String>>() {
+                new Function0<Collection<String>>() {
                     @Override
-                    public Collection<String> compute() {
+                    public Collection<String> invoke() {
                         List<String> strings = new ArrayList<String>();
                         strings.add("first");
                         return strings;
                     }
                 },
                 null,
-                new Consumer<Collection<String>>() {
+                new Function1<Collection<String>, Void>() {
                     @Override
-                    public void consume(Collection<String> strings) {
+                    public Void invoke(Collection<String> 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<Collection<String>> v = m.createNullableLazyValueWithPostCompute(
-                new Computable<Collection<String>>() {
+                new Function0<Collection<String>>() {
                     @Override
-                    public Collection<String> compute() {
+                    public Collection<String> invoke() {
                         ArrayList<String> strings = new ArrayList<String>();
                         strings.add("first");
                         return strings;
                     }
                 },
-                new Consumer<Collection<String>>() {
+                new Function1<Collection<String>, Void>() {
                     @Override
-                    public void consume(Collection<String> strings) {
+                    public Void invoke(Collection<String> strings) {
                         counter.inc();
                         strings.add("postComputed");
+                        return null;                        
                     }
                 }
         );
@@ -342,25 +347,26 @@ public class StorageManagerTest extends TestCase {
         @SuppressWarnings("unchecked")
         class C {
             NotNullLazyValue<String> rec = m.createLazyValueWithPostCompute(
-                    new Computable<String>() {
+                    new Function0<String>() {
                         @Override
-                        public String compute() {
+                        public String invoke() {
                             return rec.invoke();
                         }
                     },
-                    new Function<Boolean, String>() {
+                    new Function1<Boolean, String>() {
                         @Override
-                        public String fun(Boolean firstTime) {
+                        public String invoke(Boolean firstTime) {
                             if (firstTime) {
                                 throw new ReenteringLazyValueComputationException();
                             }
                             return "second";
                         }
                     },
-                    new Consumer<String>() {
+                    new Function1<String, Void>() {
                         @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<String>, Counter {
+    private static class CounterValueNull extends CounterImpl implements Function0<String>, 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<String, String>, Counter {
+    private static class CounterFunctionToNull extends CounterImpl implements Function1<String, String>, 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();
         }

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<KotlinJvmBinaryClass, Map<MemberSignature, List<AnnotationDescriptor>>> memberAnnotations =
             storageManager.createMemoizedFunction(
-                    new Function<KotlinJvmBinaryClass, Map<MemberSignature, List<AnnotationDescriptor>>>() {
+                    new Function1<KotlinJvmBinaryClass, Map<MemberSignature, List<AnnotationDescriptor>>>() {
                         @NotNull
                         @Override
-                        public Map<MemberSignature, List<AnnotationDescriptor>> fun(@NotNull KotlinJvmBinaryClass kotlinClass) {
+                        public Map<MemberSignature, List<AnnotationDescriptor>> invoke(@NotNull KotlinJvmBinaryClass kotlinClass) {
                             try {
                                 return loadMemberAnnotationsFromClass(kotlinClass);
                             }

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<TypeConstructor>() {
+        this.typeConstructor = storageManager.createLazyValue(new Function0<TypeConstructor>() {
             @Override
-            public TypeConstructor compute() {
+            public TypeConstructor invoke() {
                 return createTypeConstructor();
             }
         });
-        this.defaultType = storageManager.createLazyValue(new Computable<JetType>() {
+        this.defaultType = storageManager.createLazyValue(new Function0<JetType>() {
             @Override
-            public JetType compute() {
+            public JetType invoke() {
                 return createDefaultType(storageManager);
             }
         });
-        this.upperBounds = storageManager.createLazyValue(new Computable<Set<JetType>>() {
+        this.upperBounds = storageManager.createLazyValue(new Function0<Set<JetType>>() {
             @Override
-            public Set<JetType> compute() {
+            public Set<JetType> invoke() {
                 return resolveUpperBounds();
             }
         });
-        this.upperBoundsAsType = storageManager.createLazyValue(new Computable<JetType>() {
+        this.upperBoundsAsType = storageManager.createLazyValue(new Function0<JetType>() {
             @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<JetScope>() {
+                new Function0<JetScope>() {
                     @Override
-                    public JetScope compute() {
+                    public JetScope invoke() {
                         return getUpperBoundsAsType().getMemberScope();
                     }
                 }

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.<TypeProjection>emptyList(),
-                            new LazyScopeAdapter(NO_LOCKS.createLazyValue(new Computable<JetScope>() {
+                            new LazyScopeAdapter(NO_LOCKS.createLazyValue(new Function0<JetScope>() {
                                 @Override
-                                public JetScope compute() {
+                                public JetScope invoke() {
                                     return getUpperBoundsAsType().getMemberScope();
                                 }
                             })));

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<Collection<Name>>() {
+            classNames = storageManager.createLazyValue(new Function0<Collection<Name>>() {
                 @Override
                 @NotNull
-                public Collection<Name> compute() {
+                public Collection<Name> invoke() {
                     InputStream in = getStream(BuiltInsSerializationUtil.getClassNamesFilePath(BuiltinsNamespaceDescriptorImpl.this));
 
                     try {

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 <K, V> MemoizedFunctionToNotNull<K, V> createMemoizedFunction(
-            @NotNull Function<K, V> compute, @NotNull ReferenceKind valuesReferenceKind
+            @NotNull Function1<K, V> compute, @NotNull ReferenceKind valuesReferenceKind
     ) {
         ConcurrentMap<K, Object> map = createConcurrentMap(valuesReferenceKind);
         return new MapBasedMemoizedFunctionToNotNull<K, V>(lock, map, compute);
@@ -61,7 +60,7 @@ public class LockBasedStorageManager implements StorageManager {
     @NotNull
     @Override
     public <K, V> MemoizedFunctionToNullable<K, V> createMemoizedFunctionWithNullableValues(
-            @NotNull Function<K, V> compute, @NotNull ReferenceKind valuesReferenceKind
+            @NotNull Function1<K, V> compute, @NotNull ReferenceKind valuesReferenceKind
     ) {
         ConcurrentMap<K, Object> map = createConcurrentMap(valuesReferenceKind);
         return new MapBasedMemoizedFunction<K, V>(lock, map, compute);
@@ -73,14 +72,14 @@ public class LockBasedStorageManager implements StorageManager {
 
     @NotNull
     @Override
-    public <T> NotNullLazyValue<T> createLazyValue(@NotNull Computable<T> computable) {
+    public <T> NotNullLazyValue<T> createLazyValue(@NotNull Function0<T> computable) {
         return new LockBasedNotNullLazyValue<T>(lock, computable);
     }
 
     @NotNull
     @Override
     public <T> NotNullLazyValue<T> createRecursionTolerantLazyValue(
-            @NotNull Computable<T> computable, @NotNull final T onRecursiveCall
+            @NotNull Function0<T> computable, @NotNull final T onRecursiveCall
     ) {
         return new LockBasedNotNullLazyValue<T>(lock, computable) {
             @Override
@@ -93,9 +92,9 @@ public class LockBasedStorageManager implements StorageManager {
     @NotNull
     @Override
     public <T> NotNullLazyValue<T> createLazyValueWithPostCompute(
-            @NotNull Computable<T> computable,
+            @NotNull Function0<T> computable,
-            final Function<Boolean, T> onRecursiveCall,
+            final Function1<Boolean, T> onRecursiveCall,
-            @NotNull final Consumer<T> postCompute
+            @NotNull final Function1<T, Void> postCompute
     ) {
         return new LockBasedNotNullLazyValue<T>(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 <T> NullableLazyValue<T> createNullableLazyValue(@NotNull Computable<T> computable) {
+    public <T> NullableLazyValue<T> createNullableLazyValue(@NotNull Function0<T> computable) {
         return new LockBasedLazyValue<T>(lock, computable);
     }
 
     @NotNull
     @Override
-    public <T> NullableLazyValue<T> createRecursionTolerantNullableLazyValue(@NotNull Computable<T> computable, final T onRecursiveCall) {
+    public <T> NullableLazyValue<T> createRecursionTolerantNullableLazyValue(@NotNull Function0<T> computable, final T onRecursiveCall) {
         return new LockBasedLazyValue<T>(lock, computable) {
             @Override
             protected T recursionDetected(boolean firstTime) {
@@ -134,21 +133,21 @@ public class LockBasedStorageManager implements StorageManager {
     @NotNull
     @Override
     public <T> NullableLazyValue<T> createNullableLazyValueWithPostCompute(
-            @NotNull Computable<T> computable, @NotNull final Consumer<T> postCompute
+            @NotNull Function0<T> computable, @NotNull final Function1<T, Void> postCompute
     ) {
         return new LockBasedLazyValue<T>(lock, computable) {
             @Override
             protected void postCompute(@Nullable T value) {
-                postCompute.consume(value);
+                postCompute.invoke(value);
             }
         };
     }
 
     @Override
-    public <T> T compute(@NotNull Computable<T> computable) {
+    public <T> T compute(@NotNull Function0<T> 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<T> computable;
+        private final Function0<T> computable;
 
         @Nullable
         private volatile Object value = NotValue.NOT_COMPUTED;
 
-        public LockBasedLazyValue(@NotNull Lock lock, @NotNull Computable<T> computable) {
+        public LockBasedLazyValue(@NotNull Lock lock, @NotNull Function0<T> 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<T> extends LockBasedLazyValue<T> implements NotNullLazyValue<T> {
 
-        public LockBasedNotNullLazyValue(@NotNull Lock lock, @NotNull Computable<T> computable) {
+        public LockBasedNotNullLazyValue(@NotNull Lock lock, @NotNull Function0<T> computable) {
             super(lock, computable);
         }
 
@@ -250,9 +249,9 @@ public class LockBasedStorageManager implements StorageManager {
     private static class MapBasedMemoizedFunction<K, V> implements MemoizedFunctionToNullable<K, V> {
         private final Lock lock;
         private final ConcurrentMap<K, Object> cache;
-        private final Function<K, V> compute;
+        private final Function1<K, V> compute;
 
-        public MapBasedMemoizedFunction(@NotNull Lock lock, @NotNull ConcurrentMap<K, Object> map, @NotNull Function<K, V> compute) {
+        public MapBasedMemoizedFunction(@NotNull Lock lock, @NotNull ConcurrentMap<K, Object> map, @NotNull Function1<K, V> 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<K, Object> map,
-                @NotNull Function<K, V> compute
+                @NotNull Function1<K, V> compute
         ) {
             super(lock, map, compute);
         }

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 jet.Function0;
-import com.intellij.util.Consumer;
+import jet.Function1;
-import com.intellij.util.Function;
 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
-    <K, V> MemoizedFunctionToNotNull<K, V> createMemoizedFunction(@NotNull Function<K, V> compute, @NotNull ReferenceKind valuesReferenceKind);
+    <K, V> MemoizedFunctionToNotNull<K, V> createMemoizedFunction(@NotNull Function1<K, V> compute, @NotNull ReferenceKind valuesReferenceKind);
     @NotNull
-    <K, V> MemoizedFunctionToNullable<K, V> createMemoizedFunctionWithNullableValues(@NotNull Function<K, V> compute, @NotNull ReferenceKind valuesReferenceKind);
+    <K, V> MemoizedFunctionToNullable<K, V> createMemoizedFunctionWithNullableValues(@NotNull Function1<K, V> compute, @NotNull ReferenceKind valuesReferenceKind);
 
     @NotNull
-    <T> NotNullLazyValue<T> createLazyValue(@NotNull Computable<T> computable);
+    <T> NotNullLazyValue<T> createLazyValue(@NotNull Function0<T> computable);
 
     @NotNull
-    <T> NotNullLazyValue<T> createRecursionTolerantLazyValue(@NotNull Computable<T> computable, @NotNull T onRecursiveCall);
+    <T> NotNullLazyValue<T> createRecursionTolerantLazyValue(@NotNull Function0<T> 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
     <T> NotNullLazyValue<T> createLazyValueWithPostCompute(
-            @NotNull Computable<T> computable,
+            @NotNull Function0<T> computable,
-            @Nullable Function<Boolean, T> onRecursiveCall,
+            @Nullable Function1<Boolean, T> onRecursiveCall,
-            @NotNull Consumer<T> postCompute
+            @NotNull Function1<T, Void> postCompute
     );
 
     @NotNull
-    <T> NullableLazyValue<T> createNullableLazyValue(@NotNull Computable<T> computable);
+    <T> NullableLazyValue<T> createNullableLazyValue(@NotNull Function0<T> computable);
 
     @NotNull
-    <T> NullableLazyValue<T> createRecursionTolerantNullableLazyValue(@NotNull Computable<T> computable, @Nullable T onRecursiveCall);
+    <T> NullableLazyValue<T> createRecursionTolerantNullableLazyValue(@NotNull Function0<T> 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
-    <T> NullableLazyValue<T> createNullableLazyValueWithPostCompute(@NotNull Computable<T> computable, @NotNull Consumer<T> postCompute);
+    <T> NullableLazyValue<T> createNullableLazyValueWithPostCompute(@NotNull Function0<T> computable, @NotNull Function1<T, Void> postCompute);
 
-    <T> T compute(@NotNull Computable<T> computable);
+    <T> T compute(@NotNull Function0<T> computable);
 
     enum ReferenceKind {
         STRONG,

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 jet.Function0;
-import com.intellij.util.Consumer;
+import jet.Function1;
-import com.intellij.util.Function;
 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<Object, Void>() {
+                @Override
+                public Void invoke(Object t) {
+                    return null;
+                }
+            };
+
+
     public static <T> NotNullLazyValue<T> createRecursionIntolerantLazyValueWithDefault(
             @NotNull final T defaultValue,
-            @NotNull Computable<T> compute
+            @NotNull Function0<T> compute
     ) {
         //noinspection unchecked
         return NO_LOCKS.createLazyValueWithPostCompute(
                 compute,
-                new Function<Boolean, T>() {
+                new Function1<Boolean, T>() {
                     @Override
-                    public T fun(Boolean firstTime) {
+                    public T invoke(Boolean firstTime) {
                         if (firstTime) throw new ReenteringLazyValueComputationException();
                         return defaultValue;
                     }
                 },
-                Consumer.EMPTY_CONSUMER
+                EMPTY_CONSUMER
         );
     }
 }

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<MemoizedFunctionToNotNull<JetElement, BindingContext>> compute() {
                                 StorageManager manager = ResolveElementCache.this.resolveSession.getStorageManager();
                                 MemoizedFunctionToNotNull<JetElement, BindingContext> elementsCacheFunction =
-                                        manager.createMemoizedFunction(new com.intellij.util.Function<JetElement, BindingContext>() {
+                                        manager.createMemoizedFunction(new Function1<JetElement, BindingContext>() {
                                             @Override
-                                            public BindingContext fun(JetElement jetElement) {
+                                            public BindingContext invoke(JetElement jetElement) {
                                                 return elementAdditionalResolve(jetElement);
                                             }
                                         }, StorageManager.ReferenceKind.WEAK);