Thread-safe lazy values used in lazy resolve

compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/descriptors/LazyClassMemberScope.java

@@ -34,7 +34,6 @@ import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 import org.jetbrains.jet.lang.types.DeferredType;
 import org.jetbrains.jet.lang.types.JetType;
 import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
-import org.jetbrains.jet.storage.NotNullLazyValueImpl;
 import org.jetbrains.jet.storage.NullableLazyValue;
 
 import java.util.Collection;
@@ -378,13 +377,14 @@ public class LazyClassMemberScope extends AbstractLazyMemberScope<LazyClassDescr
     }
 
     private void setDeferredReturnType(@NotNull ConstructorDescriptorImpl descriptor) {
-        descriptor.setReturnType(DeferredType.create(resolveSession.getTrace(), new NotNullLazyValueImpl<JetType>() {
+        descriptor.setReturnType(DeferredType.create(resolveSession.getTrace(), resolveSession.getStorageManager().createLazyValue(
-            @NotNull
+                new Computable<JetType>() {
-            @Override
+                    @Override
-            protected JetType doCompute() {
+                    public JetType compute() {
-                return thisDescriptor.getDefaultType();
+                        return thisDescriptor.getDefaultType();
-            }
+                    }
-        }));
+                })
+        ));
     }
 
     @Override

compiler/frontend/src/org/jetbrains/jet/lang/types/DeferredType.java

@@ -20,9 +20,9 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
 import org.jetbrains.jet.lang.resolve.BindingTrace;
 import org.jetbrains.jet.lang.resolve.scopes.JetScope;
-import org.jetbrains.jet.storage.NotNullLazyValueImpl;
+import org.jetbrains.jet.storage.NotNullLazyValue;
-import org.jetbrains.jet.util.Box;
 import org.jetbrains.jet.storage.ReenteringLazyValueComputationException;
+import org.jetbrains.jet.util.Box;
 
 import java.util.List;
 
@@ -30,15 +30,15 @@ import static org.jetbrains.jet.lang.resolve.BindingContext.DEFERRED_TYPE;
 
 public class DeferredType implements JetType {
     
-    public static DeferredType create(BindingTrace trace, NotNullLazyValueImpl<JetType> lazyValue) {
+    public static DeferredType create(BindingTrace trace, NotNullLazyValue<JetType> lazyValue) {
         DeferredType deferredType = new DeferredType(lazyValue);
         trace.record(DEFERRED_TYPE, new Box<DeferredType>(deferredType));
         return deferredType;
     }
     
-    private final NotNullLazyValueImpl<JetType> lazyValue;
+    private final NotNullLazyValue<JetType> lazyValue;
 
-    private DeferredType(NotNullLazyValueImpl<JetType> lazyValue) {
+    private DeferredType(NotNullLazyValue<JetType> lazyValue) {
         this.lazyValue = lazyValue;
     }
 

core/descriptors/src/org/jetbrains/jet/lang/descriptors/impl/AbstractLazyTypeParameterDescriptor.java

@@ -31,7 +31,6 @@ import org.jetbrains.jet.lang.types.checker.JetTypeChecker;
 import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
 import org.jetbrains.jet.renderer.DescriptorRenderer;
 import org.jetbrains.jet.storage.NotNullLazyValue;
-import org.jetbrains.jet.storage.NotNullLazyValueImpl;
 import org.jetbrains.jet.storage.StorageManager;
 
 import java.util.Collection;
@@ -53,7 +52,7 @@ public abstract class AbstractLazyTypeParameterDescriptor implements TypeParamet
     private final NotNullLazyValue<JetType> upperBoundsAsType;
 
     public AbstractLazyTypeParameterDescriptor(
-            @NotNull StorageManager storageManager,
+            @NotNull final StorageManager storageManager,
             @NotNull DeclarationDescriptor containingDeclaration,
             @NotNull Name name,
             @NotNull Variance variance,
@@ -75,7 +74,7 @@ public abstract class AbstractLazyTypeParameterDescriptor implements TypeParamet
         this.defaultType = storageManager.createLazyValue(new Computable<JetType>() {
             @Override
             public JetType compute() {
-                return createDefaultType();
+                return createDefaultType(storageManager);
             }
         });
         this.upperBounds = storageManager.createLazyValue(new Computable<Set<JetType>>() {
@@ -197,14 +196,15 @@ public abstract class AbstractLazyTypeParameterDescriptor implements TypeParamet
     }
 
     @NotNull
-    private JetType createDefaultType() {
+    private JetType createDefaultType(@NotNull StorageManager storageManager) {
-        return new JetTypeImpl(getTypeConstructor(), new LazyScopeAdapter(new NotNullLazyValueImpl<JetScope>() {
+        return new JetTypeImpl(getTypeConstructor(), new LazyScopeAdapter(storageManager.createLazyValue(
-                        @NotNull
+                new Computable<JetScope>() {
-                        @Override
+                    @Override
-                        protected JetScope doCompute() {
+                    public JetScope compute() {
-                            return getUpperBoundsAsType().getMemberScope();
+                        return getUpperBoundsAsType().getMemberScope();
-                        }
+                    }
-                    }));
+                }
+        )));
     }
 
     @Override