azalea/kotlin-fork
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Making deferred types thread-safe

Browse Source
This commit is contained in:
Andrey Breslav
2014-01-24 18:39:48 +04:00
parent 707255eef6
commit d7e256e992
7 changed files with 121 additions and 123 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/frontend/src/org/jetbrains/jet/lang/resolve/DescriptorResolver.java
+44 -43
View File
@@ -43,6 +43,7 @@ import org.jetbrains.jet.lang.types.expressions.ExpressionTypingServices;
import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
import org.jetbrains.jet.lexer.JetKeywordToken; import org.jetbrains.jet.lexer.JetKeywordToken;
import org.jetbrains.jet.lexer.JetTokens; import org.jetbrains.jet.lexer.JetTokens;
import org.jetbrains.jet.storage.StorageManager;
import javax.inject.Inject; import javax.inject.Inject;
import java.util.*; import java.util.*;
@@ -53,7 +54,7 @@ import static org.jetbrains.jet.lang.resolve.BindingContext.CONSTRUCTOR;
import static org.jetbrains.jet.lang.resolve.DescriptorUtils.*; import static org.jetbrains.jet.lang.resolve.DescriptorUtils.*;
import static org.jetbrains.jet.lang.resolve.ModifiersChecker.*; import static org.jetbrains.jet.lang.resolve.ModifiersChecker.*;
import static org.jetbrains.jet.lexer.JetTokens.OVERRIDE_KEYWORD; import static org.jetbrains.jet.lexer.JetTokens.OVERRIDE_KEYWORD;
import static org.jetbrains.jet.util.StorageUtil.createRecursionIntolerantLazyValueWithDefault; import static org.jetbrains.jet.storage.LockBasedStorageManager.NO_LOCKS;
public class DescriptorResolver { public class DescriptorResolver {
public static final Name COPY_METHOD_NAME = Name.identifier("copy"); public static final Name COPY_METHOD_NAME = Name.identifier("copy");
@@ -67,6 +68,8 @@ public class DescriptorResolver {
private ExpressionTypingServices expressionTypingServices; private ExpressionTypingServices expressionTypingServices;
@NotNull @NotNull
private DelegatedPropertyResolver delegatedPropertyResolver; private DelegatedPropertyResolver delegatedPropertyResolver;
@NotNull
private StorageManager storageManager;
@Inject @Inject
public void setTypeResolver(@NotNull TypeResolver typeResolver) { public void setTypeResolver(@NotNull TypeResolver typeResolver) {
@@ -88,6 +91,11 @@ public class DescriptorResolver {
this.delegatedPropertyResolver = delegatedPropertyResolver; this.delegatedPropertyResolver = delegatedPropertyResolver;
} }
@Inject
public void setStorageManager(@NotNull StorageManager storageManager) {
this.storageManager = storageManager;
}
public void resolveMutableClassDescriptor( public void resolveMutableClassDescriptor(
@NotNull JetClass classElement, @NotNull JetClass classElement,
@NotNull MutableClassDescriptor descriptor, @NotNull MutableClassDescriptor descriptor,
@@ -319,19 +327,17 @@ public class DescriptorResolver {
JetExpression bodyExpression = function.getBodyExpression(); JetExpression bodyExpression = function.getBodyExpression();
if (bodyExpression != null) { if (bodyExpression != null) {
returnType = returnType =
DeferredType.create(trace, DeferredType.createRecursionIntolerant(
createRecursionIntolerantLazyValueWithDefault( storageManager,
ErrorUtils.createErrorType("Recursive dependency"), trace,
new Function0<JetType>() { new Function0<JetType>() {
@Override @Override
public JetType invoke() { public JetType invoke() {
JetType type = expressionTypingServices JetType type = expressionTypingServices
.getBodyExpressionType(trace, scope, dataFlowInfo, function, .getBodyExpressionType(trace, scope, dataFlowInfo, function, functionDescriptor);
functionDescriptor); return transformAnonymousTypeIfNeeded(functionDescriptor, function, type, trace);
return transformAnonymousTypeIfNeeded(functionDescriptor, function, type, }
trace); });
}
}));
} }
else { else {
returnType = ErrorUtils.createErrorType("No type, no body"); returnType = ErrorUtils.createErrorType("No type, no body");
@@ -924,17 +930,16 @@ public class DescriptorResolver {
final JetProperty property = (JetProperty) variable; final JetProperty property = (JetProperty) variable;
final JetExpression propertyDelegateExpression = property.getDelegateExpression(); final JetExpression propertyDelegateExpression = property.getDelegateExpression();
if (propertyDelegateExpression != null) { if (propertyDelegateExpression != null) {
return DeferredType.create( return DeferredType.createRecursionIntolerant(
storageManager,
trace, trace,
createRecursionIntolerantLazyValueWithDefault( new Function0<JetType>() {
ErrorUtils.createErrorType("Recursive dependency"), @Override
new Function0<JetType>() { public JetType invoke() {
@Override return resolveDelegatedPropertyType(property, (PropertyDescriptor) variableDescriptor, scope,
public JetType invoke() { propertyDelegateExpression, dataFlowInfo, trace);
return resolveDelegatedPropertyType(property, (PropertyDescriptor) variableDescriptor, scope, }
propertyDelegateExpression, dataFlowInfo, trace); });
}
}));
} }
} }
if (!notLocal) { if (!notLocal) {
@@ -944,24 +949,20 @@ public class DescriptorResolver {
} }
else { else {
if (notLocal) { if (notLocal) {
return DeferredType.create(trace, return DeferredType.createRecursionIntolerant(
createRecursionIntolerantLazyValueWithDefault( storageManager,
ErrorUtils.createErrorType("Recursive dependency"), trace,
new Function0<JetType>() { new Function0<JetType>() {
@Override @Override
public JetType invoke() { public JetType invoke() {
JetType type = JetType type = resolveInitializerType(scope, initializer, dataFlowInfo, trace);
resolveInitializerType(scope, initializer, dataFlowInfo, trace);
EvaluatePackage.recordCompileTimeValueForInitializerIfNeeded( EvaluatePackage.recordCompileTimeValueForInitializerIfNeeded(
variableDescriptor, variableDescriptor, initializer, type, trace);
initializer, type, return transformAnonymousTypeIfNeeded(variableDescriptor, variable, type, trace);
trace); }
return transformAnonymousTypeIfNeeded(variableDescriptor, variable, type, }
trace); );
}
}
));
} }
else { else {
return resolveInitializerType(scope, initializer, dataFlowInfo, trace); return resolveInitializerType(scope, initializer, dataFlowInfo, trace);
@@ -1283,7 +1284,7 @@ public class DescriptorResolver {
final ClassDescriptor enumClassDescriptor = (ClassDescriptor) classObject.getContainingDeclaration(); final ClassDescriptor enumClassDescriptor = (ClassDescriptor) classObject.getContainingDeclaration();
assert DescriptorUtils.isEnumClass(enumClassDescriptor) : "values should be created in enum class: " + enumClassDescriptor; assert DescriptorUtils.isEnumClass(enumClassDescriptor) : "values should be created in enum class: " + enumClassDescriptor;
return DescriptorFactory return DescriptorFactory
.createEnumClassObjectValuesMethod(classObject, DeferredType.create(trace, new Function0<JetType>() { .createEnumClassObjectValuesMethod(classObject, DeferredType.create(NO_LOCKS, trace, new Function0<JetType>() {
@Override @Override
public JetType invoke() { public JetType invoke() {
return KotlinBuiltIns.getInstance().getArrayType(enumClassDescriptor.getDefaultType()); return KotlinBuiltIns.getInstance().getArrayType(enumClassDescriptor.getDefaultType());
@@ -1300,7 +1301,7 @@ public class DescriptorResolver {
final ClassDescriptor enumClassDescriptor = (ClassDescriptor) classObject.getContainingDeclaration(); final ClassDescriptor enumClassDescriptor = (ClassDescriptor) classObject.getContainingDeclaration();
assert DescriptorUtils.isEnumClass(enumClassDescriptor) : "valueOf should be created in enum class: " + enumClassDescriptor; assert DescriptorUtils.isEnumClass(enumClassDescriptor) : "valueOf should be created in enum class: " + enumClassDescriptor;
return DescriptorFactory return DescriptorFactory
.createEnumClassObjectValueOfMethod(classObject, DeferredType.create(trace, new Function0<JetType>() { .createEnumClassObjectValueOfMethod(classObject, DeferredType.create(NO_LOCKS, trace, new Function0<JetType>() {
@Override @Override
public JetType invoke() { public JetType invoke() {
return enumClassDescriptor.getDefaultType(); return enumClassDescriptor.getDefaultType();
compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/descriptors/LazyClassMemberScope.java
+2 -2
View File
@@ -378,14 +378,14 @@ public class LazyClassMemberScope extends AbstractLazyMemberScope<LazyClassDescr
} }
private void setDeferredReturnType(@NotNull ConstructorDescriptorImpl descriptor) { private void setDeferredReturnType(@NotNull ConstructorDescriptorImpl descriptor) {
descriptor.setReturnType(DeferredType.create(resolveSession.getTrace(), resolveSession.getStorageManager().createLazyValue( descriptor.setReturnType(DeferredType.create(resolveSession.getStorageManager(), resolveSession.getTrace(),
new Function0<JetType>() { new Function0<JetType>() {
@Override @Override
public JetType invoke() { public JetType invoke() {
return thisDescriptor.getDefaultType(); return thisDescriptor.getDefaultType();
} }
}) })
)); );
} }
@Override @Override
compiler/frontend/src/org/jetbrains/jet/lang/types/DeferredType.java
+40 -7
View File
@@ -17,12 +17,13 @@
package org.jetbrains.jet.lang.types; package org.jetbrains.jet.lang.types;
import jet.Function0; import jet.Function0;
import jet.Function1;
import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.NotNull;
import org.jetbrains.jet.lang.descriptors.annotations.Annotations; import org.jetbrains.jet.lang.descriptors.annotations.Annotations;
import org.jetbrains.jet.lang.resolve.BindingTrace; import org.jetbrains.jet.lang.resolve.BindingTrace;
import org.jetbrains.jet.lang.resolve.scopes.JetScope; import org.jetbrains.jet.lang.resolve.scopes.JetScope;
import org.jetbrains.jet.storage.LockBasedStorageManager;
import org.jetbrains.jet.storage.NotNullLazyValue; import org.jetbrains.jet.storage.NotNullLazyValue;
import org.jetbrains.jet.storage.StorageManager;
import org.jetbrains.jet.util.Box; import org.jetbrains.jet.util.Box;
import org.jetbrains.jet.util.ReenteringLazyValueComputationException; import org.jetbrains.jet.util.ReenteringLazyValueComputationException;
@@ -31,20 +32,52 @@ import java.util.List;
import static org.jetbrains.jet.lang.resolve.BindingContext.DEFERRED_TYPE; import static org.jetbrains.jet.lang.resolve.BindingContext.DEFERRED_TYPE;
public class DeferredType implements LazyType { public class DeferredType implements LazyType {
public static DeferredType create(BindingTrace trace, NotNullLazyValue<JetType> lazyValue) { private static final Function1 EMPTY_CONSUMER = new Function1<Object, Void>() {
DeferredType deferredType = new DeferredType(lazyValue); @Override
public Void invoke(Object t) {
return null;
}
};
private static final Function1<Boolean,JetType> RECURSION_PREVENTER = new Function1<Boolean, JetType>() {
@Override
public JetType invoke(Boolean firstTime) {
if (firstTime) throw new ReenteringLazyValueComputationException();
return ErrorUtils.createErrorType("Recursive dependency");
}
};
@NotNull
public static DeferredType create(
@NotNull StorageManager storageManager,
@NotNull BindingTrace trace,
@NotNull Function0<JetType> compute
) {
DeferredType deferredType = new DeferredType(storageManager.createLazyValue(compute));
trace.record(DEFERRED_TYPE, new Box<DeferredType>(deferredType)); trace.record(DEFERRED_TYPE, new Box<DeferredType>(deferredType));
return deferredType; return deferredType;
} }
public static DeferredType create(BindingTrace trace, Function0<JetType> compute) { @NotNull
return create(trace, LockBasedStorageManager.NO_LOCKS.createLazyValue(compute)); public static DeferredType createRecursionIntolerant(
@NotNull StorageManager storageManager,
@NotNull BindingTrace trace,
@NotNull Function0<JetType> compute
) {
//noinspection unchecked
DeferredType deferredType = new DeferredType(storageManager.createLazyValueWithPostCompute(
compute,
RECURSION_PREVENTER,
EMPTY_CONSUMER
));
trace.record(DEFERRED_TYPE, new Box<DeferredType>(deferredType));
return deferredType;
} }
private final NotNullLazyValue<JetType> lazyValue; private final NotNullLazyValue<JetType> lazyValue;
private DeferredType(NotNullLazyValue<JetType> lazyValue) { private DeferredType(@NotNull NotNullLazyValue<JetType> lazyValue) {
this.lazyValue = lazyValue; this.lazyValue = lazyValue;
} }
compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ClosureExpressionsTypingVisitor.java
+16 -11
View File
@@ -31,9 +31,13 @@ import org.jetbrains.jet.lang.resolve.*;
import org.jetbrains.jet.lang.resolve.name.LabelName; import org.jetbrains.jet.lang.resolve.name.LabelName;
import org.jetbrains.jet.lang.resolve.name.Name; import org.jetbrains.jet.lang.resolve.name.Name;
import org.jetbrains.jet.lang.resolve.scopes.JetScope; import org.jetbrains.jet.lang.resolve.scopes.JetScope;
import org.jetbrains.jet.lang.types.*; import org.jetbrains.jet.lang.types.CommonSupertypes;
import org.jetbrains.jet.lang.types.DeferredType;
import org.jetbrains.jet.lang.types.JetType;
import org.jetbrains.jet.lang.types.JetTypeInfo;
import org.jetbrains.jet.lang.types.checker.JetTypeChecker; import org.jetbrains.jet.lang.types.checker.JetTypeChecker;
import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
import org.jetbrains.jet.storage.StorageManager;
import org.jetbrains.jet.util.slicedmap.WritableSlice; import org.jetbrains.jet.util.slicedmap.WritableSlice;
import java.util.Collection; import java.util.Collection;
@@ -45,11 +49,13 @@ import static org.jetbrains.jet.lang.resolve.BindingContext.*;
import static org.jetbrains.jet.lang.resolve.calls.context.ContextDependency.INDEPENDENT; import static org.jetbrains.jet.lang.resolve.calls.context.ContextDependency.INDEPENDENT;
import static org.jetbrains.jet.lang.types.TypeUtils.*; import static org.jetbrains.jet.lang.types.TypeUtils.*;
import static org.jetbrains.jet.lang.types.expressions.CoercionStrategy.COERCION_TO_UNIT; import static org.jetbrains.jet.lang.types.expressions.CoercionStrategy.COERCION_TO_UNIT;
import static org.jetbrains.jet.util.StorageUtil.createRecursionIntolerantLazyValueWithDefault;
public class ClosureExpressionsTypingVisitor extends ExpressionTypingVisitor { public class ClosureExpressionsTypingVisitor extends ExpressionTypingVisitor {
protected ClosureExpressionsTypingVisitor(@NotNull ExpressionTypingInternals facade) { private final StorageManager storageManager;
protected ClosureExpressionsTypingVisitor(@NotNull ExpressionTypingInternals facade, @NotNull StorageManager storageManager) {
super(facade); super(facade);
this.storageManager = storageManager;
} }
@Override @Override
@@ -67,14 +73,13 @@ public class ClosureExpressionsTypingVisitor extends ExpressionTypingVisitor {
@Override @Override
public void handleRecord(WritableSlice<PsiElement, ClassDescriptor> slice, PsiElement declaration, final ClassDescriptor descriptor) { public void handleRecord(WritableSlice<PsiElement, ClassDescriptor> slice, PsiElement declaration, final ClassDescriptor descriptor) {
if (slice == CLASS && declaration == expression.getObjectDeclaration()) { if (slice == CLASS && declaration == expression.getObjectDeclaration()) {
JetType defaultType = DeferredType.create(context.trace, createRecursionIntolerantLazyValueWithDefault( JetType defaultType = DeferredType.createRecursionIntolerant(storageManager, context.trace,
ErrorUtils.createErrorType("Recursive dependency"), new Function0<JetType>() {
new Function0<JetType>() { @Override
@Override public JetType invoke() {
public JetType invoke() { return descriptor.getDefaultType();
return descriptor.getDefaultType(); }
} });
}));
result[0] = defaultType; result[0] = defaultType;
if (!context.trace.get(PROCESSED, expression)) { if (!context.trace.get(PROCESSED, expression)) {
temporaryTrace.record(EXPRESSION_TYPE, expression, defaultType); temporaryTrace.record(EXPRESSION_TYPE, expression, defaultType);
compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingServices.java
+11 -3
View File
@@ -44,6 +44,7 @@ import org.jetbrains.jet.lang.types.JetType;
import org.jetbrains.jet.lang.types.JetTypeInfo; import org.jetbrains.jet.lang.types.JetTypeInfo;
import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
import org.jetbrains.jet.lexer.JetTokens; import org.jetbrains.jet.lexer.JetTokens;
import org.jetbrains.jet.storage.StorageManager;
import javax.inject.Inject; import javax.inject.Inject;
import java.util.Iterator; import java.util.Iterator;
@@ -73,6 +74,8 @@ public class ExpressionTypingServices {
private PlatformToKotlinClassMap platformToKotlinClassMap; private PlatformToKotlinClassMap platformToKotlinClassMap;
@NotNull @NotNull
private CallResolverExtensionProvider extensionProvider; private CallResolverExtensionProvider extensionProvider;
@NotNull
private StorageManager storageManager;
@NotNull @NotNull
public Project getProject() { public Project getProject() {
@@ -137,7 +140,7 @@ public class ExpressionTypingServices {
@Inject @Inject
public void setPlatformToKotlinClassMap(@NotNull PlatformToKotlinClassMap platformToKotlinClassMap) { public void setPlatformToKotlinClassMap(@NotNull PlatformToKotlinClassMap platformToKotlinClassMap) {
this.platformToKotlinClassMap = platformToKotlinClassMap; this.platformToKotlinClassMap = platformToKotlinClassMap;
this.expressionTypingFacade = ExpressionTypingVisitorDispatcher.create(platformToKotlinClassMap); this.expressionTypingFacade = ExpressionTypingVisitorDispatcher.create(storageManager, platformToKotlinClassMap);
} }
@NotNull @NotNull
@@ -150,6 +153,11 @@ public class ExpressionTypingServices {
this.extensionProvider = extensionProvider; this.extensionProvider = extensionProvider;
} }
@Inject
public void setStorageManager(@NotNull StorageManager storageManager) {
this.storageManager = storageManager;
}
@NotNull @NotNull
public JetType safeGetType(@NotNull JetScope scope, @NotNull JetExpression expression, @NotNull JetType expectedType, @NotNull DataFlowInfo dataFlowInfo, @NotNull BindingTrace trace) { public JetType safeGetType(@NotNull JetScope scope, @NotNull JetExpression expression, @NotNull JetType expectedType, @NotNull DataFlowInfo dataFlowInfo, @NotNull BindingTrace trace) {
JetType type = getType(scope, expression, expectedType, dataFlowInfo, trace); JetType type = getType(scope, expression, expectedType, dataFlowInfo, trace);
@@ -276,7 +284,7 @@ public class ExpressionTypingServices {
return JetTypeInfo.create(KotlinBuiltIns.getInstance().getUnitType(), context.dataFlowInfo); return JetTypeInfo.create(KotlinBuiltIns.getInstance().getUnitType(), context.dataFlowInfo);
} }
ExpressionTypingInternals blockLevelVisitor = ExpressionTypingVisitorDispatcher.createForBlock(platformToKotlinClassMap, scope); ExpressionTypingInternals blockLevelVisitor = ExpressionTypingVisitorDispatcher.createForBlock(storageManager, platformToKotlinClassMap, scope);
ExpressionTypingContext newContext = createContext(context, trace, scope, context.dataFlowInfo, NO_EXPECTED_TYPE); ExpressionTypingContext newContext = createContext(context, trace, scope, context.dataFlowInfo, NO_EXPECTED_TYPE);
JetTypeInfo result = JetTypeInfo.create(null, context.dataFlowInfo); JetTypeInfo result = JetTypeInfo.create(null, context.dataFlowInfo);
@@ -300,7 +308,7 @@ public class ExpressionTypingServices {
if (newDataFlowInfo != context.dataFlowInfo) { if (newDataFlowInfo != context.dataFlowInfo) {
newContext = newContext.replaceDataFlowInfo(newDataFlowInfo); newContext = newContext.replaceDataFlowInfo(newDataFlowInfo);
} }
blockLevelVisitor = ExpressionTypingVisitorDispatcher.createForBlock(platformToKotlinClassMap, scope); blockLevelVisitor = ExpressionTypingVisitorDispatcher.createForBlock(storageManager, platformToKotlinClassMap, scope);
} }
return result; return result;
} }
compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingVisitorDispatcher.java
+8 -5
View File
@@ -27,6 +27,7 @@ import org.jetbrains.jet.lang.resolve.scopes.WritableScope;
import org.jetbrains.jet.lang.types.DeferredType; import org.jetbrains.jet.lang.types.DeferredType;
import org.jetbrains.jet.lang.types.ErrorUtils; import org.jetbrains.jet.lang.types.ErrorUtils;
import org.jetbrains.jet.lang.types.JetTypeInfo; import org.jetbrains.jet.lang.types.JetTypeInfo;
import org.jetbrains.jet.storage.StorageManager;
import org.jetbrains.jet.util.ReenteringLazyValueComputationException; import org.jetbrains.jet.util.ReenteringLazyValueComputationException;
import static org.jetbrains.jet.lang.diagnostics.Errors.TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM; import static org.jetbrains.jet.lang.diagnostics.Errors.TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM;
@@ -34,25 +35,26 @@ import static org.jetbrains.jet.lang.diagnostics.Errors.TYPECHECKER_HAS_RUN_INTO
public class ExpressionTypingVisitorDispatcher extends JetVisitor<JetTypeInfo, ExpressionTypingContext> implements ExpressionTypingInternals { public class ExpressionTypingVisitorDispatcher extends JetVisitor<JetTypeInfo, ExpressionTypingContext> implements ExpressionTypingInternals {
@NotNull @NotNull
public static ExpressionTypingFacade create(@NotNull PlatformToKotlinClassMap platformToKotlinClassMap) { public static ExpressionTypingFacade create(@NotNull StorageManager storageManager, @NotNull PlatformToKotlinClassMap platformToKotlinClassMap) {
return new ExpressionTypingVisitorDispatcher(platformToKotlinClassMap, null); return new ExpressionTypingVisitorDispatcher(storageManager, platformToKotlinClassMap, null);
} }
@NotNull @NotNull
public static ExpressionTypingInternals createForBlock( public static ExpressionTypingInternals createForBlock(
@NotNull StorageManager storageManager,
@NotNull PlatformToKotlinClassMap platformToKotlinClassMap, @NotNull PlatformToKotlinClassMap platformToKotlinClassMap,
@NotNull WritableScope writableScope @NotNull WritableScope writableScope
) { ) {
return new ExpressionTypingVisitorDispatcher(platformToKotlinClassMap, writableScope); return new ExpressionTypingVisitorDispatcher(storageManager, platformToKotlinClassMap, writableScope);
} }
private final BasicExpressionTypingVisitor basic; private final BasicExpressionTypingVisitor basic;
private final ExpressionTypingVisitorForStatements statements; private final ExpressionTypingVisitorForStatements statements;
private final ClosureExpressionsTypingVisitor closures = new ClosureExpressionsTypingVisitor(this); private final ClosureExpressionsTypingVisitor closures;
private final ControlStructureTypingVisitor controlStructures = new ControlStructureTypingVisitor(this); private final ControlStructureTypingVisitor controlStructures = new ControlStructureTypingVisitor(this);
private final PatternMatchingTypingVisitor patterns = new PatternMatchingTypingVisitor(this); private final PatternMatchingTypingVisitor patterns = new PatternMatchingTypingVisitor(this);
private ExpressionTypingVisitorDispatcher(PlatformToKotlinClassMap platformToKotlinClassMap, WritableScope writableScope) { private ExpressionTypingVisitorDispatcher(StorageManager storageManager, PlatformToKotlinClassMap platformToKotlinClassMap, WritableScope writableScope) {
this.basic = new BasicExpressionTypingVisitor(this, platformToKotlinClassMap); this.basic = new BasicExpressionTypingVisitor(this, platformToKotlinClassMap);
if (writableScope != null) { if (writableScope != null) {
this.statements = new ExpressionTypingVisitorForStatements(this, writableScope, basic, controlStructures, patterns); this.statements = new ExpressionTypingVisitorForStatements(this, writableScope, basic, controlStructures, patterns);
@@ -60,6 +62,7 @@ public class ExpressionTypingVisitorDispatcher extends JetVisitor<JetTypeInfo, E
else { else {
this.statements = null; this.statements = null;
} }
closures = new ClosureExpressionsTypingVisitor(this, storageManager);
} }
@NotNull @NotNull
compiler/frontend/src/org/jetbrains/jet/util/StorageUtil.java
-52
View File
@@ -1,52 +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 jet.Function0;
import jet.Function1;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.jet.storage.NotNullLazyValue;
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 Function0<T> compute
) {
//noinspection unchecked
return NO_LOCKS.createLazyValueWithPostCompute(
compute,
new Function1<Boolean, T>() {
@Override
public T invoke(Boolean firstTime) {
if (firstTime) throw new ReenteringLazyValueComputationException();
return defaultValue;
}
},
EMPTY_CONSUMER
);
}
}