From 9bb77b09a3547cc52ded454d056c262c7c9d248c Mon Sep 17 00:00:00 2001 From: Andrey Breslav Date: Tue, 1 Oct 2013 21:23:24 +0400 Subject: [PATCH] Lazy values unified in the project --- .../jet/lang/resolve/DescriptorResolver.java | 28 +++++---- .../jet/lang/resolve/TypeResolver.java | 7 ++- .../descriptors/LazyClassMemberScope.java | 9 +-- .../jet/lang/types/DeferredType.java | 10 +-- .../ClosureExpressionsTypingVisitor.java | 7 ++- ...cursionIntolerantLazyValueWithDefault.java | 32 ---------- .../AbstractLazyTypeParameterDescriptor.java | 11 ++-- .../impl/TypeParameterDescriptorImpl.java | 7 ++- .../lang/resolve/scopes/LazyScopeAdapter.java | 8 +-- .../utils/RecursionIntolerantLazyValue.java | 61 ------------------- 10 files changed, 48 insertions(+), 132 deletions(-) delete mode 100644 compiler/frontend/src/org/jetbrains/jet/util/RecursionIntolerantLazyValueWithDefault.java delete mode 100644 core/util.runtime/src/org/jetbrains/jet/utils/RecursionIntolerantLazyValue.java 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 56dbc099ecc..628b46ff8fb 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DescriptorResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DescriptorResolver.java @@ -42,8 +42,8 @@ import org.jetbrains.jet.lang.types.expressions.ExpressionTypingServices; import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; import org.jetbrains.jet.lexer.JetKeywordToken; import org.jetbrains.jet.lexer.JetTokens; -import org.jetbrains.jet.util.RecursionIntolerantLazyValueWithDefault; -import org.jetbrains.jet.utils.RecursionIntolerantLazyValue; +import org.jetbrains.jet.storage.NotNullLazyValueImpl; +import org.jetbrains.jet.storage.NotNullLazyValueWithDefault; import javax.inject.Inject; import java.util.*; @@ -313,9 +313,10 @@ public class DescriptorResolver { JetExpression bodyExpression = function.getBodyExpression(); if (bodyExpression != null) { returnType = - DeferredType.create(trace, new RecursionIntolerantLazyValueWithDefault(ErrorUtils.createErrorType("Recursive dependency")) { + DeferredType.create(trace, new NotNullLazyValueWithDefault(ErrorUtils.createErrorType("Recursive dependency")) { + @NotNull @Override - protected JetType compute() { + protected JetType doCompute() { JetType type = expressionTypingServices.getBodyExpressionType(trace, scope, dataFlowInfo, function, functionDescriptor); return transformAnonymousTypeIfNeeded(functionDescriptor, function, type, trace); } @@ -1027,9 +1028,10 @@ public class DescriptorResolver { if (hasDelegate && variableDescriptor instanceof PropertyDescriptor) { final JetExpression propertyDelegateExpression = ((JetProperty) variable).getDelegateExpression(); if (propertyDelegateExpression != null) { - return DeferredType.create(trace, new RecursionIntolerantLazyValueWithDefault(ErrorUtils.createErrorType("Recursive dependency")) { + return DeferredType.create(trace, new NotNullLazyValueWithDefault(ErrorUtils.createErrorType("Recursive dependency")) { + @NotNull @Override - protected JetType compute() { + protected JetType doCompute() { return resolveDelegatedPropertyType((PropertyDescriptor) variableDescriptor, scope, propertyDelegateExpression, dataFlowInfo, trace); } @@ -1043,9 +1045,9 @@ public class DescriptorResolver { } else { if (notLocal) { - return DeferredType.create(trace, new RecursionIntolerantLazyValueWithDefault(ErrorUtils.createErrorType("Recursive dependency")) { + return DeferredType.create(trace, new NotNullLazyValueWithDefault(ErrorUtils.createErrorType("Recursive dependency")) { @Override - protected JetType compute() { + protected JetType doCompute() { JetType type = resolveInitializerType(scope, initializer, dataFlowInfo, trace); return transformAnonymousTypeIfNeeded(variableDescriptor, variable, type, trace); @@ -1368,9 +1370,10 @@ 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 RecursionIntolerantLazyValue() { + .createEnumClassObjectValuesMethod(classObject, DeferredType.create(trace, new NotNullLazyValueImpl() { + @NotNull @Override - protected JetType compute() { + protected JetType doCompute() { return KotlinBuiltIns.getInstance().getArrayType(enumClassDescriptor.getDefaultType()); } })); @@ -1385,9 +1388,10 @@ 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 RecursionIntolerantLazyValue() { + .createEnumClassObjectValueOfMethod(classObject, DeferredType.create(trace, new NotNullLazyValueImpl() { + @NotNull @Override - protected JetType compute() { + protected JetType doCompute() { 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 a484a96e04c..f65aa0c3767 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TypeResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TypeResolver.java @@ -25,7 +25,7 @@ import org.jetbrains.jet.lang.resolve.scopes.JetScope; import org.jetbrains.jet.lang.resolve.scopes.LazyScopeAdapter; import org.jetbrains.jet.lang.types.*; import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; -import org.jetbrains.jet.utils.RecursionIntolerantLazyValue; +import org.jetbrains.jet.storage.NotNullLazyValueImpl; import javax.inject.Inject; import java.util.ArrayList; @@ -239,9 +239,10 @@ public class TypeResolver { return typeParameterDescriptor.getUpperBoundsAsType().getMemberScope(); } else { - return new LazyScopeAdapter(new RecursionIntolerantLazyValue() { + return new LazyScopeAdapter(new NotNullLazyValueImpl() { + @NotNull @Override - protected JetScope compute() { + protected JetScope doCompute() { return typeParameterDescriptor.getUpperBoundsAsType().getMemberScope(); } }); 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 a6b9e162f2f..4527c3fed4c 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 @@ -29,13 +29,13 @@ import org.jetbrains.jet.lang.resolve.*; import org.jetbrains.jet.lang.resolve.lazy.ResolveSession; import org.jetbrains.jet.lang.resolve.lazy.data.JetClassLikeInfo; import org.jetbrains.jet.lang.resolve.lazy.declarations.ClassMemberDeclarationProvider; -import org.jetbrains.jet.storage.NullableLazyValue; import org.jetbrains.jet.lang.resolve.name.Name; 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.utils.RecursionIntolerantLazyValue; +import org.jetbrains.jet.storage.NotNullLazyValueImpl; +import org.jetbrains.jet.storage.NullableLazyValue; import java.util.Collection; import java.util.Collections; @@ -378,9 +378,10 @@ public class LazyClassMemberScope extends AbstractLazyMemberScope() { + descriptor.setReturnType(DeferredType.create(resolveSession.getTrace(), new NotNullLazyValueImpl() { + @NotNull @Override - protected JetType compute() { + protected JetType doCompute() { return thisDescriptor.getDefaultType(); } })); 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 d7bbdc40654..b09eea68f73 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/types/DeferredType.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/DeferredType.java @@ -20,8 +20,8 @@ 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.util.Box; -import org.jetbrains.jet.utils.RecursionIntolerantLazyValue; import org.jetbrains.jet.utils.ReenteringLazyValueComputationException; 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, RecursionIntolerantLazyValue lazyValue) { + public static DeferredType create(BindingTrace trace, NotNullLazyValueImpl lazyValue) { DeferredType deferredType = new DeferredType(lazyValue); trace.record(DEFERRED_TYPE, new Box(deferredType)); return deferredType; } - private final RecursionIntolerantLazyValue lazyValue; + private final NotNullLazyValueImpl lazyValue; - private DeferredType(RecursionIntolerantLazyValue lazyValue) { + private DeferredType(NotNullLazyValueImpl lazyValue) { this.lazyValue = lazyValue; } @@ -48,7 +48,7 @@ public class DeferredType implements JetType { @NotNull public JetType getActualType() { - return lazyValue.get(); + return lazyValue.compute(); } @Override 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 fbad40619d3..22451c374d8 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 @@ -33,7 +33,7 @@ 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.lang.types.lang.KotlinBuiltIns; -import org.jetbrains.jet.util.RecursionIntolerantLazyValueWithDefault; +import org.jetbrains.jet.storage.NotNullLazyValueWithDefault; import org.jetbrains.jet.util.slicedmap.WritableSlice; import java.util.Collection; @@ -66,9 +66,10 @@ public class ClosureExpressionsTypingVisitor extends ExpressionTypingVisitor { @Override public void handleRecord(WritableSlice slice, PsiElement declaration, final ClassDescriptor descriptor) { if (slice == CLASS && declaration == expression.getObjectDeclaration()) { - JetType defaultType = DeferredType.create(context.trace, new RecursionIntolerantLazyValueWithDefault(ErrorUtils.createErrorType("Recursive dependency")) { + JetType defaultType = DeferredType.create(context.trace, new NotNullLazyValueWithDefault(ErrorUtils.createErrorType("Recursive dependency")) { + @NotNull @Override - protected JetType compute() { + protected JetType doCompute() { return descriptor.getDefaultType(); } }); diff --git a/compiler/frontend/src/org/jetbrains/jet/util/RecursionIntolerantLazyValueWithDefault.java b/compiler/frontend/src/org/jetbrains/jet/util/RecursionIntolerantLazyValueWithDefault.java deleted file mode 100644 index ae1e03126a6..00000000000 --- a/compiler/frontend/src/org/jetbrains/jet/util/RecursionIntolerantLazyValueWithDefault.java +++ /dev/null @@ -1,32 +0,0 @@ -/* - * Copyright 2010-2013 JetBrains s.r.o. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package org.jetbrains.jet.util; - -import org.jetbrains.jet.utils.RecursionIntolerantLazyValue; - -public abstract class RecursionIntolerantLazyValueWithDefault extends RecursionIntolerantLazyValue { - private final T defaultValue; - - protected RecursionIntolerantLazyValueWithDefault(T defaultValue) { - this.defaultValue = defaultValue; - } - - @Override - protected T getValueOnErrorReentry() { - return defaultValue; - } -} 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 c9a1fc15e1a..6a71a32c070 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 @@ -23,8 +23,6 @@ import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor; import org.jetbrains.jet.lang.descriptors.DeclarationDescriptorVisitor; import org.jetbrains.jet.lang.descriptors.TypeParameterDescriptor; import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor; -import org.jetbrains.jet.storage.NotNullLazyValue; -import org.jetbrains.jet.storage.StorageManager; import org.jetbrains.jet.lang.resolve.name.Name; import org.jetbrains.jet.lang.resolve.scopes.JetScope; import org.jetbrains.jet.lang.resolve.scopes.LazyScopeAdapter; @@ -32,7 +30,9 @@ import org.jetbrains.jet.lang.types.*; 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.utils.RecursionIntolerantLazyValue; +import org.jetbrains.jet.storage.NotNullLazyValue; +import org.jetbrains.jet.storage.NotNullLazyValueImpl; +import org.jetbrains.jet.storage.StorageManager; import java.util.Collection; import java.util.Collections; @@ -198,9 +198,10 @@ public abstract class AbstractLazyTypeParameterDescriptor implements TypeParamet @NotNull private JetType createDefaultType() { - return new JetTypeImpl(getTypeConstructor(), new LazyScopeAdapter(new RecursionIntolerantLazyValue() { + return new JetTypeImpl(getTypeConstructor(), new LazyScopeAdapter(new NotNullLazyValueImpl() { + @NotNull @Override - protected JetScope compute() { + protected JetScope doCompute() { 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 913636aa72c..1565582d6f6 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 @@ -30,7 +30,7 @@ import org.jetbrains.jet.lang.types.*; 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.utils.RecursionIntolerantLazyValue; +import org.jetbrains.jet.storage.NotNullLazyValueImpl; import java.util.Collections; import java.util.List; @@ -222,9 +222,10 @@ public class TypeParameterDescriptorImpl extends DeclarationDescriptorNonRootImp getTypeConstructor(), TypeUtils.hasNullableLowerBound(this), Collections.emptyList(), - new LazyScopeAdapter(new RecursionIntolerantLazyValue() { + new LazyScopeAdapter(new NotNullLazyValueImpl() { + @NotNull @Override - protected JetScope compute() { + protected JetScope doCompute() { return getUpperBoundsAsType().getMemberScope(); } })); diff --git a/core/descriptors/src/org/jetbrains/jet/lang/resolve/scopes/LazyScopeAdapter.java b/core/descriptors/src/org/jetbrains/jet/lang/resolve/scopes/LazyScopeAdapter.java index c190558e4d3..5d8fe4a168a 100644 --- a/core/descriptors/src/org/jetbrains/jet/lang/resolve/scopes/LazyScopeAdapter.java +++ b/core/descriptors/src/org/jetbrains/jet/lang/resolve/scopes/LazyScopeAdapter.java @@ -17,19 +17,19 @@ package org.jetbrains.jet.lang.resolve.scopes; import org.jetbrains.annotations.NotNull; -import org.jetbrains.jet.utils.RecursionIntolerantLazyValue; +import org.jetbrains.jet.storage.NotNullLazyValue; public class LazyScopeAdapter extends AbstractScopeAdapter { - private final RecursionIntolerantLazyValue scope; + private final NotNullLazyValue scope; - public LazyScopeAdapter(RecursionIntolerantLazyValue scope) { + public LazyScopeAdapter(NotNullLazyValue scope) { this.scope = scope; } @NotNull @Override protected JetScope getWorkerScope() { - return scope.get(); + return scope.compute(); } } diff --git a/core/util.runtime/src/org/jetbrains/jet/utils/RecursionIntolerantLazyValue.java b/core/util.runtime/src/org/jetbrains/jet/utils/RecursionIntolerantLazyValue.java deleted file mode 100644 index 26a449ca7a8..00000000000 --- a/core/util.runtime/src/org/jetbrains/jet/utils/RecursionIntolerantLazyValue.java +++ /dev/null @@ -1,61 +0,0 @@ -/* - * Copyright 2010-2013 JetBrains s.r.o. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package org.jetbrains.jet.utils; - -public abstract class RecursionIntolerantLazyValue { - - private enum State { - NOT_COMPUTED, - BEING_COMPUTED, - COMPUTED, - ERROR - } - - private State state = State.NOT_COMPUTED; - private T value; - - protected abstract T compute(); - - protected T getValueOnErrorReentry() { - throw new ReenteringLazyValueComputationException(); - } - - public boolean isComputed() { - return state == State.ERROR || state == State.COMPUTED; - } - - public final T get() { - switch (state) { - case NOT_COMPUTED: - state = State.BEING_COMPUTED; - value = compute(); - state = State.COMPUTED; - return value; - case BEING_COMPUTED: - state = State.ERROR; - throw new ReenteringLazyValueComputationException(); - case COMPUTED: - return value; - case ERROR: - return getValueOnErrorReentry(); - } - throw new IllegalStateException("Unreachable"); - } - - - -}