Allow to use dynamic types for JS projects in IDEA.

compiler/frontend/src/org/jetbrains/jet/di/InjectorForLazyBodyResolve.java

@@ -22,6 +22,7 @@ import org.jetbrains.jet.storage.StorageManager;
 import org.jetbrains.jet.lang.resolve.lazy.KotlinCodeAnalyzer;
 import org.jetbrains.jet.lang.resolve.BindingTrace;
 import org.jetbrains.jet.lang.resolve.AdditionalCheckerProvider;
+import org.jetbrains.jet.lang.types.DynamicTypesSettings;
 import org.jetbrains.jet.lang.descriptors.ModuleDescriptor;
 import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
 import org.jetbrains.jet.lang.PlatformToKotlinClassMap;
@@ -33,7 +34,6 @@ import org.jetbrains.jet.lang.resolve.calls.ArgumentTypeResolver;
 import org.jetbrains.jet.lang.types.expressions.ExpressionTypingServices;
 import org.jetbrains.jet.lang.types.expressions.ExpressionTypingComponents;
 import org.jetbrains.jet.lang.types.expressions.ControlStructureTypingUtils;
-import org.jetbrains.jet.lang.types.DynamicTypesSettings;
 import org.jetbrains.jet.lang.types.expressions.ExpressionTypingUtils;
 import org.jetbrains.jet.lang.types.expressions.ForLoopConventionsChecker;
 import org.jetbrains.jet.lang.reflect.ReflectionTypes;
