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 a8473e02d97..91d3eae991f 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 @@ -1,5 +1,5 @@ /* - * Copyright 2010-2013 JetBrains s.r.o. + * 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. @@ -27,6 +27,7 @@ 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.InjectorForLazyResolve; import org.jetbrains.jet.di.InjectorForTopDownAnalyzerForJvm; import org.jetbrains.jet.lang.descriptors.DependencyKind; import org.jetbrains.jet.lang.descriptors.ModuleDescriptor; @@ -115,7 +116,7 @@ public enum AnalyzerFacadeForJVM implements AnalyzerFacade { module.addFragmentProvider(DependencyKind.BUILT_INS, KotlinBuiltIns.getInstance().getBuiltInsModule().getPackageFragmentProvider()); } - return new ResolveSession(project, storageManager, module, declarationProviderFactory, trace); + return new InjectorForLazyResolve(project, storageManager, module, declarationProviderFactory, trace).getResolveSession(); } @NotNull diff --git a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForLazyResolve.java b/compiler/frontend/src/org/jetbrains/jet/di/InjectorForLazyResolve.java index 2c8d8d810fe..4ded6beda22 100644 --- a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForLazyResolve.java +++ b/compiler/frontend/src/org/jetbrains/jet/di/InjectorForLazyResolve.java @@ -17,23 +17,25 @@ package org.jetbrains.jet.di; import com.intellij.openapi.project.Project; +import org.jetbrains.jet.storage.LockBasedStorageManagerWithExceptionTracking; +import org.jetbrains.jet.lang.descriptors.ModuleDescriptorImpl; +import org.jetbrains.jet.lang.resolve.lazy.declarations.DeclarationProviderFactory; +import org.jetbrains.jet.lang.resolve.BindingTrace; import org.jetbrains.jet.lang.resolve.lazy.ResolveSession; -import org.jetbrains.jet.lang.descriptors.ModuleDescriptor; -import org.jetbrains.jet.lang.resolve.DescriptorResolver; -import org.jetbrains.jet.lang.types.expressions.ExpressionTypingServices; -import org.jetbrains.jet.lang.resolve.TypeResolver; -import org.jetbrains.jet.lang.resolve.lazy.ScopeProvider; -import org.jetbrains.jet.lang.resolve.AnnotationResolver; -import org.jetbrains.jet.lang.resolve.QualifiedExpressionResolver; -import org.jetbrains.jet.lang.psi.JetImportsFactory; import org.jetbrains.jet.lang.resolve.calls.CallResolverExtensionProvider; import org.jetbrains.jet.lang.PlatformToKotlinClassMap; -import org.jetbrains.jet.storage.StorageManager; -import org.jetbrains.jet.lang.resolve.DelegatedPropertyResolver; -import org.jetbrains.jet.lang.resolve.calls.CallExpressionResolver; +import org.jetbrains.jet.lang.resolve.AnnotationResolver; import org.jetbrains.jet.lang.resolve.calls.CallResolver; import org.jetbrains.jet.lang.resolve.calls.ArgumentTypeResolver; +import org.jetbrains.jet.lang.types.expressions.ExpressionTypingServices; +import org.jetbrains.jet.lang.resolve.calls.CallExpressionResolver; +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.resolve.calls.CandidateResolver; +import org.jetbrains.jet.lang.psi.JetImportsFactory; +import org.jetbrains.jet.lang.resolve.lazy.ScopeProvider; import org.jetbrains.annotations.NotNull; import javax.annotation.PreDestroy; @@ -42,74 +44,63 @@ import javax.annotation.PreDestroy; public class InjectorForLazyResolve { private final Project project; + private final LockBasedStorageManagerWithExceptionTracking lockBasedStorageManagerWithExceptionTracking; + private final ModuleDescriptorImpl moduleDescriptor; + private final DeclarationProviderFactory declarationProviderFactory; + private final BindingTrace bindingTrace; private final ResolveSession resolveSession; - private final ModuleDescriptor moduleDescriptor; - private final DescriptorResolver descriptorResolver; - private final ExpressionTypingServices expressionTypingServices; - private final TypeResolver typeResolver; - private final ScopeProvider scopeProvider; - private final AnnotationResolver annotationResolver; - private final QualifiedExpressionResolver qualifiedExpressionResolver; - private final JetImportsFactory jetImportsFactory; private final CallResolverExtensionProvider callResolverExtensionProvider; private final PlatformToKotlinClassMap platformToKotlinClassMap; - private final StorageManager storageManager; - private final DelegatedPropertyResolver delegatedPropertyResolver; - private final CallExpressionResolver callExpressionResolver; + private final AnnotationResolver annotationResolver; private final CallResolver callResolver; private final ArgumentTypeResolver argumentTypeResolver; + private final ExpressionTypingServices expressionTypingServices; + private final CallExpressionResolver callExpressionResolver; + private final DescriptorResolver descriptorResolver; + private final DelegatedPropertyResolver delegatedPropertyResolver; + private final TypeResolver typeResolver; + private final QualifiedExpressionResolver qualifiedExpressionResolver; private final CandidateResolver candidateResolver; + private final JetImportsFactory jetImportsFactory; + private final ScopeProvider scopeProvider; public InjectorForLazyResolve( @NotNull Project project, - @NotNull ResolveSession resolveSession, - @NotNull ModuleDescriptor moduleDescriptor + @NotNull LockBasedStorageManagerWithExceptionTracking lockBasedStorageManagerWithExceptionTracking, + @NotNull ModuleDescriptorImpl moduleDescriptor, + @NotNull DeclarationProviderFactory declarationProviderFactory, + @NotNull BindingTrace bindingTrace ) { this.project = project; - this.resolveSession = resolveSession; + this.lockBasedStorageManagerWithExceptionTracking = lockBasedStorageManagerWithExceptionTracking; this.moduleDescriptor = moduleDescriptor; - this.descriptorResolver = new DescriptorResolver(); - this.storageManager = resolveSession.getStorageManager(); - this.platformToKotlinClassMap = moduleDescriptor.getPlatformToKotlinClassMap(); - this.expressionTypingServices = new ExpressionTypingServices(storageManager, platformToKotlinClassMap); - this.typeResolver = new TypeResolver(); - this.scopeProvider = new ScopeProvider(resolveSession); - this.annotationResolver = new AnnotationResolver(); - this.qualifiedExpressionResolver = new QualifiedExpressionResolver(); - this.jetImportsFactory = new JetImportsFactory(); + this.declarationProviderFactory = declarationProviderFactory; + this.bindingTrace = bindingTrace; + this.resolveSession = new ResolveSession(project, lockBasedStorageManagerWithExceptionTracking, moduleDescriptor, declarationProviderFactory, bindingTrace); this.callResolverExtensionProvider = new CallResolverExtensionProvider(); - this.delegatedPropertyResolver = new DelegatedPropertyResolver(); - this.callExpressionResolver = new CallExpressionResolver(); + this.platformToKotlinClassMap = moduleDescriptor.getPlatformToKotlinClassMap(); + this.annotationResolver = new AnnotationResolver(); this.callResolver = new CallResolver(); this.argumentTypeResolver = new ArgumentTypeResolver(); + this.expressionTypingServices = new ExpressionTypingServices(lockBasedStorageManagerWithExceptionTracking, platformToKotlinClassMap); + this.callExpressionResolver = new CallExpressionResolver(); + this.descriptorResolver = new DescriptorResolver(); + this.delegatedPropertyResolver = new DelegatedPropertyResolver(); + this.typeResolver = new TypeResolver(); + this.qualifiedExpressionResolver = new QualifiedExpressionResolver(); this.candidateResolver = new CandidateResolver(); + this.jetImportsFactory = new JetImportsFactory(); + this.scopeProvider = new ScopeProvider(getResolveSession()); - this.descriptorResolver.setAnnotationResolver(annotationResolver); - this.descriptorResolver.setDelegatedPropertyResolver(delegatedPropertyResolver); - this.descriptorResolver.setExpressionTypingServices(expressionTypingServices); - this.descriptorResolver.setStorageManager(storageManager); - this.descriptorResolver.setTypeResolver(typeResolver); + this.resolveSession.setAnnotationResolve(annotationResolver); + this.resolveSession.setDescriptorResolver(descriptorResolver); + this.resolveSession.setJetImportFactory(jetImportsFactory); + this.resolveSession.setQualifiedExpressionResolver(qualifiedExpressionResolver); + this.resolveSession.setScopeProvider(scopeProvider); + this.resolveSession.setTypeResolver(typeResolver); - this.expressionTypingServices.setAnnotationResolver(annotationResolver); - this.expressionTypingServices.setCallExpressionResolver(callExpressionResolver); - this.expressionTypingServices.setCallResolver(callResolver); - this.expressionTypingServices.setDescriptorResolver(descriptorResolver); - this.expressionTypingServices.setExtensionProvider(callResolverExtensionProvider); - this.expressionTypingServices.setProject(project); - this.expressionTypingServices.setTypeResolver(typeResolver); - - this.typeResolver.setAnnotationResolver(annotationResolver); - this.typeResolver.setModuleDescriptor(moduleDescriptor); - this.typeResolver.setQualifiedExpressionResolver(qualifiedExpressionResolver); - - this.annotationResolver.setCallResolver(callResolver); - this.annotationResolver.setExpressionTypingServices(expressionTypingServices); - - this.jetImportsFactory.setProject(project); - - delegatedPropertyResolver.setExpressionTypingServices(expressionTypingServices); - - callExpressionResolver.setExpressionTypingServices(expressionTypingServices); + annotationResolver.setCallResolver(callResolver); + annotationResolver.setExpressionTypingServices(expressionTypingServices); callResolver.setArgumentTypeResolver(argumentTypeResolver); callResolver.setCandidateResolver(candidateResolver); @@ -119,40 +110,40 @@ public class InjectorForLazyResolve { argumentTypeResolver.setExpressionTypingServices(expressionTypingServices); argumentTypeResolver.setTypeResolver(typeResolver); + expressionTypingServices.setAnnotationResolver(annotationResolver); + expressionTypingServices.setCallExpressionResolver(callExpressionResolver); + expressionTypingServices.setCallResolver(callResolver); + expressionTypingServices.setDescriptorResolver(descriptorResolver); + expressionTypingServices.setExtensionProvider(callResolverExtensionProvider); + expressionTypingServices.setProject(project); + expressionTypingServices.setTypeResolver(typeResolver); + + callExpressionResolver.setExpressionTypingServices(expressionTypingServices); + + descriptorResolver.setAnnotationResolver(annotationResolver); + descriptorResolver.setDelegatedPropertyResolver(delegatedPropertyResolver); + descriptorResolver.setExpressionTypingServices(expressionTypingServices); + descriptorResolver.setStorageManager(lockBasedStorageManagerWithExceptionTracking); + descriptorResolver.setTypeResolver(typeResolver); + + delegatedPropertyResolver.setExpressionTypingServices(expressionTypingServices); + + typeResolver.setAnnotationResolver(annotationResolver); + typeResolver.setModuleDescriptor(moduleDescriptor); + typeResolver.setQualifiedExpressionResolver(qualifiedExpressionResolver); + candidateResolver.setArgumentTypeResolver(argumentTypeResolver); + jetImportsFactory.setProject(project); + } @PreDestroy public void destroy() { } - public DescriptorResolver getDescriptorResolver() { - return this.descriptorResolver; - } - - public ExpressionTypingServices getExpressionTypingServices() { - return this.expressionTypingServices; - } - - public TypeResolver getTypeResolver() { - return this.typeResolver; - } - - public ScopeProvider getScopeProvider() { - return this.scopeProvider; - } - - public AnnotationResolver getAnnotationResolver() { - return this.annotationResolver; - } - - public QualifiedExpressionResolver getQualifiedExpressionResolver() { - return this.qualifiedExpressionResolver; - } - - public JetImportsFactory getJetImportsFactory() { - return this.jetImportsFactory; + public ResolveSession getResolveSession() { + return this.resolveSession; } } 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 e6d1fc4a50e..06a40b1c068 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 @@ -27,7 +27,6 @@ import com.intellij.util.containers.ContainerUtil; import jet.Function0; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; -import org.jetbrains.jet.di.InjectorForLazyResolve; import org.jetbrains.jet.lang.descriptors.*; import org.jetbrains.jet.lang.psi.*; import org.jetbrains.jet.lang.resolve.*; @@ -44,6 +43,7 @@ import org.jetbrains.jet.lang.resolve.scopes.JetScope; import org.jetbrains.jet.renderer.DescriptorRenderer; import org.jetbrains.jet.storage.*; +import javax.inject.Inject; import java.util.Collection; import java.util.Collections; import java.util.List; @@ -51,8 +51,7 @@ import java.util.List; import static org.jetbrains.jet.lang.resolve.lazy.ResolveSessionUtils.safeNameForLazyResolve; public class ResolveSession implements KotlinCodeAnalyzer { - public static final Function NO_ALIASES = new Function() { - + private static final Function NO_ALIASES = new Function() { @Override public Name fun(FqName name) { return null; @@ -69,13 +68,51 @@ public class ResolveSession implements KotlinCodeAnalyzer { private final Predicate specialClasses; - private final InjectorForLazyResolve injector; - private final Function classifierAliases; private final MemoizedFunctionToNullable packages; private final PackageFragmentProvider packageFragmentProvider; + private ScopeProvider scopeProvider; + + private JetImportsFactory jetImportFactory; + private AnnotationResolver annotationResolve; + private DescriptorResolver descriptorResolver; + private TypeResolver typeResolver; + private QualifiedExpressionResolver qualifiedExpressionResolver; + + @Inject + public void setJetImportFactory(JetImportsFactory jetImportFactory) { + this.jetImportFactory = jetImportFactory; + } + + @Inject + public void setAnnotationResolve(AnnotationResolver annotationResolve) { + this.annotationResolve = annotationResolve; + } + + @Inject + public void setDescriptorResolver(DescriptorResolver descriptorResolver) { + this.descriptorResolver = descriptorResolver; + } + + @Inject + public void setTypeResolver(TypeResolver typeResolver) { + this.typeResolver = typeResolver; + } + + @Inject + public void setQualifiedExpressionResolver(QualifiedExpressionResolver qualifiedExpressionResolver) { + this.qualifiedExpressionResolver = qualifiedExpressionResolver; + } + + @Inject + public void setScopeProvider(ScopeProvider scopeProvider) { + this.scopeProvider = scopeProvider; + } + + // Only calls from injectors expected + @Deprecated public ResolveSession( @NotNull Project project, @NotNull LockBasedStorageManagerWithExceptionTracking storageManager, @@ -87,7 +124,6 @@ public class ResolveSession implements KotlinCodeAnalyzer { this.storageManager = lockBasedLazyResolveStorageManager; this.exceptionTracker = storageManager.getTracker(); this.trace = lockBasedLazyResolveStorageManager.createSafeTrace(delegationTrace); - this.injector = new InjectorForLazyResolve(project, this, rootDescriptor); this.module = rootDescriptor; this.classifierAliases = NO_ALIASES; @@ -391,31 +427,31 @@ public class ResolveSession implements KotlinCodeAnalyzer { @NotNull public ScopeProvider getScopeProvider() { - return injector.getScopeProvider(); + return scopeProvider; } @NotNull public JetImportsFactory getJetImportsFactory() { - return injector.getJetImportsFactory(); + return jetImportFactory; } @NotNull public AnnotationResolver getAnnotationResolver() { - return injector.getAnnotationResolver(); + return annotationResolve; } @NotNull public DescriptorResolver getDescriptorResolver() { - return injector.getDescriptorResolver(); + return descriptorResolver; } @NotNull public TypeResolver getTypeResolver() { - return injector.getTypeResolver(); + return typeResolver; } @NotNull public QualifiedExpressionResolver getQualifiedExpressionResolver() { - return injector.getQualifiedExpressionResolver(); + return qualifiedExpressionResolver; } } 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 9e2a6f9b0e6..8efbec1e3ae 100644 --- a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveDescriptorRendererTest.java +++ b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveDescriptorRendererTest.java @@ -1,5 +1,5 @@ /* - * Copyright 2010-2013 JetBrains s.r.o. + * 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. @@ -25,6 +25,7 @@ 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.InjectorForLazyResolve; import org.jetbrains.jet.lang.descriptors.*; import org.jetbrains.jet.lang.psi.*; import org.jetbrains.jet.lang.resolve.BindingTraceContext; @@ -34,8 +35,6 @@ import org.jetbrains.jet.lang.resolve.name.FqName; import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; import org.jetbrains.jet.renderer.DescriptorRenderer; import org.jetbrains.jet.storage.LockBasedStorageManagerWithExceptionTracking; -import org.jetbrains.jet.storage.LockBasedLazyResolveStorageManager; -import org.jetbrains.jet.storage.LockBasedStorageManager; import java.io.File; import java.io.IOException; @@ -62,9 +61,10 @@ public abstract class AbstractLazyResolveDescriptorRendererTest extends KotlinTe final ModuleDescriptorImpl lazyModule = AnalyzerFacadeForJVM.createJavaModule(""); lazyModule.addFragmentProvider(DependencyKind.BUILT_INS, KotlinBuiltIns.getInstance().getBuiltInsModule().getPackageFragmentProvider()); LockBasedStorageManagerWithExceptionTracking storageManager = LockBasedStorageManagerWithExceptionTracking.create(); - final ResolveSession resolveSession = new ResolveSession(getProject(), storageManager, lazyModule, - new FileBasedDeclarationProviderFactory(storageManager, files), - new BindingTraceContext()); + final ResolveSession resolveSession = new InjectorForLazyResolve( + getProject(), storageManager, lazyModule, + new FileBasedDeclarationProviderFactory(storageManager, files), + new BindingTraceContext()).getResolveSession(); final List descriptors = new ArrayList(); psiFile.accept(new JetVisitorVoid() { diff --git a/generators/src/org/jetbrains/jet/generators/injectors/GenerateInjectors.java b/generators/src/org/jetbrains/jet/generators/injectors/GenerateInjectors.java index 20cdc7588c4..0552cac1188 100644 --- a/generators/src/org/jetbrains/jet/generators/injectors/GenerateInjectors.java +++ b/generators/src/org/jetbrains/jet/generators/injectors/GenerateInjectors.java @@ -29,7 +29,6 @@ import org.jetbrains.jet.di.InjectorForTopDownAnalyzer; import org.jetbrains.jet.lang.PlatformToKotlinClassMap; import org.jetbrains.jet.lang.descriptors.ModuleDescriptor; import org.jetbrains.jet.lang.descriptors.ModuleDescriptorImpl; -import org.jetbrains.jet.lang.psi.JetImportsFactory; import org.jetbrains.jet.lang.resolve.*; import org.jetbrains.jet.lang.resolve.calls.CallResolver; import org.jetbrains.jet.lang.resolve.calls.CallResolverExtensionProvider; @@ -39,7 +38,7 @@ import org.jetbrains.jet.lang.resolve.java.mapping.JavaToKotlinClassMap; import org.jetbrains.jet.lang.resolve.java.resolver.*; import org.jetbrains.jet.lang.resolve.kotlin.VirtualFileFinder; import org.jetbrains.jet.lang.resolve.lazy.ResolveSession; -import org.jetbrains.jet.lang.resolve.lazy.ScopeProvider; +import org.jetbrains.jet.lang.resolve.lazy.declarations.DeclarationProviderFactory; import org.jetbrains.jet.lang.types.DependencyClassByQualifiedNameResolverDummyImpl; import org.jetbrains.jet.lang.types.expressions.ExpressionTypingServices; import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; @@ -52,7 +51,7 @@ import java.util.Arrays; import java.util.List; // NOTE: After making changes, you need to re-generate the injectors. -// To do that, you can run either this class +// To do that, you can run main in this class. public class GenerateInjectors { private GenerateInjectors() { @@ -86,19 +85,18 @@ public class GenerateInjectors { private static DependencyInjectorGenerator generateInjectorForLazyResolve() throws IOException { DependencyInjectorGenerator generator = new DependencyInjectorGenerator(); + generator.addParameter(Project.class); - generator.addParameter(ResolveSession.class); - generator.addParameter(ModuleDescriptor.class); - generator.addPublicField(DescriptorResolver.class); - generator.addPublicField(ExpressionTypingServices.class); - generator.addPublicField(TypeResolver.class); - generator.addPublicField(ScopeProvider.class); - generator.addPublicField(AnnotationResolver.class); - generator.addPublicField(QualifiedExpressionResolver.class); - generator.addPublicField(JetImportsFactory.class); + generator.addParameter(LockBasedStorageManagerWithExceptionTracking.class); + generator.addParameter(ModuleDescriptorImpl.class); + generator.addParameter(DeclarationProviderFactory.class); + generator.addParameter(BindingTrace.class); + + generator.addPublicField(ResolveSession.class); + generator.addField(CallResolverExtensionProvider.class); generator.addField(false, PlatformToKotlinClassMap.class, null, new GivenExpression("moduleDescriptor.getPlatformToKotlinClassMap()")); - generator.addField(false, StorageManager.class, null, new GivenExpression("resolveSession.getStorageManager()")); + generator.configure("compiler/frontend/src", "org.jetbrains.jet.di", "InjectorForLazyResolve", GenerateInjectors.class); return generator; } diff --git a/idea/src/org/jetbrains/jet/plugin/libraries/JetSourceNavigationHelper.java b/idea/src/org/jetbrains/jet/plugin/libraries/JetSourceNavigationHelper.java index c36ca411bb2..2c97d046353 100644 --- a/idea/src/org/jetbrains/jet/plugin/libraries/JetSourceNavigationHelper.java +++ b/idea/src/org/jetbrains/jet/plugin/libraries/JetSourceNavigationHelper.java @@ -42,6 +42,7 @@ import org.jetbrains.annotations.Nullable; import org.jetbrains.annotations.TestOnly; import org.jetbrains.jet.asJava.LightClassUtil; import org.jetbrains.jet.codegen.binding.PsiCodegenPredictor; +import org.jetbrains.jet.di.InjectorForLazyResolve; import org.jetbrains.jet.lang.PlatformToKotlinClassMap; import org.jetbrains.jet.lang.descriptors.CallableDescriptor; import org.jetbrains.jet.lang.descriptors.ClassDescriptor; @@ -54,7 +55,6 @@ import org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM; import org.jetbrains.jet.lang.resolve.java.JvmClassName; 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; import org.jetbrains.jet.lang.resolve.lazy.declarations.FileBasedDeclarationProviderFactory; import org.jetbrains.jet.lang.resolve.name.FqName; import org.jetbrains.jet.lang.resolve.name.FqNameUnsafe; @@ -229,12 +229,12 @@ public class JetSourceNavigationHelper { moduleDescriptor.addFragmentProvider(DependencyKind.BUILT_INS, KotlinBuiltIns.getInstance().getBuiltInsModule().getPackageFragmentProvider()); - KotlinCodeAnalyzer analyzer = new ResolveSession( + KotlinCodeAnalyzer analyzer = new InjectorForLazyResolve( project, storageManager, moduleDescriptor, providerFactory, - new BindingTraceContext()); + new BindingTraceContext()).getResolveSession(); for (JetNamedDeclaration candidate : candidates) { //noinspection unchecked 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 694e266afc5..287dcf5a205 100644 --- a/js/js.translator/src/org/jetbrains/k2js/analyze/AnalyzerFacadeForJS.java +++ b/js/js.translator/src/org/jetbrains/k2js/analyze/AnalyzerFacadeForJS.java @@ -25,6 +25,7 @@ import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.analyzer.AnalyzeExhaust; import org.jetbrains.jet.analyzer.AnalyzerFacadeForEverything; +import org.jetbrains.jet.di.InjectorForLazyResolve; import org.jetbrains.jet.di.InjectorForTopDownAnalyzerForJs; import org.jetbrains.jet.lang.PlatformToKotlinClassMap; import org.jetbrains.jet.lang.descriptors.DependencyKind; @@ -158,7 +159,13 @@ public final class AnalyzerFacadeForJS { storageManager, Config.withJsLibAdded(files, config), Predicates.alwaysFalse()); ModuleDescriptorImpl module = createJsModule(""); module.addFragmentProvider(DependencyKind.BUILT_INS, KotlinBuiltIns.getInstance().getBuiltInsModule().getPackageFragmentProvider()); - return new ResolveSession(config.getProject(), storageManager, module, declarationProviderFactory, new BindingTraceContext()); + + return new InjectorForLazyResolve( + config.getProject(), + storageManager, + module, + declarationProviderFactory, + new BindingTraceContext()).getResolveSession(); } @NotNull