azalea/kotlin-fork
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Refactoring: use injector for creating lazy resolve session

Browse Source
This commit is contained in:
Nikolay Krasko
2014-01-22 14:52:37 +04:00
parent b8ddb658fb
commit f526129ca4
7 changed files with 157 additions and 124 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/AnalyzerFacadeForJVM.java
+3 -2
View File
@@ -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
compiler/frontend/src/org/jetbrains/jet/di/InjectorForLazyResolve.java
+78 -87
View File
@@ -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;
}
}
compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/ResolveSession.java
+48 -12
View File
@@ -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<FqName, Name> NO_ALIASES = new Function<FqName, Name>() {
private static final Function<FqName, Name> NO_ALIASES = new Function<FqName, Name>() {
@Override
public Name fun(FqName name) {
return null;
@@ -69,13 +68,51 @@ public class ResolveSession implements KotlinCodeAnalyzer {
private final Predicate<FqNameUnsafe> specialClasses;
private final InjectorForLazyResolve injector;
private final Function<FqName, Name> classifierAliases;
private final MemoizedFunctionToNullable<FqName, LazyPackageDescriptor> 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;
}
}
compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveDescriptorRendererTest.java
+6 -6
View File
@@ -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("<lazy module>");
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<DeclarationDescriptor> descriptors = new ArrayList<DeclarationDescriptor>();
psiFile.accept(new JetVisitorVoid() {
generators/src/org/jetbrains/jet/generators/injectors/GenerateInjectors.java
+11 -13
View File
@@ -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;
}
idea/src/org/jetbrains/jet/plugin/libraries/JetSourceNavigationHelper.java
+3 -3
View File
@@ -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
js/js.translator/src/org/jetbrains/k2js/analyze/AnalyzerFacadeForJS.java
+8 -1
View File
@@ -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.<FqName>alwaysFalse());
ModuleDescriptorImpl module = createJsModule("<lazy module>");
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