@@ -77,6 +77,7 @@ public class InjectorForLazyBodyResolve {
     private final KotlinCodeAnalyzer analyzer;
     private final BindingTrace bindingTrace;
     private final AdditionalCheckerProvider additionalCheckerProvider;
+    private final DynamicTypesSettings dynamicTypesSettings;
     private final ModuleDescriptor moduleDescriptor;
     private final KotlinBuiltIns kotlinBuiltIns;
     private final PlatformToKotlinClassMap platformToKotlinClassMap;
@@ -88,7 +89,6 @@ public class InjectorForLazyBodyResolve {
     private final ExpressionTypingServices expressionTypingServices;
     private final ExpressionTypingComponents expressionTypingComponents;
     private final ControlStructureTypingUtils controlStructureTypingUtils;
-    private final DynamicTypesSettings dynamicTypesSettings;
     private final ExpressionTypingUtils expressionTypingUtils;
     private final ForLoopConventionsChecker forLoopConventionsChecker;
     private final ReflectionTypes reflectionTypes;
@@ -125,7 +125,8 @@ public class InjectorForLazyBodyResolve {
         @NotNull GlobalContext globalContext,
         @NotNull KotlinCodeAnalyzer analyzer,
         @NotNull BindingTrace bindingTrace,
-        @NotNull AdditionalCheckerProvider additionalCheckerProvider
+        @NotNull AdditionalCheckerProvider additionalCheckerProvider,
+        @NotNull DynamicTypesSettings dynamicTypesSettings
     ) {
         this.project = project;
         this.globalContext = globalContext;
@@ -133,6 +134,7 @@ public class InjectorForLazyBodyResolve {
         this.analyzer = analyzer;
         this.bindingTrace = bindingTrace;
         this.additionalCheckerProvider = additionalCheckerProvider;
+        this.dynamicTypesSettings = dynamicTypesSettings;
         this.moduleDescriptor = analyzer.getModuleDescriptor();
         this.kotlinBuiltIns = moduleDescriptor.getBuiltIns();
         this.platformToKotlinClassMap = moduleDescriptor.getPlatformToKotlinClassMap();
@@ -144,7 +146,6 @@ public class InjectorForLazyBodyResolve {
         this.expressionTypingComponents = new ExpressionTypingComponents();
         this.expressionTypingServices = new ExpressionTypingServices(expressionTypingComponents);
         this.controlStructureTypingUtils = new ControlStructureTypingUtils(expressionTypingServices);
-        this.dynamicTypesSettings = new DynamicTypesSettings();
         this.expressionTypingUtils = new ExpressionTypingUtils(expressionTypingServices, callResolver, kotlinBuiltIns);
         this.forLoopConventionsChecker = new ForLoopConventionsChecker();
         this.reflectionTypes = new ReflectionTypes(moduleDescriptor);

compiler/frontend/src/org/jetbrains/jet/di/InjectorForLazyResolve.java

@@ -25,6 +25,7 @@ import org.jetbrains.jet.lang.PlatformToKotlinClassMap;
 import org.jetbrains.jet.lang.resolve.lazy.declarations.DeclarationProviderFactory;
 import org.jetbrains.jet.lang.resolve.BindingTrace;
 import org.jetbrains.jet.lang.resolve.AdditionalCheckerProvider;
+import org.jetbrains.jet.lang.types.DynamicTypesSettings;
 import org.jetbrains.jet.lang.resolve.lazy.ResolveSession;
 import org.jetbrains.jet.context.LazyResolveToken;
 import org.jetbrains.jet.lang.resolve.AnnotationResolver;
@@ -33,7 +34,6 @@ import org.jetbrains.jet.lang.resolve.calls.ArgumentTypeResolver;
 import org.jetbrains.jet.lang.types.expressions.ExpressionTypingServices;
 import org.jetbrains.jet.lang.types.expressions.ExpressionTypingComponents;
 import org.jetbrains.jet.lang.types.expressions.ControlStructureTypingUtils;
-import org.jetbrains.jet.lang.types.DynamicTypesSettings;
 import org.jetbrains.jet.lang.types.expressions.ExpressionTypingUtils;
 import org.jetbrains.jet.lang.types.expressions.ForLoopConventionsChecker;
 import org.jetbrains.jet.lang.reflect.ReflectionTypes;
@@ -68,6 +68,7 @@ public class InjectorForLazyResolve {
     private final DeclarationProviderFactory declarationProviderFactory;
     private final BindingTrace bindingTrace;
     private final AdditionalCheckerProvider additionalCheckerProvider;
+    private final DynamicTypesSettings dynamicTypesSettings;
     private final ResolveSession resolveSession;
     private final LazyResolveToken lazyResolveToken;
     private final AnnotationResolver annotationResolver;
@@ -76,7 +77,6 @@ public class InjectorForLazyResolve {
     private final ExpressionTypingServices expressionTypingServices;
     private final ExpressionTypingComponents expressionTypingComponents;
     private final ControlStructureTypingUtils controlStructureTypingUtils;
-    private final DynamicTypesSettings dynamicTypesSettings;
     private final ExpressionTypingUtils expressionTypingUtils;
     private final ForLoopConventionsChecker forLoopConventionsChecker;
     private final ReflectionTypes reflectionTypes;
@@ -102,7 +102,8 @@ public class InjectorForLazyResolve {
         @NotNull ModuleDescriptorImpl moduleDescriptor,
         @NotNull DeclarationProviderFactory declarationProviderFactory,
         @NotNull BindingTrace bindingTrace,
-        @NotNull AdditionalCheckerProvider additionalCheckerProvider
+        @NotNull AdditionalCheckerProvider additionalCheckerProvider,
+        @NotNull DynamicTypesSettings dynamicTypesSettings
     ) {
         this.project = project;
         this.globalContext = globalContext;
@@ -113,6 +114,7 @@ public class InjectorForLazyResolve {
         this.declarationProviderFactory = declarationProviderFactory;
         this.bindingTrace = bindingTrace;
         this.additionalCheckerProvider = additionalCheckerProvider;
+        this.dynamicTypesSettings = dynamicTypesSettings;
         this.resolveSession = new ResolveSession(project, globalContext, moduleDescriptor, declarationProviderFactory, bindingTrace);
         this.lazyResolveToken = new LazyResolveToken();
         this.annotationResolver = new AnnotationResolver();
@@ -121,7 +123,6 @@ public class InjectorForLazyResolve {
         this.expressionTypingComponents = new ExpressionTypingComponents();
         this.expressionTypingServices = new ExpressionTypingServices(expressionTypingComponents);
         this.controlStructureTypingUtils = new ControlStructureTypingUtils(expressionTypingServices);
-        this.dynamicTypesSettings = new DynamicTypesSettings();
         this.expressionTypingUtils = new ExpressionTypingUtils(expressionTypingServices, callResolver, kotlinBuiltIns);
         this.forLoopConventionsChecker = new ForLoopConventionsChecker();
         this.reflectionTypes = new ReflectionTypes(moduleDescriptor);

compiler/tests/org/jetbrains/jet/renderer/AbstractDescriptorRendererTest.kt

@@ -49,6 +49,7 @@ import org.jetbrains.jet.lang.psi.JetClassInitializer
 import org.jetbrains.jet.lang.resolve.lazy.KotlinTestWithEnvironment
 import com.intellij.openapi.util.io.FileUtil
 import org.jetbrains.jet.lang.psi.JetPsiFactory
+import org.jetbrains.jet.lang.types.DynamicTypesSettings
 
 public abstract class AbstractDescriptorRendererTest : KotlinTestWithEnvironment() {
     protected open fun getDescriptor(declaration: JetDeclaration, resolveSession: ResolveSession): DeclarationDescriptor {
@@ -66,7 +67,7 @@ public abstract class AbstractDescriptorRendererTest : KotlinTestWithEnvironment
                 getProject(), globalContext, lazyModule,
                 FileBasedDeclarationProviderFactory(globalContext.storageManager, listOf(psiFile)),
                 CliLightClassGenerationSupport.NoScopeRecordCliBindingTrace(),
-                JavaDeclarationCheckerProvider).getResolveSession()
+                JavaDeclarationCheckerProvider, DynamicTypesSettings()).getResolveSession()
 
         lazyModule.initialize(resolveSession.getPackageFragmentProvider())
 

generators/src/org/jetbrains/jet/generators/injectors/GenerateInjectors.kt

@@ -113,6 +113,7 @@ private fun generatorForLazyBodyResolve() =
             parameter<KotlinCodeAnalyzer>(name = "analyzer")
             parameter<BindingTrace>()
             parameter<AdditionalCheckerProvider>()
+            parameter<DynamicTypesSettings>()
 
             field<ModuleDescriptor>(init = GivenExpression("analyzer.getModuleDescriptor()"), useAsContext = true)
 
@@ -253,6 +254,7 @@ private fun generatorForLazyResolve() =
             parameter<DeclarationProviderFactory>()
             parameter<BindingTrace>()
             parameter<AdditionalCheckerProvider>()
+            parameter<DynamicTypesSettings>()
 
             publicField<ResolveSession>()
 

idea/idea-analysis/src/org/jetbrains/jet/plugin/caches/resolve/JsAnalyzerFacade.kt

@@ -32,6 +32,7 @@ import org.jetbrains.jet.lang.descriptors.impl.ModuleDescriptorImpl
 import org.jetbrains.jet.analyzer.ModuleInfo
 import org.jetbrains.jet.analyzer.ModuleContent
 import org.jetbrains.k2js.resolve.KotlinJsDeclarationCheckerProvider
+import org.jetbrains.jet.lang.types.DynamicTypesAllowed
 
 public class JsResolverForModule(
         override val lazyResolveSession: ResolveSession
@@ -53,7 +54,8 @@ public object JsAnalyzerFacade : AnalyzerFacade<JsResolverForModule, PlatformAna
                 project, globalContext.storageManager, syntheticFiles, moduleContentScope
         )
 
-        val injector = InjectorForLazyResolve(project, globalContext, moduleDescriptor, declarationProviderFactory, BindingTraceContext(), KotlinJsDeclarationCheckerProvider)
+        val injector = InjectorForLazyResolve(project, globalContext, moduleDescriptor, declarationProviderFactory, BindingTraceContext(),
+                                              KotlinJsDeclarationCheckerProvider, DynamicTypesAllowed())
         val resolveSession = injector.getResolveSession()!!
         moduleDescriptor.initialize(resolveSession.getPackageFragmentProvider())
         return JsResolverForModule(resolveSession)

idea/idea-analysis/src/org/jetbrains/jet/plugin/caches/resolve/KotlinResolveCache.kt

@@ -239,12 +239,14 @@ private object KotlinResolveDataProvider {
 
             val trace = DelegatingBindingTrace(resolveSession.getBindingContext(), "Trace for resolution of " + analyzableElement)
 
+            val targetPlatform = TargetPlatformDetector.getPlatform(analyzableElement.getContainingJetFile())
             val lazyTopDownAnalyzer = InjectorForLazyBodyResolve(
                     project,
                     SimpleGlobalContext(resolveSession.getStorageManager(), resolveSession.getExceptionTracker()),
                     resolveSession,
                     trace,
-                    TargetPlatformDetector.getPlatform(analyzableElement.getContainingJetFile()).getAdditionalCheckerProvider()
+                    targetPlatform.getAdditionalCheckerProvider(),
+                    targetPlatform.getDynamicTypesSettings()
             ).getLazyTopDownAnalyzer()!!
 
             lazyTopDownAnalyzer.analyzeDeclarations(

idea/idea-analysis/src/org/jetbrains/jet/plugin/decompiler/navigation/JetSourceNavigationHelper.java

@@ -49,8 +49,8 @@ import org.jetbrains.jet.lang.psi.*;
 import org.jetbrains.jet.lang.resolve.AdditionalCheckerProvider;
 import org.jetbrains.jet.lang.resolve.BindingTraceContext;
 import org.jetbrains.jet.lang.resolve.DescriptorUtils;
-import org.jetbrains.jet.lang.resolve.java.TopDownAnalyzerFacadeForJVM;
 import org.jetbrains.jet.lang.resolve.java.JvmClassName;
+import org.jetbrains.jet.lang.resolve.java.TopDownAnalyzerFacadeForJVM;
 import org.jetbrains.jet.lang.resolve.java.mapping.KotlinToJavaTypesMap;
 import org.jetbrains.jet.lang.resolve.lazy.KotlinCodeAnalyzer;
 import org.jetbrains.jet.lang.resolve.lazy.ResolveSession;
@@ -58,6 +58,7 @@ import org.jetbrains.jet.lang.resolve.lazy.declarations.FileBasedDeclarationProv
 import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.lang.resolve.name.FqNameUnsafe;
 import org.jetbrains.jet.lang.resolve.name.Name;
+import org.jetbrains.jet.lang.types.DynamicTypesSettings;
 import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
 import org.jetbrains.jet.lexer.JetTokens;
 import org.jetbrains.jet.plugin.stubindex.JetFullClassNameIndex;
@@ -259,7 +260,8 @@ public class JetSourceNavigationHelper {
                 moduleDescriptor,
                 providerFactory,
                 new BindingTraceContext(),
-                AdditionalCheckerProvider.Empty.INSTANCE$).getResolveSession();
+                AdditionalCheckerProvider.Empty.INSTANCE$,
+                new DynamicTypesSettings()).getResolveSession();
 
         moduleDescriptor.initialize(resolveSession.getPackageFragmentProvider());
         return resolveSession;

idea/idea-analysis/src/org/jetbrains/jet/plugin/project/TargetPlatform.java

@@ -19,12 +19,17 @@ package org.jetbrains.jet.plugin.project;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.resolve.AdditionalCheckerProvider;
 import org.jetbrains.jet.lang.resolve.kotlin.JavaDeclarationCheckerProvider;
+import org.jetbrains.jet.lang.types.DynamicTypesAllowed;
+import org.jetbrains.jet.lang.types.DynamicTypesSettings;
 import org.jetbrains.k2js.resolve.KotlinJsDeclarationCheckerProvider;
 
 public interface TargetPlatform {
     @NotNull
     AdditionalCheckerProvider getAdditionalCheckerProvider();
 
-    TargetPlatform JVM = new TargetPlatformImpl("JVM", JavaDeclarationCheckerProvider.INSTANCE$);
+    @NotNull
-    TargetPlatform JS = new TargetPlatformImpl("JS", KotlinJsDeclarationCheckerProvider.INSTANCE$);
+    DynamicTypesSettings getDynamicTypesSettings();
+
+    TargetPlatform JVM = new TargetPlatformImpl("JVM", JavaDeclarationCheckerProvider.INSTANCE$, new DynamicTypesSettings());
+    TargetPlatform JS = new TargetPlatformImpl("JS", KotlinJsDeclarationCheckerProvider.INSTANCE$, new DynamicTypesAllowed());
 }

idea/idea-analysis/src/org/jetbrains/jet/plugin/project/TargetPlatformImpl.java

@@ -18,18 +18,21 @@ package org.jetbrains.jet.plugin.project;
 
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.resolve.AdditionalCheckerProvider;
+import org.jetbrains.jet.lang.types.DynamicTypesSettings;
 
 public class TargetPlatformImpl implements TargetPlatform {
     @NotNull private final String platformName;
     @NotNull private final AdditionalCheckerProvider additionalCheckerProvider;
+    @NotNull private final DynamicTypesSettings dynamicTypesSettings;
 
-    public TargetPlatformImpl(@NotNull String platformName) {
+    public TargetPlatformImpl(
-        this(platformName, AdditionalCheckerProvider.Empty.INSTANCE$);
+            @NotNull String platformName,
-    }
+            @NotNull AdditionalCheckerProvider additionalCheckerProvider,
-
+            @NotNull DynamicTypesSettings dynamicTypesSettings
-    public TargetPlatformImpl(@NotNull String platformName, @NotNull AdditionalCheckerProvider additionalCheckerProvider) {
+    ) {
-        this.additionalCheckerProvider = additionalCheckerProvider;
         this.platformName = platformName;
+        this.additionalCheckerProvider = additionalCheckerProvider;
+        this.dynamicTypesSettings = dynamicTypesSettings;
     }
 
     @NotNull
@@ -38,6 +41,12 @@ public class TargetPlatformImpl implements TargetPlatform {
         return additionalCheckerProvider;
     }
 
+    @NotNull
+    @Override
+    public DynamicTypesSettings getDynamicTypesSettings() {
+        return dynamicTypesSettings;
+    }
+
     @Override
     public String toString() {
         return platformName;

idea/testData/checker/js/dynamic.kt

@@ -0,0 +1,12 @@
+fun test(d: dynamic): dynamic {
+    val d1: dynamic = ""
+    var d2: dynamic = null
+
+    d2.foo(1)
+    d2[2]
+    d2.get(3)
+    d2.get(4)
+
+    d2 = d + d1 + 2
+    return d2
+}

idea/tests/org/jetbrains/jet/checkers/JetJsCheckerTestGenerated.java

@@ -42,6 +42,12 @@ public class JetJsCheckerTestGenerated extends AbstractJetJsCheckerTest {
         doTest(fileName);
     }
 
+    @TestMetadata("dynamic.kt")
+    public void testDynamic() throws Exception {
+        String fileName = JetTestUtils.navigationMetadata("idea/testData/checker/js/dynamic.kt");
+        doTest(fileName);
+    }
+
     @TestMetadata("helloWorld.kt")
     public void testHelloWorld() throws Exception {
         String fileName = JetTestUtils.navigationMetadata("idea/testData/checker/js/helloWorld.kt");