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

Rename: PartialBodyResolveProvider -> StatementFilter

Browse Source
This commit is contained in:
Svetlana Isakova
2015-01-29 17:22:28 +03:00
parent a2f03f2d52
commit 6511086034
25 changed files with 134 additions and 134 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/frontend.java/src/org/jetbrains/kotlin/di/InjectorForLazyResolveWithJava.java
+4 -4
View File
@@ -59,7 +59,7 @@ import org.jetbrains.kotlin.resolve.TypeResolver;
import org.jetbrains.kotlin.resolve.QualifiedExpressionResolver;
import org.jetbrains.kotlin.types.reflect.ReflectionTypes;
import org.jetbrains.kotlin.resolve.calls.CallExpressionResolver;
import org.jetbrains.kotlin.resolve.PartialBodyResolveProvider;
import org.jetbrains.kotlin.resolve.StatementFilter;
import org.jetbrains.kotlin.resolve.calls.CallCompleter;
import org.jetbrains.kotlin.resolve.calls.CandidateResolver;
import org.jetbrains.kotlin.resolve.calls.tasks.TaskPrioritizer;
@@ -124,7 +124,7 @@ public class InjectorForLazyResolveWithJava {
private final QualifiedExpressionResolver qualifiedExpressionResolver;
private final ReflectionTypes reflectionTypes;
private final CallExpressionResolver callExpressionResolver;
private final PartialBodyResolveProvider partialBodyResolveProvider;
private final StatementFilter statementFilter;
private final CallCompleter callCompleter;
private final CandidateResolver candidateResolver;
private final TaskPrioritizer taskPrioritizer;
@@ -195,7 +195,7 @@ public class InjectorForLazyResolveWithJava {
this.delegatedPropertyResolver = new DelegatedPropertyResolver();
this.reflectionTypes = new ReflectionTypes(module);
this.callExpressionResolver = new CallExpressionResolver();
this.partialBodyResolveProvider = new PartialBodyResolveProvider();
this.statementFilter = new StatementFilter();
this.candidateResolver = new CandidateResolver();
this.callCompleter = new CallCompleter(argumentTypeResolver, candidateResolver);
this.taskPrioritizer = new TaskPrioritizer(storageManager);
@@ -259,8 +259,8 @@ public class InjectorForLazyResolveWithJava {
expressionTypingServices.setCallExpressionResolver(callExpressionResolver);
expressionTypingServices.setCallResolver(callResolver);
expressionTypingServices.setDescriptorResolver(descriptorResolver);
expressionTypingServices.setPartialBodyResolveProvider(partialBodyResolveProvider);
expressionTypingServices.setProject(project);
expressionTypingServices.setStatementFilter(statementFilter);
expressionTypingServices.setTypeResolver(typeResolver);
expressionTypingComponents.setAdditionalCheckerProvider(kotlinJvmCheckerProvider);
compiler/frontend.java/src/org/jetbrains/kotlin/di/InjectorForReplWithJava.java
+4 -4
View File
@@ -63,7 +63,7 @@ import org.jetbrains.kotlin.resolve.QualifiedExpressionResolver;
import org.jetbrains.kotlin.context.LazinessToken;
import org.jetbrains.kotlin.types.reflect.ReflectionTypes;
import org.jetbrains.kotlin.resolve.calls.CallExpressionResolver;
import org.jetbrains.kotlin.resolve.PartialBodyResolveProvider;
import org.jetbrains.kotlin.resolve.StatementFilter;
import org.jetbrains.kotlin.resolve.calls.CallCompleter;
import org.jetbrains.kotlin.resolve.calls.CandidateResolver;
import org.jetbrains.kotlin.resolve.calls.tasks.TaskPrioritizer;
@@ -139,7 +139,7 @@ public class InjectorForReplWithJava {
private final LazinessToken lazinessToken;
private final ReflectionTypes reflectionTypes;
private final CallExpressionResolver callExpressionResolver;
private final PartialBodyResolveProvider partialBodyResolveProvider;
private final StatementFilter statementFilter;
private final CallCompleter callCompleter;
private final CandidateResolver candidateResolver;
private final TaskPrioritizer taskPrioritizer;
@@ -223,7 +223,7 @@ public class InjectorForReplWithJava {
this.delegatedPropertyResolver = new DelegatedPropertyResolver();
this.reflectionTypes = new ReflectionTypes(module);
this.callExpressionResolver = new CallExpressionResolver();
this.partialBodyResolveProvider = new PartialBodyResolveProvider();
this.statementFilter = new StatementFilter();
this.candidateResolver = new CandidateResolver();
this.callCompleter = new CallCompleter(argumentTypeResolver, candidateResolver);
this.taskPrioritizer = new TaskPrioritizer(storageManager);
@@ -309,8 +309,8 @@ public class InjectorForReplWithJava {
expressionTypingServices.setCallExpressionResolver(callExpressionResolver);
expressionTypingServices.setCallResolver(callResolver);
expressionTypingServices.setDescriptorResolver(descriptorResolver);
expressionTypingServices.setPartialBodyResolveProvider(partialBodyResolveProvider);
expressionTypingServices.setProject(project);
expressionTypingServices.setStatementFilter(statementFilter);
expressionTypingServices.setTypeResolver(typeResolver);
expressionTypingComponents.setAdditionalCheckerProvider(kotlinJvmCheckerProvider);
compiler/frontend.java/src/org/jetbrains/kotlin/di/InjectorForTopDownAnalyzerForJvm.java
+4 -4
View File
@@ -62,7 +62,7 @@ import org.jetbrains.kotlin.resolve.QualifiedExpressionResolver;
import org.jetbrains.kotlin.context.LazinessToken;
import org.jetbrains.kotlin.types.reflect.ReflectionTypes;
import org.jetbrains.kotlin.resolve.calls.CallExpressionResolver;
import org.jetbrains.kotlin.resolve.PartialBodyResolveProvider;
import org.jetbrains.kotlin.resolve.StatementFilter;
import org.jetbrains.kotlin.resolve.calls.CallCompleter;
import org.jetbrains.kotlin.resolve.calls.CandidateResolver;
import org.jetbrains.kotlin.resolve.calls.tasks.TaskPrioritizer;
@@ -138,7 +138,7 @@ public class InjectorForTopDownAnalyzerForJvm {
private final LazinessToken lazinessToken;
private final ReflectionTypes reflectionTypes;
private final CallExpressionResolver callExpressionResolver;
private final PartialBodyResolveProvider partialBodyResolveProvider;
private final StatementFilter statementFilter;
private final CallCompleter callCompleter;
private final CandidateResolver candidateResolver;
private final TaskPrioritizer taskPrioritizer;
@@ -221,7 +221,7 @@ public class InjectorForTopDownAnalyzerForJvm {
this.delegatedPropertyResolver = new DelegatedPropertyResolver();
this.reflectionTypes = new ReflectionTypes(module);
this.callExpressionResolver = new CallExpressionResolver();
this.partialBodyResolveProvider = new PartialBodyResolveProvider();
this.statementFilter = new StatementFilter();
this.candidateResolver = new CandidateResolver();
this.callCompleter = new CallCompleter(argumentTypeResolver, candidateResolver);
this.taskPrioritizer = new TaskPrioritizer(storageManager);
@@ -308,8 +308,8 @@ public class InjectorForTopDownAnalyzerForJvm {
expressionTypingServices.setCallExpressionResolver(callExpressionResolver);
expressionTypingServices.setCallResolver(callResolver);
expressionTypingServices.setDescriptorResolver(descriptorResolver);
expressionTypingServices.setPartialBodyResolveProvider(partialBodyResolveProvider);
expressionTypingServices.setProject(project);
expressionTypingServices.setStatementFilter(statementFilter);
expressionTypingServices.setTypeResolver(typeResolver);
expressionTypingComponents.setAdditionalCheckerProvider(kotlinJvmCheckerProvider);
compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForBodyResolve.java
+5 -5
View File
@@ -24,7 +24,7 @@ import org.jetbrains.kotlin.descriptors.ModuleDescriptor;
import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
import org.jetbrains.kotlin.platform.PlatformToKotlinClassMap;
import org.jetbrains.kotlin.resolve.AdditionalCheckerProvider;
import org.jetbrains.kotlin.resolve.PartialBodyResolveProvider;
import org.jetbrains.kotlin.resolve.StatementFilter;
import org.jetbrains.kotlin.resolve.BodyResolver;
import org.jetbrains.kotlin.resolve.AnnotationResolver;
import org.jetbrains.kotlin.resolve.calls.CallResolver;
@@ -67,7 +67,7 @@ public class InjectorForBodyResolve {
private final KotlinBuiltIns kotlinBuiltIns;
private final PlatformToKotlinClassMap platformToKotlinClassMap;
private final AdditionalCheckerProvider additionalCheckerProvider;
private final PartialBodyResolveProvider partialBodyResolveProvider;
private final StatementFilter statementFilter;
private final BodyResolver bodyResolver;
private final AnnotationResolver annotationResolver;
private final CallResolver callResolver;
@@ -102,7 +102,7 @@ public class InjectorForBodyResolve {
@NotNull BindingTrace bindingTrace,
@NotNull ModuleDescriptor moduleDescriptor,
@NotNull AdditionalCheckerProvider additionalCheckerProvider,
@NotNull PartialBodyResolveProvider partialBodyResolveProvider
@NotNull StatementFilter statementFilter
) {
this.project = project;
this.globalContext = globalContext;
@@ -112,7 +112,7 @@ public class InjectorForBodyResolve {
this.kotlinBuiltIns = moduleDescriptor.getBuiltIns();
this.platformToKotlinClassMap = moduleDescriptor.getPlatformToKotlinClassMap();
this.additionalCheckerProvider = additionalCheckerProvider;
this.partialBodyResolveProvider = partialBodyResolveProvider;
this.statementFilter = statementFilter;
this.bodyResolver = new BodyResolver();
this.annotationResolver = new AnnotationResolver();
this.callResolver = new CallResolver();
@@ -171,8 +171,8 @@ public class InjectorForBodyResolve {
expressionTypingServices.setCallExpressionResolver(callExpressionResolver);
expressionTypingServices.setCallResolver(callResolver);
expressionTypingServices.setDescriptorResolver(descriptorResolver);
expressionTypingServices.setPartialBodyResolveProvider(partialBodyResolveProvider);
expressionTypingServices.setProject(project);
expressionTypingServices.setStatementFilter(statementFilter);
expressionTypingServices.setTypeResolver(typeResolver);
expressionTypingComponents.setAdditionalCheckerProvider(additionalCheckerProvider);
compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForLazyBodyResolve.java
+4 -4
View File
@@ -50,7 +50,7 @@ import org.jetbrains.kotlin.resolve.TypeResolver.FlexibleTypeCapabilitiesProvide
import org.jetbrains.kotlin.context.LazinessToken;
import org.jetbrains.kotlin.types.reflect.ReflectionTypes;
import org.jetbrains.kotlin.resolve.calls.CallExpressionResolver;
import org.jetbrains.kotlin.resolve.PartialBodyResolveProvider;
import org.jetbrains.kotlin.resolve.StatementFilter;
import org.jetbrains.kotlin.resolve.calls.CallCompleter;
import org.jetbrains.kotlin.resolve.calls.CandidateResolver;
import org.jetbrains.kotlin.resolve.calls.tasks.TaskPrioritizer;
@@ -104,7 +104,7 @@ public class InjectorForLazyBodyResolve {
private final LazinessToken lazinessToken;
private final ReflectionTypes reflectionTypes;
private final CallExpressionResolver callExpressionResolver;
private final PartialBodyResolveProvider partialBodyResolveProvider;
private final StatementFilter statementFilter;
private final CallCompleter callCompleter;
private final CandidateResolver candidateResolver;
private final TaskPrioritizer taskPrioritizer;
@@ -160,7 +160,7 @@ public class InjectorForLazyBodyResolve {
this.delegatedPropertyResolver = new DelegatedPropertyResolver();
this.reflectionTypes = new ReflectionTypes(moduleDescriptor);
this.callExpressionResolver = new CallExpressionResolver();
this.partialBodyResolveProvider = new PartialBodyResolveProvider();
this.statementFilter = new StatementFilter();
this.candidateResolver = new CandidateResolver();
this.callCompleter = new CallCompleter(argumentTypeResolver, candidateResolver);
this.taskPrioritizer = new TaskPrioritizer(storageManager);
@@ -224,8 +224,8 @@ public class InjectorForLazyBodyResolve {
expressionTypingServices.setCallExpressionResolver(callExpressionResolver);
expressionTypingServices.setCallResolver(callResolver);
expressionTypingServices.setDescriptorResolver(descriptorResolver);
expressionTypingServices.setPartialBodyResolveProvider(partialBodyResolveProvider);
expressionTypingServices.setProject(project);
expressionTypingServices.setStatementFilter(statementFilter);
expressionTypingServices.setTypeResolver(typeResolver);
expressionTypingComponents.setAdditionalCheckerProvider(additionalCheckerProvider);
compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForLazyLocalClassifierAnalyzer.java
+4 -4
View File
@@ -49,7 +49,7 @@ import org.jetbrains.kotlin.resolve.TypeResolver.FlexibleTypeCapabilitiesProvide
import org.jetbrains.kotlin.context.LazinessToken;
import org.jetbrains.kotlin.types.reflect.ReflectionTypes;
import org.jetbrains.kotlin.resolve.calls.CallExpressionResolver;
import org.jetbrains.kotlin.resolve.PartialBodyResolveProvider;
import org.jetbrains.kotlin.resolve.StatementFilter;
import org.jetbrains.kotlin.resolve.calls.CallCompleter;
import org.jetbrains.kotlin.resolve.calls.CandidateResolver;
import org.jetbrains.kotlin.resolve.calls.tasks.TaskPrioritizer;
@@ -102,7 +102,7 @@ public class InjectorForLazyLocalClassifierAnalyzer {
private final LazinessToken lazinessToken;
private final ReflectionTypes reflectionTypes;
private final CallExpressionResolver callExpressionResolver;
private final PartialBodyResolveProvider partialBodyResolveProvider;
private final StatementFilter statementFilter;
private final CallCompleter callCompleter;
private final CandidateResolver candidateResolver;
private final TaskPrioritizer taskPrioritizer;
@@ -158,7 +158,7 @@ public class InjectorForLazyLocalClassifierAnalyzer {
this.delegatedPropertyResolver = new DelegatedPropertyResolver();
this.reflectionTypes = new ReflectionTypes(module);
this.callExpressionResolver = new CallExpressionResolver();
this.partialBodyResolveProvider = new PartialBodyResolveProvider();
this.statementFilter = new StatementFilter();
this.candidateResolver = new CandidateResolver();
this.callCompleter = new CallCompleter(argumentTypeResolver, candidateResolver);
this.taskPrioritizer = new TaskPrioritizer(storageManager);
@@ -219,8 +219,8 @@ public class InjectorForLazyLocalClassifierAnalyzer {
expressionTypingServices.setCallExpressionResolver(callExpressionResolver);
expressionTypingServices.setCallResolver(callResolver);
expressionTypingServices.setDescriptorResolver(descriptorResolver);
expressionTypingServices.setPartialBodyResolveProvider(partialBodyResolveProvider);
expressionTypingServices.setProject(project);
expressionTypingServices.setStatementFilter(statementFilter);
expressionTypingServices.setTypeResolver(typeResolver);
expressionTypingComponents.setAdditionalCheckerProvider(additionalCheckerProvider);
compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForLazyResolve.java
+4 -4
View File
@@ -45,7 +45,7 @@ import org.jetbrains.kotlin.resolve.QualifiedExpressionResolver;
import org.jetbrains.kotlin.resolve.TypeResolver.FlexibleTypeCapabilitiesProvider;
import org.jetbrains.kotlin.types.reflect.ReflectionTypes;
import org.jetbrains.kotlin.resolve.calls.CallExpressionResolver;
import org.jetbrains.kotlin.resolve.PartialBodyResolveProvider;
import org.jetbrains.kotlin.resolve.StatementFilter;
import org.jetbrains.kotlin.resolve.calls.CallCompleter;
import org.jetbrains.kotlin.resolve.calls.CandidateResolver;
import org.jetbrains.kotlin.resolve.calls.tasks.TaskPrioritizer;
@@ -90,7 +90,7 @@ public class InjectorForLazyResolve {
private final FlexibleTypeCapabilitiesProvider flexibleTypeCapabilitiesProvider;
private final ReflectionTypes reflectionTypes;
private final CallExpressionResolver callExpressionResolver;
private final PartialBodyResolveProvider partialBodyResolveProvider;
private final StatementFilter statementFilter;
private final CallCompleter callCompleter;
private final CandidateResolver candidateResolver;
private final TaskPrioritizer taskPrioritizer;
@@ -138,7 +138,7 @@ public class InjectorForLazyResolve {
this.delegatedPropertyResolver = new DelegatedPropertyResolver();
this.reflectionTypes = new ReflectionTypes(moduleDescriptor);
this.callExpressionResolver = new CallExpressionResolver();
this.partialBodyResolveProvider = new PartialBodyResolveProvider();
this.statementFilter = new StatementFilter();
this.candidateResolver = new CandidateResolver();
this.callCompleter = new CallCompleter(argumentTypeResolver, candidateResolver);
this.taskPrioritizer = new TaskPrioritizer(storageManager);
@@ -180,8 +180,8 @@ public class InjectorForLazyResolve {
expressionTypingServices.setCallExpressionResolver(callExpressionResolver);
expressionTypingServices.setCallResolver(callResolver);
expressionTypingServices.setDescriptorResolver(descriptorResolver);
expressionTypingServices.setPartialBodyResolveProvider(partialBodyResolveProvider);
expressionTypingServices.setProject(project);
expressionTypingServices.setStatementFilter(statementFilter);
expressionTypingServices.setTypeResolver(typeResolver);
expressionTypingComponents.setAdditionalCheckerProvider(additionalCheckerProvider);
compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForLazyTopDownAnalyzerBasic.java
+4 -4
View File
@@ -46,7 +46,7 @@ import org.jetbrains.kotlin.resolve.TypeResolver.FlexibleTypeCapabilitiesProvide
import org.jetbrains.kotlin.context.LazinessToken;
import org.jetbrains.kotlin.types.reflect.ReflectionTypes;
import org.jetbrains.kotlin.resolve.calls.CallExpressionResolver;
import org.jetbrains.kotlin.resolve.PartialBodyResolveProvider;
import org.jetbrains.kotlin.resolve.StatementFilter;
import org.jetbrains.kotlin.resolve.calls.CallCompleter;
import org.jetbrains.kotlin.resolve.calls.CandidateResolver;
import org.jetbrains.kotlin.resolve.calls.tasks.TaskPrioritizer;
@@ -102,7 +102,7 @@ public class InjectorForLazyTopDownAnalyzerBasic {
private final LazinessToken lazinessToken;
private final ReflectionTypes reflectionTypes;
private final CallExpressionResolver callExpressionResolver;
private final PartialBodyResolveProvider partialBodyResolveProvider;
private final StatementFilter statementFilter;
private final CallCompleter callCompleter;
private final CandidateResolver candidateResolver;
private final TaskPrioritizer taskPrioritizer;
@@ -159,7 +159,7 @@ public class InjectorForLazyTopDownAnalyzerBasic {
this.delegatedPropertyResolver = new DelegatedPropertyResolver();
this.reflectionTypes = new ReflectionTypes(module);
this.callExpressionResolver = new CallExpressionResolver();
this.partialBodyResolveProvider = new PartialBodyResolveProvider();
this.statementFilter = new StatementFilter();
this.candidateResolver = new CandidateResolver();
this.callCompleter = new CallCompleter(argumentTypeResolver, candidateResolver);
this.taskPrioritizer = new TaskPrioritizer(storageManager);
@@ -214,8 +214,8 @@ public class InjectorForLazyTopDownAnalyzerBasic {
expressionTypingServices.setCallExpressionResolver(callExpressionResolver);
expressionTypingServices.setCallResolver(callResolver);
expressionTypingServices.setDescriptorResolver(descriptorResolver);
expressionTypingServices.setPartialBodyResolveProvider(partialBodyResolveProvider);
expressionTypingServices.setProject(project);
expressionTypingServices.setStatementFilter(statementFilter);
expressionTypingServices.setTypeResolver(typeResolver);
expressionTypingComponents.setAdditionalCheckerProvider(defaultProvider);
compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForMacros.java
+4 -4
View File
@@ -35,7 +35,7 @@ import org.jetbrains.kotlin.types.DynamicTypesSettings;
import org.jetbrains.kotlin.resolve.calls.CallExpressionResolver;
import org.jetbrains.kotlin.resolve.DescriptorResolver;
import org.jetbrains.kotlin.resolve.DelegatedPropertyResolver;
import org.jetbrains.kotlin.resolve.PartialBodyResolveProvider;
import org.jetbrains.kotlin.resolve.StatementFilter;
import org.jetbrains.kotlin.types.expressions.ControlStructureTypingUtils;
import org.jetbrains.kotlin.types.expressions.ExpressionTypingUtils;
import org.jetbrains.kotlin.types.expressions.ForLoopConventionsChecker;
@@ -71,7 +71,7 @@ public class InjectorForMacros {
private final CallExpressionResolver callExpressionResolver;
private final DescriptorResolver descriptorResolver;
private final DelegatedPropertyResolver delegatedPropertyResolver;
private final PartialBodyResolveProvider partialBodyResolveProvider;
private final StatementFilter statementFilter;
private final ControlStructureTypingUtils controlStructureTypingUtils;
private final ExpressionTypingUtils expressionTypingUtils;
private final ForLoopConventionsChecker forLoopConventionsChecker;
@@ -105,7 +105,7 @@ public class InjectorForMacros {
this.callExpressionResolver = new CallExpressionResolver();
this.descriptorResolver = new DescriptorResolver();
this.delegatedPropertyResolver = new DelegatedPropertyResolver();
this.partialBodyResolveProvider = new PartialBodyResolveProvider();
this.statementFilter = new StatementFilter();
this.controlStructureTypingUtils = new ControlStructureTypingUtils(getExpressionTypingServices());
this.expressionTypingUtils = new ExpressionTypingUtils(getExpressionTypingServices(), getCallResolver(), kotlinBuiltIns);
this.forLoopConventionsChecker = new ForLoopConventionsChecker();
@@ -121,8 +121,8 @@ public class InjectorForMacros {
this.expressionTypingServices.setCallExpressionResolver(callExpressionResolver);
this.expressionTypingServices.setCallResolver(callResolver);
this.expressionTypingServices.setDescriptorResolver(descriptorResolver);
this.expressionTypingServices.setPartialBodyResolveProvider(partialBodyResolveProvider);
this.expressionTypingServices.setProject(project);
this.expressionTypingServices.setStatementFilter(statementFilter);
this.expressionTypingServices.setTypeResolver(typeResolver);
this.expressionTypingComponents.setAdditionalCheckerProvider(defaultProvider);
compiler/frontend/src/org/jetbrains/kotlin/resolve/AnnotationResolver.java
+1 -1
View File
@@ -353,7 +353,7 @@ public class AnnotationResolver {
SimpleResolutionContext context =
new SimpleResolutionContext(trace, JetScope.Empty.INSTANCE$, NO_EXPECTED_TYPE, DataFlowInfo.EMPTY,
ContextDependency.INDEPENDENT,
new CompositeChecker(Lists.<CallChecker>newArrayList()), PartialBodyResolveProvider.NONE);
new CompositeChecker(Lists.<CallChecker>newArrayList()), StatementFilter.NONE);
ArgumentTypeResolver.updateNumberType(defaultType, argumentExpression, context);
}
if (constant != null) {
compiler/frontend/src/org/jetbrains/kotlin/resolve/PartialBodyResolveProvider.kt → compiler/frontend/src/org/jetbrains/kotlin/resolve/StatementFilter.kt
+4 -4
View File
@@ -20,19 +20,19 @@ import org.jetbrains.kotlin.psi.JetElement
import org.jetbrains.kotlin.psi.JetBlockExpression
import org.jetbrains.kotlin.psi.JetPsiUtil
public open class PartialBodyResolveProvider {
public open class StatementFilter {
public open val filter: ((JetElement) -> Boolean)?
get() = null
class object {
public val NONE: PartialBodyResolveProvider = PartialBodyResolveProvider()
public val NONE: StatementFilter = StatementFilter()
}
}
fun PartialBodyResolveProvider.filterStatements(block: JetBlockExpression): List<JetElement> {
fun StatementFilter.filterStatements(block: JetBlockExpression): List<JetElement> {
if (filter == null || block is JetPsiUtil.JetExpressionWrapper) return block.getStatements()
return block.getStatements().filter { filter!!(it) }
}
fun PartialBodyResolveProvider.getLastStatementInABlock(block: JetBlockExpression) = filterStatements(block).lastOrNull()
fun StatementFilter.getLastStatementInABlock(block: JetBlockExpression) = filterStatements(block).lastOrNull()
compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/ArgumentTypeResolver.java
+1 -1
View File
@@ -167,7 +167,7 @@ public class ArgumentTypeResolver {
// This case is a temporary hack for 'if' branches.
// The right way to implement this logic is to interpret 'if' branches as function literals with explicitly-typed signatures
// (no arguments and no receiver) and therefore analyze them straight away (not in the 'complete' phase).
JetElement lastStatementInABlock = ResolvePackage.getLastStatementInABlock(context.partialBodyResolveProvider, blockExpression);
JetElement lastStatementInABlock = ResolvePackage.getLastStatementInABlock(context.statementFilter, blockExpression);
if (lastStatementInABlock instanceof JetExpression) {
return getLastElementDeparenthesized((JetExpression) lastStatementInABlock, context);
}
compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/context/BasicCallResolutionContext.java
+8 -8
View File
@@ -20,7 +20,7 @@ import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.kotlin.psi.Call;
import org.jetbrains.kotlin.resolve.BindingTrace;
import org.jetbrains.kotlin.resolve.PartialBodyResolveProvider;
import org.jetbrains.kotlin.resolve.StatementFilter;
import org.jetbrains.kotlin.resolve.calls.checkers.CallChecker;
import org.jetbrains.kotlin.resolve.calls.model.MutableDataFlowInfoForArguments;
import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo;
@@ -39,12 +39,12 @@ public class BasicCallResolutionContext extends CallResolutionContext<BasicCallR
@NotNull ResolutionResultsCache resolutionResultsCache,
@Nullable MutableDataFlowInfoForArguments dataFlowInfoForArguments,
@NotNull CallChecker callChecker,
@NotNull PartialBodyResolveProvider partialBodyResolveProvider,
@NotNull StatementFilter statementFilter,
boolean isAnnotationContext,
boolean collectAllCandidates
) {
super(trace, scope, call, expectedType, dataFlowInfo, contextDependency, checkArguments, resolutionResultsCache,
dataFlowInfoForArguments, callChecker, partialBodyResolveProvider, isAnnotationContext, collectAllCandidates);
dataFlowInfoForArguments, callChecker, statementFilter, isAnnotationContext, collectAllCandidates);
}
@NotNull
@@ -61,7 +61,7 @@ public class BasicCallResolutionContext extends CallResolutionContext<BasicCallR
) {
return new BasicCallResolutionContext(trace, scope, call, expectedType, dataFlowInfo, contextDependency, checkArguments,
new ResolutionResultsCacheImpl(), null,
callChecker, PartialBodyResolveProvider.NONE, isAnnotationContext, false);
callChecker, StatementFilter.NONE, isAnnotationContext, false);
}
@NotNull
@@ -71,7 +71,7 @@ public class BasicCallResolutionContext extends CallResolutionContext<BasicCallR
) {
return new BasicCallResolutionContext(
context.trace, context.scope, call, context.expectedType, context.dataFlowInfo, context.contextDependency, checkArguments,
context.resolutionResultsCache, dataFlowInfoForArguments, context.callChecker, context.partialBodyResolveProvider,
context.resolutionResultsCache, dataFlowInfoForArguments, context.callChecker, context.statementFilter,
context.isAnnotationContext, context.collectAllCandidates);
}
@@ -90,18 +90,18 @@ public class BasicCallResolutionContext extends CallResolutionContext<BasicCallR
@NotNull JetType expectedType,
@NotNull ContextDependency contextDependency,
@NotNull ResolutionResultsCache resolutionResultsCache,
@NotNull PartialBodyResolveProvider partialBodyResolveProvider,
@NotNull StatementFilter statementFilter,
boolean collectAllCandidates
) {
return new BasicCallResolutionContext(
trace, scope, call, expectedType, dataFlowInfo, contextDependency, checkArguments, resolutionResultsCache,
dataFlowInfoForArguments, callChecker, partialBodyResolveProvider, isAnnotationContext, collectAllCandidates);
dataFlowInfoForArguments, callChecker, statementFilter, isAnnotationContext, collectAllCandidates);
}
@NotNull
public BasicCallResolutionContext replaceCall(@NotNull Call newCall) {
return new BasicCallResolutionContext(
trace, scope, newCall, expectedType, dataFlowInfo, contextDependency, checkArguments, resolutionResultsCache,
dataFlowInfoForArguments, callChecker, partialBodyResolveProvider, isAnnotationContext, collectAllCandidates);
dataFlowInfoForArguments, callChecker, statementFilter, isAnnotationContext, collectAllCandidates);
}
}
compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/context/CallCandidateResolutionContext.java
+7 -7
View File
@@ -21,7 +21,7 @@ import org.jetbrains.annotations.Nullable;
import org.jetbrains.kotlin.descriptors.CallableDescriptor;
import org.jetbrains.kotlin.psi.Call;
import org.jetbrains.kotlin.resolve.BindingTrace;
import org.jetbrains.kotlin.resolve.PartialBodyResolveProvider;
import org.jetbrains.kotlin.resolve.StatementFilter;
import org.jetbrains.kotlin.resolve.calls.checkers.CallChecker;
import org.jetbrains.kotlin.resolve.calls.model.MutableDataFlowInfoForArguments;
import org.jetbrains.kotlin.resolve.calls.model.MutableResolvedCall;
@@ -52,13 +52,13 @@ public final class CallCandidateResolutionContext<D extends CallableDescriptor>
@NotNull ResolutionResultsCache resolutionResultsCache,
@Nullable MutableDataFlowInfoForArguments dataFlowInfoForArguments,
@NotNull CallChecker callChecker,
@NotNull PartialBodyResolveProvider partialBodyResolveProvider,
@NotNull StatementFilter statementFilter,
@NotNull ReceiverValue explicitExtensionReceiverForInvoke,
boolean isAnnotationContext,
boolean collectAllCandidates
) {
super(trace, scope, call, expectedType, dataFlowInfo, contextDependency, checkArguments, resolutionResultsCache,
dataFlowInfoForArguments, callChecker, partialBodyResolveProvider, isAnnotationContext, collectAllCandidates);
dataFlowInfoForArguments, callChecker, statementFilter, isAnnotationContext, collectAllCandidates);
this.candidateCall = candidateCall;
this.tracing = tracing;
this.explicitExtensionReceiverForInvoke = explicitExtensionReceiverForInvoke;
@@ -73,7 +73,7 @@ public final class CallCandidateResolutionContext<D extends CallableDescriptor>
candidateCall, tracing, trace, context.scope, call, context.expectedType,
context.dataFlowInfo, context.contextDependency, context.checkArguments,
context.resolutionResultsCache, context.dataFlowInfoForArguments,
context.callChecker, context.partialBodyResolveProvider, explicitExtensionReceiverForInvoke,
context.callChecker, context.statementFilter, explicitExtensionReceiverForInvoke,
context.isAnnotationContext, context.collectAllCandidates);
}
@@ -97,7 +97,7 @@ public final class CallCandidateResolutionContext<D extends CallableDescriptor>
return new CallCandidateResolutionContext<D>(
candidateCall, tracing, context.trace, context.scope, context.call, context.expectedType,
context.dataFlowInfo, context.contextDependency, context.checkArguments, context.resolutionResultsCache,
context.dataFlowInfoForArguments, context.callChecker, context.partialBodyResolveProvider, ReceiverValue.NO_RECEIVER,
context.dataFlowInfoForArguments, context.callChecker, context.statementFilter, ReceiverValue.NO_RECEIVER,
context.isAnnotationContext, context.collectAllCandidates);
}
@@ -109,12 +109,12 @@ public final class CallCandidateResolutionContext<D extends CallableDescriptor>
@NotNull JetType expectedType,
@NotNull ContextDependency contextDependency,
@NotNull ResolutionResultsCache resolutionResultsCache,
@NotNull PartialBodyResolveProvider partialBodyResolveProvider,
@NotNull StatementFilter statementFilter,
boolean collectAllCandidates
) {
return new CallCandidateResolutionContext<D>(
candidateCall, tracing, trace, scope, call, expectedType, dataFlowInfo, contextDependency, checkArguments,
resolutionResultsCache, dataFlowInfoForArguments, callChecker, partialBodyResolveProvider,
resolutionResultsCache, dataFlowInfoForArguments, callChecker, statementFilter,
explicitExtensionReceiverForInvoke, isAnnotationContext, collectAllCandidates);
}
}
compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/context/CallResolutionContext.java
+3 -3
View File
@@ -20,7 +20,7 @@ import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.kotlin.psi.Call;
import org.jetbrains.kotlin.resolve.BindingTrace;
import org.jetbrains.kotlin.resolve.PartialBodyResolveProvider;
import org.jetbrains.kotlin.resolve.StatementFilter;
import org.jetbrains.kotlin.resolve.calls.checkers.CallChecker;
import org.jetbrains.kotlin.resolve.calls.model.DataFlowInfoForArgumentsImpl;
import org.jetbrains.kotlin.resolve.calls.model.MutableDataFlowInfoForArguments;
@@ -48,12 +48,12 @@ public abstract class CallResolutionContext<Context extends CallResolutionContex
@SuppressWarnings("NullableProblems")
@Nullable MutableDataFlowInfoForArguments dataFlowInfoForArguments,
@NotNull CallChecker callChecker,
@NotNull PartialBodyResolveProvider partialBodyResolveProvider,
@NotNull StatementFilter statementFilter,
boolean isAnnotationContext,
boolean collectAllCandidates
) {
super(trace, scope, expectedType, dataFlowInfo, contextDependency, resolutionResultsCache, callChecker,
partialBodyResolveProvider, isAnnotationContext, collectAllCandidates);
statementFilter, isAnnotationContext, collectAllCandidates);
this.call = call;
this.checkArguments = checkArguments;
if (dataFlowInfoForArguments != null) {
compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/context/ResolutionContext.java
+14 -14
View File
@@ -19,7 +19,7 @@ package org.jetbrains.kotlin.resolve.calls.context;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.kotlin.resolve.BindingTrace;
import org.jetbrains.kotlin.resolve.PartialBodyResolveProvider;
import org.jetbrains.kotlin.resolve.StatementFilter;
import org.jetbrains.kotlin.resolve.calls.checkers.CallChecker;
import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo;
import org.jetbrains.kotlin.resolve.scopes.JetScope;
@@ -42,7 +42,7 @@ public abstract class ResolutionContext<Context extends ResolutionContext<Contex
@NotNull
public final CallChecker callChecker;
@NotNull
public final PartialBodyResolveProvider partialBodyResolveProvider;
public final StatementFilter statementFilter;
public final boolean isAnnotationContext;
@@ -56,7 +56,7 @@ public abstract class ResolutionContext<Context extends ResolutionContext<Contex
@NotNull ContextDependency contextDependency,
@NotNull ResolutionResultsCache resolutionResultsCache,
@NotNull CallChecker callChecker,
@NotNull PartialBodyResolveProvider partialBodyResolveProvider,
@NotNull StatementFilter statementFilter,
boolean isAnnotationContext,
boolean collectAllCandidates
) {
@@ -67,7 +67,7 @@ public abstract class ResolutionContext<Context extends ResolutionContext<Contex
this.contextDependency = contextDependency;
this.resolutionResultsCache = resolutionResultsCache;
this.callChecker = callChecker;
this.partialBodyResolveProvider = partialBodyResolveProvider;
this.statementFilter = statementFilter;
this.isAnnotationContext = isAnnotationContext;
this.collectAllCandidates = collectAllCandidates;
}
@@ -79,7 +79,7 @@ public abstract class ResolutionContext<Context extends ResolutionContext<Contex
@NotNull JetType expectedType,
@NotNull ContextDependency contextDependency,
@NotNull ResolutionResultsCache resolutionResultsCache,
@NotNull PartialBodyResolveProvider partialBodyResolveProvider,
@NotNull StatementFilter statementFilter,
boolean collectAllCandidates
);
@@ -92,14 +92,14 @@ public abstract class ResolutionContext<Context extends ResolutionContext<Contex
@NotNull
public Context replaceBindingTrace(@NotNull BindingTrace trace) {
if (this.trace == trace) return self();
return create(trace, scope, dataFlowInfo, expectedType, contextDependency, resolutionResultsCache, partialBodyResolveProvider,
return create(trace, scope, dataFlowInfo, expectedType, contextDependency, resolutionResultsCache, statementFilter,
collectAllCandidates);
}
@NotNull
public Context replaceDataFlowInfo(@NotNull DataFlowInfo newDataFlowInfo) {
if (newDataFlowInfo == dataFlowInfo) return self();
return create(trace, scope, newDataFlowInfo, expectedType, contextDependency, resolutionResultsCache, partialBodyResolveProvider,
return create(trace, scope, newDataFlowInfo, expectedType, contextDependency, resolutionResultsCache, statementFilter,
collectAllCandidates);
}
@@ -107,28 +107,28 @@ public abstract class ResolutionContext<Context extends ResolutionContext<Contex
public Context replaceExpectedType(@Nullable JetType newExpectedType) {
if (newExpectedType == null) return replaceExpectedType(TypeUtils.NO_EXPECTED_TYPE);
if (expectedType == newExpectedType) return self();
return create(trace, scope, dataFlowInfo, newExpectedType, contextDependency, resolutionResultsCache, partialBodyResolveProvider,
return create(trace, scope, dataFlowInfo, newExpectedType, contextDependency, resolutionResultsCache, statementFilter,
collectAllCandidates);
}
@NotNull
public Context replaceScope(@NotNull JetScope newScope) {
if (newScope == scope) return self();
return create(trace, newScope, dataFlowInfo, expectedType, contextDependency, resolutionResultsCache, partialBodyResolveProvider,
return create(trace, newScope, dataFlowInfo, expectedType, contextDependency, resolutionResultsCache, statementFilter,
collectAllCandidates);
}
@NotNull
public Context replaceContextDependency(@NotNull ContextDependency newContextDependency) {
if (newContextDependency == contextDependency) return self();
return create(trace, scope, dataFlowInfo, expectedType, newContextDependency, resolutionResultsCache, partialBodyResolveProvider,
return create(trace, scope, dataFlowInfo, expectedType, newContextDependency, resolutionResultsCache, statementFilter,
collectAllCandidates);
}
@NotNull
public Context replaceResolutionResultsCache(@NotNull ResolutionResultsCache newResolutionResultsCache) {
if (newResolutionResultsCache == resolutionResultsCache) return self();
return create(trace, scope, dataFlowInfo, expectedType, contextDependency, newResolutionResultsCache, partialBodyResolveProvider,
return create(trace, scope, dataFlowInfo, expectedType, contextDependency, newResolutionResultsCache, statementFilter,
collectAllCandidates);
}
@@ -139,13 +139,13 @@ public abstract class ResolutionContext<Context extends ResolutionContext<Contex
@NotNull
public Context replaceCollectAllCandidates(boolean newCollectAllCandidates) {
return create(trace, scope, dataFlowInfo, expectedType, contextDependency, resolutionResultsCache, partialBodyResolveProvider,
return create(trace, scope, dataFlowInfo, expectedType, contextDependency, resolutionResultsCache, statementFilter,
newCollectAllCandidates);
}
@NotNull
public Context replacePartialBodyResolveProvider(@NotNull PartialBodyResolveProvider partialBodyResolveProvider) {
return create(trace, scope, dataFlowInfo, expectedType, contextDependency, resolutionResultsCache, partialBodyResolveProvider,
public Context replacestatementFilter(@NotNull StatementFilter statementFilter) {
return create(trace, scope, dataFlowInfo, expectedType, contextDependency, resolutionResultsCache, statementFilter,
collectAllCandidates);
}
}
compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/context/SimpleResolutionContext.java
+7 -7
View File
@@ -18,7 +18,7 @@ package org.jetbrains.kotlin.resolve.calls.context;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.kotlin.resolve.BindingTrace;
import org.jetbrains.kotlin.resolve.PartialBodyResolveProvider;
import org.jetbrains.kotlin.resolve.StatementFilter;
import org.jetbrains.kotlin.resolve.calls.checkers.CallChecker;
import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo;
import org.jetbrains.kotlin.resolve.scopes.JetScope;
@@ -33,11 +33,11 @@ public class SimpleResolutionContext extends ResolutionContext<SimpleResolutionC
@NotNull ContextDependency contextDependency,
@NotNull ResolutionResultsCache resolutionResultsCache,
@NotNull CallChecker callChecker,
@NotNull PartialBodyResolveProvider partialBodyResolveProvider,
@NotNull StatementFilter statementFilter,
boolean isAnnotationContext,
boolean collectAllCandidates
) {
super(trace, scope, expectedType, dataFlowInfo, contextDependency, resolutionResultsCache, callChecker, partialBodyResolveProvider,
super(trace, scope, expectedType, dataFlowInfo, contextDependency, resolutionResultsCache, callChecker, statementFilter,
isAnnotationContext, collectAllCandidates);
}
@@ -48,10 +48,10 @@ public class SimpleResolutionContext extends ResolutionContext<SimpleResolutionC
@NotNull DataFlowInfo dataFlowInfo,
@NotNull ContextDependency contextDependency,
@NotNull CallChecker callChecker,
@NotNull PartialBodyResolveProvider partialBodyResolveProvider
@NotNull StatementFilter statementFilter
) {
this(trace, scope, expectedType, dataFlowInfo, contextDependency, new ResolutionResultsCacheImpl(),
callChecker, partialBodyResolveProvider, false, false);
callChecker, statementFilter, false, false);
}
@Override
@@ -62,11 +62,11 @@ public class SimpleResolutionContext extends ResolutionContext<SimpleResolutionC
@NotNull JetType expectedType,
@NotNull ContextDependency contextDependency,
@NotNull ResolutionResultsCache resolutionResultsCache,
@NotNull PartialBodyResolveProvider partialBodyResolveProvider,
@NotNull StatementFilter statementFilter,
boolean collectAllCandidates
) {
return new SimpleResolutionContext(
trace, scope, expectedType, dataFlowInfo, contextDependency, resolutionResultsCache, callChecker, partialBodyResolveProvider,
trace, scope, expectedType, dataFlowInfo, contextDependency, resolutionResultsCache, callChecker, statementFilter,
isAnnotationContext, collectAllCandidates);
}
}
compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/ResolutionTask.java
+7 -7
View File
@@ -24,7 +24,7 @@ import org.jetbrains.kotlin.descriptors.CallableDescriptor;
import org.jetbrains.kotlin.psi.Call;
import org.jetbrains.kotlin.psi.JetReferenceExpression;
import org.jetbrains.kotlin.resolve.BindingTrace;
import org.jetbrains.kotlin.resolve.PartialBodyResolveProvider;
import org.jetbrains.kotlin.resolve.StatementFilter;
import org.jetbrains.kotlin.resolve.calls.context.*;
import org.jetbrains.kotlin.resolve.calls.checkers.CallChecker;
import org.jetbrains.kotlin.resolve.calls.model.MutableDataFlowInfoForArguments;
@@ -56,13 +56,13 @@ public class ResolutionTask<D extends CallableDescriptor, F extends D> extends C
@NotNull ResolutionResultsCache resolutionResultsCache,
@Nullable MutableDataFlowInfoForArguments dataFlowInfoForArguments,
@NotNull CallChecker callChecker,
@NotNull PartialBodyResolveProvider partialBodyResolveProvider,
@NotNull StatementFilter statementFilter,
@NotNull Collection<MutableResolvedCall<F>> resolvedCalls,
boolean isAnnotationContext,
boolean collectAllCandidates
) {
super(trace, scope, call, expectedType, dataFlowInfo, contextDependency, checkArguments, resolutionResultsCache,
dataFlowInfoForArguments, callChecker, partialBodyResolveProvider, isAnnotationContext, collectAllCandidates);
dataFlowInfoForArguments, callChecker, statementFilter, isAnnotationContext, collectAllCandidates);
this.lazyCandidates = lazyCandidates;
this.resolvedCalls = resolvedCalls;
this.tracing = tracing;
@@ -77,7 +77,7 @@ public class ResolutionTask<D extends CallableDescriptor, F extends D> extends C
context.trace, context.scope, context.call,
context.expectedType, context.dataFlowInfo, context.contextDependency, context.checkArguments,
context.resolutionResultsCache, context.dataFlowInfoForArguments,
context.callChecker, context.partialBodyResolveProvider, Lists.<MutableResolvedCall<F>>newArrayList(),
context.callChecker, context.statementFilter, Lists.<MutableResolvedCall<F>>newArrayList(),
context.isAnnotationContext, context.collectAllCandidates);
}
@@ -116,12 +116,12 @@ public class ResolutionTask<D extends CallableDescriptor, F extends D> extends C
@NotNull JetType expectedType,
@NotNull ContextDependency contextDependency,
@NotNull ResolutionResultsCache resolutionResultsCache,
@NotNull PartialBodyResolveProvider partialBodyResolveProvider,
@NotNull StatementFilter statementFilter,
boolean collectAllCandidates
) {
return new ResolutionTask<D, F>(
lazyCandidates, tracing, trace, scope, call, expectedType, dataFlowInfo, contextDependency, checkArguments,
resolutionResultsCache, dataFlowInfoForArguments, callChecker, partialBodyResolveProvider, resolvedCalls,
resolutionResultsCache, dataFlowInfoForArguments, callChecker, statementFilter, resolvedCalls,
isAnnotationContext, collectAllCandidates);
}
@@ -132,7 +132,7 @@ public class ResolutionTask<D extends CallableDescriptor, F extends D> extends C
public ResolutionTask<D, F> replaceCall(@NotNull Call newCall) {
return new ResolutionTask<D, F>(
lazyCandidates, tracing, trace, scope, newCall, expectedType, dataFlowInfo, contextDependency, checkArguments,
resolutionResultsCache, dataFlowInfoForArguments, callChecker, partialBodyResolveProvider, resolvedCalls,
resolutionResultsCache, dataFlowInfoForArguments, callChecker, statementFilter, resolvedCalls,
isAnnotationContext, collectAllCandidates);
}
compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingContext.java
+9 -9
View File
@@ -18,7 +18,7 @@ package org.jetbrains.kotlin.types.expressions;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.kotlin.resolve.BindingTrace;
import org.jetbrains.kotlin.resolve.PartialBodyResolveProvider;
import org.jetbrains.kotlin.resolve.StatementFilter;
import org.jetbrains.kotlin.resolve.calls.context.ContextDependency;
import org.jetbrains.kotlin.resolve.calls.context.ResolutionContext;
import org.jetbrains.kotlin.resolve.calls.context.ResolutionResultsCache;
@@ -41,14 +41,14 @@ public class ExpressionTypingContext extends ResolutionContext<ExpressionTypingC
) {
return newContext(trace, scope, dataFlowInfo, expectedType,
ContextDependency.INDEPENDENT, new ResolutionResultsCacheImpl(),
expressionTypingServices.getCallChecker(), PartialBodyResolveProvider.NONE, false);
expressionTypingServices.getCallChecker(), StatementFilter.NONE, false);
}
@NotNull
public static ExpressionTypingContext newContext(@NotNull ResolutionContext context) {
return new ExpressionTypingContext(
context.trace, context.scope, context.dataFlowInfo, context.expectedType,
context.contextDependency, context.resolutionResultsCache, context.callChecker, context.partialBodyResolveProvider,
context.contextDependency, context.resolutionResultsCache, context.callChecker, context.statementFilter,
context.isAnnotationContext, context.collectAllCandidates
);
}
@@ -62,12 +62,12 @@ public class ExpressionTypingContext extends ResolutionContext<ExpressionTypingC
@NotNull ContextDependency contextDependency,
@NotNull ResolutionResultsCache resolutionResultsCache,
@NotNull CallChecker callChecker,
@NotNull PartialBodyResolveProvider partialBodyResolveProvider,
@NotNull StatementFilter statementFilter,
boolean isAnnotationContext
) {
return new ExpressionTypingContext(
trace, scope, dataFlowInfo, expectedType, contextDependency, resolutionResultsCache, callChecker,
partialBodyResolveProvider, isAnnotationContext, false);
statementFilter, isAnnotationContext, false);
}
private CompileTimeConstantChecker compileTimeConstantChecker;
@@ -80,12 +80,12 @@ public class ExpressionTypingContext extends ResolutionContext<ExpressionTypingC
@NotNull ContextDependency contextDependency,
@NotNull ResolutionResultsCache resolutionResultsCache,
@NotNull CallChecker callChecker,
@NotNull PartialBodyResolveProvider partialBodyResolveProvider,
@NotNull StatementFilter statementFilter,
boolean isAnnotationContext,
boolean collectAllCandidates
) {
super(trace, scope, expectedType, dataFlowInfo, contextDependency, resolutionResultsCache, callChecker,
partialBodyResolveProvider, isAnnotationContext, collectAllCandidates);
statementFilter, isAnnotationContext, collectAllCandidates);
}
@Override
@@ -96,12 +96,12 @@ public class ExpressionTypingContext extends ResolutionContext<ExpressionTypingC
@NotNull JetType expectedType,
@NotNull ContextDependency contextDependency,
@NotNull ResolutionResultsCache resolutionResultsCache,
@NotNull PartialBodyResolveProvider partialBodyResolveProvider,
@NotNull StatementFilter statementFilter,
boolean collectAllCandidates
) {
return new ExpressionTypingContext(trace, scope, dataFlowInfo,
expectedType, contextDependency, resolutionResultsCache, callChecker,
partialBodyResolveProvider, isAnnotationContext, collectAllCandidates);
statementFilter, isAnnotationContext, collectAllCandidates);
}
///////////// LAZY ACCESSORS
compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingServices.java
+7 -7
View File
@@ -65,7 +65,7 @@ public class ExpressionTypingServices {
private DescriptorResolver descriptorResolver;
private TypeResolver typeResolver;
private AnnotationResolver annotationResolver;
private PartialBodyResolveProvider partialBodyResolveProvider;
private StatementFilter statementFilter;
private KotlinBuiltIns builtIns;
@NotNull
@@ -129,13 +129,13 @@ public class ExpressionTypingServices {
}
@NotNull
private PartialBodyResolveProvider getPartialBodyResolveProvider() {
return partialBodyResolveProvider;
private StatementFilter getStatementFilter() {
return statementFilter;
}
@Inject
public void setPartialBodyResolveProvider(@NotNull PartialBodyResolveProvider partialBodyResolveProvider) {
this.partialBodyResolveProvider = partialBodyResolveProvider;
public void setStatementFilter(@NotNull StatementFilter statementFilter) {
this.statementFilter = statementFilter;
}
@Inject
@@ -208,7 +208,7 @@ public class ExpressionTypingServices {
@NotNull CoercionStrategy coercionStrategyForLastExpression,
@NotNull ExpressionTypingContext context
) {
List<JetElement> block = ResolvePackage.filterStatements(getPartialBodyResolveProvider(), expression);
List<JetElement> block = ResolvePackage.filterStatements(getStatementFilter(), expression);
// SCRIPT: get code descriptor for script declaration
DeclarationDescriptor containingDescriptor = context.scope.getContainingDeclaration();
@@ -229,7 +229,7 @@ public class ExpressionTypingServices {
}
else {
r = getBlockReturnedTypeWithWritableScope(scope, block, coercionStrategyForLastExpression,
context.replacePartialBodyResolveProvider(getPartialBodyResolveProvider()));
context.replacestatementFilter(getStatementFilter()));
}
scope.changeLockLevel(WritableScope.LockLevel.READING);
compiler/tests/org/jetbrains/kotlin/di/InjectorForTests.java
+4 -4
View File
@@ -41,7 +41,7 @@ import org.jetbrains.kotlin.types.expressions.ForLoopConventionsChecker;
import org.jetbrains.kotlin.types.expressions.LocalClassifierAnalyzer;
import org.jetbrains.kotlin.types.reflect.ReflectionTypes;
import org.jetbrains.kotlin.resolve.calls.CallExpressionResolver;
import org.jetbrains.kotlin.resolve.PartialBodyResolveProvider;
import org.jetbrains.kotlin.resolve.StatementFilter;
import org.jetbrains.kotlin.resolve.QualifiedExpressionResolver;
import org.jetbrains.kotlin.resolve.TypeResolver.FlexibleTypeCapabilitiesProvider;
import org.jetbrains.kotlin.context.LazinessToken;
@@ -77,7 +77,7 @@ public class InjectorForTests {
private final LocalClassifierAnalyzer localClassifierAnalyzer;
private final ReflectionTypes reflectionTypes;
private final CallExpressionResolver callExpressionResolver;
private final PartialBodyResolveProvider partialBodyResolveProvider;
private final StatementFilter statementFilter;
private final QualifiedExpressionResolver qualifiedExpressionResolver;
private final FlexibleTypeCapabilitiesProvider flexibleTypeCapabilitiesProvider;
private final LazinessToken lazinessToken;
@@ -114,7 +114,7 @@ public class InjectorForTests {
this.localClassifierAnalyzer = new LocalClassifierAnalyzer(getDescriptorResolver(), getTypeResolver(), annotationResolver);
this.reflectionTypes = new ReflectionTypes(moduleDescriptor);
this.callExpressionResolver = new CallExpressionResolver();
this.partialBodyResolveProvider = new PartialBodyResolveProvider();
this.statementFilter = new StatementFilter();
this.descriptorResolver.setAnnotationResolver(annotationResolver);
this.descriptorResolver.setBuiltIns(kotlinBuiltIns);
@@ -128,8 +128,8 @@ public class InjectorForTests {
this.expressionTypingServices.setCallExpressionResolver(callExpressionResolver);
this.expressionTypingServices.setCallResolver(callResolver);
this.expressionTypingServices.setDescriptorResolver(descriptorResolver);
this.expressionTypingServices.setPartialBodyResolveProvider(partialBodyResolveProvider);
this.expressionTypingServices.setProject(project);
this.expressionTypingServices.setStatementFilter(statementFilter);
this.expressionTypingServices.setTypeResolver(typeResolver);
annotationResolver.setCallResolver(callResolver);
generators/src/org/jetbrains/kotlin/generators/injectors/GenerateInjectors.kt
+1 -1
View File
@@ -252,7 +252,7 @@ private fun generatorForBodyResolve() =
parameter<BindingTrace>()
parameter<ModuleDescriptor>(useAsContext = true)
parameter<AdditionalCheckerProvider>()
parameter<PartialBodyResolveProvider>()
parameter<StatementFilter>()
publicField<BodyResolver>()
}
idea/ide-common/src/org/jetbrains/kotlin/resolve/lazy/ElementResolver.java
+18 -18
View File
@@ -134,26 +134,26 @@ public abstract class ElementResolver {
JetFile file = resolveElement.getContainingJetFile();
PartialBodyResolveProvider partialResolveProvider;
StatementFilter statementFilter;
if (bodyResolveMode != BodyResolveMode.FULL && resolveElement instanceof JetDeclaration) {
partialResolveProvider = new PartialBodyResolveFilter(
statementFilter = new PartialBodyResolveFilter(
contextElement,
(JetDeclaration) resolveElement,
probablyNothingCallableNames(),
bodyResolveMode == BodyResolveMode.PARTIAL_FOR_COMPLETION);
}
else {
partialResolveProvider = PartialBodyResolveProvider.NONE;
statementFilter = StatementFilter.NONE;
}
if (resolveElement instanceof JetNamedFunction) {
functionAdditionalResolve(resolveSession, (JetNamedFunction) resolveElement, trace, file, partialResolveProvider);
functionAdditionalResolve(resolveSession, (JetNamedFunction) resolveElement, trace, file, statementFilter);
}
else if (resolveElement instanceof JetClassInitializer) {
initializerAdditionalResolve(resolveSession, (JetClassInitializer) resolveElement, trace, file, partialResolveProvider);
initializerAdditionalResolve(resolveSession, (JetClassInitializer) resolveElement, trace, file, statementFilter);
}
else if (resolveElement instanceof JetProperty) {
propertyAdditionalResolve(resolveSession, (JetProperty) resolveElement, trace, file, partialResolveProvider);
propertyAdditionalResolve(resolveSession, (JetProperty) resolveElement, trace, file, statementFilter);
}
else if (resolveElement instanceof JetDelegationSpecifierList) {
delegationSpecifierAdditionalResolve(resolveSession, (JetDelegationSpecifierList) resolveElement, trace, file);
@@ -167,7 +167,7 @@ public abstract class ElementResolver {
annotationAdditionalResolve(resolveSession, (JetAnnotationEntry) resolveElement);
}
else if (resolveElement instanceof JetClass) {
constructorAdditionalResolve(resolveSession, (JetClass) resolveElement, trace, file, partialResolveProvider);
constructorAdditionalResolve(resolveSession, (JetClass) resolveElement, trace, file, statementFilter);
}
else if (resolveElement instanceof JetTypeParameter) {
typeParameterAdditionalResolve(resolveSession, (JetTypeParameter) resolveElement);
@@ -345,7 +345,7 @@ public abstract class ElementResolver {
// Activate resolving of supertypes
ForceResolveUtil.forceResolveAllContents(descriptor.getTypeConstructor().getSupertypes());
BodyResolver bodyResolver = createBodyResolver(resolveSession, trace, file, PartialBodyResolveProvider.NONE);
BodyResolver bodyResolver = createBodyResolver(resolveSession, trace, file, StatementFilter.NONE);
bodyResolver.resolveDelegationSpecifierList(createEmptyContext(resolveSession), classOrObject, descriptor,
descriptor.getUnsubstitutedPrimaryConstructor(),
descriptor.getScopeForClassHeaderResolution(),
@@ -357,7 +357,7 @@ public abstract class ElementResolver {
final JetProperty jetProperty,
BindingTrace trace,
JetFile file,
@NotNull PartialBodyResolveProvider partialResolveProvider
@NotNull StatementFilter statementFilter
) {
JetScope propertyResolutionScope = resolveSession.getScopeProvider().getResolutionScopeForDeclaration(jetProperty);
@@ -371,7 +371,7 @@ public abstract class ElementResolver {
return resolveSession.getScopeProvider().getResolutionScopeForDeclaration(declaration);
}
});
BodyResolver bodyResolver = createBodyResolver(resolveSession, trace, file, partialResolveProvider);
BodyResolver bodyResolver = createBodyResolver(resolveSession, trace, file, statementFilter);
PropertyDescriptor descriptor = (PropertyDescriptor) resolveSession.resolveToDescriptor(jetProperty);
ForceResolveUtil.forceResolveAllContents(descriptor);
@@ -397,13 +397,13 @@ public abstract class ElementResolver {
JetNamedFunction namedFunction,
BindingTrace trace,
JetFile file,
@NotNull PartialBodyResolveProvider partialResolveProvider
@NotNull StatementFilter statementFilter
) {
JetScope scope = resolveSession.getScopeProvider().getResolutionScopeForDeclaration(namedFunction);
FunctionDescriptor functionDescriptor = (FunctionDescriptor) resolveSession.resolveToDescriptor(namedFunction);
ForceResolveUtil.forceResolveAllContents(functionDescriptor);
BodyResolver bodyResolver = createBodyResolver(resolveSession, trace, file, partialResolveProvider);
BodyResolver bodyResolver = createBodyResolver(resolveSession, trace, file, statementFilter);
bodyResolver.resolveFunctionBody(createEmptyContext(resolveSession), trace, namedFunction, functionDescriptor, scope);
}
@@ -412,7 +412,7 @@ public abstract class ElementResolver {
JetClass klass,
BindingTrace trace,
JetFile file,
@NotNull PartialBodyResolveProvider partialResolveProvider
@NotNull StatementFilter statementFilter
) {
JetScope scope = resolveSession.getScopeProvider().getResolutionScopeForDeclaration(klass);
@@ -423,7 +423,7 @@ public abstract class ElementResolver {
classDescriptor,
JetPsiUtil.getElementTextWithContext(klass));
BodyResolver bodyResolver = createBodyResolver(resolveSession, trace, file, partialResolveProvider);
BodyResolver bodyResolver = createBodyResolver(resolveSession, trace, file, statementFilter);
bodyResolver.resolveConstructorParameterDefaultValuesAndAnnotations(createEmptyContext(resolveSession), trace, klass,
constructorDescriptor, scope);
}
@@ -433,23 +433,23 @@ public abstract class ElementResolver {
JetClassInitializer classInitializer,
BindingTrace trace,
JetFile file,
@NotNull PartialBodyResolveProvider partialResolveProvider
@NotNull StatementFilter statementFilter
) {
JetClassOrObject classOrObject = PsiTreeUtil.getParentOfType(classInitializer, JetClassOrObject.class);
LazyClassDescriptor classOrObjectDescriptor = (LazyClassDescriptor) resolveSession.resolveToDescriptor(classOrObject);
BodyResolver bodyResolver = createBodyResolver(resolveSession, trace, file, partialResolveProvider);
BodyResolver bodyResolver = createBodyResolver(resolveSession, trace, file, statementFilter);
bodyResolver.resolveAnonymousInitializer(createEmptyContext(resolveSession), classInitializer, classOrObjectDescriptor);
}
private BodyResolver createBodyResolver(ResolveSession resolveSession, BindingTrace trace, JetFile file, @NotNull PartialBodyResolveProvider partialResolveProvider) {
private BodyResolver createBodyResolver(ResolveSession resolveSession, BindingTrace trace, JetFile file, @NotNull StatementFilter statementFilter) {
InjectorForBodyResolve bodyResolve = new InjectorForBodyResolve(
file.getProject(),
createParameters(resolveSession),
trace,
resolveSession.getModuleDescriptor(),
getAdditionalCheckerProvider(file),
partialResolveProvider
statementFilter
);
return bodyResolve.getBodyResolver();
}
idea/ide-common/src/org/jetbrains/kotlin/resolve/lazy/PartialBodyResolveFilter.kt
+2 -2
View File
@@ -27,7 +27,7 @@ import com.intellij.psi.PsiElement
import org.jetbrains.kotlin.JetNodeTypes
import org.jetbrains.kotlin.utils.addToStdlib.firstIsInstanceOrNull
import org.jetbrains.kotlin.psi.psiUtil.isAncestor
import org.jetbrains.kotlin.resolve.PartialBodyResolveProvider
import org.jetbrains.kotlin.resolve.StatementFilter
import org.jetbrains.kotlin.psi.psiUtil.isProbablyNothing
//TODO: do resolve anonymous object's body
@@ -37,7 +37,7 @@ class PartialBodyResolveFilter(
private val declaration: JetDeclaration,
probablyNothingCallableNames: ProbablyNothingCallableNames,
forCompletion: Boolean
) : PartialBodyResolveProvider() {
) : StatementFilter() {
private val statementMarks = StatementMarks()
js/js.frontend/src/org/jetbrains/kotlin/di/InjectorForTopDownAnalyzerForJs.java
+4 -4
View File
@@ -46,7 +46,7 @@ import org.jetbrains.kotlin.resolve.TypeResolver.FlexibleTypeCapabilitiesProvide
import org.jetbrains.kotlin.context.LazinessToken;
import org.jetbrains.kotlin.types.reflect.ReflectionTypes;
import org.jetbrains.kotlin.resolve.calls.CallExpressionResolver;
import org.jetbrains.kotlin.resolve.PartialBodyResolveProvider;
import org.jetbrains.kotlin.resolve.StatementFilter;
import org.jetbrains.kotlin.resolve.calls.CallCompleter;
import org.jetbrains.kotlin.resolve.calls.CandidateResolver;
import org.jetbrains.kotlin.resolve.calls.tasks.TaskPrioritizer;
@@ -102,7 +102,7 @@ public class InjectorForTopDownAnalyzerForJs {
private final LazinessToken lazinessToken;
private final ReflectionTypes reflectionTypes;
private final CallExpressionResolver callExpressionResolver;
private final PartialBodyResolveProvider partialBodyResolveProvider;
private final StatementFilter statementFilter;
private final CallCompleter callCompleter;
private final CandidateResolver candidateResolver;
private final TaskPrioritizer taskPrioritizer;
@@ -159,7 +159,7 @@ public class InjectorForTopDownAnalyzerForJs {
this.delegatedPropertyResolver = new DelegatedPropertyResolver();
this.reflectionTypes = new ReflectionTypes(module);
this.callExpressionResolver = new CallExpressionResolver();
this.partialBodyResolveProvider = new PartialBodyResolveProvider();
this.statementFilter = new StatementFilter();
this.candidateResolver = new CandidateResolver();
this.callCompleter = new CallCompleter(argumentTypeResolver, candidateResolver);
this.taskPrioritizer = new TaskPrioritizer(storageManager);
@@ -214,8 +214,8 @@ public class InjectorForTopDownAnalyzerForJs {
expressionTypingServices.setCallExpressionResolver(callExpressionResolver);
expressionTypingServices.setCallResolver(callResolver);
expressionTypingServices.setDescriptorResolver(descriptorResolver);
expressionTypingServices.setPartialBodyResolveProvider(partialBodyResolveProvider);
expressionTypingServices.setProject(project);
expressionTypingServices.setStatementFilter(statementFilter);
expressionTypingServices.setTypeResolver(typeResolver);
expressionTypingComponents.setAdditionalCheckerProvider(kotlinJsCheckerProvider);