diff --git a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForLazyResolveWithJava.java b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForLazyResolveWithJava.java index 6ff07a01d27..f6a2566b55b 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForLazyResolveWithJava.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForLazyResolveWithJava.java @@ -44,6 +44,7 @@ import org.jetbrains.jet.lang.resolve.kotlin.JavaDeclarationCheckerProvider; import org.jetbrains.jet.lang.resolve.AnnotationResolver; import org.jetbrains.jet.lang.resolve.calls.CallResolver; import org.jetbrains.jet.lang.resolve.calls.ArgumentTypeResolver; +import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; import org.jetbrains.jet.lang.types.expressions.ExpressionTypingServices; import org.jetbrains.jet.lang.types.expressions.ExpressionTypingComponents; import org.jetbrains.jet.lang.types.expressions.ControlStructureTypingUtils; @@ -106,6 +107,7 @@ public class InjectorForLazyResolveWithJava { private final AnnotationResolver annotationResolver; private final CallResolver callResolver; private final ArgumentTypeResolver argumentTypeResolver; + private final KotlinBuiltIns kotlinBuiltIns; private final ExpressionTypingServices expressionTypingServices; private final ExpressionTypingComponents expressionTypingComponents; private final ControlStructureTypingUtils controlStructureTypingUtils; @@ -174,11 +176,12 @@ public class InjectorForLazyResolveWithJava { this.annotationResolver = new AnnotationResolver(); this.callResolver = new CallResolver(); this.argumentTypeResolver = new ArgumentTypeResolver(); + this.kotlinBuiltIns = KotlinBuiltIns.getInstance(); this.expressionTypingComponents = new ExpressionTypingComponents(); this.expressionTypingServices = new ExpressionTypingServices(expressionTypingComponents); this.controlStructureTypingUtils = new ControlStructureTypingUtils(expressionTypingServices); this.dynamicTypesSettings = new DynamicTypesSettings(); - this.expressionTypingUtils = new ExpressionTypingUtils(expressionTypingServices, callResolver); + this.expressionTypingUtils = new ExpressionTypingUtils(expressionTypingServices, callResolver, kotlinBuiltIns); this.forLoopConventionsChecker = new ForLoopConventionsChecker(); this.reflectionTypes = new ReflectionTypes(module); this.callExpressionResolver = new CallExpressionResolver(); @@ -237,10 +240,12 @@ public class InjectorForLazyResolveWithJava { callResolver.setTaskPrioritizer(taskPrioritizer); callResolver.setTypeResolver(typeResolver); + argumentTypeResolver.setBuiltIns(kotlinBuiltIns); argumentTypeResolver.setExpressionTypingServices(expressionTypingServices); argumentTypeResolver.setTypeResolver(typeResolver); expressionTypingServices.setAnnotationResolver(annotationResolver); + expressionTypingServices.setBuiltIns(kotlinBuiltIns); expressionTypingServices.setCallExpressionResolver(callExpressionResolver); expressionTypingServices.setCallResolver(callResolver); expressionTypingServices.setDescriptorResolver(descriptorResolver); @@ -250,6 +255,7 @@ public class InjectorForLazyResolveWithJava { expressionTypingServices.setTypeResolver(typeResolver); expressionTypingComponents.setAdditionalCheckerProvider(javaDeclarationCheckerProvider); + expressionTypingComponents.setBuiltIns(kotlinBuiltIns); expressionTypingComponents.setCallResolver(callResolver); expressionTypingComponents.setControlStructureTypingUtils(controlStructureTypingUtils); expressionTypingComponents.setDynamicTypesSettings(dynamicTypesSettings); @@ -267,11 +273,13 @@ public class InjectorForLazyResolveWithJava { callExpressionResolver.setExpressionTypingServices(expressionTypingServices); descriptorResolver.setAnnotationResolver(annotationResolver); + descriptorResolver.setBuiltIns(kotlinBuiltIns); descriptorResolver.setDelegatedPropertyResolver(delegatedPropertyResolver); descriptorResolver.setExpressionTypingServices(expressionTypingServices); descriptorResolver.setStorageManager(storageManager); descriptorResolver.setTypeResolver(typeResolver); + delegatedPropertyResolver.setBuiltIns(kotlinBuiltIns); delegatedPropertyResolver.setCallResolver(callResolver); delegatedPropertyResolver.setExpressionTypingServices(expressionTypingServices); diff --git a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForReplWithJava.java b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForReplWithJava.java index 2f9b292f5af..809be2c2a5d 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForReplWithJava.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForReplWithJava.java @@ -47,6 +47,7 @@ import org.jetbrains.jet.lang.resolve.lazy.ScopeProvider.AdditionalFileScopeProv import org.jetbrains.jet.lang.resolve.AnnotationResolver; import org.jetbrains.jet.lang.resolve.calls.CallResolver; import org.jetbrains.jet.lang.resolve.calls.ArgumentTypeResolver; +import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; import org.jetbrains.jet.lang.types.expressions.ExpressionTypingServices; import org.jetbrains.jet.lang.types.expressions.ExpressionTypingComponents; import org.jetbrains.jet.lang.types.expressions.ControlStructureTypingUtils; @@ -124,6 +125,7 @@ public class InjectorForReplWithJava { private final AnnotationResolver annotationResolver; private final CallResolver callResolver; private final ArgumentTypeResolver argumentTypeResolver; + private final KotlinBuiltIns kotlinBuiltIns; private final ExpressionTypingServices expressionTypingServices; private final ExpressionTypingComponents expressionTypingComponents; private final ControlStructureTypingUtils controlStructureTypingUtils; @@ -209,11 +211,12 @@ public class InjectorForReplWithJava { this.annotationResolver = new AnnotationResolver(); this.callResolver = new CallResolver(); this.argumentTypeResolver = new ArgumentTypeResolver(); + this.kotlinBuiltIns = KotlinBuiltIns.getInstance(); this.expressionTypingComponents = new ExpressionTypingComponents(); this.expressionTypingServices = new ExpressionTypingServices(expressionTypingComponents); this.controlStructureTypingUtils = new ControlStructureTypingUtils(expressionTypingServices); this.dynamicTypesSettings = new DynamicTypesSettings(); - this.expressionTypingUtils = new ExpressionTypingUtils(expressionTypingServices, callResolver); + this.expressionTypingUtils = new ExpressionTypingUtils(expressionTypingServices, callResolver, kotlinBuiltIns); this.forLoopConventionsChecker = new ForLoopConventionsChecker(); this.reflectionTypes = new ReflectionTypes(module); this.callExpressionResolver = new CallExpressionResolver(); @@ -294,10 +297,12 @@ public class InjectorForReplWithJava { callResolver.setTaskPrioritizer(taskPrioritizer); callResolver.setTypeResolver(typeResolver); + argumentTypeResolver.setBuiltIns(kotlinBuiltIns); argumentTypeResolver.setExpressionTypingServices(expressionTypingServices); argumentTypeResolver.setTypeResolver(typeResolver); expressionTypingServices.setAnnotationResolver(annotationResolver); + expressionTypingServices.setBuiltIns(kotlinBuiltIns); expressionTypingServices.setCallExpressionResolver(callExpressionResolver); expressionTypingServices.setCallResolver(callResolver); expressionTypingServices.setDescriptorResolver(descriptorResolver); @@ -307,6 +312,7 @@ public class InjectorForReplWithJava { expressionTypingServices.setTypeResolver(typeResolver); expressionTypingComponents.setAdditionalCheckerProvider(javaDeclarationCheckerProvider); + expressionTypingComponents.setBuiltIns(kotlinBuiltIns); expressionTypingComponents.setCallResolver(callResolver); expressionTypingComponents.setControlStructureTypingUtils(controlStructureTypingUtils); expressionTypingComponents.setDynamicTypesSettings(dynamicTypesSettings); @@ -324,11 +330,13 @@ public class InjectorForReplWithJava { callExpressionResolver.setExpressionTypingServices(expressionTypingServices); descriptorResolver.setAnnotationResolver(annotationResolver); + descriptorResolver.setBuiltIns(kotlinBuiltIns); descriptorResolver.setDelegatedPropertyResolver(delegatedPropertyResolver); descriptorResolver.setExpressionTypingServices(expressionTypingServices); descriptorResolver.setStorageManager(storageManager); descriptorResolver.setTypeResolver(typeResolver); + delegatedPropertyResolver.setBuiltIns(kotlinBuiltIns); delegatedPropertyResolver.setCallResolver(callResolver); delegatedPropertyResolver.setExpressionTypingServices(expressionTypingServices); diff --git a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java index 1b59cf4a8a8..a0d3c8ccbce 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java @@ -46,6 +46,7 @@ import org.jetbrains.jet.lang.resolve.kotlin.JavaDeclarationCheckerProvider; import org.jetbrains.jet.lang.resolve.AnnotationResolver; import org.jetbrains.jet.lang.resolve.calls.CallResolver; import org.jetbrains.jet.lang.resolve.calls.ArgumentTypeResolver; +import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; import org.jetbrains.jet.lang.types.expressions.ExpressionTypingServices; import org.jetbrains.jet.lang.types.expressions.ExpressionTypingComponents; import org.jetbrains.jet.lang.types.expressions.ControlStructureTypingUtils; @@ -123,6 +124,7 @@ public class InjectorForTopDownAnalyzerForJvm { private final AnnotationResolver annotationResolver; private final CallResolver callResolver; private final ArgumentTypeResolver argumentTypeResolver; + private final KotlinBuiltIns kotlinBuiltIns; private final ExpressionTypingServices expressionTypingServices; private final ExpressionTypingComponents expressionTypingComponents; private final ControlStructureTypingUtils controlStructureTypingUtils; @@ -207,11 +209,12 @@ public class InjectorForTopDownAnalyzerForJvm { this.annotationResolver = new AnnotationResolver(); this.callResolver = new CallResolver(); this.argumentTypeResolver = new ArgumentTypeResolver(); + this.kotlinBuiltIns = KotlinBuiltIns.getInstance(); this.expressionTypingComponents = new ExpressionTypingComponents(); this.expressionTypingServices = new ExpressionTypingServices(expressionTypingComponents); this.controlStructureTypingUtils = new ControlStructureTypingUtils(expressionTypingServices); this.dynamicTypesSettings = new DynamicTypesSettings(); - this.expressionTypingUtils = new ExpressionTypingUtils(expressionTypingServices, callResolver); + this.expressionTypingUtils = new ExpressionTypingUtils(expressionTypingServices, callResolver, kotlinBuiltIns); this.forLoopConventionsChecker = new ForLoopConventionsChecker(); this.reflectionTypes = new ReflectionTypes(module); this.callExpressionResolver = new CallExpressionResolver(); @@ -293,10 +296,12 @@ public class InjectorForTopDownAnalyzerForJvm { callResolver.setTaskPrioritizer(taskPrioritizer); callResolver.setTypeResolver(typeResolver); + argumentTypeResolver.setBuiltIns(kotlinBuiltIns); argumentTypeResolver.setExpressionTypingServices(expressionTypingServices); argumentTypeResolver.setTypeResolver(typeResolver); expressionTypingServices.setAnnotationResolver(annotationResolver); + expressionTypingServices.setBuiltIns(kotlinBuiltIns); expressionTypingServices.setCallExpressionResolver(callExpressionResolver); expressionTypingServices.setCallResolver(callResolver); expressionTypingServices.setDescriptorResolver(descriptorResolver); @@ -306,6 +311,7 @@ public class InjectorForTopDownAnalyzerForJvm { expressionTypingServices.setTypeResolver(typeResolver); expressionTypingComponents.setAdditionalCheckerProvider(javaDeclarationCheckerProvider); + expressionTypingComponents.setBuiltIns(kotlinBuiltIns); expressionTypingComponents.setCallResolver(callResolver); expressionTypingComponents.setControlStructureTypingUtils(controlStructureTypingUtils); expressionTypingComponents.setDynamicTypesSettings(dynamicTypesSettings); @@ -323,11 +329,13 @@ public class InjectorForTopDownAnalyzerForJvm { callExpressionResolver.setExpressionTypingServices(expressionTypingServices); descriptorResolver.setAnnotationResolver(annotationResolver); + descriptorResolver.setBuiltIns(kotlinBuiltIns); descriptorResolver.setDelegatedPropertyResolver(delegatedPropertyResolver); descriptorResolver.setExpressionTypingServices(expressionTypingServices); descriptorResolver.setStorageManager(storageManager); descriptorResolver.setTypeResolver(typeResolver); + delegatedPropertyResolver.setBuiltIns(kotlinBuiltIns); delegatedPropertyResolver.setCallResolver(callResolver); delegatedPropertyResolver.setExpressionTypingServices(expressionTypingServices); diff --git a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForBodyResolve.java b/compiler/frontend/src/org/jetbrains/jet/di/InjectorForBodyResolve.java index 8c59514bc65..b7f3325db70 100644 --- a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForBodyResolve.java +++ b/compiler/frontend/src/org/jetbrains/jet/di/InjectorForBodyResolve.java @@ -28,6 +28,7 @@ import org.jetbrains.jet.lang.resolve.BodyResolver; import org.jetbrains.jet.lang.resolve.AnnotationResolver; import org.jetbrains.jet.lang.resolve.calls.CallResolver; import org.jetbrains.jet.lang.resolve.calls.ArgumentTypeResolver; +import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; import org.jetbrains.jet.lang.types.expressions.ExpressionTypingServices; import org.jetbrains.jet.lang.types.expressions.ExpressionTypingComponents; import org.jetbrains.jet.lang.types.expressions.ControlStructureTypingUtils; @@ -70,6 +71,7 @@ public class InjectorForBodyResolve { private final AnnotationResolver annotationResolver; private final CallResolver callResolver; private final ArgumentTypeResolver argumentTypeResolver; + private final KotlinBuiltIns kotlinBuiltIns; private final ExpressionTypingServices expressionTypingServices; private final ExpressionTypingComponents expressionTypingComponents; private final ControlStructureTypingUtils controlStructureTypingUtils; @@ -114,11 +116,12 @@ public class InjectorForBodyResolve { this.annotationResolver = new AnnotationResolver(); this.callResolver = new CallResolver(); this.argumentTypeResolver = new ArgumentTypeResolver(); + this.kotlinBuiltIns = KotlinBuiltIns.getInstance(); this.expressionTypingComponents = new ExpressionTypingComponents(); this.expressionTypingServices = new ExpressionTypingServices(expressionTypingComponents); this.controlStructureTypingUtils = new ControlStructureTypingUtils(expressionTypingServices); this.dynamicTypesSettings = new DynamicTypesSettings(); - this.expressionTypingUtils = new ExpressionTypingUtils(expressionTypingServices, callResolver); + this.expressionTypingUtils = new ExpressionTypingUtils(expressionTypingServices, callResolver, kotlinBuiltIns); this.forLoopConventionsChecker = new ForLoopConventionsChecker(); this.reflectionTypes = new ReflectionTypes(moduleDescriptor); this.callExpressionResolver = new CallExpressionResolver(); @@ -159,10 +162,12 @@ public class InjectorForBodyResolve { callResolver.setTaskPrioritizer(taskPrioritizer); callResolver.setTypeResolver(typeResolver); + argumentTypeResolver.setBuiltIns(kotlinBuiltIns); argumentTypeResolver.setExpressionTypingServices(expressionTypingServices); argumentTypeResolver.setTypeResolver(typeResolver); expressionTypingServices.setAnnotationResolver(annotationResolver); + expressionTypingServices.setBuiltIns(kotlinBuiltIns); expressionTypingServices.setCallExpressionResolver(callExpressionResolver); expressionTypingServices.setCallResolver(callResolver); expressionTypingServices.setDescriptorResolver(descriptorResolver); @@ -172,6 +177,7 @@ public class InjectorForBodyResolve { expressionTypingServices.setTypeResolver(typeResolver); expressionTypingComponents.setAdditionalCheckerProvider(additionalCheckerProvider); + expressionTypingComponents.setBuiltIns(kotlinBuiltIns); expressionTypingComponents.setCallResolver(callResolver); expressionTypingComponents.setControlStructureTypingUtils(controlStructureTypingUtils); expressionTypingComponents.setDynamicTypesSettings(dynamicTypesSettings); @@ -189,11 +195,13 @@ public class InjectorForBodyResolve { callExpressionResolver.setExpressionTypingServices(expressionTypingServices); descriptorResolver.setAnnotationResolver(annotationResolver); + descriptorResolver.setBuiltIns(kotlinBuiltIns); descriptorResolver.setDelegatedPropertyResolver(delegatedPropertyResolver); descriptorResolver.setExpressionTypingServices(expressionTypingServices); descriptorResolver.setStorageManager(storageManager); descriptorResolver.setTypeResolver(typeResolver); + delegatedPropertyResolver.setBuiltIns(kotlinBuiltIns); delegatedPropertyResolver.setCallResolver(callResolver); delegatedPropertyResolver.setExpressionTypingServices(expressionTypingServices); diff --git a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForLazyBodyResolve.java b/compiler/frontend/src/org/jetbrains/jet/di/InjectorForLazyBodyResolve.java index 2c48b06283e..975477f03de 100644 --- a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForLazyBodyResolve.java +++ b/compiler/frontend/src/org/jetbrains/jet/di/InjectorForLazyBodyResolve.java @@ -29,6 +29,7 @@ import org.jetbrains.jet.lang.resolve.BodyResolver; import org.jetbrains.jet.lang.resolve.AnnotationResolver; import org.jetbrains.jet.lang.resolve.calls.CallResolver; import org.jetbrains.jet.lang.resolve.calls.ArgumentTypeResolver; +import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; import org.jetbrains.jet.lang.types.expressions.ExpressionTypingServices; import org.jetbrains.jet.lang.types.expressions.ExpressionTypingComponents; import org.jetbrains.jet.lang.types.expressions.ControlStructureTypingUtils; @@ -83,6 +84,7 @@ public class InjectorForLazyBodyResolve { private final AnnotationResolver annotationResolver; private final CallResolver callResolver; private final ArgumentTypeResolver argumentTypeResolver; + private final KotlinBuiltIns kotlinBuiltIns; private final ExpressionTypingServices expressionTypingServices; private final ExpressionTypingComponents expressionTypingComponents; private final ControlStructureTypingUtils controlStructureTypingUtils; @@ -138,11 +140,12 @@ public class InjectorForLazyBodyResolve { this.annotationResolver = new AnnotationResolver(); this.callResolver = new CallResolver(); this.argumentTypeResolver = new ArgumentTypeResolver(); + this.kotlinBuiltIns = KotlinBuiltIns.getInstance(); this.expressionTypingComponents = new ExpressionTypingComponents(); this.expressionTypingServices = new ExpressionTypingServices(expressionTypingComponents); this.controlStructureTypingUtils = new ControlStructureTypingUtils(expressionTypingServices); this.dynamicTypesSettings = new DynamicTypesSettings(); - this.expressionTypingUtils = new ExpressionTypingUtils(expressionTypingServices, callResolver); + this.expressionTypingUtils = new ExpressionTypingUtils(expressionTypingServices, callResolver, kotlinBuiltIns); this.forLoopConventionsChecker = new ForLoopConventionsChecker(); this.reflectionTypes = new ReflectionTypes(moduleDescriptor); this.callExpressionResolver = new CallExpressionResolver(); @@ -204,10 +207,12 @@ public class InjectorForLazyBodyResolve { callResolver.setTaskPrioritizer(taskPrioritizer); callResolver.setTypeResolver(typeResolver); + argumentTypeResolver.setBuiltIns(kotlinBuiltIns); argumentTypeResolver.setExpressionTypingServices(expressionTypingServices); argumentTypeResolver.setTypeResolver(typeResolver); expressionTypingServices.setAnnotationResolver(annotationResolver); + expressionTypingServices.setBuiltIns(kotlinBuiltIns); expressionTypingServices.setCallExpressionResolver(callExpressionResolver); expressionTypingServices.setCallResolver(callResolver); expressionTypingServices.setDescriptorResolver(descriptorResolver); @@ -217,6 +222,7 @@ public class InjectorForLazyBodyResolve { expressionTypingServices.setTypeResolver(typeResolver); expressionTypingComponents.setAdditionalCheckerProvider(additionalCheckerProvider); + expressionTypingComponents.setBuiltIns(kotlinBuiltIns); expressionTypingComponents.setCallResolver(callResolver); expressionTypingComponents.setControlStructureTypingUtils(controlStructureTypingUtils); expressionTypingComponents.setDynamicTypesSettings(dynamicTypesSettings); @@ -234,11 +240,13 @@ public class InjectorForLazyBodyResolve { callExpressionResolver.setExpressionTypingServices(expressionTypingServices); descriptorResolver.setAnnotationResolver(annotationResolver); + descriptorResolver.setBuiltIns(kotlinBuiltIns); descriptorResolver.setDelegatedPropertyResolver(delegatedPropertyResolver); descriptorResolver.setExpressionTypingServices(expressionTypingServices); descriptorResolver.setStorageManager(storageManager); descriptorResolver.setTypeResolver(typeResolver); + delegatedPropertyResolver.setBuiltIns(kotlinBuiltIns); delegatedPropertyResolver.setCallResolver(callResolver); delegatedPropertyResolver.setExpressionTypingServices(expressionTypingServices); diff --git a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForLazyResolve.java b/compiler/frontend/src/org/jetbrains/jet/di/InjectorForLazyResolve.java index d8aa816310b..18a148bf988 100644 --- a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForLazyResolve.java +++ b/compiler/frontend/src/org/jetbrains/jet/di/InjectorForLazyResolve.java @@ -29,6 +29,7 @@ import org.jetbrains.jet.context.LazyResolveToken; import org.jetbrains.jet.lang.resolve.AnnotationResolver; import org.jetbrains.jet.lang.resolve.calls.CallResolver; import org.jetbrains.jet.lang.resolve.calls.ArgumentTypeResolver; +import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; import org.jetbrains.jet.lang.types.expressions.ExpressionTypingServices; import org.jetbrains.jet.lang.types.expressions.ExpressionTypingComponents; import org.jetbrains.jet.lang.types.expressions.ControlStructureTypingUtils; @@ -71,6 +72,7 @@ public class InjectorForLazyResolve { private final AnnotationResolver annotationResolver; private final CallResolver callResolver; private final ArgumentTypeResolver argumentTypeResolver; + private final KotlinBuiltIns kotlinBuiltIns; private final ExpressionTypingServices expressionTypingServices; private final ExpressionTypingComponents expressionTypingComponents; private final ControlStructureTypingUtils controlStructureTypingUtils; @@ -115,11 +117,12 @@ public class InjectorForLazyResolve { this.annotationResolver = new AnnotationResolver(); this.callResolver = new CallResolver(); this.argumentTypeResolver = new ArgumentTypeResolver(); + this.kotlinBuiltIns = KotlinBuiltIns.getInstance(); this.expressionTypingComponents = new ExpressionTypingComponents(); this.expressionTypingServices = new ExpressionTypingServices(expressionTypingComponents); this.controlStructureTypingUtils = new ControlStructureTypingUtils(expressionTypingServices); this.dynamicTypesSettings = new DynamicTypesSettings(); - this.expressionTypingUtils = new ExpressionTypingUtils(expressionTypingServices, callResolver); + this.expressionTypingUtils = new ExpressionTypingUtils(expressionTypingServices, callResolver, kotlinBuiltIns); this.forLoopConventionsChecker = new ForLoopConventionsChecker(); this.reflectionTypes = new ReflectionTypes(moduleDescriptor); this.callExpressionResolver = new CallExpressionResolver(); @@ -157,10 +160,12 @@ public class InjectorForLazyResolve { callResolver.setTaskPrioritizer(taskPrioritizer); callResolver.setTypeResolver(typeResolver); + argumentTypeResolver.setBuiltIns(kotlinBuiltIns); argumentTypeResolver.setExpressionTypingServices(expressionTypingServices); argumentTypeResolver.setTypeResolver(typeResolver); expressionTypingServices.setAnnotationResolver(annotationResolver); + expressionTypingServices.setBuiltIns(kotlinBuiltIns); expressionTypingServices.setCallExpressionResolver(callExpressionResolver); expressionTypingServices.setCallResolver(callResolver); expressionTypingServices.setDescriptorResolver(descriptorResolver); @@ -170,6 +175,7 @@ public class InjectorForLazyResolve { expressionTypingServices.setTypeResolver(typeResolver); expressionTypingComponents.setAdditionalCheckerProvider(additionalCheckerProvider); + expressionTypingComponents.setBuiltIns(kotlinBuiltIns); expressionTypingComponents.setCallResolver(callResolver); expressionTypingComponents.setControlStructureTypingUtils(controlStructureTypingUtils); expressionTypingComponents.setDynamicTypesSettings(dynamicTypesSettings); @@ -187,11 +193,13 @@ public class InjectorForLazyResolve { callExpressionResolver.setExpressionTypingServices(expressionTypingServices); descriptorResolver.setAnnotationResolver(annotationResolver); + descriptorResolver.setBuiltIns(kotlinBuiltIns); descriptorResolver.setDelegatedPropertyResolver(delegatedPropertyResolver); descriptorResolver.setExpressionTypingServices(expressionTypingServices); descriptorResolver.setStorageManager(storageManager); descriptorResolver.setTypeResolver(typeResolver); + delegatedPropertyResolver.setBuiltIns(kotlinBuiltIns); delegatedPropertyResolver.setCallResolver(callResolver); delegatedPropertyResolver.setExpressionTypingServices(expressionTypingServices); diff --git a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForLazyTopDownAnalyzerBasic.java b/compiler/frontend/src/org/jetbrains/jet/di/InjectorForLazyTopDownAnalyzerBasic.java index 9e7953129b2..c134c43f3b4 100644 --- a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForLazyTopDownAnalyzerBasic.java +++ b/compiler/frontend/src/org/jetbrains/jet/di/InjectorForLazyTopDownAnalyzerBasic.java @@ -29,6 +29,7 @@ import org.jetbrains.jet.lang.resolve.AdditionalCheckerProvider.Empty; import org.jetbrains.jet.lang.resolve.AnnotationResolver; import org.jetbrains.jet.lang.resolve.calls.CallResolver; import org.jetbrains.jet.lang.resolve.calls.ArgumentTypeResolver; +import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; import org.jetbrains.jet.lang.types.expressions.ExpressionTypingServices; import org.jetbrains.jet.lang.types.expressions.ExpressionTypingComponents; import org.jetbrains.jet.lang.types.expressions.ControlStructureTypingUtils; @@ -86,6 +87,7 @@ public class InjectorForLazyTopDownAnalyzerBasic { private final AnnotationResolver annotationResolver; private final CallResolver callResolver; private final ArgumentTypeResolver argumentTypeResolver; + private final KotlinBuiltIns kotlinBuiltIns; private final ExpressionTypingServices expressionTypingServices; private final ExpressionTypingComponents expressionTypingComponents; private final ControlStructureTypingUtils controlStructureTypingUtils; @@ -144,11 +146,12 @@ public class InjectorForLazyTopDownAnalyzerBasic { this.annotationResolver = new AnnotationResolver(); this.callResolver = new CallResolver(); this.argumentTypeResolver = new ArgumentTypeResolver(); + this.kotlinBuiltIns = KotlinBuiltIns.getInstance(); this.expressionTypingComponents = new ExpressionTypingComponents(); this.expressionTypingServices = new ExpressionTypingServices(expressionTypingComponents); this.controlStructureTypingUtils = new ControlStructureTypingUtils(expressionTypingServices); this.dynamicTypesSettings = new DynamicTypesSettings(); - this.expressionTypingUtils = new ExpressionTypingUtils(expressionTypingServices, callResolver); + this.expressionTypingUtils = new ExpressionTypingUtils(expressionTypingServices, callResolver, kotlinBuiltIns); this.forLoopConventionsChecker = new ForLoopConventionsChecker(); this.reflectionTypes = new ReflectionTypes(module); this.callExpressionResolver = new CallExpressionResolver(); @@ -211,10 +214,12 @@ public class InjectorForLazyTopDownAnalyzerBasic { callResolver.setTaskPrioritizer(taskPrioritizer); callResolver.setTypeResolver(typeResolver); + argumentTypeResolver.setBuiltIns(kotlinBuiltIns); argumentTypeResolver.setExpressionTypingServices(expressionTypingServices); argumentTypeResolver.setTypeResolver(typeResolver); expressionTypingServices.setAnnotationResolver(annotationResolver); + expressionTypingServices.setBuiltIns(kotlinBuiltIns); expressionTypingServices.setCallExpressionResolver(callExpressionResolver); expressionTypingServices.setCallResolver(callResolver); expressionTypingServices.setDescriptorResolver(descriptorResolver); @@ -224,6 +229,7 @@ public class InjectorForLazyTopDownAnalyzerBasic { expressionTypingServices.setTypeResolver(typeResolver); expressionTypingComponents.setAdditionalCheckerProvider(empty); + expressionTypingComponents.setBuiltIns(kotlinBuiltIns); expressionTypingComponents.setCallResolver(callResolver); expressionTypingComponents.setControlStructureTypingUtils(controlStructureTypingUtils); expressionTypingComponents.setDynamicTypesSettings(dynamicTypesSettings); @@ -241,11 +247,13 @@ public class InjectorForLazyTopDownAnalyzerBasic { callExpressionResolver.setExpressionTypingServices(expressionTypingServices); descriptorResolver.setAnnotationResolver(annotationResolver); + descriptorResolver.setBuiltIns(kotlinBuiltIns); descriptorResolver.setDelegatedPropertyResolver(delegatedPropertyResolver); descriptorResolver.setExpressionTypingServices(expressionTypingServices); descriptorResolver.setStorageManager(storageManager); descriptorResolver.setTypeResolver(typeResolver); + delegatedPropertyResolver.setBuiltIns(kotlinBuiltIns); delegatedPropertyResolver.setCallResolver(callResolver); delegatedPropertyResolver.setExpressionTypingServices(expressionTypingServices); diff --git a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForMacros.java b/compiler/frontend/src/org/jetbrains/jet/di/InjectorForMacros.java index d2fddf14c68..61d6ee1134f 100644 --- a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForMacros.java +++ b/compiler/frontend/src/org/jetbrains/jet/di/InjectorForMacros.java @@ -31,6 +31,7 @@ import org.jetbrains.jet.lang.resolve.QualifiedExpressionResolver; import org.jetbrains.jet.lang.resolve.TypeResolver.FlexibleTypeCapabilitiesProvider; import org.jetbrains.jet.context.LazinessToken; import org.jetbrains.jet.lang.types.DynamicTypesSettings; +import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; import org.jetbrains.jet.lang.resolve.calls.CallExpressionResolver; import org.jetbrains.jet.lang.resolve.DescriptorResolver; import org.jetbrains.jet.lang.resolve.DelegatedPropertyResolver; @@ -66,6 +67,7 @@ public class InjectorForMacros { private final FlexibleTypeCapabilitiesProvider flexibleTypeCapabilitiesProvider; private final LazinessToken lazinessToken; private final DynamicTypesSettings dynamicTypesSettings; + private final KotlinBuiltIns kotlinBuiltIns; private final CallExpressionResolver callExpressionResolver; private final DescriptorResolver descriptorResolver; private final DelegatedPropertyResolver delegatedPropertyResolver; @@ -99,13 +101,14 @@ public class InjectorForMacros { this.lazinessToken = new LazinessToken(); this.dynamicTypesSettings = new DynamicTypesSettings(); this.typeResolver = new TypeResolver(annotationResolver, qualifiedExpressionResolver, moduleDescriptor, flexibleTypeCapabilitiesProvider, storageManager, lazinessToken, dynamicTypesSettings); + this.kotlinBuiltIns = KotlinBuiltIns.getInstance(); this.callExpressionResolver = new CallExpressionResolver(); this.descriptorResolver = new DescriptorResolver(); this.delegatedPropertyResolver = new DelegatedPropertyResolver(); this.callResolverExtensionProvider = new CallResolverExtensionProvider(); this.partialBodyResolveProvider = new PartialBodyResolveProvider(); this.controlStructureTypingUtils = new ControlStructureTypingUtils(getExpressionTypingServices()); - this.expressionTypingUtils = new ExpressionTypingUtils(getExpressionTypingServices(), getCallResolver()); + this.expressionTypingUtils = new ExpressionTypingUtils(getExpressionTypingServices(), getCallResolver(), kotlinBuiltIns); this.forLoopConventionsChecker = new ForLoopConventionsChecker(); this.reflectionTypes = new ReflectionTypes(moduleDescriptor); this.argumentTypeResolver = new ArgumentTypeResolver(); @@ -114,6 +117,7 @@ public class InjectorForMacros { this.taskPrioritizer = new TaskPrioritizer(storageManager); this.expressionTypingServices.setAnnotationResolver(annotationResolver); + this.expressionTypingServices.setBuiltIns(kotlinBuiltIns); this.expressionTypingServices.setCallExpressionResolver(callExpressionResolver); this.expressionTypingServices.setCallResolver(callResolver); this.expressionTypingServices.setDescriptorResolver(descriptorResolver); @@ -123,6 +127,7 @@ public class InjectorForMacros { this.expressionTypingServices.setTypeResolver(typeResolver); this.expressionTypingComponents.setAdditionalCheckerProvider(empty); + this.expressionTypingComponents.setBuiltIns(kotlinBuiltIns); this.expressionTypingComponents.setCallResolver(callResolver); this.expressionTypingComponents.setControlStructureTypingUtils(controlStructureTypingUtils); this.expressionTypingComponents.setDynamicTypesSettings(dynamicTypesSettings); @@ -147,11 +152,13 @@ public class InjectorForMacros { callExpressionResolver.setExpressionTypingServices(expressionTypingServices); descriptorResolver.setAnnotationResolver(annotationResolver); + descriptorResolver.setBuiltIns(kotlinBuiltIns); descriptorResolver.setDelegatedPropertyResolver(delegatedPropertyResolver); descriptorResolver.setExpressionTypingServices(expressionTypingServices); descriptorResolver.setStorageManager(storageManager); descriptorResolver.setTypeResolver(typeResolver); + delegatedPropertyResolver.setBuiltIns(kotlinBuiltIns); delegatedPropertyResolver.setCallResolver(callResolver); delegatedPropertyResolver.setExpressionTypingServices(expressionTypingServices); @@ -159,6 +166,7 @@ public class InjectorForMacros { forLoopConventionsChecker.setExpressionTypingUtils(expressionTypingUtils); forLoopConventionsChecker.setProject(project); + argumentTypeResolver.setBuiltIns(kotlinBuiltIns); argumentTypeResolver.setExpressionTypingServices(expressionTypingServices); argumentTypeResolver.setTypeResolver(typeResolver); diff --git a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerBasic.java b/compiler/frontend/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerBasic.java index a5fc9ccaf85..3fc86eef511 100644 --- a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerBasic.java +++ b/compiler/frontend/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerBasic.java @@ -30,6 +30,7 @@ import org.jetbrains.jet.lang.resolve.BodyResolver; import org.jetbrains.jet.lang.resolve.AnnotationResolver; import org.jetbrains.jet.lang.resolve.calls.CallResolver; import org.jetbrains.jet.lang.resolve.calls.ArgumentTypeResolver; +import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; import org.jetbrains.jet.lang.types.expressions.ExpressionTypingServices; import org.jetbrains.jet.lang.types.expressions.ExpressionTypingComponents; import org.jetbrains.jet.lang.types.expressions.ControlStructureTypingUtils; @@ -82,6 +83,7 @@ public class InjectorForTopDownAnalyzerBasic { private final AnnotationResolver annotationResolver; private final CallResolver callResolver; private final ArgumentTypeResolver argumentTypeResolver; + private final KotlinBuiltIns kotlinBuiltIns; private final ExpressionTypingServices expressionTypingServices; private final ExpressionTypingComponents expressionTypingComponents; private final ControlStructureTypingUtils controlStructureTypingUtils; @@ -136,10 +138,11 @@ public class InjectorForTopDownAnalyzerBasic { this.annotationResolver = new AnnotationResolver(); this.callResolver = new CallResolver(); this.argumentTypeResolver = new ArgumentTypeResolver(); + this.kotlinBuiltIns = KotlinBuiltIns.getInstance(); this.expressionTypingComponents = new ExpressionTypingComponents(); this.expressionTypingServices = new ExpressionTypingServices(expressionTypingComponents); this.controlStructureTypingUtils = new ControlStructureTypingUtils(expressionTypingServices); - this.expressionTypingUtils = new ExpressionTypingUtils(expressionTypingServices, callResolver); + this.expressionTypingUtils = new ExpressionTypingUtils(expressionTypingServices, callResolver, kotlinBuiltIns); this.forLoopConventionsChecker = new ForLoopConventionsChecker(); this.reflectionTypes = new ReflectionTypes(getModuleDescriptor()); this.callExpressionResolver = new CallExpressionResolver(); @@ -198,10 +201,12 @@ public class InjectorForTopDownAnalyzerBasic { callResolver.setTaskPrioritizer(taskPrioritizer); callResolver.setTypeResolver(typeResolver); + argumentTypeResolver.setBuiltIns(kotlinBuiltIns); argumentTypeResolver.setExpressionTypingServices(expressionTypingServices); argumentTypeResolver.setTypeResolver(typeResolver); expressionTypingServices.setAnnotationResolver(annotationResolver); + expressionTypingServices.setBuiltIns(kotlinBuiltIns); expressionTypingServices.setCallExpressionResolver(callExpressionResolver); expressionTypingServices.setCallResolver(callResolver); expressionTypingServices.setDescriptorResolver(descriptorResolver); @@ -211,6 +216,7 @@ public class InjectorForTopDownAnalyzerBasic { expressionTypingServices.setTypeResolver(typeResolver); expressionTypingComponents.setAdditionalCheckerProvider(additionalCheckerProvider); + expressionTypingComponents.setBuiltIns(kotlinBuiltIns); expressionTypingComponents.setCallResolver(callResolver); expressionTypingComponents.setControlStructureTypingUtils(controlStructureTypingUtils); expressionTypingComponents.setDynamicTypesSettings(dynamicTypesSettings); @@ -228,11 +234,13 @@ public class InjectorForTopDownAnalyzerBasic { callExpressionResolver.setExpressionTypingServices(expressionTypingServices); descriptorResolver.setAnnotationResolver(annotationResolver); + descriptorResolver.setBuiltIns(kotlinBuiltIns); descriptorResolver.setDelegatedPropertyResolver(delegatedPropertyResolver); descriptorResolver.setExpressionTypingServices(expressionTypingServices); descriptorResolver.setStorageManager(storageManager); descriptorResolver.setTypeResolver(typeResolver); + delegatedPropertyResolver.setBuiltIns(kotlinBuiltIns); delegatedPropertyResolver.setCallResolver(callResolver); delegatedPropertyResolver.setExpressionTypingServices(expressionTypingServices); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DelegatedPropertyResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DelegatedPropertyResolver.java index e6733b52068..c0682d709eb 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DelegatedPropertyResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DelegatedPropertyResolver.java @@ -55,11 +55,9 @@ import static org.jetbrains.jet.lang.types.expressions.ExpressionTypingUtils.cre public class DelegatedPropertyResolver { - @NotNull private ExpressionTypingServices expressionTypingServices; - - @NotNull private CallResolver callResolver; + private KotlinBuiltIns builtIns; private static final String PD_METHOD_NAME = "propertyDelegated"; @@ -73,6 +71,11 @@ public class DelegatedPropertyResolver { this.callResolver = callResolver; } + @Inject + public void setBuiltIns(@NotNull KotlinBuiltIns builtIns) { + this.builtIns = builtIns; + } + @Nullable public JetType getDelegatedPropertyGetMethodReturnType( @NotNull PropertyDescriptor propertyDescriptor, @@ -118,11 +121,11 @@ public class DelegatedPropertyResolver { } @NotNull - private static JetExpression createExpressionForPropertyMetadata( + private JetExpression createExpressionForPropertyMetadata( @NotNull JetPsiFactory psiFactory, @NotNull PropertyDescriptor propertyDescriptor ) { - return psiFactory.createExpression(KotlinBuiltIns.getInstance().getPropertyMetadataImpl().getName().asString() + + return psiFactory.createExpression(builtIns.getPropertyMetadataImpl().getName().asString() + "(\"" + propertyDescriptor.getName().asString() + "\")"); @@ -363,7 +366,7 @@ public class DelegatedPropertyResolver { JetType typeOfThis = extensionReceiver != null ? extensionReceiver.getType() : dispatchReceiver != null ? dispatchReceiver.getType() : - KotlinBuiltIns.getInstance().getNullableNothingType(); + builtIns.getNullableNothingType(); List valueParameters = resultingDescriptor.getValueParameters(); if (valueParameters.isEmpty()) return; diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DescriptorResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DescriptorResolver.java index cab6787ace6..e3ae5f995ff 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DescriptorResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DescriptorResolver.java @@ -71,16 +71,12 @@ public class DescriptorResolver { MODIFIERS_ILLEGAL_ON_PARAMETERS.remove(JetTokens.VARARG_KEYWORD); } - @NotNull private TypeResolver typeResolver; - @NotNull private AnnotationResolver annotationResolver; - @NotNull private ExpressionTypingServices expressionTypingServices; - @NotNull private DelegatedPropertyResolver delegatedPropertyResolver; - @NotNull private StorageManager storageManager; + private KotlinBuiltIns builtIns; @Inject public void setTypeResolver(@NotNull TypeResolver typeResolver) { @@ -107,6 +103,11 @@ public class DescriptorResolver { this.storageManager = storageManager; } + @Inject + public void setBuiltIns(@NotNull KotlinBuiltIns builtIns) { + this.builtIns = builtIns; + } + public void resolveMutableClassDescriptor( @NotNull TopDownAnalysisParameters topDownAnalysisParameters, @NotNull JetClass classElement, @@ -178,7 +179,7 @@ public class DescriptorResolver { } if (classDescriptor.getKind() == ClassKind.ENUM_CLASS && !containsClass(supertypes)) { - supertypes.add(0, KotlinBuiltIns.getInstance().getEnumType(classDescriptor.getDefaultType())); + supertypes.add(0, builtIns.getEnumType(classDescriptor.getDefaultType())); } if (supertypes.isEmpty()) { @@ -219,9 +220,9 @@ public class DescriptorResolver { } } else if (jetClass instanceof JetClass && ((JetClass) jetClass).isAnnotation()) { - return KotlinBuiltIns.getInstance().getAnnotationType(); + return builtIns.getAnnotationType(); } - return KotlinBuiltIns.getInstance().getAnyType(); + return builtIns.getAnyType(); } public Collection resolveDelegationSpecifiers( @@ -350,7 +351,7 @@ public class DescriptorResolver { returnType = typeResolver.resolveType(innerScope, returnTypeRef, trace, true); } else if (function.hasBlockBody()) { - returnType = KotlinBuiltIns.getInstance().getUnitType(); + returnType = builtIns.getUnitType(); } else { if (function.hasBody()) { @@ -554,7 +555,7 @@ public class DescriptorResolver { } @NotNull - private static ValueParameterDescriptorImpl resolveValueParameterDescriptor( + private ValueParameterDescriptorImpl resolveValueParameterDescriptor( DeclarationDescriptor declarationDescriptor, JetParameter valueParameter, int index, JetType type, BindingTrace trace, Annotations annotations @@ -582,12 +583,12 @@ public class DescriptorResolver { } @NotNull - private static JetType getVarargParameterType(@NotNull JetType elementType) { - JetType primitiveArrayType = KotlinBuiltIns.getInstance().getPrimitiveArrayJetTypeByPrimitiveJetType(elementType); + private JetType getVarargParameterType(@NotNull JetType elementType) { + JetType primitiveArrayType = builtIns.getPrimitiveArrayJetTypeByPrimitiveJetType(elementType); if (primitiveArrayType != null) { return primitiveArrayType; } - return KotlinBuiltIns.getInstance().getArrayType(Variance.INVARIANT, elementType); + return builtIns.getArrayType(Variance.INVARIANT, elementType); } public List resolveTypeParametersForCallableDescriptor( diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/ArgumentTypeResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/ArgumentTypeResolver.java index 7f48d6539d9..e74a4723734 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/ArgumentTypeResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/ArgumentTypeResolver.java @@ -52,10 +52,9 @@ import static org.jetbrains.jet.lang.types.TypeUtils.*; public class ArgumentTypeResolver { - @NotNull private TypeResolver typeResolver; - @NotNull private ExpressionTypingServices expressionTypingServices; + private KotlinBuiltIns builtIns; @Inject public void setTypeResolver(@NotNull TypeResolver typeResolver) { @@ -67,6 +66,11 @@ public class ArgumentTypeResolver { this.expressionTypingServices = expressionTypingServices; } + @Inject + public void setBuiltIns(@NotNull KotlinBuiltIns builtIns) { + this.builtIns = builtIns; + } + public static boolean isSubtypeOfForArgumentType( @NotNull JetType actualType, @NotNull JetType expectedType @@ -205,7 +209,7 @@ public class ArgumentTypeResolver { boolean expectedTypeIsUnknown ) { if (expression.getFunctionLiteral().getValueParameterList() == null) { - return expectedTypeIsUnknown ? PLACEHOLDER_FUNCTION_TYPE : KotlinBuiltIns.getInstance().getFunctionType( + return expectedTypeIsUnknown ? PLACEHOLDER_FUNCTION_TYPE : builtIns.getFunctionType( Annotations.EMPTY, null, Collections.emptyList(), DONT_CARE); } List valueParameters = expression.getValueParameters(); @@ -219,7 +223,7 @@ public class ArgumentTypeResolver { JetType returnType = resolveTypeRefWithDefault(functionLiteral.getTypeReference(), scope, temporaryTrace, DONT_CARE); assert returnType != null; JetType receiverType = resolveTypeRefWithDefault(functionLiteral.getReceiverTypeReference(), scope, temporaryTrace, null); - return KotlinBuiltIns.getInstance().getFunctionType(Annotations.EMPTY, receiverType, parameterTypes, + return builtIns.getFunctionType(Annotations.EMPTY, receiverType, parameterTypes, returnType); } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/BasicExpressionTypingVisitor.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/BasicExpressionTypingVisitor.java index a34a9ffa5ca..5abb65fbc7c 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/BasicExpressionTypingVisitor.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/BasicExpressionTypingVisitor.java @@ -357,7 +357,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { else { // supertypes may be empty when all the supertypes are error types (are not resolved, for example) JetType type = supertypes.isEmpty() - ? KotlinBuiltIns.getInstance().getAnyType() + ? components.builtIns.getAnyType() : supertypes.iterator().next(); result = substitutor.substitute(type, Variance.INVARIANT); } @@ -745,7 +745,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { if (operationType == JetTokens.PLUSPLUS || operationType == JetTokens.MINUSMINUS) { assert returnType != null : "returnType is null for " + resolutionResults.getResultingDescriptor(); if (KotlinBuiltIns.isUnit(returnType)) { - result = ErrorUtils.createErrorType(KotlinBuiltIns.getInstance().getUnit().getName().asString()); + result = ErrorUtils.createErrorType(components.builtIns.getUnit().getName().asString()); context.trace.report(INC_DEC_SHOULD_NOT_RETURN_UNIT.on(operationSign)); } else { @@ -916,10 +916,10 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { result = visitEquality(expression, context, operationSign, left, right); } else if (OperatorConventions.IDENTITY_EQUALS_OPERATIONS.contains(operationType)) { - context.trace.record(REFERENCE_TARGET, operationSign, KotlinBuiltIns.getInstance().getIdentityEquals()); + context.trace.record(REFERENCE_TARGET, operationSign, components.builtIns.getIdentityEquals()); ensureNonemptyIntersectionOfOperandTypes(expression, context); // TODO : Check comparison pointlessness - result = JetTypeInfo.create(KotlinBuiltIns.getInstance().getBooleanType(), context.dataFlowInfo); + result = JetTypeInfo.create(components.builtIns.getBooleanType(), context.dataFlowInfo); } else if (OperatorConventions.IN_OPERATIONS.contains(operationType)) { ValueArgument leftArgument = CallMaker.makeValueArgument(left, left != null ? left : operationSign); @@ -951,7 +951,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { if (right == null || left == null) { ExpressionTypingUtils.getTypeInfoOrNullType(right, context, facade); ExpressionTypingUtils.getTypeInfoOrNullType(left, context, facade); - return JetTypeInfo.create(KotlinBuiltIns.getInstance().getBooleanType(), dataFlowInfo); + return JetTypeInfo.create(components.builtIns.getBooleanType(), dataFlowInfo); } ExpressionReceiver receiver = ExpressionTypingUtils.safeGetExpressionReceiver(facade, left, context); @@ -965,7 +965,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { TemporaryBindingTrace traceInterpretingRightAsNullableAny = TemporaryBindingTrace.create( context.trace, "trace to resolve 'equals(Any?)' interpreting as of type Any? an expression:", right); - traceInterpretingRightAsNullableAny.record(EXPRESSION_TYPE, right, KotlinBuiltIns.getInstance().getNullableAnyType()); + traceInterpretingRightAsNullableAny.record(EXPRESSION_TYPE, right, components.builtIns.getNullableAnyType()); Call call = CallMaker.makeCallWithExpressions(expression, receiver, null, operationSign, Collections.singletonList(right)); ExpressionTypingContext newContext = context.replaceBindingTrace(traceInterpretingRightAsNullableAny); @@ -1001,7 +1001,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { context.trace.report(EQUALS_MISSING.on(operationSign)); } } - return JetTypeInfo.create(KotlinBuiltIns.getInstance().getBooleanType(), dataFlowInfo); + return JetTypeInfo.create(components.builtIns.getBooleanType(), dataFlowInfo); } @NotNull @@ -1015,9 +1015,8 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { JetType compareToReturnType = typeInfo.getType(); JetType type = null; if (compareToReturnType != null && !compareToReturnType.isError()) { - KotlinBuiltIns builtIns = KotlinBuiltIns.getInstance(); - if (JetTypeChecker.DEFAULT.equalTypes(builtIns.getIntType(), compareToReturnType)) { - type = builtIns.getBooleanType(); + if (JetTypeChecker.DEFAULT.equalTypes(components.builtIns.getIntType(), compareToReturnType)) { + type = components.builtIns.getBooleanType(); } else { context.trace.report(COMPARE_TO_TYPE_MISMATCH.on(operationSign, compareToReturnType)); @@ -1033,7 +1032,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { @Nullable JetExpression right, @NotNull ExpressionTypingContext context ) { - JetType booleanType = KotlinBuiltIns.getInstance().getBooleanType(); + JetType booleanType = components.builtIns.getBooleanType(); JetTypeInfo leftTypeInfo = getTypeInfoOrNullType(left, context.replaceExpectedType(booleanType), facade); DataFlowInfo dataFlowInfo = leftTypeInfo.getDataFlowInfo(); @@ -1126,7 +1125,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { dataFlowInfo = facade.getTypeInfo(left, contextWithDataFlow).getDataFlowInfo().and(dataFlowInfo); } - return JetTypeInfo.create(resolutionResult.isSuccess() ? KotlinBuiltIns.getInstance().getBooleanType() : null, dataFlowInfo); + return JetTypeInfo.create(resolutionResult.isSuccess() ? components.builtIns.getBooleanType() : null, dataFlowInfo); } private void ensureNonemptyIntersectionOfOperandTypes(JetBinaryExpression expression, ExpressionTypingContext context) { @@ -1279,7 +1278,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { }); } ConstantExpressionEvaluator.OBJECT$.evaluate(expression, context.trace, contextWithExpectedType.expectedType); - return DataFlowUtils.checkType(KotlinBuiltIns.getInstance().getStringType(), expression, contextWithExpectedType, dataFlowInfo[0]); + return DataFlowUtils.checkType(components.builtIns.getStringType(), expression, contextWithExpectedType, dataFlowInfo[0]); } @Override diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ClosureExpressionsTypingVisitor.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ClosureExpressionsTypingVisitor.java index 42ed5bb3f9c..b83d3aaf8db 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ClosureExpressionsTypingVisitor.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ClosureExpressionsTypingVisitor.java @@ -116,7 +116,7 @@ public class ClosureExpressionsTypingVisitor extends ExpressionTypingVisitor { JetType receiver = DescriptorUtils.getReceiverParameterType(functionDescriptor.getExtensionReceiverParameter()); List valueParametersTypes = ExpressionTypingUtils.getValueParametersTypes(functionDescriptor.getValueParameters()); - JetType resultType = KotlinBuiltIns.getInstance().getFunctionType( + JetType resultType = components.builtIns.getFunctionType( Annotations.EMPTY, receiver, valueParametersTypes, safeReturnType); if (!noExpectedType(expectedType) && KotlinBuiltIns.isFunctionOrExtensionFunctionType(expectedType)) { // all checks were done before @@ -266,7 +266,7 @@ public class ClosureExpressionsTypingVisitor extends ExpressionTypingVisitor { if (!expression.getFunctionLiteral().hasDeclaredReturnType() && functionTypeExpected) { if (KotlinBuiltIns.isUnit(expectedReturnType)) { - return KotlinBuiltIns.getInstance().getUnitType(); + return components.builtIns.getUnitType(); } } return returnType == null ? CANT_INFER_LAMBDA_PARAM_TYPE : returnType; @@ -314,7 +314,7 @@ public class ClosureExpressionsTypingVisitor extends ExpressionTypingVisitor { return CommonSupertypes.commonSupertype(returnedExpressionTypes); } - private static List getTypesOfLocallyReturnedExpressions( + private List getTypesOfLocallyReturnedExpressions( final JetFunctionLiteral functionLiteral, final BindingTrace trace, Collection returnExpressions @@ -336,7 +336,7 @@ public class ClosureExpressionsTypingVisitor extends ExpressionTypingVisitor { JetExpression returnedExpression = returnExpression.getReturnedExpression(); if (returnedExpression == null) { - return KotlinBuiltIns.getInstance().getUnitType(); + return components.builtIns.getUnitType(); } JetType returnedType = trace.get(EXPRESSION_TYPE, returnedExpression); assert returnedType != null : "No type for returned expression: " + returnedExpression + ",\n" + diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ControlStructureTypingVisitor.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ControlStructureTypingVisitor.java index 7975ba8853b..d20d9a17493 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ControlStructureTypingVisitor.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ControlStructureTypingVisitor.java @@ -64,7 +64,7 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor { private DataFlowInfo checkCondition(@NotNull JetScope scope, @Nullable JetExpression condition, ExpressionTypingContext context) { if (condition != null) { JetTypeInfo typeInfo = facade.getTypeInfo(condition, context.replaceScope(scope) - .replaceExpectedType(KotlinBuiltIns.getInstance().getBooleanType()).replaceContextDependency(INDEPENDENT)); + .replaceExpectedType(components.builtIns.getBooleanType()).replaceContextDependency(INDEPENDENT)); JetType conditionType = typeInfo.getType(); if (conditionType != null && !isBoolean(conditionType)) { @@ -102,7 +102,7 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor { return getTypeInfoWhenOnlyOneBranchIsPresent( thenBranch, thenScope, thenInfo, elseInfo, contextWithExpectedType, ifExpression, isStatement); } - return DataFlowUtils.checkImplicitCast(KotlinBuiltIns.getInstance().getUnitType(), ifExpression, contextWithExpectedType, + return DataFlowUtils.checkImplicitCast(components.builtIns.getUnitType(), ifExpression, contextWithExpectedType, isStatement, thenInfo.or(elseInfo)); } if (thenBranch == null) { @@ -172,7 +172,7 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor { } else { dataFlowInfo = typeInfo.getDataFlowInfo().or(otherInfo); } - JetType typeForIfExpression = DataFlowUtils.checkType(KotlinBuiltIns.getInstance().getUnitType(), ifExpression, context); + JetType typeForIfExpression = DataFlowUtils.checkType(components.builtIns.getUnitType(), ifExpression, context); return DataFlowUtils.checkImplicitCast(typeForIfExpression, ifExpression, context, isStatement, dataFlowInfo); } @@ -201,7 +201,7 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor { if (!containsJumpOutOfLoop(expression, context)) { dataFlowInfo = DataFlowUtils.extractDataFlowInfoFromCondition(condition, false, context).and(dataFlowInfo); } - return DataFlowUtils.checkType(KotlinBuiltIns.getInstance().getUnitType(), expression, contextWithExpectedType, dataFlowInfo); + return DataFlowUtils.checkType(components.builtIns.getUnitType(), expression, contextWithExpectedType, dataFlowInfo); } private boolean containsJumpOutOfLoop(final JetLoopExpression loopExpression, final ExpressionTypingContext context) { @@ -288,7 +288,7 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor { else { dataFlowInfo = context.dataFlowInfo; } - return DataFlowUtils.checkType(KotlinBuiltIns.getInstance().getUnitType(), expression, contextWithExpectedType, dataFlowInfo); + return DataFlowUtils.checkType(components.builtIns.getUnitType(), expression, contextWithExpectedType, dataFlowInfo); } @Override @@ -336,7 +336,7 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor { CoercionStrategy.NO_COERCION, context.replaceDataFlowInfo(dataFlowInfo), context.trace); } - return DataFlowUtils.checkType(KotlinBuiltIns.getInstance().getUnitType(), expression, contextWithExpectedType, dataFlowInfo); + return DataFlowUtils.checkType(components.builtIns.getUnitType(), expression, contextWithExpectedType, dataFlowInfo); } private VariableDescriptor createLoopParameterDescriptor( @@ -391,7 +391,7 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor { VariableDescriptor variableDescriptor = components.expressionTypingServices.getDescriptorResolver().resolveLocalVariableDescriptor( context.scope, catchParameter, context.trace); - JetType throwableType = KotlinBuiltIns.getInstance().getThrowable().getDefaultType(); + JetType throwableType = components.builtIns.getThrowable().getDefaultType(); DataFlowUtils.checkType(variableDescriptor.getType(), catchParameter, context.replaceExpectedType(throwableType)); if (catchBody != null) { WritableScope catchScope = newWritableScopeImpl(context, "Catch scope"); @@ -426,11 +426,11 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor { public JetTypeInfo visitThrowExpression(@NotNull JetThrowExpression expression, ExpressionTypingContext context) { JetExpression thrownExpression = expression.getThrownExpression(); if (thrownExpression != null) { - JetType throwableType = KotlinBuiltIns.getInstance().getThrowable().getDefaultType(); + JetType throwableType = components.builtIns.getThrowable().getDefaultType(); facade.getTypeInfo(thrownExpression, context .replaceExpectedType(throwableType).replaceScope(context.scope).replaceContextDependency(INDEPENDENT)); } - return DataFlowUtils.checkType(KotlinBuiltIns.getInstance().getNothingType(), expression, context, context.dataFlowInfo); + return DataFlowUtils.checkType(components.builtIns.getNothingType(), expression, context, context.dataFlowInfo); } @Override @@ -440,7 +440,7 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor { JetExpression returnedExpression = expression.getReturnedExpression(); JetType expectedType = NO_EXPECTED_TYPE; - JetType resultType = KotlinBuiltIns.getInstance().getNothingType(); + JetType resultType = components.builtIns.getNothingType(); JetDeclaration parentDeclaration = PsiTreeUtil.getParentOfType(expression, JetDeclaration.class); if (parentDeclaration instanceof JetParameter) { @@ -505,13 +505,13 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor { @Override public JetTypeInfo visitBreakExpression(@NotNull JetBreakExpression expression, ExpressionTypingContext context) { LabelResolver.INSTANCE.resolveControlLabel(expression, context); - return DataFlowUtils.checkType(KotlinBuiltIns.getInstance().getNothingType(), expression, context, context.dataFlowInfo); + return DataFlowUtils.checkType(components.builtIns.getNothingType(), expression, context, context.dataFlowInfo); } @Override public JetTypeInfo visitContinueExpression(@NotNull JetContinueExpression expression, ExpressionTypingContext context) { LabelResolver.INSTANCE.resolveControlLabel(expression, context); - return DataFlowUtils.checkType(KotlinBuiltIns.getInstance().getNothingType(), expression, context, context.dataFlowInfo); + return DataFlowUtils.checkType(components.builtIns.getNothingType(), expression, context, context.dataFlowInfo); } @NotNull diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingComponents.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingComponents.java index 96e897954b6..1bbe8133925 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingComponents.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingComponents.java @@ -23,6 +23,7 @@ import org.jetbrains.jet.lang.reflect.ReflectionTypes; import org.jetbrains.jet.lang.resolve.AdditionalCheckerProvider; import org.jetbrains.jet.lang.resolve.calls.CallResolver; import org.jetbrains.jet.lang.types.DynamicTypesSettings; +import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; import javax.inject.Inject; @@ -37,6 +38,7 @@ public class ExpressionTypingComponents { /*package*/ ReflectionTypes reflectionTypes; /*package*/ AdditionalCheckerProvider additionalCheckerProvider; /*package*/ DynamicTypesSettings dynamicTypesSettings; + /*package*/ KotlinBuiltIns builtIns; @Inject public void setGlobalContext(@NotNull GlobalContext globalContext) { @@ -88,6 +90,11 @@ public class ExpressionTypingComponents { this.dynamicTypesSettings = dynamicTypesSettings; } + @Inject + public void setBuiltIns(@NotNull KotlinBuiltIns builtIns) { + this.builtIns = builtIns; + } + @NotNull public ForLoopConventionsChecker getForLoopConventionsChecker() { return forLoopConventionsChecker; diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingServices.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingServices.java index 9039dbd5737..e14f29633b3 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingServices.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingServices.java @@ -61,22 +61,15 @@ public class ExpressionTypingServices { @NotNull private final ExpressionTypingComponents expressionTypingComponents; - @NotNull private Project project; - @NotNull private CallResolver callResolver; - @NotNull private CallExpressionResolver callExpressionResolver; - @NotNull private DescriptorResolver descriptorResolver; - @NotNull private TypeResolver typeResolver; - @NotNull private AnnotationResolver annotationResolver; - @NotNull private CallResolverExtensionProvider extensionProvider; - @NotNull private PartialBodyResolveProvider partialBodyResolveProvider; + private KotlinBuiltIns builtIns; @NotNull public Project getProject() { @@ -153,6 +146,11 @@ public class ExpressionTypingServices { this.partialBodyResolveProvider = partialBodyResolveProvider; } + @Inject + public void setBuiltIns(@NotNull KotlinBuiltIns builtIns) { + this.builtIns = builtIns; + } + public ExpressionTypingServices(@NotNull ExpressionTypingComponents components) { this.expressionTypingComponents = components; this.expressionTypingFacade = ExpressionTypingVisitorDispatcher.create(components); @@ -240,7 +238,7 @@ public class ExpressionTypingServices { JetTypeInfo r; if (block.isEmpty()) { - r = DataFlowUtils.checkType(KotlinBuiltIns.getInstance().getUnitType(), expression, context, context.dataFlowInfo); + r = DataFlowUtils.checkType(builtIns.getUnitType(), expression, context, context.dataFlowInfo); } else { r = getBlockReturnedTypeWithWritableScope(scope, block, coercionStrategyForLastExpression, context, context.trace); @@ -288,7 +286,7 @@ public class ExpressionTypingServices { @NotNull BindingTrace trace ) { if (block.isEmpty()) { - return JetTypeInfo.create(KotlinBuiltIns.getInstance().getUnitType(), context.dataFlowInfo); + return JetTypeInfo.create(builtIns.getUnitType(), context.dataFlowInfo); } ExpressionTypingInternals blockLevelVisitor = ExpressionTypingVisitorDispatcher.createForBlock(expressionTypingComponents, scope); @@ -354,7 +352,7 @@ public class ExpressionTypingServices { if (mightBeUnit) { // ExpressionTypingVisitorForStatements should return only null or Unit for declarations and assignments assert result.getType() == null || KotlinBuiltIns.isUnit(result.getType()); - result = JetTypeInfo.create(KotlinBuiltIns.getInstance().getUnitType(), context.dataFlowInfo); + result = JetTypeInfo.create(builtIns.getUnitType(), context.dataFlowInfo); } } return result; diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingUtils.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingUtils.java index 8d71a939d30..939d4f6e46a 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingUtils.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingUtils.java @@ -65,10 +65,16 @@ public class ExpressionTypingUtils { private final ExpressionTypingServices expressionTypingServices; private final CallResolver callResolver; + private final KotlinBuiltIns builtIns; - public ExpressionTypingUtils(@NotNull ExpressionTypingServices expressionTypingServices, @NotNull CallResolver resolver) { + public ExpressionTypingUtils( + @NotNull ExpressionTypingServices expressionTypingServices, + @NotNull CallResolver resolver, + @NotNull KotlinBuiltIns builtIns + ) { this.expressionTypingServices = expressionTypingServices; - callResolver = resolver; + this.callResolver = resolver; + this.builtIns = builtIns; } @Nullable diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingVisitorForStatements.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingVisitorForStatements.java index d1a9197487d..30730ecf42a 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingVisitorForStatements.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingVisitorForStatements.java @@ -287,7 +287,7 @@ public class ExpressionTypingVisitorForStatements extends ExpressionTypingVisito else if (assignmentOperationType != null && (assignmentOperationDescriptors.isSuccess() || !binaryOperationDescriptors.isSuccess())) { // There's 'plusAssign()', so we do a.plusAssign(b) temporaryForAssignmentOperation.commit(); - if (!JetTypeChecker.DEFAULT.equalTypes(KotlinBuiltIns.getInstance().getUnitType(), assignmentOperationType)) { + if (!JetTypeChecker.DEFAULT.equalTypes(components.builtIns.getUnitType(), assignmentOperationType)) { context.trace.report(ASSIGNMENT_OPERATOR_SHOULD_RETURN_UNIT.on(operationSign, assignmentOperationDescriptors.getResultingDescriptor(), operationSign)); } } diff --git a/compiler/tests/org/jetbrains/jet/di/InjectorForTests.java b/compiler/tests/org/jetbrains/jet/di/InjectorForTests.java index 5dfc9df027e..1a4f118661d 100644 --- a/compiler/tests/org/jetbrains/jet/di/InjectorForTests.java +++ b/compiler/tests/org/jetbrains/jet/di/InjectorForTests.java @@ -29,6 +29,7 @@ import org.jetbrains.jet.lang.resolve.kotlin.JavaDeclarationCheckerProvider; import org.jetbrains.jet.lang.resolve.AnnotationResolver; import org.jetbrains.jet.lang.resolve.calls.CallResolver; import org.jetbrains.jet.lang.resolve.calls.ArgumentTypeResolver; +import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; import org.jetbrains.jet.lang.resolve.calls.CallCompleter; import org.jetbrains.jet.lang.resolve.calls.CandidateResolver; import org.jetbrains.jet.lang.resolve.calls.tasks.TaskPrioritizer; @@ -64,6 +65,7 @@ public class InjectorForTests { private final AnnotationResolver annotationResolver; private final CallResolver callResolver; private final ArgumentTypeResolver argumentTypeResolver; + private final KotlinBuiltIns kotlinBuiltIns; private final CallCompleter callCompleter; private final CandidateResolver candidateResolver; private final TaskPrioritizer taskPrioritizer; @@ -91,7 +93,8 @@ public class InjectorForTests { this.expressionTypingComponents = new ExpressionTypingComponents(); this.expressionTypingServices = new ExpressionTypingServices(expressionTypingComponents); this.callResolver = new CallResolver(); - this.expressionTypingUtils = new ExpressionTypingUtils(getExpressionTypingServices(), callResolver); + this.kotlinBuiltIns = KotlinBuiltIns.getInstance(); + this.expressionTypingUtils = new ExpressionTypingUtils(getExpressionTypingServices(), callResolver, kotlinBuiltIns); this.annotationResolver = new AnnotationResolver(); this.qualifiedExpressionResolver = new QualifiedExpressionResolver(); this.flexibleTypeCapabilitiesProvider = new FlexibleTypeCapabilitiesProvider(); @@ -114,12 +117,14 @@ public class InjectorForTests { this.partialBodyResolveProvider = new PartialBodyResolveProvider(); this.descriptorResolver.setAnnotationResolver(annotationResolver); + this.descriptorResolver.setBuiltIns(kotlinBuiltIns); this.descriptorResolver.setDelegatedPropertyResolver(delegatedPropertyResolver); this.descriptorResolver.setExpressionTypingServices(expressionTypingServices); this.descriptorResolver.setStorageManager(storageManager); this.descriptorResolver.setTypeResolver(typeResolver); this.expressionTypingServices.setAnnotationResolver(annotationResolver); + this.expressionTypingServices.setBuiltIns(kotlinBuiltIns); this.expressionTypingServices.setCallExpressionResolver(callExpressionResolver); this.expressionTypingServices.setCallResolver(callResolver); this.expressionTypingServices.setDescriptorResolver(descriptorResolver); @@ -139,15 +144,18 @@ public class InjectorForTests { callResolver.setTaskPrioritizer(taskPrioritizer); callResolver.setTypeResolver(typeResolver); + argumentTypeResolver.setBuiltIns(kotlinBuiltIns); argumentTypeResolver.setExpressionTypingServices(expressionTypingServices); argumentTypeResolver.setTypeResolver(typeResolver); candidateResolver.setArgumentTypeResolver(argumentTypeResolver); + delegatedPropertyResolver.setBuiltIns(kotlinBuiltIns); delegatedPropertyResolver.setCallResolver(callResolver); delegatedPropertyResolver.setExpressionTypingServices(expressionTypingServices); expressionTypingComponents.setAdditionalCheckerProvider(javaDeclarationCheckerProvider); + expressionTypingComponents.setBuiltIns(kotlinBuiltIns); expressionTypingComponents.setCallResolver(callResolver); expressionTypingComponents.setControlStructureTypingUtils(controlStructureTypingUtils); expressionTypingComponents.setDynamicTypesSettings(dynamicTypesSettings); diff --git a/js/js.frontend/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJs.java b/js/js.frontend/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJs.java index f9c835d6331..ea3aeb5e8b6 100644 --- a/js/js.frontend/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJs.java +++ b/js/js.frontend/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJs.java @@ -31,6 +31,7 @@ import org.jetbrains.jet.lang.types.DynamicTypesAllowed; import org.jetbrains.jet.lang.resolve.AnnotationResolver; import org.jetbrains.jet.lang.resolve.calls.CallResolver; import org.jetbrains.jet.lang.resolve.calls.ArgumentTypeResolver; +import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; import org.jetbrains.jet.lang.types.expressions.ExpressionTypingServices; import org.jetbrains.jet.lang.types.expressions.ExpressionTypingComponents; import org.jetbrains.jet.lang.types.expressions.ControlStructureTypingUtils; @@ -88,6 +89,7 @@ public class InjectorForTopDownAnalyzerForJs { private final AnnotationResolver annotationResolver; private final CallResolver callResolver; private final ArgumentTypeResolver argumentTypeResolver; + private final KotlinBuiltIns kotlinBuiltIns; private final ExpressionTypingServices expressionTypingServices; private final ExpressionTypingComponents expressionTypingComponents; private final ControlStructureTypingUtils controlStructureTypingUtils; @@ -146,10 +148,11 @@ public class InjectorForTopDownAnalyzerForJs { this.annotationResolver = new AnnotationResolver(); this.callResolver = new CallResolver(); this.argumentTypeResolver = new ArgumentTypeResolver(); + this.kotlinBuiltIns = KotlinBuiltIns.getInstance(); this.expressionTypingComponents = new ExpressionTypingComponents(); this.expressionTypingServices = new ExpressionTypingServices(expressionTypingComponents); this.controlStructureTypingUtils = new ControlStructureTypingUtils(expressionTypingServices); - this.expressionTypingUtils = new ExpressionTypingUtils(expressionTypingServices, callResolver); + this.expressionTypingUtils = new ExpressionTypingUtils(expressionTypingServices, callResolver, kotlinBuiltIns); this.forLoopConventionsChecker = new ForLoopConventionsChecker(); this.reflectionTypes = new ReflectionTypes(module); this.callExpressionResolver = new CallExpressionResolver(); @@ -211,10 +214,12 @@ public class InjectorForTopDownAnalyzerForJs { callResolver.setTaskPrioritizer(taskPrioritizer); callResolver.setTypeResolver(typeResolver); + argumentTypeResolver.setBuiltIns(kotlinBuiltIns); argumentTypeResolver.setExpressionTypingServices(expressionTypingServices); argumentTypeResolver.setTypeResolver(typeResolver); expressionTypingServices.setAnnotationResolver(annotationResolver); + expressionTypingServices.setBuiltIns(kotlinBuiltIns); expressionTypingServices.setCallExpressionResolver(callExpressionResolver); expressionTypingServices.setCallResolver(callResolver); expressionTypingServices.setDescriptorResolver(descriptorResolver); @@ -224,6 +229,7 @@ public class InjectorForTopDownAnalyzerForJs { expressionTypingServices.setTypeResolver(typeResolver); expressionTypingComponents.setAdditionalCheckerProvider(kotlinJsDeclarationCheckerProvider); + expressionTypingComponents.setBuiltIns(kotlinBuiltIns); expressionTypingComponents.setCallResolver(callResolver); expressionTypingComponents.setControlStructureTypingUtils(controlStructureTypingUtils); expressionTypingComponents.setDynamicTypesSettings(dynamicTypesAllowed); @@ -241,11 +247,13 @@ public class InjectorForTopDownAnalyzerForJs { callExpressionResolver.setExpressionTypingServices(expressionTypingServices); descriptorResolver.setAnnotationResolver(annotationResolver); + descriptorResolver.setBuiltIns(kotlinBuiltIns); descriptorResolver.setDelegatedPropertyResolver(delegatedPropertyResolver); descriptorResolver.setExpressionTypingServices(expressionTypingServices); descriptorResolver.setStorageManager(storageManager); descriptorResolver.setTypeResolver(typeResolver); + delegatedPropertyResolver.setBuiltIns(kotlinBuiltIns); delegatedPropertyResolver.setCallResolver(callResolver); delegatedPropertyResolver.setExpressionTypingServices(expressionTypingServices);