From 20513abe04dd3c5979a89e8292ba27762b4aae8d Mon Sep 17 00:00:00 2001 From: Andrey Breslav Date: Tue, 25 Nov 2014 18:40:55 +0300 Subject: [PATCH] Allow dynamic types only in some contexts --- .../di/InjectorForLazyResolveWithJava.java | 5 ++- .../jet/di/InjectorForReplWithJava.java | 5 ++- .../di/InjectorForTopDownAnalyzerForJvm.java | 5 ++- .../jet/di/InjectorForBodyResolve.java | 5 ++- .../jet/di/InjectorForLazyBodyResolve.java | 5 ++- .../jet/di/InjectorForLazyResolve.java | 5 ++- .../InjectorForLazyTopDownAnalyzerBasic.java | 5 ++- .../jetbrains/jet/di/InjectorForMacros.java | 5 ++- .../di/InjectorForTopDownAnalyzerBasic.java | 5 ++- .../jet/lang/resolve/TypeResolver.kt | 11 +++++- .../tests/dynamicTypes/assignment.kt | 11 ++++++ .../tests/dynamicTypes/assignment.txt | 3 ++ .../tests/dynamicTypes/unsupported.kt | 1 + .../tests/dynamicTypes/unsupported.txt | 3 ++ .../checkers/JetDiagnosticsTestGenerated.java | 23 +++++++++++- .../jetbrains/jet/di/InjectorForTests.java | 5 ++- .../jetbrains/jet/lang/types/dynamicTypes.kt | 37 +++++++++++++++++++ .../generators/injectors/GenerateInjectors.kt | 2 + .../di/InjectorForTopDownAnalyzerForJs.java | 5 ++- spec-docs/dynamic-types.md | 6 ++- 20 files changed, 138 insertions(+), 14 deletions(-) create mode 100644 compiler/testData/diagnostics/tests/dynamicTypes/assignment.kt create mode 100644 compiler/testData/diagnostics/tests/dynamicTypes/assignment.txt create mode 100644 compiler/testData/diagnostics/tests/dynamicTypes/unsupported.kt create mode 100644 compiler/testData/diagnostics/tests/dynamicTypes/unsupported.txt create mode 100644 core/descriptors/src/org/jetbrains/jet/lang/types/dynamicTypes.kt 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 3b526f36663..fc7b4a64883 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForLazyResolveWithJava.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForLazyResolveWithJava.java @@ -55,6 +55,7 @@ import org.jetbrains.jet.lang.resolve.DescriptorResolver; import org.jetbrains.jet.lang.resolve.DelegatedPropertyResolver; import org.jetbrains.jet.lang.resolve.TypeResolver; import org.jetbrains.jet.lang.resolve.QualifiedExpressionResolver; +import org.jetbrains.jet.lang.types.DynamicTypesSettings; import org.jetbrains.jet.lang.resolve.calls.CallResolverExtensionProvider; import org.jetbrains.jet.lang.resolve.PartialBodyResolveProvider; import org.jetbrains.jet.lang.resolve.calls.CallCompleter; @@ -116,6 +117,7 @@ public class InjectorForLazyResolveWithJava { private final DelegatedPropertyResolver delegatedPropertyResolver; private final TypeResolver typeResolver; private final QualifiedExpressionResolver qualifiedExpressionResolver; + private final DynamicTypesSettings dynamicTypesSettings; private final CallResolverExtensionProvider callResolverExtensionProvider; private final PartialBodyResolveProvider partialBodyResolveProvider; private final CallCompleter callCompleter; @@ -182,7 +184,8 @@ public class InjectorForLazyResolveWithJava { this.descriptorResolver = new DescriptorResolver(); this.delegatedPropertyResolver = new DelegatedPropertyResolver(); this.qualifiedExpressionResolver = new QualifiedExpressionResolver(); - this.typeResolver = new TypeResolver(annotationResolver, qualifiedExpressionResolver, module, javaFlexibleTypeCapabilitiesProvider, storageManager, lazyResolveToken); + this.dynamicTypesSettings = new DynamicTypesSettings(); + this.typeResolver = new TypeResolver(annotationResolver, qualifiedExpressionResolver, module, javaFlexibleTypeCapabilitiesProvider, storageManager, lazyResolveToken, dynamicTypesSettings); this.callResolverExtensionProvider = new CallResolverExtensionProvider(); this.partialBodyResolveProvider = new PartialBodyResolveProvider(); this.candidateResolver = new CandidateResolver(); 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 b37a95e2160..197b5cb7963 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForReplWithJava.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForReplWithJava.java @@ -59,6 +59,7 @@ import org.jetbrains.jet.lang.resolve.DelegatedPropertyResolver; import org.jetbrains.jet.lang.resolve.TypeResolver; import org.jetbrains.jet.lang.resolve.QualifiedExpressionResolver; import org.jetbrains.jet.context.LazinessToken; +import org.jetbrains.jet.lang.types.DynamicTypesSettings; import org.jetbrains.jet.lang.resolve.calls.CallResolverExtensionProvider; import org.jetbrains.jet.lang.resolve.PartialBodyResolveProvider; import org.jetbrains.jet.lang.resolve.calls.CallCompleter; @@ -134,6 +135,7 @@ public class InjectorForReplWithJava { private final TypeResolver typeResolver; private final QualifiedExpressionResolver qualifiedExpressionResolver; private final LazinessToken lazinessToken; + private final DynamicTypesSettings dynamicTypesSettings; private final CallResolverExtensionProvider callResolverExtensionProvider; private final PartialBodyResolveProvider partialBodyResolveProvider; private final CallCompleter callCompleter; @@ -216,7 +218,8 @@ public class InjectorForReplWithJava { this.delegatedPropertyResolver = new DelegatedPropertyResolver(); this.qualifiedExpressionResolver = new QualifiedExpressionResolver(); this.lazinessToken = new LazinessToken(); - this.typeResolver = new TypeResolver(annotationResolver, qualifiedExpressionResolver, module, javaFlexibleTypeCapabilitiesProvider, storageManager, lazinessToken); + this.dynamicTypesSettings = new DynamicTypesSettings(); + this.typeResolver = new TypeResolver(annotationResolver, qualifiedExpressionResolver, module, javaFlexibleTypeCapabilitiesProvider, storageManager, lazinessToken, dynamicTypesSettings); this.callResolverExtensionProvider = new CallResolverExtensionProvider(); this.partialBodyResolveProvider = new PartialBodyResolveProvider(); this.candidateResolver = new CandidateResolver(); 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 96962039968..2b187907308 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java @@ -58,6 +58,7 @@ import org.jetbrains.jet.lang.resolve.DelegatedPropertyResolver; import org.jetbrains.jet.lang.resolve.TypeResolver; import org.jetbrains.jet.lang.resolve.QualifiedExpressionResolver; import org.jetbrains.jet.context.LazinessToken; +import org.jetbrains.jet.lang.types.DynamicTypesSettings; import org.jetbrains.jet.lang.resolve.calls.CallResolverExtensionProvider; import org.jetbrains.jet.lang.resolve.PartialBodyResolveProvider; import org.jetbrains.jet.lang.resolve.calls.CallCompleter; @@ -133,6 +134,7 @@ public class InjectorForTopDownAnalyzerForJvm { private final TypeResolver typeResolver; private final QualifiedExpressionResolver qualifiedExpressionResolver; private final LazinessToken lazinessToken; + private final DynamicTypesSettings dynamicTypesSettings; private final CallResolverExtensionProvider callResolverExtensionProvider; private final PartialBodyResolveProvider partialBodyResolveProvider; private final CallCompleter callCompleter; @@ -214,7 +216,8 @@ public class InjectorForTopDownAnalyzerForJvm { this.delegatedPropertyResolver = new DelegatedPropertyResolver(); this.qualifiedExpressionResolver = new QualifiedExpressionResolver(); this.lazinessToken = new LazinessToken(); - this.typeResolver = new TypeResolver(annotationResolver, qualifiedExpressionResolver, module, javaFlexibleTypeCapabilitiesProvider, storageManager, lazinessToken); + this.dynamicTypesSettings = new DynamicTypesSettings(); + this.typeResolver = new TypeResolver(annotationResolver, qualifiedExpressionResolver, module, javaFlexibleTypeCapabilitiesProvider, storageManager, lazinessToken, dynamicTypesSettings); this.callResolverExtensionProvider = new CallResolverExtensionProvider(); this.partialBodyResolveProvider = new PartialBodyResolveProvider(); this.candidateResolver = new CandidateResolver(); diff --git a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForBodyResolve.java b/compiler/frontend/src/org/jetbrains/jet/di/InjectorForBodyResolve.java index 55995209cca..a890c68ed2d 100644 --- a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForBodyResolve.java +++ b/compiler/frontend/src/org/jetbrains/jet/di/InjectorForBodyResolve.java @@ -41,6 +41,7 @@ import org.jetbrains.jet.lang.resolve.TypeResolver; 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.resolve.calls.CallResolverExtensionProvider; import org.jetbrains.jet.lang.resolve.calls.CallCompleter; import org.jetbrains.jet.lang.resolve.calls.CandidateResolver; @@ -82,6 +83,7 @@ public class InjectorForBodyResolve { private final QualifiedExpressionResolver qualifiedExpressionResolver; private final FlexibleTypeCapabilitiesProvider flexibleTypeCapabilitiesProvider; private final LazinessToken lazinessToken; + private final DynamicTypesSettings dynamicTypesSettings; private final CallResolverExtensionProvider callResolverExtensionProvider; private final CallCompleter callCompleter; private final CandidateResolver candidateResolver; @@ -124,7 +126,8 @@ public class InjectorForBodyResolve { this.qualifiedExpressionResolver = new QualifiedExpressionResolver(); this.flexibleTypeCapabilitiesProvider = new FlexibleTypeCapabilitiesProvider(); this.lazinessToken = new LazinessToken(); - this.typeResolver = new TypeResolver(annotationResolver, qualifiedExpressionResolver, moduleDescriptor, flexibleTypeCapabilitiesProvider, storageManager, lazinessToken); + this.dynamicTypesSettings = new DynamicTypesSettings(); + this.typeResolver = new TypeResolver(annotationResolver, qualifiedExpressionResolver, moduleDescriptor, flexibleTypeCapabilitiesProvider, storageManager, lazinessToken, dynamicTypesSettings); this.callResolverExtensionProvider = new CallResolverExtensionProvider(); this.candidateResolver = new CandidateResolver(); this.callCompleter = new CallCompleter(argumentTypeResolver, candidateResolver); diff --git a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForLazyBodyResolve.java b/compiler/frontend/src/org/jetbrains/jet/di/InjectorForLazyBodyResolve.java index 91dd471cdad..914210ef777 100644 --- a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForLazyBodyResolve.java +++ b/compiler/frontend/src/org/jetbrains/jet/di/InjectorForLazyBodyResolve.java @@ -42,6 +42,7 @@ import org.jetbrains.jet.lang.resolve.TypeResolver; 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.resolve.calls.CallResolverExtensionProvider; import org.jetbrains.jet.lang.resolve.PartialBodyResolveProvider; import org.jetbrains.jet.lang.resolve.calls.CallCompleter; @@ -94,6 +95,7 @@ public class InjectorForLazyBodyResolve { private final QualifiedExpressionResolver qualifiedExpressionResolver; private final FlexibleTypeCapabilitiesProvider flexibleTypeCapabilitiesProvider; private final LazinessToken lazinessToken; + private final DynamicTypesSettings dynamicTypesSettings; private final CallResolverExtensionProvider callResolverExtensionProvider; private final PartialBodyResolveProvider partialBodyResolveProvider; private final CallCompleter callCompleter; @@ -146,7 +148,8 @@ public class InjectorForLazyBodyResolve { this.qualifiedExpressionResolver = new QualifiedExpressionResolver(); this.flexibleTypeCapabilitiesProvider = new FlexibleTypeCapabilitiesProvider(); this.lazinessToken = new LazinessToken(); - this.typeResolver = new TypeResolver(annotationResolver, qualifiedExpressionResolver, moduleDescriptor, flexibleTypeCapabilitiesProvider, storageManager, lazinessToken); + this.dynamicTypesSettings = new DynamicTypesSettings(); + this.typeResolver = new TypeResolver(annotationResolver, qualifiedExpressionResolver, moduleDescriptor, flexibleTypeCapabilitiesProvider, storageManager, lazinessToken, dynamicTypesSettings); this.callResolverExtensionProvider = new CallResolverExtensionProvider(); this.partialBodyResolveProvider = new PartialBodyResolveProvider(); this.candidateResolver = new CandidateResolver(); diff --git a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForLazyResolve.java b/compiler/frontend/src/org/jetbrains/jet/di/InjectorForLazyResolve.java index f6adadb8adf..1b317012a67 100644 --- a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForLazyResolve.java +++ b/compiler/frontend/src/org/jetbrains/jet/di/InjectorForLazyResolve.java @@ -41,6 +41,7 @@ import org.jetbrains.jet.lang.resolve.DelegatedPropertyResolver; import org.jetbrains.jet.lang.resolve.TypeResolver; import org.jetbrains.jet.lang.resolve.QualifiedExpressionResolver; import org.jetbrains.jet.lang.resolve.TypeResolver.FlexibleTypeCapabilitiesProvider; +import org.jetbrains.jet.lang.types.DynamicTypesSettings; import org.jetbrains.jet.lang.resolve.calls.CallResolverExtensionProvider; import org.jetbrains.jet.lang.resolve.PartialBodyResolveProvider; import org.jetbrains.jet.lang.resolve.calls.CallCompleter; @@ -82,6 +83,7 @@ public class InjectorForLazyResolve { private final TypeResolver typeResolver; private final QualifiedExpressionResolver qualifiedExpressionResolver; private final FlexibleTypeCapabilitiesProvider flexibleTypeCapabilitiesProvider; + private final DynamicTypesSettings dynamicTypesSettings; private final CallResolverExtensionProvider callResolverExtensionProvider; private final PartialBodyResolveProvider partialBodyResolveProvider; private final CallCompleter callCompleter; @@ -124,7 +126,8 @@ public class InjectorForLazyResolve { this.delegatedPropertyResolver = new DelegatedPropertyResolver(); this.qualifiedExpressionResolver = new QualifiedExpressionResolver(); this.flexibleTypeCapabilitiesProvider = new FlexibleTypeCapabilitiesProvider(); - this.typeResolver = new TypeResolver(annotationResolver, qualifiedExpressionResolver, moduleDescriptor, flexibleTypeCapabilitiesProvider, storageManager, lazyResolveToken); + this.dynamicTypesSettings = new DynamicTypesSettings(); + this.typeResolver = new TypeResolver(annotationResolver, qualifiedExpressionResolver, moduleDescriptor, flexibleTypeCapabilitiesProvider, storageManager, lazyResolveToken, dynamicTypesSettings); this.callResolverExtensionProvider = new CallResolverExtensionProvider(); this.partialBodyResolveProvider = new PartialBodyResolveProvider(); this.candidateResolver = new CandidateResolver(); diff --git a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForLazyTopDownAnalyzerBasic.java b/compiler/frontend/src/org/jetbrains/jet/di/InjectorForLazyTopDownAnalyzerBasic.java index 5f38d8eca16..fbd7a58334d 100644 --- a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForLazyTopDownAnalyzerBasic.java +++ b/compiler/frontend/src/org/jetbrains/jet/di/InjectorForLazyTopDownAnalyzerBasic.java @@ -42,6 +42,7 @@ import org.jetbrains.jet.lang.resolve.TypeResolver; 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.resolve.calls.CallResolverExtensionProvider; import org.jetbrains.jet.lang.resolve.PartialBodyResolveProvider; import org.jetbrains.jet.lang.resolve.calls.CallCompleter; @@ -97,6 +98,7 @@ public class InjectorForLazyTopDownAnalyzerBasic { private final QualifiedExpressionResolver qualifiedExpressionResolver; private final FlexibleTypeCapabilitiesProvider flexibleTypeCapabilitiesProvider; private final LazinessToken lazinessToken; + private final DynamicTypesSettings dynamicTypesSettings; private final CallResolverExtensionProvider callResolverExtensionProvider; private final PartialBodyResolveProvider partialBodyResolveProvider; private final CallCompleter callCompleter; @@ -152,7 +154,8 @@ public class InjectorForLazyTopDownAnalyzerBasic { this.qualifiedExpressionResolver = new QualifiedExpressionResolver(); this.flexibleTypeCapabilitiesProvider = new FlexibleTypeCapabilitiesProvider(); this.lazinessToken = new LazinessToken(); - this.typeResolver = new TypeResolver(annotationResolver, qualifiedExpressionResolver, module, flexibleTypeCapabilitiesProvider, storageManager, lazinessToken); + this.dynamicTypesSettings = new DynamicTypesSettings(); + this.typeResolver = new TypeResolver(annotationResolver, qualifiedExpressionResolver, module, flexibleTypeCapabilitiesProvider, storageManager, lazinessToken, dynamicTypesSettings); this.callResolverExtensionProvider = new CallResolverExtensionProvider(); this.partialBodyResolveProvider = new PartialBodyResolveProvider(); this.candidateResolver = new CandidateResolver(); diff --git a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForMacros.java b/compiler/frontend/src/org/jetbrains/jet/di/InjectorForMacros.java index e00c828e318..faf58ac5fd1 100644 --- a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForMacros.java +++ b/compiler/frontend/src/org/jetbrains/jet/di/InjectorForMacros.java @@ -30,6 +30,7 @@ import org.jetbrains.jet.lang.resolve.TypeResolver; 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.resolve.calls.CallExpressionResolver; import org.jetbrains.jet.lang.resolve.DescriptorResolver; import org.jetbrains.jet.lang.resolve.DelegatedPropertyResolver; @@ -64,6 +65,7 @@ public class InjectorForMacros { private final QualifiedExpressionResolver qualifiedExpressionResolver; private final FlexibleTypeCapabilitiesProvider flexibleTypeCapabilitiesProvider; private final LazinessToken lazinessToken; + private final DynamicTypesSettings dynamicTypesSettings; private final CallExpressionResolver callExpressionResolver; private final DescriptorResolver descriptorResolver; private final DelegatedPropertyResolver delegatedPropertyResolver; @@ -95,7 +97,8 @@ public class InjectorForMacros { this.qualifiedExpressionResolver = new QualifiedExpressionResolver(); this.flexibleTypeCapabilitiesProvider = new FlexibleTypeCapabilitiesProvider(); this.lazinessToken = new LazinessToken(); - this.typeResolver = new TypeResolver(annotationResolver, qualifiedExpressionResolver, moduleDescriptor, flexibleTypeCapabilitiesProvider, storageManager, lazinessToken); + this.dynamicTypesSettings = new DynamicTypesSettings(); + this.typeResolver = new TypeResolver(annotationResolver, qualifiedExpressionResolver, moduleDescriptor, flexibleTypeCapabilitiesProvider, storageManager, lazinessToken, dynamicTypesSettings); this.callExpressionResolver = new CallExpressionResolver(); this.descriptorResolver = new DescriptorResolver(); this.delegatedPropertyResolver = new DelegatedPropertyResolver(); diff --git a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerBasic.java b/compiler/frontend/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerBasic.java index 8bdc2b64cca..adae5cee072 100644 --- a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerBasic.java +++ b/compiler/frontend/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerBasic.java @@ -42,6 +42,7 @@ import org.jetbrains.jet.lang.resolve.TypeResolver; 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.resolve.calls.CallResolverExtensionProvider; import org.jetbrains.jet.lang.resolve.PartialBodyResolveProvider; import org.jetbrains.jet.lang.resolve.calls.CallCompleter; @@ -92,6 +93,7 @@ public class InjectorForTopDownAnalyzerBasic { private final QualifiedExpressionResolver qualifiedExpressionResolver; private final FlexibleTypeCapabilitiesProvider flexibleTypeCapabilitiesProvider; private final LazinessToken lazinessToken; + private final DynamicTypesSettings dynamicTypesSettings; private final CallResolverExtensionProvider callResolverExtensionProvider; private final PartialBodyResolveProvider partialBodyResolveProvider; private final CallCompleter callCompleter; @@ -142,7 +144,8 @@ public class InjectorForTopDownAnalyzerBasic { this.qualifiedExpressionResolver = new QualifiedExpressionResolver(); this.flexibleTypeCapabilitiesProvider = new FlexibleTypeCapabilitiesProvider(); this.lazinessToken = new LazinessToken(); - this.typeResolver = new TypeResolver(annotationResolver, qualifiedExpressionResolver, getModuleDescriptor(), flexibleTypeCapabilitiesProvider, storageManager, lazinessToken); + this.dynamicTypesSettings = new DynamicTypesSettings(); + this.typeResolver = new TypeResolver(annotationResolver, qualifiedExpressionResolver, getModuleDescriptor(), flexibleTypeCapabilitiesProvider, storageManager, lazinessToken, dynamicTypesSettings); this.callResolverExtensionProvider = new CallResolverExtensionProvider(); this.partialBodyResolveProvider = new PartialBodyResolveProvider(); this.candidateResolver = new CandidateResolver(); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TypeResolver.kt b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TypeResolver.kt index 8875e952082..00f3ad749e4 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TypeResolver.kt +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TypeResolver.kt @@ -35,6 +35,7 @@ import org.jetbrains.jet.context.LazinessToken import org.jetbrains.jet.lang.resolve.lazy.LazyEntity import org.jetbrains.jet.lang.resolve.lazy.ForceResolveUtil import org.jetbrains.jet.utils.addToStdlib.firstIsInstanceOrNull +import org.jetbrains.jet.lang.diagnostics.Errors public class TypeResolver( private val annotationResolver: AnnotationResolver, @@ -42,7 +43,8 @@ public class TypeResolver( private val moduleDescriptor: ModuleDescriptor, private val flexibleTypeCapabilitiesProvider: FlexibleTypeCapabilitiesProvider, private val storageManager: StorageManager, - private val lazinessToken: LazinessToken + private val lazinessToken: LazinessToken, + private val dynamicTypesSettings: DynamicTypesSettings ) { public open class FlexibleTypeCapabilitiesProvider { @@ -220,6 +222,13 @@ public class TypeResolver( result = type(KotlinBuiltIns.getInstance().getFunctionType(annotations, receiverType, parameterTypes, returnType)) } + override fun visitDynamicType(type: JetDynamicType) { + result = type(DynamicType) + if (!dynamicTypesSettings.dynamicTypesAllowed) { + c.trace.report(UNSUPPORTED.on(type, "Dynamic types are not supported in this context")) + } + } + override fun visitJetElement(element: JetElement) { c.trace.report(UNSUPPORTED.on(element, "Self-types are not supported yet")) } diff --git a/compiler/testData/diagnostics/tests/dynamicTypes/assignment.kt b/compiler/testData/diagnostics/tests/dynamicTypes/assignment.kt new file mode 100644 index 00000000000..6abd3d49c09 --- /dev/null +++ b/compiler/testData/diagnostics/tests/dynamicTypes/assignment.kt @@ -0,0 +1,11 @@ +// !DIAGNOSTICS: -UNUSED_VARIABLE +// !CHECK_TYPE + +// MODULE[js]: m1 +// FILE: k.kt + +fun foo(d: dynamic) { + val s: String = d + val d1: dynamic = "" + val d2: dynamic = null +} \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/dynamicTypes/assignment.txt b/compiler/testData/diagnostics/tests/dynamicTypes/assignment.txt new file mode 100644 index 00000000000..7a544c63a17 --- /dev/null +++ b/compiler/testData/diagnostics/tests/dynamicTypes/assignment.txt @@ -0,0 +1,3 @@ +package + +internal fun foo(/*0*/ d: (kotlin.Nothing..kotlin.Any?)): kotlin.Unit diff --git a/compiler/testData/diagnostics/tests/dynamicTypes/unsupported.kt b/compiler/testData/diagnostics/tests/dynamicTypes/unsupported.kt new file mode 100644 index 00000000000..138958f212a --- /dev/null +++ b/compiler/testData/diagnostics/tests/dynamicTypes/unsupported.kt @@ -0,0 +1 @@ +val foo: dynamic = 1 \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/dynamicTypes/unsupported.txt b/compiler/testData/diagnostics/tests/dynamicTypes/unsupported.txt new file mode 100644 index 00000000000..b683ae4d819 --- /dev/null +++ b/compiler/testData/diagnostics/tests/dynamicTypes/unsupported.txt @@ -0,0 +1,3 @@ +package + +internal val foo: dynamic = 1 diff --git a/compiler/tests/org/jetbrains/jet/checkers/JetDiagnosticsTestGenerated.java b/compiler/tests/org/jetbrains/jet/checkers/JetDiagnosticsTestGenerated.java index bd7bfc7dd36..2d0f1daf642 100644 --- a/compiler/tests/org/jetbrains/jet/checkers/JetDiagnosticsTestGenerated.java +++ b/compiler/tests/org/jetbrains/jet/checkers/JetDiagnosticsTestGenerated.java @@ -33,7 +33,7 @@ import java.util.regex.Pattern; public class JetDiagnosticsTestGenerated extends AbstractJetDiagnosticsTest { @TestMetadata("compiler/testData/diagnostics/tests") @TestDataPath("$PROJECT_ROOT") - @InnerTestClasses({Tests.Annotations.class, Tests.BackingField.class, Tests.Cast.class, Tests.CheckArguments.class, Tests.ClassObjects.class, Tests.ControlFlowAnalysis.class, Tests.ControlStructures.class, Tests.CyclicHierarchy.class, Tests.DataClasses.class, Tests.DataFlow.class, Tests.DataFlowInfoTraversal.class, Tests.DeclarationChecks.class, Tests.DelegatedProperty.class, Tests.Delegation.class, Tests.Deparenthesize.class, Tests.DuplicateJvmSignature.class, Tests.Enum.class, Tests.Evaluate.class, Tests.Extensions.class, Tests.FunctionLiterals.class, Tests.Generics.class, Tests.Imports.class, Tests.IncompleteCode.class, Tests.Inference.class, Tests.Infos.class, Tests.Inline.class, Tests.Inner.class, Tests.J_k.class, Tests.Jdk_annotations.class, Tests.Labels.class, Tests.Library.class, Tests.Multimodule.class, Tests.NamedArguments.class, Tests.NullabilityAndSmartCasts.class, Tests.NullableTypes.class, Tests.Numbers.class, Tests.Objects.class, Tests.OperatorsOverloading.class, Tests.Overload.class, Tests.Override.class, Tests.PlatformTypes.class, Tests.Recovery.class, Tests.Redeclarations.class, Tests.Regressions.class, Tests.Resolve.class, Tests.Scopes.class, Tests.SenselessComparison.class, Tests.Shadowing.class, Tests.SmartCasts.class, Tests.Substitutions.class, Tests.Subtyping.class, Tests.Suppress.class, Tests.ThisAndSuper.class, Tests.TraitWithRequired.class, Tests.Typedefs.class, Tests.Unit.class, Tests.Varargs.class, Tests.When.class}) + @InnerTestClasses({Tests.Annotations.class, Tests.BackingField.class, Tests.Cast.class, Tests.CheckArguments.class, Tests.ClassObjects.class, Tests.ControlFlowAnalysis.class, Tests.ControlStructures.class, Tests.CyclicHierarchy.class, Tests.DataClasses.class, Tests.DataFlow.class, Tests.DataFlowInfoTraversal.class, Tests.DeclarationChecks.class, Tests.DelegatedProperty.class, Tests.Delegation.class, Tests.Deparenthesize.class, Tests.DuplicateJvmSignature.class, Tests.DynamicTypes.class, Tests.Enum.class, Tests.Evaluate.class, Tests.Extensions.class, Tests.FunctionLiterals.class, Tests.Generics.class, Tests.Imports.class, Tests.IncompleteCode.class, Tests.Inference.class, Tests.Infos.class, Tests.Inline.class, Tests.Inner.class, Tests.J_k.class, Tests.Jdk_annotations.class, Tests.Labels.class, Tests.Library.class, Tests.Multimodule.class, Tests.NamedArguments.class, Tests.NullabilityAndSmartCasts.class, Tests.NullableTypes.class, Tests.Numbers.class, Tests.Objects.class, Tests.OperatorsOverloading.class, Tests.Overload.class, Tests.Override.class, Tests.PlatformTypes.class, Tests.Recovery.class, Tests.Redeclarations.class, Tests.Regressions.class, Tests.Resolve.class, Tests.Scopes.class, Tests.SenselessComparison.class, Tests.Shadowing.class, Tests.SmartCasts.class, Tests.Substitutions.class, Tests.Subtyping.class, Tests.Suppress.class, Tests.ThisAndSuper.class, Tests.TraitWithRequired.class, Tests.Typedefs.class, Tests.Unit.class, Tests.Varargs.class, Tests.When.class}) @RunWith(JUnit3RunnerWithInners.class) public static class Tests extends AbstractJetDiagnosticsTest { @TestMetadata("Abstract.kt") @@ -3708,6 +3708,27 @@ public class JetDiagnosticsTestGenerated extends AbstractJetDiagnosticsTest { } } + @TestMetadata("compiler/testData/diagnostics/tests/dynamicTypes") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class DynamicTypes extends AbstractJetDiagnosticsTest { + public void testAllFilesPresentInDynamicTypes() throws Exception { + JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/dynamicTypes"), Pattern.compile("^(.+)\\.kt$"), true); + } + + @TestMetadata("assignment.kt") + public void testAssignment() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/dynamicTypes/assignment.kt"); + doTest(fileName); + } + + @TestMetadata("unsupported.kt") + public void testUnsupported() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/dynamicTypes/unsupported.kt"); + doTest(fileName); + } + } + @TestMetadata("compiler/testData/diagnostics/tests/enum") @TestDataPath("$PROJECT_ROOT") @InnerTestClasses({Enum.Inner.class}) diff --git a/compiler/tests/org/jetbrains/jet/di/InjectorForTests.java b/compiler/tests/org/jetbrains/jet/di/InjectorForTests.java index 1bf1fbb85c9..08fba5b6ec2 100644 --- a/compiler/tests/org/jetbrains/jet/di/InjectorForTests.java +++ b/compiler/tests/org/jetbrains/jet/di/InjectorForTests.java @@ -43,6 +43,7 @@ import org.jetbrains.jet.lang.resolve.PartialBodyResolveProvider; 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.annotations.NotNull; import javax.annotation.PreDestroy; @@ -77,6 +78,7 @@ public class InjectorForTests { private final QualifiedExpressionResolver qualifiedExpressionResolver; private final FlexibleTypeCapabilitiesProvider flexibleTypeCapabilitiesProvider; private final LazinessToken lazinessToken; + private final DynamicTypesSettings dynamicTypesSettings; public InjectorForTests( @NotNull Project project, @@ -96,7 +98,8 @@ public class InjectorForTests { this.globalContext = org.jetbrains.jet.context.ContextPackage.GlobalContext(); this.storageManager = globalContext.getStorageManager(); this.lazinessToken = new LazinessToken(); - this.typeResolver = new TypeResolver(annotationResolver, qualifiedExpressionResolver, moduleDescriptor, flexibleTypeCapabilitiesProvider, storageManager, lazinessToken); + this.dynamicTypesSettings = new DynamicTypesSettings(); + this.typeResolver = new TypeResolver(annotationResolver, qualifiedExpressionResolver, moduleDescriptor, flexibleTypeCapabilitiesProvider, storageManager, lazinessToken, dynamicTypesSettings); this.additionalCheckerProvider = org.jetbrains.jet.lang.resolve.kotlin.JavaDeclarationCheckerProvider.INSTANCE$; this.argumentTypeResolver = new ArgumentTypeResolver(); this.candidateResolver = new CandidateResolver(); diff --git a/core/descriptors/src/org/jetbrains/jet/lang/types/dynamicTypes.kt b/core/descriptors/src/org/jetbrains/jet/lang/types/dynamicTypes.kt new file mode 100644 index 00000000000..696fdd86589 --- /dev/null +++ b/core/descriptors/src/org/jetbrains/jet/lang/types/dynamicTypes.kt @@ -0,0 +1,37 @@ +/* + * Copyright 2010-2014 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.jetbrains.jet.lang.types + +import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns + +open class DynamicTypesSettings { + open val dynamicTypesAllowed: Boolean + get() = false +} + +class DynamicTypesAllowed: DynamicTypesSettings() { + override val dynamicTypesAllowed: Boolean + get() = true +} + +object DynamicType : DelegatingFlexibleType( + KotlinBuiltIns.getInstance().getNothingType(), + KotlinBuiltIns.getInstance().getNullableAnyType(), + FlexibleTypeCapabilities.NONE +) { + override fun getDelegate() = upperBound +} \ No newline at end of file diff --git a/generators/src/org/jetbrains/jet/generators/injectors/GenerateInjectors.kt b/generators/src/org/jetbrains/jet/generators/injectors/GenerateInjectors.kt index 6e6d7e89eac..f8e8d85787a 100644 --- a/generators/src/org/jetbrains/jet/generators/injectors/GenerateInjectors.kt +++ b/generators/src/org/jetbrains/jet/generators/injectors/GenerateInjectors.kt @@ -49,6 +49,7 @@ import org.jetbrains.jet.lang.resolve.java.JavaLazyAnalyzerPostConstruct import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolverPostConstruct import org.jetbrains.jet.lang.resolve.lazy.ScopeProvider import org.jetbrains.k2js.resolve.KotlinJsDeclarationCheckerProvider +import org.jetbrains.jet.lang.types.DynamicTypesAllowed // NOTE: After making changes, you need to re-generate the injectors. // To do that, you can run main in this file. @@ -134,6 +135,7 @@ private fun generatorForTopDownAnalyzerForJs() = field(javaClass()) field(javaClass(), init = GivenExpression(javaClass().getName() + ".INSTANCE$")) + field(javaClass()) } private fun generatorForTopDownAnalyzerForJvm() = 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 017c13588a4..af385f1e2ba 100644 --- a/js/js.frontend/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJs.java +++ b/js/js.frontend/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJs.java @@ -27,6 +27,7 @@ import org.jetbrains.jet.lang.resolve.lazy.ResolveSession; import org.jetbrains.jet.lang.resolve.LazyTopDownAnalyzer; import org.jetbrains.jet.lang.resolve.MutablePackageFragmentProvider; import org.jetbrains.jet.lang.resolve.AdditionalCheckerProvider; +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; @@ -82,6 +83,7 @@ public class InjectorForTopDownAnalyzerForJs { private final LazyTopDownAnalyzer lazyTopDownAnalyzer; private final MutablePackageFragmentProvider mutablePackageFragmentProvider; private final AdditionalCheckerProvider additionalCheckerProvider; + private final DynamicTypesAllowed dynamicTypesAllowed; private final AnnotationResolver annotationResolver; private final CallResolver callResolver; private final ArgumentTypeResolver argumentTypeResolver; @@ -138,6 +140,7 @@ public class InjectorForTopDownAnalyzerForJs { this.lazyTopDownAnalyzer = new LazyTopDownAnalyzer(); this.mutablePackageFragmentProvider = new MutablePackageFragmentProvider(module); this.additionalCheckerProvider = org.jetbrains.k2js.resolve.KotlinJsDeclarationCheckerProvider.INSTANCE$; + this.dynamicTypesAllowed = new DynamicTypesAllowed(); this.annotationResolver = new AnnotationResolver(); this.callResolver = new CallResolver(); this.argumentTypeResolver = new ArgumentTypeResolver(); @@ -153,7 +156,7 @@ public class InjectorForTopDownAnalyzerForJs { this.qualifiedExpressionResolver = new QualifiedExpressionResolver(); this.flexibleTypeCapabilitiesProvider = new FlexibleTypeCapabilitiesProvider(); this.lazinessToken = new LazinessToken(); - this.typeResolver = new TypeResolver(annotationResolver, qualifiedExpressionResolver, module, flexibleTypeCapabilitiesProvider, storageManager, lazinessToken); + this.typeResolver = new TypeResolver(annotationResolver, qualifiedExpressionResolver, module, flexibleTypeCapabilitiesProvider, storageManager, lazinessToken, dynamicTypesAllowed); this.callResolverExtensionProvider = new CallResolverExtensionProvider(); this.partialBodyResolveProvider = new PartialBodyResolveProvider(); this.candidateResolver = new CandidateResolver(); diff --git a/spec-docs/dynamic-types.md b/spec-docs/dynamic-types.md index 24b5255701a..7e5514cfd8b 100644 --- a/spec-docs/dynamic-types.md +++ b/spec-docs/dynamic-types.md @@ -73,4 +73,8 @@ foo(listOf()) // can't determine T for listOf() Discussion: - we could tweak inference so that it takes `dynamic` as a bound for all type variables whose containing type has a dynamic bound, -but it's hard to be sure it's worth the while \ No newline at end of file +but it's hard to be sure it's worth the while + +## Notes + +- dynamic types are not supported on the JVM back-end