From 73114d7e9c66c0384ff608b4f5ac0d79b7fb735d Mon Sep 17 00:00:00 2001 From: Evgeny Gerashchenko Date: Thu, 28 Nov 2013 18:23:01 +0400 Subject: [PATCH] Fragment providers added on higher level. --- .../jet/cli/jvm/repl/ReplInterpreter.java | 6 +- ...InjectorForJavaDescriptorResolverUtil.java | 30 ++++++++ .../di/InjectorForTopDownAnalyzerForJvm.java | 68 ++++++++++--------- .../resolve/java/AnalyzerFacadeForJVM.java | 7 +- .../jet/lang/resolve/lazy/ResolveSession.java | 4 -- .../AbstractDescriptorSerializationTest.java | 3 +- .../jvm/compiler/AbstractLoadJavaTest.java | 7 +- .../compiler/JdkAnnotationsValidityTest.java | 4 +- .../jet/jvm/compiler/LoadDescriptorUtil.java | 3 +- ...solveDescriptorsFromExternalLibraries.java | 3 +- ...ractLazyResolveDescriptorRendererTest.java | 6 +- .../resolve/lazy/LazyResolveTestUtil.java | 9 ++- .../resolve/JetExpectedResolveDataUtil.java | 3 +- .../jet/types/JetTypeCheckerTest.java | 3 +- .../resolver/JavaPackageFragmentProvider.java | 2 - .../descriptors/ModuleDescriptorImpl.java | 6 ++ .../injectors/GenerateInjectors.java | 1 + .../resolve/KotlinLightClassContextCache.kt | 3 +- .../KotlinSignatureAnnotationIntention.java | 3 +- .../KotlinSignatureInJavaMarkerProvider.java | 3 +- .../libraries/DecompiledDataFactory.java | 3 +- .../libraries/JetSourceNavigationHelper.java | 3 + .../SignatureMarkerProviderTest.java | 3 +- .../k2js/analyze/AnalyzerFacadeForJS.java | 4 +- 24 files changed, 122 insertions(+), 65 deletions(-) create mode 100644 compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaDescriptorResolverUtil.java diff --git a/compiler/cli/src/org/jetbrains/jet/cli/jvm/repl/ReplInterpreter.java b/compiler/cli/src/org/jetbrains/jet/cli/jvm/repl/ReplInterpreter.java index 8e0ee8f0e71..4fd9d26ce10 100644 --- a/compiler/cli/src/org/jetbrains/jet/cli/jvm/repl/ReplInterpreter.java +++ b/compiler/cli/src/org/jetbrains/jet/cli/jvm/repl/ReplInterpreter.java @@ -103,6 +103,9 @@ public class ReplInterpreter { true, Collections.emptyList()); injector = new InjectorForTopDownAnalyzerForJvm(project, topDownAnalysisParameters, trace, module); + module.addFragmentProvider(injector.getTopDownAnalyzer().getPackageFragmentProvider()); + module.addFragmentProvider(KotlinBuiltIns.getInstance().getBuiltInsModule().getPackageFragmentProvider()); + module.addFragmentProvider(injector.getJavaPackageFragmentProvider()); List classpath = Lists.newArrayList(); @@ -285,9 +288,6 @@ public class ReplInterpreter { scope.changeLockLevel(WritableScope.LockLevel.BOTH); - module.addFragmentProvider(injector.getTopDownAnalyzer().getPackageFragmentProvider()); - module.addFragmentProvider(KotlinBuiltIns.getInstance().getBuiltInsModule().getPackageFragmentProvider()); - // Import a scope that contains all top-level namespaces that come from dependencies // This makes the namespaces visible at all, does not import themselves scope.importScope(module.getPackage(FqName.ROOT).getMemberScope()); diff --git a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaDescriptorResolverUtil.java b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaDescriptorResolverUtil.java new file mode 100644 index 00000000000..f864ba86f3d --- /dev/null +++ b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaDescriptorResolverUtil.java @@ -0,0 +1,30 @@ +/* + * Copyright 2010-2013 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.di; + +import com.intellij.openapi.project.Project; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.jet.lang.resolve.BindingTrace; + +public class InjectorForJavaDescriptorResolverUtil { + @NotNull + public static InjectorForJavaDescriptorResolver create(@NotNull Project project, @NotNull BindingTrace bindingTrace) { + InjectorForJavaDescriptorResolver injector = new InjectorForJavaDescriptorResolver(project, bindingTrace); + injector.getModule().addFragmentProvider(injector.getJavaDescriptorResolver().getPackageFragmentProvider()); + return injector; + } +} 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 9718897bc13..ee2b4f29690 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java @@ -38,6 +38,7 @@ import org.jetbrains.jet.lang.resolve.java.resolver.PsiBasedExternalAnnotationRe import org.jetbrains.jet.lang.resolve.kotlin.VirtualFileKotlinClassFinder; import org.jetbrains.jet.lang.resolve.MutablePackageFragmentProvider; import org.jetbrains.jet.lang.resolve.NamespaceFactoryImpl; +import org.jetbrains.jet.lang.resolve.java.resolver.JavaPackageFragmentProvider; import org.jetbrains.jet.lang.resolve.kotlin.VirtualFileFinder; import org.jetbrains.jet.lang.resolve.DeclarationResolver; import org.jetbrains.jet.lang.resolve.AnnotationResolver; @@ -63,12 +64,11 @@ import org.jetbrains.jet.lang.resolve.java.resolver.JavaAnnotationArgumentResolv import org.jetbrains.jet.lang.resolve.java.resolver.JavaTypeTransformer; import org.jetbrains.jet.lang.resolve.kotlin.DeserializedDescriptorResolver; import org.jetbrains.jet.lang.resolve.kotlin.AnnotationDescriptorDeserializer; -import org.jetbrains.jet.lang.resolve.java.resolver.JavaPackageFragmentProvider; -import org.jetbrains.jet.lang.resolve.java.resolver.JavaMemberResolver; -import org.jetbrains.jet.lang.resolve.java.resolver.JavaConstructorResolver; -import org.jetbrains.jet.lang.resolve.java.resolver.JavaValueParameterResolver; import org.jetbrains.jet.lang.resolve.java.resolver.JavaFunctionResolver; import org.jetbrains.jet.lang.resolve.java.resolver.JavaTypeParameterResolver; +import org.jetbrains.jet.lang.resolve.java.resolver.JavaValueParameterResolver; +import org.jetbrains.jet.lang.resolve.java.resolver.JavaMemberResolver; +import org.jetbrains.jet.lang.resolve.java.resolver.JavaConstructorResolver; import org.jetbrains.jet.lang.resolve.java.resolver.JavaPropertyResolver; import org.jetbrains.jet.lang.resolve.java.resolver.JavaSupertypeResolver; import org.jetbrains.annotations.NotNull; @@ -99,6 +99,7 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly private final VirtualFileKotlinClassFinder virtualFileKotlinClassFinder; private final MutablePackageFragmentProvider mutablePackageFragmentProvider; private final NamespaceFactoryImpl namespaceFactory; + private final JavaPackageFragmentProvider javaPackageFragmentProvider; private final VirtualFileFinder virtualFileFinder; private final DeclarationResolver declarationResolver; private final AnnotationResolver annotationResolver; @@ -124,12 +125,11 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly private final JavaTypeTransformer javaTypeTransformer; private final DeserializedDescriptorResolver deserializedDescriptorResolver; private final AnnotationDescriptorDeserializer annotationDescriptorDeserializer; - private final JavaPackageFragmentProvider javaPackageFragmentProvider; - private final JavaMemberResolver javaMemberResolver; - private final JavaConstructorResolver javaConstructorResolver; - private final JavaValueParameterResolver javaValueParameterResolver; private final JavaFunctionResolver javaFunctionResolver; private final JavaTypeParameterResolver javaTypeParameterResolver; + private final JavaValueParameterResolver javaValueParameterResolver; + private final JavaMemberResolver javaMemberResolver; + private final JavaConstructorResolver javaConstructorResolver; private final JavaPropertyResolver javaPropertyResolver; private final JavaSupertypeResolver javaSupertypeResolver; @@ -161,6 +161,7 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly this.virtualFileKotlinClassFinder = new VirtualFileKotlinClassFinder(); this.mutablePackageFragmentProvider = new MutablePackageFragmentProvider(getModuleDescriptor()); this.namespaceFactory = new NamespaceFactoryImpl(); + this.javaPackageFragmentProvider = new JavaPackageFragmentProvider(); this.virtualFileFinder = com.intellij.openapi.components.ServiceManager.getService(project, VirtualFileFinder.class); this.declarationResolver = new DeclarationResolver(); this.annotationResolver = new AnnotationResolver(); @@ -186,12 +187,11 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly this.javaTypeTransformer = new JavaTypeTransformer(); this.deserializedDescriptorResolver = new DeserializedDescriptorResolver(); this.annotationDescriptorDeserializer = new AnnotationDescriptorDeserializer(); - this.javaPackageFragmentProvider = new JavaPackageFragmentProvider(); - this.javaMemberResolver = new JavaMemberResolver(); - this.javaConstructorResolver = new JavaConstructorResolver(); - this.javaValueParameterResolver = new JavaValueParameterResolver(); this.javaFunctionResolver = new JavaFunctionResolver(); this.javaTypeParameterResolver = new JavaTypeParameterResolver(); + this.javaValueParameterResolver = new JavaValueParameterResolver(); + this.javaMemberResolver = new JavaMemberResolver(); + this.javaConstructorResolver = new JavaConstructorResolver(); this.javaPropertyResolver = new JavaPropertyResolver(); this.javaSupertypeResolver = new JavaSupertypeResolver(); @@ -251,6 +251,13 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly namespaceFactory.setPackageFragmentProvider(mutablePackageFragmentProvider); namespaceFactory.setTrace(bindingTrace); + this.javaPackageFragmentProvider.setCache(traceBasedJavaResolverCache); + this.javaPackageFragmentProvider.setDeserializedDescriptorResolver(deserializedDescriptorResolver); + this.javaPackageFragmentProvider.setJavaClassFinder(javaClassFinder); + this.javaPackageFragmentProvider.setKotlinClassFinder(virtualFileKotlinClassFinder); + this.javaPackageFragmentProvider.setMemberResolver(javaMemberResolver); + this.javaPackageFragmentProvider.setModule(moduleDescriptor); + declarationResolver.setAnnotationResolver(annotationResolver); declarationResolver.setContext(topDownAnalysisContext); declarationResolver.setDescriptorResolver(descriptorResolver); @@ -352,26 +359,6 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly annotationDescriptorDeserializer.setJavaClassResolver(javaClassResolver); annotationDescriptorDeserializer.setKotlinClassFinder(virtualFileKotlinClassFinder); - javaPackageFragmentProvider.setCache(traceBasedJavaResolverCache); - javaPackageFragmentProvider.setDeserializedDescriptorResolver(deserializedDescriptorResolver); - javaPackageFragmentProvider.setJavaClassFinder(javaClassFinder); - javaPackageFragmentProvider.setKotlinClassFinder(virtualFileKotlinClassFinder); - javaPackageFragmentProvider.setMemberResolver(javaMemberResolver); - javaPackageFragmentProvider.setModule(moduleDescriptor); - - javaMemberResolver.setClassResolver(javaClassResolver); - javaMemberResolver.setConstructorResolver(javaConstructorResolver); - javaMemberResolver.setFunctionResolver(javaFunctionResolver); - javaMemberResolver.setPropertyResolver(javaPropertyResolver); - - javaConstructorResolver.setCache(traceBasedJavaResolverCache); - javaConstructorResolver.setExternalSignatureResolver(traceBasedExternalSignatureResolver); - javaConstructorResolver.setTypeTransformer(javaTypeTransformer); - javaConstructorResolver.setValueParameterResolver(javaValueParameterResolver); - - javaValueParameterResolver.setAnnotationResolver(javaAnnotationResolver); - javaValueParameterResolver.setTypeTransformer(javaTypeTransformer); - javaFunctionResolver.setAnnotationResolver(javaAnnotationResolver); javaFunctionResolver.setCache(traceBasedJavaResolverCache); javaFunctionResolver.setErrorReporter(traceBasedErrorReporter); @@ -383,6 +370,19 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly javaTypeParameterResolver.setTypeTransformer(javaTypeTransformer); + javaValueParameterResolver.setAnnotationResolver(javaAnnotationResolver); + javaValueParameterResolver.setTypeTransformer(javaTypeTransformer); + + javaMemberResolver.setClassResolver(javaClassResolver); + javaMemberResolver.setConstructorResolver(javaConstructorResolver); + javaMemberResolver.setFunctionResolver(javaFunctionResolver); + javaMemberResolver.setPropertyResolver(javaPropertyResolver); + + javaConstructorResolver.setCache(traceBasedJavaResolverCache); + javaConstructorResolver.setExternalSignatureResolver(traceBasedExternalSignatureResolver); + javaConstructorResolver.setTypeTransformer(javaTypeTransformer); + javaConstructorResolver.setValueParameterResolver(javaValueParameterResolver); + javaPropertyResolver.setAnnotationResolver(javaAnnotationResolver); javaPropertyResolver.setCache(traceBasedJavaResolverCache); javaPropertyResolver.setErrorReporter(traceBasedErrorReporter); @@ -440,4 +440,8 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly return this.moduleDescriptor; } + public JavaPackageFragmentProvider getJavaPackageFragmentProvider() { + return this.javaPackageFragmentProvider; + } + } diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/AnalyzerFacadeForJVM.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/AnalyzerFacadeForJVM.java index dd90d0ee96e..53aad298b15 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/AnalyzerFacadeForJVM.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/AnalyzerFacadeForJVM.java @@ -26,6 +26,7 @@ import org.jetbrains.jet.analyzer.AnalyzeExhaust; import org.jetbrains.jet.analyzer.AnalyzerFacade; import org.jetbrains.jet.analyzer.AnalyzerFacadeForEverything; import org.jetbrains.jet.di.InjectorForJavaDescriptorResolver; +import org.jetbrains.jet.di.InjectorForJavaDescriptorResolverUtil; import org.jetbrains.jet.di.InjectorForTopDownAnalyzerForJvm; import org.jetbrains.jet.lang.descriptors.ModuleDescriptor; import org.jetbrains.jet.lang.descriptors.ModuleDescriptorImpl; @@ -83,7 +84,7 @@ public enum AnalyzerFacadeForJVM implements AnalyzerFacade { @Override public ResolveSession getLazyResolveSession(@NotNull Project fileProject, @NotNull Collection files) { BindingTraceContext javaResolverTrace = new BindingTraceContext(); - InjectorForJavaDescriptorResolver injector = new InjectorForJavaDescriptorResolver(fileProject, javaResolverTrace); + InjectorForJavaDescriptorResolver injector = InjectorForJavaDescriptorResolverUtil.create(fileProject, javaResolverTrace); return createLazyResolveSession(fileProject, files, javaResolverTrace, injector, true); } @@ -106,11 +107,8 @@ public enum AnalyzerFacadeForJVM implements AnalyzerFacade { } }); - JavaDescriptorResolver javaDescriptorResolver = injector.getJavaDescriptorResolver(); - ModuleDescriptorImpl module = injector.getModule(); - module.addFragmentProvider(javaDescriptorResolver.getPackageFragmentProvider()); if (addBuiltIns) { module.addFragmentProvider(KotlinBuiltIns.getInstance().getBuiltInsModule().getPackageFragmentProvider()); } @@ -198,6 +196,7 @@ public enum AnalyzerFacadeForJVM implements AnalyzerFacade { InjectorForTopDownAnalyzerForJvm injector = new InjectorForTopDownAnalyzerForJvm(project, topDownAnalysisParameters, trace, module); try { + module.addFragmentProvider(injector.getJavaPackageFragmentProvider()); injector.getTopDownAnalyzer().analyzeFiles(files, scriptParameters); BodiesResolveContext bodiesResolveContext = storeContextForBodiesResolve ? new CachedBodiesResolveContext(injector.getTopDownAnalysisContext()) : diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/ResolveSession.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/ResolveSession.java index b068aeb2892..51c8f8332fd 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/ResolveSession.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/ResolveSession.java @@ -120,8 +120,6 @@ public class ResolveSession implements KotlinCodeAnalyzer { this.trace = storageManager.createSafeTrace(delegationTrace); this.injector = new InjectorForLazyResolve(project, this, rootDescriptor); this.module = rootDescriptor; - PackageMemberDeclarationProvider provider = declarationProviderFactory.getPackageMemberDeclarationProvider(FqName.ROOT); - assert provider != null : "No declaration provider for root package in " + rootDescriptor; this.packages = storageManager.createMemoizedFunctionWithNullableValues(new MemoizedFunctionToNullable() { @Nullable @@ -133,8 +131,6 @@ public class ResolveSession implements KotlinCodeAnalyzer { this.declarationProviderFactory = declarationProviderFactory; - rootDescriptor.addFragmentProvider(KotlinBuiltIns.getInstance().getBuiltInsModule().getPackageFragmentProvider()); - this.packageFragmentProvider = new PackageFragmentProvider() { @NotNull @Override diff --git a/compiler/tests/org/jetbrains/jet/descriptors/serialization/AbstractDescriptorSerializationTest.java b/compiler/tests/org/jetbrains/jet/descriptors/serialization/AbstractDescriptorSerializationTest.java index 03088896a8c..313d4078ad2 100644 --- a/compiler/tests/org/jetbrains/jet/descriptors/serialization/AbstractDescriptorSerializationTest.java +++ b/compiler/tests/org/jetbrains/jet/descriptors/serialization/AbstractDescriptorSerializationTest.java @@ -23,6 +23,7 @@ import org.jetbrains.jet.ConfigurationKind; import org.jetbrains.jet.JetTestUtils; import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment; import org.jetbrains.jet.di.InjectorForJavaDescriptorResolver; +import org.jetbrains.jet.di.InjectorForJavaDescriptorResolverUtil; import org.jetbrains.jet.lang.descriptors.*; import org.jetbrains.jet.lang.descriptors.impl.MutablePackageFragmentDescriptor; import org.jetbrains.jet.lang.resolve.BindingTraceContext; @@ -64,7 +65,7 @@ public abstract class AbstractDescriptorSerializationTest extends KotlinTestWith PackageFragmentDescriptor testPackage = DescriptorUtils.getExactlyOnePackageFragment( moduleDescriptor, FqName.topLevel(TEST_PACKAGE_NAME)); - InjectorForJavaDescriptorResolver injector = new InjectorForJavaDescriptorResolver(getProject(), new BindingTraceContext()); + InjectorForJavaDescriptorResolver injector = InjectorForJavaDescriptorResolverUtil.create(getProject(), new BindingTraceContext()); JavaDescriptorResolver javaDescriptorResolver = injector.getJavaDescriptorResolver(); PackageFragmentDescriptor deserialized = serializeAndDeserialize(javaDescriptorResolver, testPackage); diff --git a/compiler/tests/org/jetbrains/jet/jvm/compiler/AbstractLoadJavaTest.java b/compiler/tests/org/jetbrains/jet/jvm/compiler/AbstractLoadJavaTest.java index 7b52277ef28..bb1a39e0908 100644 --- a/compiler/tests/org/jetbrains/jet/jvm/compiler/AbstractLoadJavaTest.java +++ b/compiler/tests/org/jetbrains/jet/jvm/compiler/AbstractLoadJavaTest.java @@ -144,17 +144,20 @@ public abstract class AbstractLoadJavaTest extends TestCaseWithTmpdir { // we need the same binding trace for resolve from Java and Kotlin CliLightClassGenerationSupport support = CliLightClassGenerationSupport.getInstanceForCli(environment.getProject()); BindingTrace trace = support.getTrace(); + ModuleDescriptorImpl module = support.getModule(); InjectorForTopDownAnalyzerForJvm injectorForAnalyzer = new InjectorForTopDownAnalyzerForJvm( environment.getProject(), new TopDownAnalysisParameters( Predicates.alwaysFalse(), false, false, Collections.emptyList()), trace, - support.getModule()); + module); + + module.addFragmentProvider(injectorForAnalyzer.getJavaPackageFragmentProvider()); injectorForAnalyzer.getTopDownAnalyzer().analyzeFiles(environment.getSourceFiles(), Collections.emptyList()); - PackageViewDescriptor packageView = support.getModule().getPackage(TEST_PACKAGE_FQNAME); + PackageViewDescriptor packageView = module.getPackage(TEST_PACKAGE_FQNAME); assert packageView != null : "Test namespace not found"; checkJavaPackage(expectedFile, packageView, trace.getBindingContext(), DONT_INCLUDE_METHODS_OF_OBJECT); diff --git a/compiler/tests/org/jetbrains/jet/jvm/compiler/JdkAnnotationsValidityTest.java b/compiler/tests/org/jetbrains/jet/jvm/compiler/JdkAnnotationsValidityTest.java index 42355eb878f..ec45e345fca 100644 --- a/compiler/tests/org/jetbrains/jet/jvm/compiler/JdkAnnotationsValidityTest.java +++ b/compiler/tests/org/jetbrains/jet/jvm/compiler/JdkAnnotationsValidityTest.java @@ -36,6 +36,7 @@ import org.jetbrains.jet.cli.jvm.JVMConfigurationKeys; import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment; import org.jetbrains.jet.config.CompilerConfiguration; import org.jetbrains.jet.di.InjectorForJavaDescriptorResolver; +import org.jetbrains.jet.di.InjectorForJavaDescriptorResolverUtil; import org.jetbrains.jet.lang.descriptors.*; import org.jetbrains.jet.lang.descriptors.impl.DeclarationDescriptorVisitorEmptyBodies; import org.jetbrains.jet.lang.resolve.BindingContext; @@ -95,7 +96,8 @@ public class JdkAnnotationsValidityTest extends UsefulTestCase { JetCoreEnvironment commonEnvironment = createEnvironment(parentDisposable); BindingTrace trace = new BindingTraceContext(); - InjectorForJavaDescriptorResolver injector = new InjectorForJavaDescriptorResolver(commonEnvironment.getProject(), trace); + InjectorForJavaDescriptorResolver injector = + InjectorForJavaDescriptorResolverUtil.create(commonEnvironment.getProject(), trace); BindingContext bindingContext = trace.getBindingContext(); JavaDescriptorResolver javaDescriptorResolver = injector.getJavaDescriptorResolver(); diff --git a/compiler/tests/org/jetbrains/jet/jvm/compiler/LoadDescriptorUtil.java b/compiler/tests/org/jetbrains/jet/jvm/compiler/LoadDescriptorUtil.java index 63dfc113bf1..d5ec2078326 100644 --- a/compiler/tests/org/jetbrains/jet/jvm/compiler/LoadDescriptorUtil.java +++ b/compiler/tests/org/jetbrains/jet/jvm/compiler/LoadDescriptorUtil.java @@ -31,6 +31,7 @@ import org.jetbrains.jet.codegen.GenerationUtils; import org.jetbrains.jet.codegen.state.GenerationState; import org.jetbrains.jet.config.CompilerConfiguration; import org.jetbrains.jet.di.InjectorForJavaDescriptorResolver; +import org.jetbrains.jet.di.InjectorForJavaDescriptorResolverUtil; import org.jetbrains.jet.lang.descriptors.PackageViewDescriptor; import org.jetbrains.jet.lang.psi.JetFile; import org.jetbrains.jet.lang.resolve.AnalyzerScriptParameter; @@ -85,7 +86,7 @@ public final class LoadDescriptorUtil { ); JetCoreEnvironment jetCoreEnvironment = JetCoreEnvironment.createForTests(disposable, configuration); BindingTraceContext trace = new BindingTraceContext(); - InjectorForJavaDescriptorResolver injector = new InjectorForJavaDescriptorResolver(jetCoreEnvironment.getProject(), trace); + InjectorForJavaDescriptorResolver injector = InjectorForJavaDescriptorResolverUtil.create(jetCoreEnvironment.getProject(), trace); PackageViewDescriptor packageView = injector.getModule().getPackage(TEST_PACKAGE_FQNAME); assert packageView != null; diff --git a/compiler/tests/org/jetbrains/jet/jvm/compiler/longTest/ResolveDescriptorsFromExternalLibraries.java b/compiler/tests/org/jetbrains/jet/jvm/compiler/longTest/ResolveDescriptorsFromExternalLibraries.java index 753757c7f12..e097f1602e9 100644 --- a/compiler/tests/org/jetbrains/jet/jvm/compiler/longTest/ResolveDescriptorsFromExternalLibraries.java +++ b/compiler/tests/org/jetbrains/jet/jvm/compiler/longTest/ResolveDescriptorsFromExternalLibraries.java @@ -33,6 +33,7 @@ import org.jetbrains.jet.TimeUtils; import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment; import org.jetbrains.jet.config.CompilerConfiguration; import org.jetbrains.jet.di.InjectorForJavaDescriptorResolver; +import org.jetbrains.jet.di.InjectorForJavaDescriptorResolverUtil; import org.jetbrains.jet.lang.descriptors.ClassDescriptor; import org.jetbrains.jet.lang.resolve.BindingTraceContext; import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver; @@ -157,7 +158,7 @@ public class ResolveDescriptorsFromExternalLibraries { } } - InjectorForJavaDescriptorResolver injector = new InjectorForJavaDescriptorResolver( + InjectorForJavaDescriptorResolver injector = InjectorForJavaDescriptorResolverUtil.create( jetCoreEnvironment.getProject(), new BindingTraceContext()); JavaDescriptorResolver javaDescriptorResolver = injector.getJavaDescriptorResolver(); diff --git a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveDescriptorRendererTest.java b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveDescriptorRendererTest.java index 1f41172496d..7682d431a43 100644 --- a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveDescriptorRendererTest.java +++ b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveDescriptorRendererTest.java @@ -25,13 +25,13 @@ import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.ConfigurationKind; import org.jetbrains.jet.JetTestUtils; import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment; -import org.jetbrains.jet.di.InjectorForTopDownAnalyzer; import org.jetbrains.jet.lang.descriptors.*; import org.jetbrains.jet.lang.psi.*; import org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM; import org.jetbrains.jet.lang.resolve.lazy.declarations.FileBasedDeclarationProviderFactory; import org.jetbrains.jet.lang.resolve.lazy.storage.LockBasedLazyResolveStorageManager; import org.jetbrains.jet.lang.resolve.name.FqName; +import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; import org.jetbrains.jet.renderer.DescriptorRenderer; import java.io.File; @@ -48,13 +48,11 @@ public abstract class AbstractLazyResolveDescriptorRendererTest extends KotlinTe } protected void doTest(@NotNull String testFile) throws IOException { - - InjectorForTopDownAnalyzer injectorForTopDownAnalyzer = LazyResolveTestUtil.getEagerInjectorForTopDownAnalyzer(getEnvironment()); - JetFile psiFile = JetPsiFactory.createFile(getProject(), FileUtil.loadFile(new File(testFile), true)); Collection files = Lists.newArrayList(psiFile); final ModuleDescriptorImpl lazyModule = AnalyzerFacadeForJVM.createJavaModule(""); + lazyModule.addFragmentProvider(KotlinBuiltIns.getInstance().getBuiltInsModule().getPackageFragmentProvider()); LockBasedLazyResolveStorageManager storageManager = new LockBasedLazyResolveStorageManager(); final ResolveSession resolveSession = new ResolveSession(getProject(), storageManager, lazyModule, new FileBasedDeclarationProviderFactory(storageManager, files)); diff --git a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveTestUtil.java b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveTestUtil.java index dda55155d1c..69548151360 100644 --- a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveTestUtil.java +++ b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveTestUtil.java @@ -25,6 +25,7 @@ import org.jetbrains.jet.JetTestUtils; import org.jetbrains.jet.cli.jvm.compiler.CliLightClassGenerationSupport; import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment; import org.jetbrains.jet.di.InjectorForJavaDescriptorResolver; +import org.jetbrains.jet.di.InjectorForJavaDescriptorResolverUtil; import org.jetbrains.jet.di.InjectorForTopDownAnalyzer; import org.jetbrains.jet.di.InjectorForTopDownAnalyzerForJvm; import org.jetbrains.jet.lang.descriptors.ModuleDescriptor; @@ -63,7 +64,11 @@ public class LazyResolveTestUtil { CliLightClassGenerationSupport support = CliLightClassGenerationSupport.getInstanceForCli(environment.getProject()); BindingTrace sharedTrace = support.getTrace(); ModuleDescriptorImpl sharedModule = support.getModule(); - return new InjectorForTopDownAnalyzerForJvm(environment.getProject(), params, sharedTrace, sharedModule); + + InjectorForTopDownAnalyzerForJvm injector = + new InjectorForTopDownAnalyzerForJvm(environment.getProject(), params, sharedTrace, sharedModule); + sharedModule.addFragmentProvider(injector.getJavaPackageFragmentProvider()); + return injector; } public static ModuleDescriptor resolveEagerly(List files, JetCoreEnvironment environment) { @@ -78,7 +83,7 @@ public class LazyResolveTestUtil { Project project = environment.getProject(); CliLightClassGenerationSupport support = CliLightClassGenerationSupport.getInstanceForCli(project); BindingTrace sharedTrace = support.getTrace(); - InjectorForJavaDescriptorResolver injector = new InjectorForJavaDescriptorResolver(project, sharedTrace); + InjectorForJavaDescriptorResolver injector = InjectorForJavaDescriptorResolverUtil.create(project, sharedTrace); support.setModule(injector.getModule()); return AnalyzerFacadeForJVM.createLazyResolveSession(project, files, sharedTrace, injector, addBuiltIns); diff --git a/compiler/tests/org/jetbrains/jet/resolve/JetExpectedResolveDataUtil.java b/compiler/tests/org/jetbrains/jet/resolve/JetExpectedResolveDataUtil.java index 50e4fcecea3..fa48218abd6 100644 --- a/compiler/tests/org/jetbrains/jet/resolve/JetExpectedResolveDataUtil.java +++ b/compiler/tests/org/jetbrains/jet/resolve/JetExpectedResolveDataUtil.java @@ -22,6 +22,7 @@ import junit.framework.Assert; import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.JetTestUtils; import org.jetbrains.jet.di.InjectorForJavaDescriptorResolver; +import org.jetbrains.jet.di.InjectorForJavaDescriptorResolverUtil; import org.jetbrains.jet.di.InjectorForTests; import org.jetbrains.jet.lang.descriptors.*; import org.jetbrains.jet.lang.resolve.BindingTraceContext; @@ -115,7 +116,7 @@ public class JetExpectedResolveDataUtil { @NotNull private static PsiClass findClass(String qualifiedName, Project project) { - InjectorForJavaDescriptorResolver injector = new InjectorForJavaDescriptorResolver(project, new BindingTraceContext()); + InjectorForJavaDescriptorResolver injector = InjectorForJavaDescriptorResolverUtil.create(project, new BindingTraceContext()); JavaClass javaClass = injector.getJavaClassFinder().findClass(new FqName(qualifiedName)); Assert.assertNotNull("Class wasn't found: " + qualifiedName, javaClass); assertInstanceOf(javaClass, JavaClassImpl.class); diff --git a/compiler/tests/org/jetbrains/jet/types/JetTypeCheckerTest.java b/compiler/tests/org/jetbrains/jet/types/JetTypeCheckerTest.java index 86b43bdedda..1b0e5738f04 100644 --- a/compiler/tests/org/jetbrains/jet/types/JetTypeCheckerTest.java +++ b/compiler/tests/org/jetbrains/jet/types/JetTypeCheckerTest.java @@ -26,6 +26,7 @@ import org.jetbrains.jet.JetTestCaseBuilder; import org.jetbrains.jet.JetTestUtils; import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment; import org.jetbrains.jet.di.InjectorForJavaDescriptorResolver; +import org.jetbrains.jet.di.InjectorForJavaDescriptorResolverUtil; import org.jetbrains.jet.di.InjectorForTests; import org.jetbrains.jet.lang.descriptors.ModuleDescriptor; import org.jetbrains.jet.lang.descriptors.PackageFragmentDescriptor; @@ -585,7 +586,7 @@ public class JetTypeCheckerTest extends JetLiteFixture { private WritableScopeImpl addImports(JetScope scope) { WritableScopeImpl writableScope = new WritableScopeImpl( scope, scope.getContainingDeclaration(), RedeclarationHandler.DO_NOTHING, "JetTypeCheckerTest.addImports"); - InjectorForJavaDescriptorResolver injector = new InjectorForJavaDescriptorResolver(getProject(), new BindingTraceContext()); + InjectorForJavaDescriptorResolver injector = InjectorForJavaDescriptorResolverUtil.create(getProject(), new BindingTraceContext()); JavaDescriptorResolver javaDescriptorResolver = injector.getJavaDescriptorResolver(); ModuleDescriptor module = javaDescriptorResolver.getPackageFragmentProvider().getModule(); for (ImportPath defaultImport : module.getDefaultImports()) { diff --git a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaPackageFragmentProvider.java b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaPackageFragmentProvider.java index b449ab6bfda..5a918f2e16a 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaPackageFragmentProvider.java +++ b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaPackageFragmentProvider.java @@ -86,8 +86,6 @@ public final class JavaPackageFragmentProvider implements PackageFragmentProvide @Inject public void setModule(ModuleDescriptor module) { this.module = module; - // TODO 1 hacky - ((ModuleDescriptorImpl) module).addFragmentProvider(this); } @NotNull diff --git a/core/descriptors/src/org/jetbrains/jet/lang/descriptors/ModuleDescriptorImpl.java b/core/descriptors/src/org/jetbrains/jet/lang/descriptors/ModuleDescriptorImpl.java index ebf7c51b148..3bf3793c211 100644 --- a/core/descriptors/src/org/jetbrains/jet/lang/descriptors/ModuleDescriptorImpl.java +++ b/core/descriptors/src/org/jetbrains/jet/lang/descriptors/ModuleDescriptorImpl.java @@ -17,6 +17,7 @@ package org.jetbrains.jet.lang.descriptors; import com.google.common.collect.Lists; +import com.intellij.openapi.diagnostic.Logger; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.lang.PlatformToKotlinClassMap; @@ -33,6 +34,8 @@ import java.util.Collections; import java.util.List; public class ModuleDescriptorImpl extends DeclarationDescriptorImpl implements ModuleDescriptor { + private static final Logger LOG = Logger.getInstance(ModuleDescriptorImpl.class); + private final List fragmentProviders = Lists.newArrayList(); private final CompositePackageFragmentProvider packageFragmentProvider = new CompositePackageFragmentProvider(fragmentProviders); private final List defaultImports; @@ -52,6 +55,9 @@ public class ModuleDescriptorImpl extends DeclarationDescriptorImpl implements M } public void addFragmentProvider(@NotNull PackageFragmentProvider provider) { + if (fragmentProviders.contains(provider)) { + LOG.error("Trying to add already present fragment provider: " + provider); + } fragmentProviders.add(provider); } diff --git a/generators/src/org/jetbrains/jet/generators/injectors/GenerateInjectors.java b/generators/src/org/jetbrains/jet/generators/injectors/GenerateInjectors.java index 75590ad31ba..fca25ef5df0 100644 --- a/generators/src/org/jetbrains/jet/generators/injectors/GenerateInjectors.java +++ b/generators/src/org/jetbrains/jet/generators/injectors/GenerateInjectors.java @@ -135,6 +135,7 @@ public class GenerateInjectors { generator.addField(VirtualFileKotlinClassFinder.class); generator.addField(MutablePackageFragmentProvider.class); generator.addField(NamespaceFactoryImpl.class); + generator.addPublicField(JavaPackageFragmentProvider.class); generator.addField(false, VirtualFileFinder.class, "virtualFileFinder", new GivenExpression( "com.intellij.openapi.components.ServiceManager.getService(project, VirtualFileFinder.class)")); diff --git a/idea/src/org/jetbrains/jet/plugin/caches/resolve/KotlinLightClassContextCache.kt b/idea/src/org/jetbrains/jet/plugin/caches/resolve/KotlinLightClassContextCache.kt index ad4bacdfe6a..43b7a4dbb49 100644 --- a/idea/src/org/jetbrains/jet/plugin/caches/resolve/KotlinLightClassContextCache.kt +++ b/idea/src/org/jetbrains/jet/plugin/caches/resolve/KotlinLightClassContextCache.kt @@ -40,6 +40,7 @@ import org.jetbrains.jet.lang.resolve.DelegatingBindingTrace import org.jetbrains.jet.di.InjectorForJavaDescriptorResolver import org.jetbrains.jet.lang.resolve.java.JetFilesProvider import com.intellij.psi.search.GlobalSearchScope +import org.jetbrains.jet.di.InjectorForJavaDescriptorResolverUtil class KotlinLightClassContextCache(val project: Project) { private val cacheKey = Key.create>("KOTLIN_LIGHT_CLASS_CONTEXT_CACHE") @@ -56,7 +57,7 @@ class KotlinLightClassContextCache(val project: Project) { project, JetFilesProvider.getInstance(project)!!.allInScope(GlobalSearchScope.allScope(project)), trace, - InjectorForJavaDescriptorResolver(project, trace), + InjectorForJavaDescriptorResolverUtil.create(project, trace), true ) return Result.create( diff --git a/idea/src/org/jetbrains/jet/plugin/ktSignature/KotlinSignatureAnnotationIntention.java b/idea/src/org/jetbrains/jet/plugin/ktSignature/KotlinSignatureAnnotationIntention.java index eae3a912580..52598dae78d 100644 --- a/idea/src/org/jetbrains/jet/plugin/ktSignature/KotlinSignatureAnnotationIntention.java +++ b/idea/src/org/jetbrains/jet/plugin/ktSignature/KotlinSignatureAnnotationIntention.java @@ -34,6 +34,7 @@ import com.intellij.util.messages.MessageBusConnection; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.di.InjectorForJavaDescriptorResolver; +import org.jetbrains.jet.di.InjectorForJavaDescriptorResolverUtil; import org.jetbrains.jet.lang.descriptors.*; import org.jetbrains.jet.lang.resolve.BindingContext; import org.jetbrains.jet.lang.resolve.BindingTraceContext; @@ -163,7 +164,7 @@ public class KotlinSignatureAnnotationIntention extends BaseIntentionAction impl @NotNull private static String getDefaultSignature(@NotNull Project project, @NotNull PsiMember psiMember) { BindingTraceContext trace = new BindingTraceContext(); - InjectorForJavaDescriptorResolver injector = new InjectorForJavaDescriptorResolver(project, trace); + InjectorForJavaDescriptorResolver injector = InjectorForJavaDescriptorResolverUtil.create(project, trace); JavaDescriptorResolver javaDescriptorResolver = injector.getJavaDescriptorResolver(); PsiClass containingClass = psiMember.getContainingClass(); diff --git a/idea/src/org/jetbrains/jet/plugin/ktSignature/KotlinSignatureInJavaMarkerProvider.java b/idea/src/org/jetbrains/jet/plugin/ktSignature/KotlinSignatureInJavaMarkerProvider.java index be640c13682..b4fb9fe1470 100644 --- a/idea/src/org/jetbrains/jet/plugin/ktSignature/KotlinSignatureInJavaMarkerProvider.java +++ b/idea/src/org/jetbrains/jet/plugin/ktSignature/KotlinSignatureInJavaMarkerProvider.java @@ -36,6 +36,7 @@ import com.intellij.util.ui.UIUtil; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.di.InjectorForJavaDescriptorResolver; +import org.jetbrains.jet.di.InjectorForJavaDescriptorResolverUtil; import org.jetbrains.jet.lang.descriptors.ClassDescriptor; import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor; import org.jetbrains.jet.lang.descriptors.PackageFragmentDescriptor; @@ -99,7 +100,7 @@ public class KotlinSignatureInJavaMarkerProvider implements LineMarkerProvider { } BindingTrace trace = createDelegatingTrace(project); - InjectorForJavaDescriptorResolver injector = new InjectorForJavaDescriptorResolver(project, trace); + InjectorForJavaDescriptorResolver injector = InjectorForJavaDescriptorResolverUtil.create(project, trace); JavaDescriptorResolver javaDescriptorResolver = injector.getJavaDescriptorResolver(); diff --git a/idea/src/org/jetbrains/jet/plugin/libraries/DecompiledDataFactory.java b/idea/src/org/jetbrains/jet/plugin/libraries/DecompiledDataFactory.java index bdc9817a56c..ee4e0e30fc0 100644 --- a/idea/src/org/jetbrains/jet/plugin/libraries/DecompiledDataFactory.java +++ b/idea/src/org/jetbrains/jet/plugin/libraries/DecompiledDataFactory.java @@ -22,6 +22,7 @@ import com.intellij.openapi.vfs.VirtualFile; import com.intellij.psi.PsiManager; import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.di.InjectorForJavaDescriptorResolver; +import org.jetbrains.jet.di.InjectorForJavaDescriptorResolverUtil; import org.jetbrains.jet.lang.descriptors.*; import org.jetbrains.jet.lang.psi.JetFile; import org.jetbrains.jet.lang.resolve.BindingTraceContext; @@ -63,7 +64,7 @@ public final class DecompiledDataFactory { private DecompiledDataFactory(@NotNull VirtualFile classFile, @NotNull Project project) { this.classFile = classFile; this.project = project; - InjectorForJavaDescriptorResolver injector = new InjectorForJavaDescriptorResolver(project, new BindingTraceContext()); + InjectorForJavaDescriptorResolver injector = InjectorForJavaDescriptorResolverUtil.create(project, new BindingTraceContext()); this.javaDescriptorResolver = injector.getJavaDescriptorResolver(); VirtualFileKotlinClass kotlinClass = new VirtualFileKotlinClass(classFile); diff --git a/idea/src/org/jetbrains/jet/plugin/libraries/JetSourceNavigationHelper.java b/idea/src/org/jetbrains/jet/plugin/libraries/JetSourceNavigationHelper.java index f129f5f8421..a44c7032306 100644 --- a/idea/src/org/jetbrains/jet/plugin/libraries/JetSourceNavigationHelper.java +++ b/idea/src/org/jetbrains/jet/plugin/libraries/JetSourceNavigationHelper.java @@ -224,6 +224,9 @@ public class JetSourceNavigationHelper { ModuleDescriptorImpl moduleDescriptor = new ModuleDescriptorImpl(Name.special(""), AnalyzerFacadeForJVM.DEFAULT_IMPORTS, PlatformToKotlinClassMap.EMPTY); + + moduleDescriptor.addFragmentProvider(KotlinBuiltIns.getInstance().getBuiltInsModule().getPackageFragmentProvider()); + KotlinCodeAnalyzer analyzer = new ResolveSession( project, storageManager, diff --git a/idea/tests/org/jetbrains/jet/plugin/ktSignature/SignatureMarkerProviderTest.java b/idea/tests/org/jetbrains/jet/plugin/ktSignature/SignatureMarkerProviderTest.java index 7ed132d4e2a..53c7e8c3b7d 100644 --- a/idea/tests/org/jetbrains/jet/plugin/ktSignature/SignatureMarkerProviderTest.java +++ b/idea/tests/org/jetbrains/jet/plugin/ktSignature/SignatureMarkerProviderTest.java @@ -24,6 +24,7 @@ import com.intellij.testFramework.LightProjectDescriptor; import com.intellij.testFramework.fixtures.LightCodeInsightFixtureTestCase; import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.di.InjectorForJavaDescriptorResolver; +import org.jetbrains.jet.di.InjectorForJavaDescriptorResolverUtil; import org.jetbrains.jet.lang.descriptors.ClassDescriptor; import org.jetbrains.jet.lang.resolve.BindingContext; import org.jetbrains.jet.lang.resolve.name.FqName; @@ -54,7 +55,7 @@ public class SignatureMarkerProviderTest extends LightCodeInsightFixtureTestCase ClassDescriptor preResolvedClass = context.get(BindingContext.CLASS, psiClass); InjectorForJavaDescriptorResolver injector = - new InjectorForJavaDescriptorResolver(project, KotlinSignatureInJavaMarkerProvider.createDelegatingTrace(project)); + InjectorForJavaDescriptorResolverUtil.create(project, KotlinSignatureInJavaMarkerProvider.createDelegatingTrace(project)); ClassDescriptor reResolvedClass = injector.getJavaDescriptorResolver() .resolveClass(new FqName("java.lang.Thread"), IGNORE_KOTLIN_SOURCES); diff --git a/js/js.translator/src/org/jetbrains/k2js/analyze/AnalyzerFacadeForJS.java b/js/js.translator/src/org/jetbrains/k2js/analyze/AnalyzerFacadeForJS.java index e40f1c67cec..9ca84d41485 100644 --- a/js/js.translator/src/org/jetbrains/k2js/analyze/AnalyzerFacadeForJS.java +++ b/js/js.translator/src/org/jetbrains/k2js/analyze/AnalyzerFacadeForJS.java @@ -154,7 +154,9 @@ public final class AnalyzerFacadeForJS { LockBasedLazyResolveStorageManager storageManager = new LockBasedLazyResolveStorageManager(); FileBasedDeclarationProviderFactory declarationProviderFactory = new FileBasedDeclarationProviderFactory( storageManager, Config.withJsLibAdded(files, config), Predicates.alwaysFalse()); - return new ResolveSession(config.getProject(), storageManager, createJsModule(""), declarationProviderFactory); + ModuleDescriptorImpl module = createJsModule(""); + module.addFragmentProvider(KotlinBuiltIns.getInstance().getBuiltInsModule().getPackageFragmentProvider()); + return new ResolveSession(config.getProject(), storageManager, module, declarationProviderFactory); } @NotNull