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

Usages of expressionTypingServices from ExpressionTypingContext are replaced with injection

Browse Source 
The basic principle behind this change is that no context object should store components.
Components should be injected instead, and contexts only carry parameters around.

Particular changes:
- resolveCallWithGivenName() and resolveBinaryCall() moved to CallResolver
- ForLoopConventionsChecker introduced to confine checking conventions for Iterator and Iterable
- ExpressionTypingComponents introduced to deliver necessary components to ExpressionTypingVisitor's
- Some static methods became non-static to get access to injected components
- ExpressionTypingUtils and ControlStructureTypingUtils became components (got state injected) to avoid passing parameters around
This commit is contained in:
Andrey Breslav
2014-02-21 20:53:45 +04:00
parent 7b89af320c
commit 5b67cf67eb
30 changed files with 713 additions and 320 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/tests/org/jetbrains/jet/di/InjectorForTests.java
+32 -3
View File
@@ -21,6 +21,7 @@ import org.jetbrains.jet.lang.descriptors.ModuleDescriptor;
import org.jetbrains.jet.lang.PlatformToKotlinClassMap;
import org.jetbrains.jet.lang.resolve.DescriptorResolver;
import org.jetbrains.jet.lang.types.expressions.ExpressionTypingServices;
import org.jetbrains.jet.lang.types.expressions.ExpressionTypingUtils;
import org.jetbrains.jet.lang.resolve.TypeResolver;
import org.jetbrains.jet.context.GlobalContext;
import org.jetbrains.jet.storage.StorageManager;
@@ -29,6 +30,9 @@ import org.jetbrains.jet.lang.resolve.calls.CallResolver;
import org.jetbrains.jet.lang.resolve.calls.ArgumentTypeResolver;
import org.jetbrains.jet.lang.resolve.calls.CandidateResolver;
import org.jetbrains.jet.lang.resolve.DelegatedPropertyResolver;
import org.jetbrains.jet.lang.types.expressions.ExpressionTypingComponents;
import org.jetbrains.jet.lang.types.expressions.ControlStructureTypingUtils;
import org.jetbrains.jet.lang.types.expressions.ForLoopConventionsChecker;
import org.jetbrains.jet.lang.resolve.calls.CallExpressionResolver;
import org.jetbrains.jet.lang.resolve.calls.CallResolverExtensionProvider;
import org.jetbrains.jet.lang.resolve.QualifiedExpressionResolver;
@@ -44,6 +48,7 @@ public class InjectorForTests {
private final PlatformToKotlinClassMap platformToKotlinClassMap;
private final DescriptorResolver descriptorResolver;
private final ExpressionTypingServices expressionTypingServices;
private final ExpressionTypingUtils expressionTypingUtils;
private final TypeResolver typeResolver;
private final GlobalContext globalContext;
private final StorageManager storageManager;
@@ -52,6 +57,9 @@ public class InjectorForTests {
private final ArgumentTypeResolver argumentTypeResolver;
private final CandidateResolver candidateResolver;
private final DelegatedPropertyResolver delegatedPropertyResolver;
private final ExpressionTypingComponents expressionTypingComponents;
private final ControlStructureTypingUtils controlStructureTypingUtils;
private final ForLoopConventionsChecker forLoopConventionsChecker;
private final CallExpressionResolver callExpressionResolver;
private final CallResolverExtensionProvider callResolverExtensionProvider;
private final QualifiedExpressionResolver qualifiedExpressionResolver;
@@ -64,15 +72,19 @@ public class InjectorForTests {
this.moduleDescriptor = moduleDescriptor;
this.platformToKotlinClassMap = moduleDescriptor.getPlatformToKotlinClassMap();
this.descriptorResolver = new DescriptorResolver();
this.globalContext = org.jetbrains.jet.context.ContextPackage.GlobalContext();
this.expressionTypingServices = new ExpressionTypingServices(globalContext, platformToKotlinClassMap);
this.expressionTypingComponents = new ExpressionTypingComponents();
this.expressionTypingServices = new ExpressionTypingServices(expressionTypingComponents);
this.callResolver = new CallResolver();
this.expressionTypingUtils = new ExpressionTypingUtils(getExpressionTypingServices(), callResolver);
this.typeResolver = new TypeResolver();
this.globalContext = org.jetbrains.jet.context.ContextPackage.GlobalContext();
this.storageManager = globalContext.getStorageManager();
this.annotationResolver = new AnnotationResolver();
this.callResolver = new CallResolver();
this.argumentTypeResolver = new ArgumentTypeResolver();
this.candidateResolver = new CandidateResolver();
this.delegatedPropertyResolver = new DelegatedPropertyResolver();
this.controlStructureTypingUtils = new ControlStructureTypingUtils(getExpressionTypingServices());
this.forLoopConventionsChecker = new ForLoopConventionsChecker();
this.callExpressionResolver = new CallExpressionResolver();
this.callResolverExtensionProvider = new CallResolverExtensionProvider();
this.qualifiedExpressionResolver = new QualifiedExpressionResolver();
@@ -108,8 +120,21 @@ public class InjectorForTests {
candidateResolver.setArgumentTypeResolver(argumentTypeResolver);
delegatedPropertyResolver.setCallResolver(callResolver);
delegatedPropertyResolver.setExpressionTypingServices(expressionTypingServices);
expressionTypingComponents.setCallResolver(callResolver);
expressionTypingComponents.setControlStructureTypingUtils(controlStructureTypingUtils);
expressionTypingComponents.setExpressionTypingServices(expressionTypingServices);
expressionTypingComponents.setExpressionTypingUtils(expressionTypingUtils);
expressionTypingComponents.setForLoopConventionsChecker(forLoopConventionsChecker);
expressionTypingComponents.setGlobalContext(globalContext);
expressionTypingComponents.setPlatformToKotlinClassMap(platformToKotlinClassMap);
forLoopConventionsChecker.setExpressionTypingServices(expressionTypingServices);
forLoopConventionsChecker.setExpressionTypingUtils(expressionTypingUtils);
forLoopConventionsChecker.setProject(project);
callExpressionResolver.setExpressionTypingServices(expressionTypingServices);
}
@@ -126,6 +151,10 @@ public class InjectorForTests {
return this.expressionTypingServices;
}
public ExpressionTypingUtils getExpressionTypingUtils() {
return this.expressionTypingUtils;
}
public TypeResolver getTypeResolver() {
return this.typeResolver;
}
compiler/tests/org/jetbrains/jet/resolve/JetExpectedResolveDataUtil.java
+3 -3
View File
@@ -46,7 +46,6 @@ import java.util.List;
import java.util.Map;
import static com.intellij.testFramework.UsefulTestCase.assertInstanceOf;
import static org.jetbrains.jet.lang.types.expressions.ExpressionTypingUtils.resolveFakeCall;
public class JetExpectedResolveDataUtil {
private JetExpectedResolveDataUtil() {
@@ -131,13 +130,14 @@ public class JetExpectedResolveDataUtil {
JetType... parameterTypes
) {
ModuleDescriptor emptyModule = JetTestUtils.createEmptyModule();
ExpressionTypingServices expressionTypingServices = new InjectorForTests(project, emptyModule).getExpressionTypingServices();
InjectorForTests injector = new InjectorForTests(project, emptyModule);
ExpressionTypingServices expressionTypingServices = injector.getExpressionTypingServices();
ExpressionTypingContext context = ExpressionTypingContext.newContext(
expressionTypingServices, new BindingTraceContext(), classDescriptor.getDefaultType().getMemberScope(),
DataFlowInfo.EMPTY, TypeUtils.NO_EXPECTED_TYPE);
OverloadResolutionResults<FunctionDescriptor> functions = resolveFakeCall(
OverloadResolutionResults<FunctionDescriptor> functions = injector.getExpressionTypingUtils().resolveFakeCall(
context, ReceiverValue.NO_RECEIVER, Name.identifier(name), parameterTypes);
for (ResolvedCall<? extends FunctionDescriptor> resolvedCall : functions.getResultingCalls()) {